@matheusbsbs / matheus-bagliano / commits / 26349b2e5e
Fork 0

Improve lock handling

Improve lock handling: parse the server response for the timeout, owner, and lock token Signed-off-by: Nick Hengeveld <nickh@reactrix.com> Signed-off-by: Junio C Hamano <junkio@cox.net>

Nick Hengeveld committed Nov 4, 2005 at 14:22 UTC 26349b2e5ee2311cbb12db1cb92fa48fb0f26ef8
1 file changed +147 -54
http-push.c
+147 -54
@@ -55,7 +55,6 @@ static CURL *curl_default;
55 static struct curl_slist *no_pragma_header;
56 static struct curl_slist *default_headers;
57 static char curl_errorstr[CURL_ERROR_SIZE];
58 -static char *lock_token = NULL;
58
59 static int push_verbosely = 0;
60 static int push_all = 0;
@@ -92,7 +91,7 @@ struct transfer_request
91 unsigned char sha1[20];
92 char *url;
93 char *dest;
95 - char *lock_token;
94 + struct active_lock *lock;
95 struct curl_slist *headers;
96 struct buffer buffer;
97 char filename[PATH_MAX];
@@ -136,6 +135,20 @@ static char *ssl_cainfo = NULL;
135 static long curl_low_speed_limit = -1;
136 static long curl_low_speed_time = -1;
137
138 +struct active_lock
139 +{
140 + int ctx_activelock;
141 + int ctx_owner;
142 + int ctx_owner_href;
143 + int ctx_timeout;
144 + int ctx_locktoken;
145 + int ctx_locktoken_href;
146 + char *owner;
147 + time_t start_time;
148 + long timeout;
149 + char *token;
150 +};
151 +
152 struct lockprop
153 {
154 int supported_lock;
@@ -509,7 +522,7 @@ static void start_put(struct transfer_request *request)
522 if (request->url != NULL)
523 free(request->url);
524 request->url = xmalloc(strlen(remote->url) +
512 - strlen(request->lock_token) + 51);
525 + strlen(request->lock->token) + 51);
526 strcpy(request->url, remote->url);
527 posn = request->url + strlen(remote->url);
528 strcpy(posn, "objects/");
@@ -522,7 +535,7 @@ static void start_put(struct transfer_request *request)
535 sprintf(request->dest, "Destination: %s", request->url);
536 posn += 38;
537 *(posn++) = '.';
525 - strcpy(posn, request->lock_token);
538 + strcpy(posn, request->lock->token);
539
540 slot = get_active_slot();
541 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &request->buffer);
@@ -724,7 +737,7 @@ void process_waiting_requests(void)
737 }
738 }
739
727 -void add_request(unsigned char *sha1, char *lock_token)
740 +void add_request(unsigned char *sha1, struct active_lock *lock)
741 {
742 struct transfer_request *request = request_queue_head;
743 struct packed_git *target;
@@ -741,7 +754,7 @@ void add_request(unsigned char *sha1, char *lock_token)
754 request = xmalloc(sizeof(*request));
755 memcpy(request->sha1, sha1, 20);
756 request->url = NULL;
744 - request->lock_token = lock_token;
757 + request->lock = lock;
758 request->headers = NULL;
759 request->state = NEED_CHECK;
760 request->next = request_queue_head;
@@ -998,6 +1011,68 @@ int fetch_ref(char *ref, unsigned char *sha1)
1011 return 0;
1012 }
1013
1014 +static void
1015 +start_activelock_element(void *userData, const char *name, const char **atts)
1016 +{
1017 + struct active_lock *lock = (struct active_lock *)userData;
1018 +
1019 + if (lock->ctx_activelock && !strcmp(name, "D:timeout"))
1020 + lock->ctx_timeout = 1;
1021 + else if (lock->ctx_owner && strstr(name, "href"))
1022 + lock->ctx_owner_href = 1;
1023 + else if (lock->ctx_activelock && strstr(name, "owner"))
1024 + lock->ctx_owner = 1;
1025 + else if (lock->ctx_locktoken && !strcmp(name, "D:href"))
1026 + lock->ctx_locktoken_href = 1;
1027 + else if (lock->ctx_activelock && !strcmp(name, "D:locktoken"))
1028 + lock->ctx_locktoken = 1;
1029 + else if (!strcmp(name, "D:activelock"))
1030 + lock->ctx_activelock = 1;
1031 +}
1032 +
1033 +static void
1034 +end_activelock_element(void *userData, const char *name)
1035 +{
1036 + struct active_lock *lock = (struct active_lock *)userData;
1037 +
1038 + if (lock->ctx_timeout && !strcmp(name, "D:timeout")) {
1039 + lock->ctx_timeout = 0;
1040 + } else if (lock->ctx_owner_href && strstr(name, "href")) {
1041 + lock->ctx_owner_href = 0;
1042 + } else if (lock->ctx_owner && strstr(name, "owner")) {
1043 + lock->ctx_owner = 0;
1044 + } else if (lock->ctx_locktoken_href && !strcmp(name, "D:href")) {
1045 + lock->ctx_locktoken_href = 0;
1046 + } else if (lock->ctx_locktoken && !strcmp(name, "D:locktoken")) {
1047 + lock->ctx_locktoken = 0;
1048 + } else if (lock->ctx_activelock && !strcmp(name, "D:activelock")) {
1049 + lock->ctx_activelock = 0;
1050 + }
1051 +}
1052 +
1053 +static void
1054 +activelock_cdata(void *userData, const XML_Char *s, int len)
1055 +{
1056 + struct active_lock *lock = (struct active_lock *)userData;
1057 + char *this = malloc(len+1);
1058 + strncpy(this, s, len);
1059 +
1060 + if (lock->ctx_owner_href) {
1061 + lock->owner = malloc(len+1);
1062 + strcpy(lock->owner, this);
1063 + } else if (lock->ctx_locktoken_href) {
1064 + if (!strncmp(this, "opaquelocktoken:", 16)) {
1065 + lock->token = malloc(len-15);
1066 + strcpy(lock->token, this+16);
1067 + }
1068 + } else if (lock->ctx_timeout) {
1069 + if (!strncmp(this, "Second-", 7))
1070 + lock->timeout = strtol(this+7, NULL, 10);
1071 + }
1072 +
1073 + free(this);
1074 +}
1075 +
1076 static void
1077 start_lockprop_element(void *userData, const char *name, const char **atts)
1078 {
@@ -1039,40 +1114,21 @@ end_lockprop_element(void *userData, const char *name)
1114 }
1115 }
1116
1042 -size_t process_lock_header( void *ptr, size_t size, size_t nmemb, void *stream)
1043 -{
1044 - size_t header_size = size*nmemb;
1045 - char *start;
1046 - char *end;
1047 -
1048 - if (!strncmp(ptr, "Lock-Token: <opaquelocktoken:", 29)) {
1049 - start = ptr + 29;
1050 - for (end = ptr + header_size;
1051 - *(end - 1) == '\r' || *(end - 1) == '\n' || *(end - 1) == '>';
1052 - end--) {}
1053 - if (end > start) {
1054 - lock_token = xmalloc(end - start + 1);
1055 - memcpy(lock_token, start, end - start);
1056 - lock_token[end - start] = 0;
1057 - }
1058 - }
1059 -
1060 - return header_size;
1061 -}
1062 -
1063 -char *lock_remote(char *file, int timeout)
1117 +struct active_lock *lock_remote(char *file, int timeout)
1118 {
1119 struct active_request_slot *slot;
1120 struct buffer out_buffer;
1121 + struct buffer in_buffer;
1122 char *out_data;
1123 + char *in_data;
1124 char *url;
1125 char *ep;
1126 char timeout_header[25];
1127 + struct active_lock *new_lock;
1128 + XML_Parser parser = XML_ParserCreate(NULL);
1129 + enum XML_Status result;
1130 struct curl_slist *dav_headers = NULL;
1131
1073 - if (lock_token != NULL)
1074 - free(lock_token);
1075 -
1132 url = xmalloc(strlen(remote->url) + strlen(file) + 1);
1133 sprintf(url, "%s%s", remote->url, file);
1134
@@ -1110,6 +1166,16 @@ char *lock_remote(char *file, int timeout)
1166 out_buffer.posn = 0;
1167 out_buffer.buffer = out_data;
1168
1169 + in_buffer.size = 4096;
1170 + in_data = xmalloc(in_buffer.size);
1171 + in_buffer.posn = 0;
1172 + in_buffer.buffer = in_data;
1173 +
1174 + new_lock = xmalloc(sizeof(*new_lock));
1175 + new_lock->owner = NULL;
1176 + new_lock->token = NULL;
1177 + new_lock->timeout = -1;
1178 +
1179 sprintf(timeout_header, "Timeout: Second-%d", timeout);
1180 dav_headers = curl_slist_append(dav_headers, timeout_header);
1181 dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
@@ -1118,9 +1184,9 @@ char *lock_remote(char *file, int timeout)
1184 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1185 curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1186 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1121 - curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1122 - curl_easy_setopt(slot->curl, CURLOPT_HEADERFUNCTION,
1123 - process_lock_header);
1187 + curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1188 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
1189 + fwrite_buffer_dynamic);
1190 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1191 curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1192 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
@@ -1130,13 +1196,17 @@ char *lock_remote(char *file, int timeout)
1196 run_active_slot(slot);
1197 if (slot->curl_result != CURLE_OK) {
1198 fprintf(stderr, "Got HTTP error %ld\n", slot->http_code);
1199 + free(new_lock);
1200 free(url);
1201 free(out_data);
1202 + free(in_data);
1203 return NULL;
1204 }
1205 } else {
1206 + free(new_lock);
1207 free(url);
1208 free(out_data);
1209 + free(in_data);
1210 fprintf(stderr, "Unable to start request\n");
1211 return NULL;
1212 }
@@ -1144,10 +1214,33 @@ char *lock_remote(char *file, int timeout)
1214 free(url);
1215 free(out_data);
1216
1147 - return strdup(lock_token);
1217 + XML_SetUserData(parser, new_lock);
1218 + XML_SetElementHandler(parser, start_activelock_element,
1219 + end_activelock_element);
1220 + XML_SetCharacterDataHandler(parser, activelock_cdata);
1221 + result = XML_Parse(parser, in_buffer.buffer, in_buffer.posn, 1);
1222 + free(in_data);
1223 + if (result != XML_STATUS_OK) {
1224 + fprintf(stderr, "%s", XML_ErrorString(
1225 + XML_GetErrorCode(parser)));
1226 + free(new_lock);
1227 + return NULL;
1228 + }
1229 +
1230 + if (new_lock->token == NULL || new_lock->timeout <= 0) {
1231 + if (new_lock->token != NULL)
1232 + free(new_lock->token);
1233 + if (new_lock->owner != NULL)
1234 + free(new_lock->owner);
1235 + free(new_lock);
1236 + return NULL;
1237 + }
1238 +
1239 + new_lock->start_time = time(NULL);
1240 + return new_lock;
1241 }
1242
1150 -int unlock_remote(char *file, char *lock_token)
1243 +int unlock_remote(char *file, struct active_lock *lock)
1244 {
1245 struct active_request_slot *slot;
1246 char *url;
@@ -1155,14 +1248,9 @@ int unlock_remote(char *file, char *lock_token)
1248 struct curl_slist *dav_headers = NULL;
1249 int rc = 0;
1250
1158 - if (lock_token == NULL) {
1159 - fprintf(stderr, "Unable to unlock, no lock token");
1160 - return 0;
1161 - }
1162 -
1163 - lock_token_header = xmalloc(strlen(lock_token) + 31);
1251 + lock_token_header = xmalloc(strlen(lock->token) + 31);
1252 sprintf(lock_token_header, "Lock-Token: <opaquelocktoken:%s>",
1165 - lock_token);
1253 + lock->token);
1254 url = xmalloc(strlen(remote->url) + strlen(file) + 1);
1255 sprintf(url, "%s%s", remote->url, file);
1256 dav_headers = curl_slist_append(dav_headers, lock_token_header);
@@ -1278,7 +1366,8 @@ int is_ancestor(unsigned char *sha1, struct commit *commit)
1366 return 0;
1367 }
1368
1281 -void get_delta(unsigned char *sha1, struct object *obj, char *lock_token)
1369 +void get_delta(unsigned char *sha1, struct object *obj,
1370 + struct active_lock *lock)
1371 {
1372 struct commit *commit;
1373 struct commit_list *parents;
@@ -1294,7 +1383,7 @@ void get_delta(unsigned char *sha1, struct object *obj, char *lock_token)
1383 if (obj->type == commit_type) {
1384 if (push_verbosely)
1385 fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
1297 - add_request(obj->sha1, lock_token);
1386 + add_request(obj->sha1, lock);
1387 commit = (struct commit *)obj;
1388 if (parse_commit(commit)) {
1389 fprintf(stderr, "Error parsing commit %s\n",
@@ -1307,12 +1396,12 @@ void get_delta(unsigned char *sha1, struct object *obj, char *lock_token)
1396 if (sha1 == NULL ||
1397 memcmp(sha1, parents->item->object.sha1, 20))
1398 get_delta(sha1, &parents->item->object,
1310 - lock_token);
1311 - get_delta(sha1, &commit->tree->object, lock_token);
1399 + lock);
1400 + get_delta(sha1, &commit->tree->object, lock);
1401 } else if (obj->type == tree_type) {
1402 if (push_verbosely)
1403 fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
1315 - add_request(obj->sha1, lock_token);
1404 + add_request(obj->sha1, lock);
1405 tree = (struct tree *)obj;
1406 if (parse_tree(tree)) {
1407 fprintf(stderr, "Error parsing tree %s\n",
@@ -1324,17 +1413,18 @@ void get_delta(unsigned char *sha1, struct object *obj, char *lock_token)
1413 tree->entries = NULL;
1414 while (entry) {
1415 struct tree_entry_list *next = entry->next;
1327 - get_delta(sha1, entry->item.any, lock_token);
1416 + get_delta(sha1, entry->item.any, lock);
1417 free(entry->name);
1418 free(entry);
1419 entry = next;
1420 }
1421 } else if (obj->type == blob_type || obj->type == tag_type) {
1333 - add_request(obj->sha1, lock_token);
1422 + add_request(obj->sha1, lock);
1423 }
1424 }
1425
1337 -int update_remote(char *remote_path, unsigned char *sha1, char *lock_token)
1426 +int update_remote(char *remote_path, unsigned char *sha1,
1427 + struct active_lock *lock)
1428 {
1429 struct active_request_slot *slot;
1430 char *url;
@@ -1347,8 +1437,8 @@ int update_remote(char *remote_path, unsigned char *sha1, char *lock_token)
1437 url = xmalloc(strlen(remote->url) + strlen(remote_path) + 1);
1438 sprintf(url, "%s%s", remote->url, remote_path);
1439
1350 - if_header = xmalloc(strlen(lock_token) + 25);
1351 - sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock_token);
1440 + if_header = xmalloc(strlen(lock->token) + 25);
1441 + sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
1442 dav_headers = curl_slist_append(dav_headers, if_header);
1443
1444 out_buffer.size = 41;
@@ -1411,7 +1501,7 @@ int main(int argc, char **argv)
1501 struct object *local_object = NULL;
1502 char *remote_ref = NULL;
1503 unsigned char remote_sha1[20];
1414 - char *remote_lock = NULL;
1504 + struct active_lock *remote_lock;
1505 char *remote_path = NULL;
1506 char *low_speed_limit;
1507 char *low_speed_time;
@@ -1630,6 +1720,9 @@ int main(int argc, char **argv)
1720 unlock:
1721 unlock_remote(remote_path, remote_lock);
1722 free(remote_path);
1723 + if (remote_lock->owner != NULL)
1724 + free(remote_lock->owner);
1725 + free(remote_lock->token);
1726 free(remote_lock);
1727 }
1728