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