http-push: fix revision walk
[git] / http-push.c
1 #include "cache.h"
2 #include "commit.h"
3 #include "pack.h"
4 #include "fetch.h"
5 #include "tag.h"
6 #include "blob.h"
7 #include "http.h"
8 #include "refs.h"
9 #include "revision.h"
10
11 #include <expat.h>
12
13 static const char http_push_usage[] =
14 "git-http-push [--complete] [--force] [--verbose] <url> <ref> [<ref>...]\n";
15
16 #ifndef XML_STATUS_OK
17 enum XML_Status {
18   XML_STATUS_OK = 1,
19   XML_STATUS_ERROR = 0
20 };
21 #define XML_STATUS_OK    1
22 #define XML_STATUS_ERROR 0
23 #endif
24
25 #define RANGE_HEADER_SIZE 30
26
27 /* DAV methods */
28 #define DAV_LOCK "LOCK"
29 #define DAV_MKCOL "MKCOL"
30 #define DAV_MOVE "MOVE"
31 #define DAV_PROPFIND "PROPFIND"
32 #define DAV_PUT "PUT"
33 #define DAV_UNLOCK "UNLOCK"
34
35 /* DAV lock flags */
36 #define DAV_PROP_LOCKWR (1u << 0)
37 #define DAV_PROP_LOCKEX (1u << 1)
38 #define DAV_LOCK_OK (1u << 2)
39
40 /* DAV XML properties */
41 #define DAV_CTX_LOCKENTRY ".multistatus.response.propstat.prop.supportedlock.lockentry"
42 #define DAV_CTX_LOCKTYPE_WRITE ".multistatus.response.propstat.prop.supportedlock.lockentry.locktype.write"
43 #define DAV_CTX_LOCKTYPE_EXCLUSIVE ".multistatus.response.propstat.prop.supportedlock.lockentry.lockscope.exclusive"
44 #define DAV_ACTIVELOCK_OWNER ".prop.lockdiscovery.activelock.owner.href"
45 #define DAV_ACTIVELOCK_TIMEOUT ".prop.lockdiscovery.activelock.timeout"
46 #define DAV_ACTIVELOCK_TOKEN ".prop.lockdiscovery.activelock.locktoken.href"
47 #define DAV_PROPFIND_RESP ".multistatus.response"
48 #define DAV_PROPFIND_NAME ".multistatus.response.href"
49 #define DAV_PROPFIND_COLLECTION ".multistatus.response.propstat.prop.resourcetype.collection"
50
51 /* DAV request body templates */
52 #define PROPFIND_SUPPORTEDLOCK_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:prop xmlns:R=\"%s\">\n<D:supportedlock/>\n</D:prop>\n</D:propfind>"
53 #define PROPFIND_ALL_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/>\n</D:propfind>"
54 #define LOCK_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:lockinfo xmlns:D=\"DAV:\">\n<D:lockscope><D:exclusive/></D:lockscope>\n<D:locktype><D:write/></D:locktype>\n<D:owner>\n<D:href>mailto:%s</D:href>\n</D:owner>\n</D:lockinfo>"
55
56 #define LOCK_TIME 600
57 #define LOCK_REFRESH 30
58
59 /* bits #0-4 in revision.h */
60
61 #define LOCAL   (1u << 5)
62 #define REMOTE  (1u << 6)
63 #define PUSHING (1u << 7)
64
65 static int pushing = 0;
66 static int aborted = 0;
67 static char remote_dir_exists[256];
68
69 static struct curl_slist *no_pragma_header;
70 static struct curl_slist *default_headers;
71
72 static int push_verbosely = 0;
73 static int push_all = 0;
74 static int force_all = 0;
75
76 static struct object_list *objects = NULL;
77
78 struct repo
79 {
80         char *url;
81         int path_len;
82         struct packed_git *packs;
83 };
84
85 static struct repo *remote = NULL;
86 static struct remote_lock *remote_locks = NULL;
87
88 enum transfer_state {
89         NEED_PUSH,
90         RUN_MKCOL,
91         RUN_PUT,
92         RUN_MOVE,
93         ABORTED,
94         COMPLETE,
95 };
96
97 struct transfer_request
98 {
99         struct object *obj;
100         char *url;
101         char *dest;
102         struct remote_lock *lock;
103         struct curl_slist *headers;
104         struct buffer buffer;
105         char filename[PATH_MAX];
106         char tmpfile[PATH_MAX];
107         enum transfer_state state;
108         CURLcode curl_result;
109         char errorstr[CURL_ERROR_SIZE];
110         long http_code;
111         unsigned char real_sha1[20];
112         SHA_CTX c;
113         z_stream stream;
114         int zret;
115         int rename;
116         struct active_request_slot *slot;
117         struct transfer_request *next;
118 };
119
120 static struct transfer_request *request_queue_head = NULL;
121
122 struct xml_ctx
123 {
124         char *name;
125         int len;
126         char *cdata;
127         void (*userFunc)(struct xml_ctx *ctx, int tag_closed);
128         void *userData;
129 };
130
131 struct remote_lock
132 {
133         char *url;
134         char *owner;
135         char *token;
136         time_t start_time;
137         long timeout;
138         int active;
139         int refreshing;
140         struct remote_lock *next;
141 };
142
143 struct remote_dentry
144 {
145         char *base;
146         char *name;
147         int is_dir;
148 };
149
150 static void finish_request(struct transfer_request *request);
151
152 static void process_response(void *callback_data)
153 {
154         struct transfer_request *request =
155                 (struct transfer_request *)callback_data;
156
157         finish_request(request);
158 }
159
160 static void start_mkcol(struct transfer_request *request)
161 {
162         char *hex = sha1_to_hex(request->obj->sha1);
163         struct active_request_slot *slot;
164         char *posn;
165
166         request->url = xmalloc(strlen(remote->url) + 13);
167         strcpy(request->url, remote->url);
168         posn = request->url + strlen(remote->url);
169         strcpy(posn, "objects/");
170         posn += 8;
171         memcpy(posn, hex, 2);
172         posn += 2;
173         strcpy(posn, "/");
174
175         slot = get_active_slot();
176         slot->callback_func = process_response;
177         slot->callback_data = request;
178         curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
179         curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
180         curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
181         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MKCOL);
182         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
183
184         if (start_active_slot(slot)) {
185                 request->slot = slot;
186                 request->state = RUN_MKCOL;
187         } else {
188                 request->state = ABORTED;
189                 free(request->url);
190                 request->url = NULL;
191         }
192 }
193
194 static void start_put(struct transfer_request *request)
195 {
196         char *hex = sha1_to_hex(request->obj->sha1);
197         struct active_request_slot *slot;
198         char *posn;
199         char type[20];
200         char hdr[50];
201         void *unpacked;
202         unsigned long len;
203         int hdrlen;
204         ssize_t size;
205         z_stream stream;
206
207         unpacked = read_sha1_file(request->obj->sha1, type, &len);
208         hdrlen = sprintf(hdr, "%s %lu", type, len) + 1;
209
210         /* Set it up */
211         memset(&stream, 0, sizeof(stream));
212         deflateInit(&stream, Z_BEST_COMPRESSION);
213         size = deflateBound(&stream, len + hdrlen);
214         request->buffer.buffer = xmalloc(size);
215
216         /* Compress it */
217         stream.next_out = request->buffer.buffer;
218         stream.avail_out = size;
219
220         /* First header.. */
221         stream.next_in = (void *)hdr;
222         stream.avail_in = hdrlen;
223         while (deflate(&stream, 0) == Z_OK)
224                 /* nothing */;
225
226         /* Then the data itself.. */
227         stream.next_in = unpacked;
228         stream.avail_in = len;
229         while (deflate(&stream, Z_FINISH) == Z_OK)
230                 /* nothing */;
231         deflateEnd(&stream);
232         free(unpacked);
233
234         request->buffer.size = stream.total_out;
235         request->buffer.posn = 0;
236
237         request->url = xmalloc(strlen(remote->url) + 
238                                strlen(request->lock->token) + 51);
239         strcpy(request->url, remote->url);
240         posn = request->url + strlen(remote->url);
241         strcpy(posn, "objects/");
242         posn += 8;
243         memcpy(posn, hex, 2);
244         posn += 2;
245         *(posn++) = '/';
246         strcpy(posn, hex + 2);
247         request->dest = xmalloc(strlen(request->url) + 14);
248         sprintf(request->dest, "Destination: %s", request->url);
249         posn += 38;
250         *(posn++) = '.';
251         strcpy(posn, request->lock->token);
252
253         slot = get_active_slot();
254         slot->callback_func = process_response;
255         slot->callback_data = request;
256         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &request->buffer);
257         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, request->buffer.size);
258         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
259         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
260         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
261         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
262         curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
263         curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
264         curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
265
266         if (start_active_slot(slot)) {
267                 request->slot = slot;
268                 request->state = RUN_PUT;
269         } else {
270                 request->state = ABORTED;
271                 free(request->url);
272                 request->url = NULL;
273         }
274 }
275
276 static void start_move(struct transfer_request *request)
277 {
278         struct active_request_slot *slot;
279         struct curl_slist *dav_headers = NULL;
280
281         slot = get_active_slot();
282         slot->callback_func = process_response;
283         slot->callback_data = request;
284         curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
285         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MOVE);
286         dav_headers = curl_slist_append(dav_headers, request->dest);
287         dav_headers = curl_slist_append(dav_headers, "Overwrite: T");
288         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
289         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
290         curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
291
292         if (start_active_slot(slot)) {
293                 request->slot = slot;
294                 request->state = RUN_MOVE;
295         } else {
296                 request->state = ABORTED;
297                 free(request->url);
298                 request->url = NULL;
299         }
300 }
301
302 static int refresh_lock(struct remote_lock *check_lock)
303 {
304         struct active_request_slot *slot;
305         char *if_header;
306         char timeout_header[25];
307         struct curl_slist *dav_headers = NULL;
308         struct remote_lock *lock;
309         int time_remaining;
310         time_t current_time;
311
312         /* Refresh all active locks if they're close to expiring */
313         for (lock = remote_locks; lock; lock = lock->next) {
314                 if (!lock->active)
315                         continue;
316
317                 current_time = time(NULL);
318                 time_remaining = lock->start_time + lock->timeout
319                         - current_time;
320                 if (time_remaining > LOCK_REFRESH)
321                         continue;
322
323                 lock->refreshing = 1;
324
325                 if_header = xmalloc(strlen(lock->token) + 25);
326                 sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
327                 sprintf(timeout_header, "Timeout: Second-%ld", lock->timeout);
328                 dav_headers = curl_slist_append(dav_headers, if_header);
329                 dav_headers = curl_slist_append(dav_headers, timeout_header);
330
331                 slot = get_active_slot();
332                 curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
333                 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
334                 curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
335                 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
336                 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
337
338                 if (start_active_slot(slot)) {
339                         run_active_slot(slot);
340                         if (slot->curl_result != CURLE_OK) {
341                                 fprintf(stderr, "Got HTTP error %ld\n", slot->http_code);
342                                 lock->active = 0;
343                         } else {
344                                 lock->active = 1;
345                                 lock->start_time = time(NULL);
346                         }
347                 }
348
349                 lock->refreshing = 0;
350                 curl_slist_free_all(dav_headers);
351                 free(if_header);
352         }
353
354         if (check_lock)
355                 return check_lock->active;
356         else
357                 return 0;
358 }
359
360 static void release_request(struct transfer_request *request)
361 {
362         struct transfer_request *entry = request_queue_head;
363
364         if (request == request_queue_head) {
365                 request_queue_head = request->next;
366         } else {
367                 while (entry->next != NULL && entry->next != request)
368                         entry = entry->next;
369                 if (entry->next == request)
370                         entry->next = entry->next->next;
371         }
372
373         if (request->url != NULL)
374                 free(request->url);
375         free(request);
376 }
377
378 static void finish_request(struct transfer_request *request)
379 {
380         request->curl_result =  request->slot->curl_result;
381         request->http_code = request->slot->http_code;
382         request->slot = NULL;
383
384         /* Keep locks active */
385         refresh_lock(request->lock);
386
387         if (request->headers != NULL)
388                 curl_slist_free_all(request->headers);
389
390         /* URL is reused for MOVE after PUT */
391         if (request->state != RUN_PUT) {
392                 free(request->url);
393                 request->url = NULL;
394         }
395
396         if (request->state == RUN_MKCOL) {
397                 if (request->curl_result == CURLE_OK ||
398                     request->http_code == 405) {
399                         remote_dir_exists[request->obj->sha1[0]] = 1;
400                         start_put(request);
401                 } else {
402                         fprintf(stderr, "MKCOL %s failed, aborting (%d/%ld)\n",
403                                 sha1_to_hex(request->obj->sha1),
404                                 request->curl_result, request->http_code);
405                         request->state = ABORTED;
406                         aborted = 1;
407                 }
408         } else if (request->state == RUN_PUT) {
409                 if (request->curl_result == CURLE_OK) {
410                         start_move(request);
411                 } else {
412                         fprintf(stderr, "PUT %s failed, aborting (%d/%ld)\n",
413                                 sha1_to_hex(request->obj->sha1),
414                                 request->curl_result, request->http_code);
415                         request->state = ABORTED;
416                         aborted = 1;
417                 }
418         } else if (request->state == RUN_MOVE) {
419                 if (request->curl_result == CURLE_OK) {
420                         fprintf(stderr, "    sent %s\n",
421                                 sha1_to_hex(request->obj->sha1));
422                         request->state = COMPLETE;
423                         request->obj->flags |= REMOTE;
424                         release_request(request);
425                 } else {
426                         fprintf(stderr, "MOVE %s failed, aborting (%d/%ld)\n",
427                                 sha1_to_hex(request->obj->sha1),
428                                 request->curl_result, request->http_code);
429                         request->state = ABORTED;
430                         aborted = 1;
431                 }
432         }
433 }
434
435 void fill_active_slots(void)
436 {
437         struct transfer_request *request = request_queue_head;
438         struct active_request_slot *slot = active_queue_head;
439         int num_transfers;
440
441         if (aborted)
442                 return;
443
444         while (active_requests < max_requests && request != NULL) {
445                 if (pushing && request->state == NEED_PUSH) {
446                         if (remote_dir_exists[request->obj->sha1[0]] == 1) {
447                                 start_put(request);
448                         } else {
449                                 start_mkcol(request);
450                         }
451                         curl_multi_perform(curlm, &num_transfers);
452                 }
453                 request = request->next;
454         }
455
456         while (slot != NULL) {
457                 if (!slot->in_use && slot->curl != NULL) {
458                         curl_easy_cleanup(slot->curl);
459                         slot->curl = NULL;
460                 }
461                 slot = slot->next;
462         }
463 }
464
465 static void get_remote_object_list(unsigned char parent);
466
467 static void add_request(struct object *obj, struct remote_lock *lock)
468 {
469         struct transfer_request *request = request_queue_head;
470         struct packed_git *target;
471
472         /*
473          * Don't push the object if it's known to exist on the remote
474          * or is already in the request queue
475          */
476         if (remote_dir_exists[obj->sha1[0]] == -1)
477                 get_remote_object_list(obj->sha1[0]);
478         if (obj->flags & (REMOTE | PUSHING))
479                 return;
480         target = find_sha1_pack(obj->sha1, remote->packs);
481         if (target) {
482                 obj->flags |= REMOTE;
483                 return;
484         }
485
486         obj->flags |= PUSHING;
487         request = xmalloc(sizeof(*request));
488         request->obj = obj;
489         request->url = NULL;
490         request->lock = lock;
491         request->headers = NULL;
492         request->state = NEED_PUSH;
493         request->next = request_queue_head;
494         request_queue_head = request;
495
496         fill_active_slots();
497         step_active_slots();
498 }
499
500 static int fetch_index(unsigned char *sha1)
501 {
502         char *hex = sha1_to_hex(sha1);
503         char *filename;
504         char *url;
505         char tmpfile[PATH_MAX];
506         long prev_posn = 0;
507         char range[RANGE_HEADER_SIZE];
508         struct curl_slist *range_header = NULL;
509
510         FILE *indexfile;
511         struct active_request_slot *slot;
512
513         /* Don't use the index if the pack isn't there */
514         url = xmalloc(strlen(remote->url) + 65);
515         sprintf(url, "%s/objects/pack/pack-%s.pack", remote->url, hex);
516         slot = get_active_slot();
517         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
518         curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
519         if (start_active_slot(slot)) {
520                 run_active_slot(slot);
521                 if (slot->curl_result != CURLE_OK) {
522                         free(url);
523                         return error("Unable to verify pack %s is available",
524                                      hex);
525                 }
526         } else {
527                 return error("Unable to start request");
528         }
529
530         if (has_pack_index(sha1))
531                 return 0;
532
533         if (push_verbosely)
534                 fprintf(stderr, "Getting index for pack %s\n", hex);
535         
536         sprintf(url, "%s/objects/pack/pack-%s.idx", remote->url, hex);
537         
538         filename = sha1_pack_index_name(sha1);
539         snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
540         indexfile = fopen(tmpfile, "a");
541         if (!indexfile)
542                 return error("Unable to open local file %s for pack index",
543                              filename);
544
545         slot = get_active_slot();
546         curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
547         curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
548         curl_easy_setopt(slot->curl, CURLOPT_FILE, indexfile);
549         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
550         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
551         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
552         slot->local = indexfile;
553
554         /* If there is data present from a previous transfer attempt,
555            resume where it left off */
556         prev_posn = ftell(indexfile);
557         if (prev_posn>0) {
558                 if (push_verbosely)
559                         fprintf(stderr,
560                                 "Resuming fetch of index for pack %s at byte %ld\n",
561                                 hex, prev_posn);
562                 sprintf(range, "Range: bytes=%ld-", prev_posn);
563                 range_header = curl_slist_append(range_header, range);
564                 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
565         }
566
567         if (start_active_slot(slot)) {
568                 run_active_slot(slot);
569                 if (slot->curl_result != CURLE_OK) {
570                         free(url);
571                         fclose(indexfile);
572                         return error("Unable to get pack index %s\n%s", url,
573                                      curl_errorstr);
574                 }
575         } else {
576                 free(url);
577                 fclose(indexfile);
578                 return error("Unable to start request");
579         }
580
581         free(url);
582         fclose(indexfile);
583
584         return move_temp_to_file(tmpfile, filename);
585 }
586
587 static int setup_index(unsigned char *sha1)
588 {
589         struct packed_git *new_pack;
590
591         if (fetch_index(sha1))
592                 return -1;
593
594         new_pack = parse_pack_index(sha1);
595         new_pack->next = remote->packs;
596         remote->packs = new_pack;
597         return 0;
598 }
599
600 static int fetch_indices(void)
601 {
602         unsigned char sha1[20];
603         char *url;
604         struct buffer buffer;
605         char *data;
606         int i = 0;
607
608         struct active_request_slot *slot;
609
610         data = xmalloc(4096);
611         memset(data, 0, 4096);
612         buffer.size = 4096;
613         buffer.posn = 0;
614         buffer.buffer = data;
615
616         if (push_verbosely)
617                 fprintf(stderr, "Getting pack list\n");
618         
619         url = xmalloc(strlen(remote->url) + 21);
620         sprintf(url, "%s/objects/info/packs", remote->url);
621
622         slot = get_active_slot();
623         curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
624         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
625         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
626         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
627         if (start_active_slot(slot)) {
628                 run_active_slot(slot);
629                 if (slot->curl_result != CURLE_OK) {
630                         free(buffer.buffer);
631                         free(url);
632                         if (slot->http_code == 404)
633                                 return 0;
634                         else
635                                 return error("%s", curl_errorstr);
636                 }
637         } else {
638                 free(buffer.buffer);
639                 free(url);
640                 return error("Unable to start request");
641         }
642         free(url);
643
644         data = buffer.buffer;
645         while (i < buffer.posn) {
646                 switch (data[i]) {
647                 case 'P':
648                         i++;
649                         if (i + 52 < buffer.posn &&
650                             !strncmp(data + i, " pack-", 6) &&
651                             !strncmp(data + i + 46, ".pack\n", 6)) {
652                                 get_sha1_hex(data + i + 6, sha1);
653                                 setup_index(sha1);
654                                 i += 51;
655                                 break;
656                         }
657                 default:
658                         while (data[i] != '\n')
659                                 i++;
660                 }
661                 i++;
662         }
663
664         free(buffer.buffer);
665         return 0;
666 }
667
668 static inline int needs_quote(int ch)
669 {
670         switch (ch) {
671         case '/': case '-': case '.':
672         case 'A'...'Z': case 'a'...'z': case '0'...'9':
673                 return 0;
674         default:
675                 return 1;
676         }
677 }
678
679 static inline int hex(int v)
680 {
681         if (v < 10) return '0' + v;
682         else return 'A' + v - 10;
683 }
684
685 static char *quote_ref_url(const char *base, const char *ref)
686 {
687         const char *cp;
688         char *dp, *qref;
689         int len, baselen, ch;
690
691         baselen = strlen(base);
692         len = baselen + 1;
693         for (cp = ref; (ch = *cp) != 0; cp++, len++)
694                 if (needs_quote(ch))
695                         len += 2; /* extra two hex plus replacement % */
696         qref = xmalloc(len);
697         memcpy(qref, base, baselen);
698         for (cp = ref, dp = qref + baselen; (ch = *cp) != 0; cp++) {
699                 if (needs_quote(ch)) {
700                         *dp++ = '%';
701                         *dp++ = hex((ch >> 4) & 0xF);
702                         *dp++ = hex(ch & 0xF);
703                 }
704                 else
705                         *dp++ = ch;
706         }
707         *dp = 0;
708
709         return qref;
710 }
711
712 int fetch_ref(char *ref, unsigned char *sha1)
713 {
714         char *url;
715         char hex[42];
716         struct buffer buffer;
717         char *base = remote->url;
718         struct active_request_slot *slot;
719         buffer.size = 41;
720         buffer.posn = 0;
721         buffer.buffer = hex;
722         hex[41] = '\0';
723         
724         url = quote_ref_url(base, ref);
725         slot = get_active_slot();
726         curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
727         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
728         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
729         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
730         if (start_active_slot(slot)) {
731                 run_active_slot(slot);
732                 if (slot->curl_result != CURLE_OK)
733                         return error("Couldn't get %s for %s\n%s",
734                                      url, ref, curl_errorstr);
735         } else {
736                 return error("Unable to start request");
737         }
738
739         hex[40] = '\0';
740         get_sha1_hex(hex, sha1);
741         return 0;
742 }
743
744 static void one_remote_object(const char *hex)
745 {
746         unsigned char sha1[20];
747         struct object *obj;
748
749         if (get_sha1_hex(hex, sha1) != 0)
750                 return;
751
752         obj = lookup_object(sha1);
753         if (!obj)
754                 obj = parse_object(sha1);
755
756         /* Ignore remote objects that don't exist locally */
757         if (!obj)
758                 return;
759
760         obj->flags |= REMOTE;
761         if (!object_list_contains(objects, obj))
762                 add_object(obj, &objects, NULL, "");
763 }
764
765 static void handle_lockprop_ctx(struct xml_ctx *ctx, int tag_closed)
766 {
767         int *lock_flags = (int *)ctx->userData;
768
769         if (tag_closed) {
770                 if (!strcmp(ctx->name, DAV_CTX_LOCKENTRY)) {
771                         if ((*lock_flags & DAV_PROP_LOCKEX) &&
772                             (*lock_flags & DAV_PROP_LOCKWR)) {
773                                 *lock_flags |= DAV_LOCK_OK;
774                         }
775                         *lock_flags &= DAV_LOCK_OK;
776                 } else if (!strcmp(ctx->name, DAV_CTX_LOCKTYPE_WRITE)) {
777                         *lock_flags |= DAV_PROP_LOCKWR;
778                 } else if (!strcmp(ctx->name, DAV_CTX_LOCKTYPE_EXCLUSIVE)) {
779                         *lock_flags |= DAV_PROP_LOCKEX;
780                 }
781         }
782 }
783
784 static void handle_new_lock_ctx(struct xml_ctx *ctx, int tag_closed)
785 {
786         struct remote_lock *lock = (struct remote_lock *)ctx->userData;
787
788         if (tag_closed && ctx->cdata) {
789                 if (!strcmp(ctx->name, DAV_ACTIVELOCK_OWNER)) {
790                         lock->owner = xmalloc(strlen(ctx->cdata) + 1);
791                         strcpy(lock->owner, ctx->cdata);
792                 } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TIMEOUT)) {
793                         if (!strncmp(ctx->cdata, "Second-", 7))
794                                 lock->timeout =
795                                         strtol(ctx->cdata + 7, NULL, 10);
796                 } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TOKEN)) {
797                         if (!strncmp(ctx->cdata, "opaquelocktoken:", 16)) {
798                                 lock->token = xmalloc(strlen(ctx->cdata) - 15);
799                                 strcpy(lock->token, ctx->cdata + 16);
800                         }
801                 }
802         }
803 }
804
805 static void one_remote_ref(char *refname);
806 static void crawl_remote_refs(char *path);
807
808 static void handle_crawl_ref_ctx(struct xml_ctx *ctx, int tag_closed)
809 {
810         struct remote_dentry *dentry = (struct remote_dentry *)ctx->userData;
811
812
813         if (tag_closed) {
814                 if (!strcmp(ctx->name, DAV_PROPFIND_RESP) && dentry->name) {
815                         if (dentry->is_dir) {
816                                 if (strcmp(dentry->name, dentry->base)) {
817                                         crawl_remote_refs(dentry->name);
818                                 }
819                         } else {
820                                 one_remote_ref(dentry->name);
821                         }
822                 } else if (!strcmp(ctx->name, DAV_PROPFIND_NAME) && ctx->cdata) {
823                         dentry->name = xmalloc(strlen(ctx->cdata) -
824                                                remote->path_len + 1);
825                         strcpy(dentry->name,
826                                ctx->cdata + remote->path_len);
827                 } else if (!strcmp(ctx->name, DAV_PROPFIND_COLLECTION)) {
828                         dentry->is_dir = 1;
829                 }
830         } else if (!strcmp(ctx->name, DAV_PROPFIND_RESP)) {
831                 dentry->name = NULL;
832                 dentry->is_dir = 0;
833         }
834 }
835
836 static void handle_remote_object_list_ctx(struct xml_ctx *ctx, int tag_closed)
837 {
838         char *path;
839         char *obj_hex;
840
841         if (tag_closed) {
842                 if (!strcmp(ctx->name, DAV_PROPFIND_NAME) && ctx->cdata) {
843                         path = ctx->cdata + remote->path_len;
844                         if (strlen(path) != 50)
845                                 return;
846                         path += 9;
847                         obj_hex = xmalloc(strlen(path));
848                         strncpy(obj_hex, path, 2);
849                         strcpy(obj_hex + 2, path + 3);
850                         one_remote_object(obj_hex);
851                         free(obj_hex);
852                 }
853         }
854 }
855
856 static void
857 xml_start_tag(void *userData, const char *name, const char **atts)
858 {
859         struct xml_ctx *ctx = (struct xml_ctx *)userData;
860         const char *c = index(name, ':');
861         int new_len;
862
863         if (c == NULL)
864                 c = name;
865         else
866                 c++;
867
868         new_len = strlen(ctx->name) + strlen(c) + 2;
869
870         if (new_len > ctx->len) {
871                 ctx->name = xrealloc(ctx->name, new_len);
872                 ctx->len = new_len;
873         }
874         strcat(ctx->name, ".");
875         strcat(ctx->name, c);
876
877         if (ctx->cdata) {
878                 free(ctx->cdata);
879                 ctx->cdata = NULL;
880         }
881
882         ctx->userFunc(ctx, 0);
883 }
884
885 static void
886 xml_end_tag(void *userData, const char *name)
887 {
888         struct xml_ctx *ctx = (struct xml_ctx *)userData;
889         const char *c = index(name, ':');
890         char *ep;
891
892         ctx->userFunc(ctx, 1);
893
894         if (c == NULL)
895                 c = name;
896         else
897                 c++;
898
899         ep = ctx->name + strlen(ctx->name) - strlen(c) - 1;
900         *ep = 0;
901 }
902
903 static void
904 xml_cdata(void *userData, const XML_Char *s, int len)
905 {
906         struct xml_ctx *ctx = (struct xml_ctx *)userData;
907         if (ctx->cdata)
908                 free(ctx->cdata);
909         ctx->cdata = xcalloc(len+1, 1);
910         strncpy(ctx->cdata, s, len);
911 }
912
913 static struct remote_lock *lock_remote(char *path, long timeout)
914 {
915         struct active_request_slot *slot;
916         struct buffer out_buffer;
917         struct buffer in_buffer;
918         char *out_data;
919         char *in_data;
920         char *url;
921         char *ep;
922         char timeout_header[25];
923         struct remote_lock *lock = remote_locks;
924         XML_Parser parser = XML_ParserCreate(NULL);
925         enum XML_Status result;
926         struct curl_slist *dav_headers = NULL;
927         struct xml_ctx ctx;
928
929         url = xmalloc(strlen(remote->url) + strlen(path) + 1);
930         sprintf(url, "%s%s", remote->url, path);
931
932         /* Make sure the url is not already locked */
933         while (lock && strcmp(lock->url, url)) {
934                 lock = lock->next;
935         }
936         if (lock) {
937                 free(url);
938                 if (refresh_lock(lock))
939                         return lock;
940                 else
941                         return NULL;
942         }
943
944         /* Make sure leading directories exist for the remote ref */
945         ep = strchr(url + strlen(remote->url) + 11, '/');
946         while (ep) {
947                 *ep = 0;
948                 slot = get_active_slot();
949                 curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
950                 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
951                 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MKCOL);
952                 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
953                 if (start_active_slot(slot)) {
954                         run_active_slot(slot);
955                         if (slot->curl_result != CURLE_OK &&
956                             slot->http_code != 405) {
957                                 fprintf(stderr,
958                                         "Unable to create branch path %s\n",
959                                         url);
960                                 free(url);
961                                 return NULL;
962                         }
963                 } else {
964                         fprintf(stderr, "Unable to start request\n");
965                         free(url);
966                         return NULL;
967                 }
968                 *ep = '/';
969                 ep = strchr(ep + 1, '/');
970         }
971
972         out_buffer.size = strlen(LOCK_REQUEST) + strlen(git_default_email) - 2;
973         out_data = xmalloc(out_buffer.size + 1);
974         snprintf(out_data, out_buffer.size + 1, LOCK_REQUEST, git_default_email);
975         out_buffer.posn = 0;
976         out_buffer.buffer = out_data;
977
978         in_buffer.size = 4096;
979         in_data = xmalloc(in_buffer.size);
980         in_buffer.posn = 0;
981         in_buffer.buffer = in_data;
982
983         sprintf(timeout_header, "Timeout: Second-%ld", timeout);
984         dav_headers = curl_slist_append(dav_headers, timeout_header);
985         dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
986
987         slot = get_active_slot();
988         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
989         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
990         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
991         curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
992         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
993         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
994         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
995         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
996         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
997
998         lock = xcalloc(1, sizeof(*lock));
999         lock->owner = NULL;
1000         lock->token = NULL;
1001         lock->timeout = -1;
1002         lock->refreshing = 0;
1003
1004         if (start_active_slot(slot)) {
1005                 run_active_slot(slot);
1006                 if (slot->curl_result == CURLE_OK) {
1007                         ctx.name = xcalloc(10, 1);
1008                         ctx.len = 0;
1009                         ctx.cdata = NULL;
1010                         ctx.userFunc = handle_new_lock_ctx;
1011                         ctx.userData = lock;
1012                         XML_SetUserData(parser, &ctx);
1013                         XML_SetElementHandler(parser, xml_start_tag,
1014                                               xml_end_tag);
1015                         XML_SetCharacterDataHandler(parser, xml_cdata);
1016                         result = XML_Parse(parser, in_buffer.buffer,
1017                                            in_buffer.posn, 1);
1018                         free(ctx.name);
1019                         if (result != XML_STATUS_OK) {
1020                                 fprintf(stderr, "XML error: %s\n",
1021                                         XML_ErrorString(
1022                                                 XML_GetErrorCode(parser)));
1023                                 lock->timeout = -1;
1024                         }
1025                 }
1026         } else {
1027                 fprintf(stderr, "Unable to start request\n");
1028         }
1029
1030         curl_slist_free_all(dav_headers);
1031         free(out_data);
1032         free(in_data);
1033
1034         if (lock->token == NULL || lock->timeout <= 0) {
1035                 if (lock->token != NULL)
1036                         free(lock->token);
1037                 if (lock->owner != NULL)
1038                         free(lock->owner);
1039                 free(url);
1040                 free(lock);
1041                 lock = NULL;
1042         } else {
1043                 lock->url = url;
1044                 lock->active = 1;
1045                 lock->start_time = time(NULL);
1046                 lock->next = remote_locks;
1047                 remote_locks = lock;
1048         }
1049
1050         return lock;
1051 }
1052
1053 static int unlock_remote(struct remote_lock *lock)
1054 {
1055         struct active_request_slot *slot;
1056         char *lock_token_header;
1057         struct curl_slist *dav_headers = NULL;
1058         int rc = 0;
1059
1060         lock_token_header = xmalloc(strlen(lock->token) + 31);
1061         sprintf(lock_token_header, "Lock-Token: <opaquelocktoken:%s>",
1062                 lock->token);
1063         dav_headers = curl_slist_append(dav_headers, lock_token_header);
1064
1065         slot = get_active_slot();
1066         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1067         curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
1068         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_UNLOCK);
1069         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1070
1071         if (start_active_slot(slot)) {
1072                 run_active_slot(slot);
1073                 if (slot->curl_result == CURLE_OK)
1074                         rc = 1;
1075                 else
1076                         fprintf(stderr, "Got HTTP error %ld\n",
1077                                 slot->http_code);
1078         } else {
1079                 fprintf(stderr, "Unable to start request\n");
1080         }
1081
1082         curl_slist_free_all(dav_headers);
1083         free(lock_token_header);
1084
1085         lock->active = 0;
1086
1087         return rc;
1088 }
1089
1090 static void crawl_remote_refs(char *path)
1091 {
1092         char *url;
1093         struct active_request_slot *slot;
1094         struct buffer in_buffer;
1095         struct buffer out_buffer;
1096         char *in_data;
1097         char *out_data;
1098         XML_Parser parser = XML_ParserCreate(NULL);
1099         enum XML_Status result;
1100         struct curl_slist *dav_headers = NULL;
1101         struct xml_ctx ctx;
1102         struct remote_dentry dentry;
1103
1104         fprintf(stderr, "  %s\n", path);
1105
1106         dentry.base = path;
1107         dentry.name = NULL;
1108         dentry.is_dir = 0;
1109
1110         url = xmalloc(strlen(remote->url) + strlen(path) + 1);
1111         sprintf(url, "%s%s", remote->url, path);
1112
1113         out_buffer.size = strlen(PROPFIND_ALL_REQUEST);
1114         out_data = xmalloc(out_buffer.size + 1);
1115         snprintf(out_data, out_buffer.size + 1, PROPFIND_ALL_REQUEST);
1116         out_buffer.posn = 0;
1117         out_buffer.buffer = out_data;
1118
1119         in_buffer.size = 4096;
1120         in_data = xmalloc(in_buffer.size);
1121         in_buffer.posn = 0;
1122         in_buffer.buffer = in_data;
1123
1124         dav_headers = curl_slist_append(dav_headers, "Depth: 1");
1125         dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1126
1127         slot = get_active_slot();
1128         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1129         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1130         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1131         curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1132         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1133         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1134         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1135         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
1136         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1137
1138         if (start_active_slot(slot)) {
1139                 run_active_slot(slot);
1140                 if (slot->curl_result == CURLE_OK) {
1141                         ctx.name = xcalloc(10, 1);
1142                         ctx.len = 0;
1143                         ctx.cdata = NULL;
1144                         ctx.userFunc = handle_crawl_ref_ctx;
1145                         ctx.userData = &dentry;
1146                         XML_SetUserData(parser, &ctx);
1147                         XML_SetElementHandler(parser, xml_start_tag,
1148                                               xml_end_tag);
1149                         XML_SetCharacterDataHandler(parser, xml_cdata);
1150                         result = XML_Parse(parser, in_buffer.buffer,
1151                                            in_buffer.posn, 1);
1152                         free(ctx.name);
1153
1154                         if (result != XML_STATUS_OK) {
1155                                 fprintf(stderr, "XML error: %s\n",
1156                                         XML_ErrorString(
1157                                                 XML_GetErrorCode(parser)));
1158                         }
1159                 }
1160         } else {
1161                 fprintf(stderr, "Unable to start request\n");
1162         }
1163
1164         free(url);
1165         free(out_data);
1166         free(in_buffer.buffer);
1167         curl_slist_free_all(dav_headers);
1168 }
1169
1170 static void get_remote_object_list(unsigned char parent)
1171 {
1172         char *url;
1173         struct active_request_slot *slot;
1174         struct buffer in_buffer;
1175         struct buffer out_buffer;
1176         char *in_data;
1177         char *out_data;
1178         XML_Parser parser = XML_ParserCreate(NULL);
1179         enum XML_Status result;
1180         struct curl_slist *dav_headers = NULL;
1181         struct xml_ctx ctx;
1182         char path[] = "/objects/XX/";
1183         static const char hex[] = "0123456789abcdef";
1184         unsigned int val = parent;
1185
1186         path[9] = hex[val >> 4];
1187         path[10] = hex[val & 0xf];
1188         url = xmalloc(strlen(remote->url) + strlen(path) + 1);
1189         sprintf(url, "%s%s", remote->url, path);
1190
1191         out_buffer.size = strlen(PROPFIND_ALL_REQUEST);
1192         out_data = xmalloc(out_buffer.size + 1);
1193         snprintf(out_data, out_buffer.size + 1, PROPFIND_ALL_REQUEST);
1194         out_buffer.posn = 0;
1195         out_buffer.buffer = out_data;
1196
1197         in_buffer.size = 4096;
1198         in_data = xmalloc(in_buffer.size);
1199         in_buffer.posn = 0;
1200         in_buffer.buffer = in_data;
1201
1202         dav_headers = curl_slist_append(dav_headers, "Depth: 1");
1203         dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1204
1205         slot = get_active_slot();
1206         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1207         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1208         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1209         curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1210         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1211         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1212         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1213         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
1214         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1215
1216         if (start_active_slot(slot)) {
1217                 run_active_slot(slot);
1218                 if (slot->curl_result == CURLE_OK) {
1219                         remote_dir_exists[parent] = 1;
1220                         ctx.name = xcalloc(10, 1);
1221                         ctx.len = 0;
1222                         ctx.cdata = NULL;
1223                         ctx.userFunc = handle_remote_object_list_ctx;
1224                         XML_SetUserData(parser, &ctx);
1225                         XML_SetElementHandler(parser, xml_start_tag,
1226                                               xml_end_tag);
1227                         XML_SetCharacterDataHandler(parser, xml_cdata);
1228                         result = XML_Parse(parser, in_buffer.buffer,
1229                                            in_buffer.posn, 1);
1230                         free(ctx.name);
1231
1232                         if (result != XML_STATUS_OK) {
1233                                 fprintf(stderr, "XML error: %s\n",
1234                                         XML_ErrorString(
1235                                                 XML_GetErrorCode(parser)));
1236                         }
1237                 } else {
1238                         remote_dir_exists[parent] = 0;
1239                 }
1240         } else {
1241                 fprintf(stderr, "Unable to start request\n");
1242         }
1243
1244         free(url);
1245         free(out_data);
1246         free(in_buffer.buffer);
1247         curl_slist_free_all(dav_headers);
1248 }
1249
1250 static int locking_available(void)
1251 {
1252         struct active_request_slot *slot;
1253         struct buffer in_buffer;
1254         struct buffer out_buffer;
1255         char *in_data;
1256         char *out_data;
1257         XML_Parser parser = XML_ParserCreate(NULL);
1258         enum XML_Status result;
1259         struct curl_slist *dav_headers = NULL;
1260         struct xml_ctx ctx;
1261         int lock_flags = 0;
1262
1263         out_buffer.size =
1264                 strlen(PROPFIND_SUPPORTEDLOCK_REQUEST) +
1265                 strlen(remote->url) - 2;
1266         out_data = xmalloc(out_buffer.size + 1);
1267         snprintf(out_data, out_buffer.size + 1,
1268                  PROPFIND_SUPPORTEDLOCK_REQUEST, remote->url);
1269         out_buffer.posn = 0;
1270         out_buffer.buffer = out_data;
1271
1272         in_buffer.size = 4096;
1273         in_data = xmalloc(in_buffer.size);
1274         in_buffer.posn = 0;
1275         in_buffer.buffer = in_data;
1276
1277         dav_headers = curl_slist_append(dav_headers, "Depth: 0");
1278         dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1279         
1280         slot = get_active_slot();
1281         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1282         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1283         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1284         curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1285         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1286         curl_easy_setopt(slot->curl, CURLOPT_URL, remote->url);
1287         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1288         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
1289         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1290
1291         if (start_active_slot(slot)) {
1292                 run_active_slot(slot);
1293                 if (slot->curl_result == CURLE_OK) {
1294                         ctx.name = xcalloc(10, 1);
1295                         ctx.len = 0;
1296                         ctx.cdata = NULL;
1297                         ctx.userFunc = handle_lockprop_ctx;
1298                         ctx.userData = &lock_flags;
1299                         XML_SetUserData(parser, &ctx);
1300                         XML_SetElementHandler(parser, xml_start_tag,
1301                                               xml_end_tag);
1302                         result = XML_Parse(parser, in_buffer.buffer,
1303                                            in_buffer.posn, 1);
1304                         free(ctx.name);
1305
1306                         if (result != XML_STATUS_OK) {
1307                                 fprintf(stderr, "XML error: %s\n",
1308                                         XML_ErrorString(
1309                                                 XML_GetErrorCode(parser)));
1310                                 lock_flags = 0;
1311                         }
1312                 }
1313         } else {
1314                 fprintf(stderr, "Unable to start request\n");
1315         }
1316
1317         free(out_data);
1318         free(in_buffer.buffer);
1319         curl_slist_free_all(dav_headers);
1320
1321         return lock_flags;
1322 }
1323
1324 static struct object_list **process_blob(struct blob *blob,
1325                                          struct object_list **p,
1326                                          struct name_path *path,
1327                                          const char *name)
1328 {
1329         struct object *obj = &blob->object;
1330
1331         obj->flags |= LOCAL;
1332
1333         if (obj->flags & (UNINTERESTING | SEEN))
1334                 return p;
1335
1336         obj->flags |= SEEN;
1337         return add_object(obj, p, path, name);
1338 }
1339
1340 static struct object_list **process_tree(struct tree *tree,
1341                                          struct object_list **p,
1342                                          struct name_path *path,
1343                                          const char *name)
1344 {
1345         struct object *obj = &tree->object;
1346         struct tree_entry_list *entry;
1347         struct name_path me;
1348
1349         obj->flags |= LOCAL;
1350
1351         if (obj->flags & (UNINTERESTING | SEEN))
1352                 return p;
1353         if (parse_tree(tree) < 0)
1354                 die("bad tree object %s", sha1_to_hex(obj->sha1));
1355
1356         obj->flags |= SEEN;
1357         p = add_object(obj, p, NULL, name);
1358         me.up = path;
1359         me.elem = name;
1360         me.elem_len = strlen(name);
1361         entry = tree->entries;
1362         tree->entries = NULL;
1363         while (entry) {
1364                 struct tree_entry_list *next = entry->next;
1365                 if (entry->directory)
1366                         p = process_tree(entry->item.tree, p, &me, entry->name);
1367                 else
1368                         p = process_blob(entry->item.blob, p, &me, entry->name);
1369                 free(entry);
1370                 entry = next;
1371         }
1372         return p;
1373 }
1374
1375 static void get_delta(struct rev_info *revs, struct remote_lock *lock)
1376 {
1377         struct commit *commit;
1378         struct object_list **p = &objects, *pending;
1379
1380         while ((commit = get_revision(revs)) != NULL) {
1381                 p = process_tree(commit->tree, p, NULL, "");
1382                 commit->object.flags |= LOCAL;
1383                 if (!(commit->object.flags & UNINTERESTING))
1384                         add_request(&commit->object, lock);
1385         }
1386
1387         for (pending = revs->pending_objects; pending; pending = pending->next) {
1388                 struct object *obj = pending->item;
1389                 const char *name = pending->name;
1390
1391                 if (obj->flags & (UNINTERESTING | SEEN))
1392                         continue;
1393                 if (obj->type == tag_type) {
1394                         obj->flags |= SEEN;
1395                         p = add_object(obj, p, NULL, name);
1396                         continue;
1397                 }
1398                 if (obj->type == tree_type) {
1399                         p = process_tree((struct tree *)obj, p, NULL, name);
1400                         continue;
1401                 }
1402                 if (obj->type == blob_type) {
1403                         p = process_blob((struct blob *)obj, p, NULL, name);
1404                         continue;
1405                 }
1406                 die("unknown pending object %s (%s)", sha1_to_hex(obj->sha1), name);
1407         }
1408
1409         while (objects) {
1410                 if (!(objects->item->flags & UNINTERESTING))
1411                         add_request(objects->item, lock);
1412                 objects = objects->next;
1413         }
1414 }
1415
1416 static int update_remote(unsigned char *sha1, struct remote_lock *lock)
1417 {
1418         struct active_request_slot *slot;
1419         char *out_data;
1420         char *if_header;
1421         struct buffer out_buffer;
1422         struct curl_slist *dav_headers = NULL;
1423         int i;
1424
1425         if_header = xmalloc(strlen(lock->token) + 25);
1426         sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
1427         dav_headers = curl_slist_append(dav_headers, if_header);
1428
1429         out_buffer.size = 41;
1430         out_data = xmalloc(out_buffer.size + 1);
1431         i = snprintf(out_data, out_buffer.size + 1, "%s\n", sha1_to_hex(sha1));
1432         if (i != out_buffer.size) {
1433                 fprintf(stderr, "Unable to initialize PUT request body\n");
1434                 return 0;
1435         }
1436         out_buffer.posn = 0;
1437         out_buffer.buffer = out_data;
1438
1439         slot = get_active_slot();
1440         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1441         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1442         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1443         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1444         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
1445         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1446         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1447         curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
1448         curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
1449
1450         if (start_active_slot(slot)) {
1451                 run_active_slot(slot);
1452                 free(out_data);
1453                 free(if_header);
1454                 if (slot->curl_result != CURLE_OK) {
1455                         fprintf(stderr,
1456                                 "PUT error: curl result=%d, HTTP code=%ld\n",
1457                                 slot->curl_result, slot->http_code);
1458                         /* We should attempt recovery? */
1459                         return 0;
1460                 }
1461         } else {
1462                 free(out_data);
1463                 free(if_header);
1464                 fprintf(stderr, "Unable to start PUT request\n");
1465                 return 0;
1466         }
1467
1468         return 1;
1469 }
1470
1471 static struct ref *local_refs, **local_tail;
1472 static struct ref *remote_refs, **remote_tail;
1473
1474 static int one_local_ref(const char *refname, const unsigned char *sha1)
1475 {
1476         struct ref *ref;
1477         int len = strlen(refname) + 1;
1478         ref = xcalloc(1, sizeof(*ref) + len);
1479         memcpy(ref->new_sha1, sha1, 20);
1480         memcpy(ref->name, refname, len);
1481         *local_tail = ref;
1482         local_tail = &ref->next;
1483         return 0;
1484 }
1485
1486 static void one_remote_ref(char *refname)
1487 {
1488         struct ref *ref;
1489         unsigned char remote_sha1[20];
1490
1491         if (fetch_ref(refname, remote_sha1) != 0) {
1492                 fprintf(stderr,
1493                         "Unable to fetch ref %s from %s\n",
1494                         refname, remote->url);
1495                 return;
1496         }
1497
1498         int len = strlen(refname) + 1;
1499         ref = xcalloc(1, sizeof(*ref) + len);
1500         memcpy(ref->old_sha1, remote_sha1, 20);
1501         memcpy(ref->name, refname, len);
1502         *remote_tail = ref;
1503         remote_tail = &ref->next;
1504 }
1505
1506 static void get_local_heads(void)
1507 {
1508         local_tail = &local_refs;
1509         for_each_ref(one_local_ref);
1510 }
1511
1512 static void get_dav_remote_heads(void)
1513 {
1514         remote_tail = &remote_refs;
1515         crawl_remote_refs("refs/");
1516 }
1517
1518 static int is_zero_sha1(const unsigned char *sha1)
1519 {
1520         int i;
1521
1522         for (i = 0; i < 20; i++) {
1523                 if (*sha1++)
1524                         return 0;
1525         }
1526         return 1;
1527 }
1528
1529 static void unmark_and_free(struct commit_list *list, unsigned int mark)
1530 {
1531         while (list) {
1532                 struct commit_list *temp = list;
1533                 temp->item->object.flags &= ~mark;
1534                 list = temp->next;
1535                 free(temp);
1536         }
1537 }
1538
1539 static int ref_newer(const unsigned char *new_sha1,
1540                      const unsigned char *old_sha1)
1541 {
1542         struct object *o;
1543         struct commit *old, *new;
1544         struct commit_list *list, *used;
1545         int found = 0;
1546
1547         /* Both new and old must be commit-ish and new is descendant of
1548          * old.  Otherwise we require --force.
1549          */
1550         o = deref_tag(parse_object(old_sha1), NULL, 0);
1551         if (!o || o->type != commit_type)
1552                 return 0;
1553         old = (struct commit *) o;
1554
1555         o = deref_tag(parse_object(new_sha1), NULL, 0);
1556         if (!o || o->type != commit_type)
1557                 return 0;
1558         new = (struct commit *) o;
1559
1560         if (parse_commit(new) < 0)
1561                 return 0;
1562
1563         used = list = NULL;
1564         commit_list_insert(new, &list);
1565         while (list) {
1566                 new = pop_most_recent_commit(&list, TMP_MARK);
1567                 commit_list_insert(new, &used);
1568                 if (new == old) {
1569                         found = 1;
1570                         break;
1571                 }
1572         }
1573         unmark_and_free(list, TMP_MARK);
1574         unmark_and_free(used, TMP_MARK);
1575         return found;
1576 }
1577
1578 static void mark_edge_parents_uninteresting(struct commit *commit)
1579 {
1580         struct commit_list *parents;
1581
1582         for (parents = commit->parents; parents; parents = parents->next) {
1583                 struct commit *parent = parents->item;
1584                 if (!(parent->object.flags & UNINTERESTING))
1585                         continue;
1586                 mark_tree_uninteresting(parent->tree);
1587         }
1588 }
1589
1590 static void mark_edges_uninteresting(struct commit_list *list)
1591 {
1592         for ( ; list; list = list->next) {
1593                 struct commit *commit = list->item;
1594
1595                 if (commit->object.flags & UNINTERESTING) {
1596                         mark_tree_uninteresting(commit->tree);
1597                         continue;
1598                 }
1599                 mark_edge_parents_uninteresting(commit);
1600         }
1601 }
1602
1603 int main(int argc, char **argv)
1604 {
1605         struct transfer_request *request;
1606         struct transfer_request *next_request;
1607         int nr_refspec = 0;
1608         char **refspec = NULL;
1609         struct remote_lock *ref_lock;
1610         struct rev_info revs;
1611         int rc = 0;
1612         int i;
1613
1614         setup_git_directory();
1615         setup_ident();
1616
1617         remote = xmalloc(sizeof(*remote));
1618         remote->url = NULL;
1619         remote->path_len = 0;
1620         remote->packs = NULL;
1621
1622         argv++;
1623         for (i = 1; i < argc; i++, argv++) {
1624                 char *arg = *argv;
1625
1626                 if (*arg == '-') {
1627                         if (!strcmp(arg, "--all")) {
1628                                 push_all = 1;
1629                                 continue;
1630                         }
1631                         if (!strcmp(arg, "--force")) {
1632                                 force_all = 1;
1633                                 continue;
1634                         }
1635                         if (!strcmp(arg, "--verbose")) {
1636                                 push_verbosely = 1;
1637                                 continue;
1638                         }
1639                         usage(http_push_usage);
1640                 }
1641                 if (!remote->url) {
1642                         remote->url = arg;
1643                         char *path = strstr(arg, "//");
1644                         if (path) {
1645                                 path = index(path+2, '/');
1646                                 if (path)
1647                                         remote->path_len = strlen(path);
1648                         }
1649                         continue;
1650                 }
1651                 refspec = argv;
1652                 nr_refspec = argc - i;
1653                 break;
1654         }
1655
1656         if (!remote->url)
1657                 usage(http_push_usage);
1658
1659         memset(remote_dir_exists, -1, 256);
1660
1661         http_init();
1662
1663         no_pragma_header = curl_slist_append(no_pragma_header, "Pragma:");
1664         default_headers = curl_slist_append(default_headers, "Range:");
1665         default_headers = curl_slist_append(default_headers, "Destination:");
1666         default_headers = curl_slist_append(default_headers, "If:");
1667         default_headers = curl_slist_append(default_headers,
1668                                             "Pragma: no-cache");
1669
1670         /* Verify DAV compliance/lock support */
1671         if (!locking_available()) {
1672                 fprintf(stderr, "Error: no DAV locking support on remote repo %s\n", remote->url);
1673                 rc = 1;
1674                 goto cleanup;
1675         }
1676
1677         /* Get a list of all local and remote heads to validate refspecs */
1678         get_local_heads();
1679         fprintf(stderr, "Fetching remote heads...\n");
1680         get_dav_remote_heads();
1681
1682         /* match them up */
1683         if (!remote_tail)
1684                 remote_tail = &remote_refs;
1685         if (match_refs(local_refs, remote_refs, &remote_tail,
1686                        nr_refspec, refspec, push_all))
1687                 return -1;
1688         if (!remote_refs) {
1689                 fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
1690                 return 0;
1691         }
1692
1693         int ret = 0;
1694         int new_refs = 0;
1695         struct ref *ref;
1696         for (ref = remote_refs; ref; ref = ref->next) {
1697                 char old_hex[60], *new_hex;
1698                 if (!ref->peer_ref)
1699                         continue;
1700                 if (!memcmp(ref->old_sha1, ref->peer_ref->new_sha1, 20)) {
1701                         if (push_verbosely || 1)
1702                                 fprintf(stderr, "'%s': up-to-date\n", ref->name);
1703                         continue;
1704                 }
1705
1706                 if (!force_all &&
1707                     !is_zero_sha1(ref->old_sha1) &&
1708                     !ref->force) {
1709                         if (!has_sha1_file(ref->old_sha1) ||
1710                             !ref_newer(ref->peer_ref->new_sha1,
1711                                        ref->old_sha1)) {
1712                                 /* We do not have the remote ref, or
1713                                  * we know that the remote ref is not
1714                                  * an ancestor of what we are trying to
1715                                  * push.  Either way this can be losing
1716                                  * commits at the remote end and likely
1717                                  * we were not up to date to begin with.
1718                                  */
1719                                 error("remote '%s' is not a strict "
1720                                       "subset of local ref '%s'. "
1721                                       "maybe you are not up-to-date and "
1722                                       "need to pull first?",
1723                                       ref->name,
1724                                       ref->peer_ref->name);
1725                                 ret = -2;
1726                                 continue;
1727                         }
1728                 }
1729                 memcpy(ref->new_sha1, ref->peer_ref->new_sha1, 20);
1730                 if (is_zero_sha1(ref->new_sha1)) {
1731                         error("cannot happen anymore");
1732                         ret = -3;
1733                         continue;
1734                 }
1735                 new_refs++;
1736                 strcpy(old_hex, sha1_to_hex(ref->old_sha1));
1737                 new_hex = sha1_to_hex(ref->new_sha1);
1738
1739                 fprintf(stderr, "updating '%s'", ref->name);
1740                 if (strcmp(ref->name, ref->peer_ref->name))
1741                         fprintf(stderr, " using '%s'", ref->peer_ref->name);
1742                 fprintf(stderr, "\n  from %s\n  to   %s\n", old_hex, new_hex);
1743
1744
1745                 /* Lock remote branch ref */
1746                 ref_lock = lock_remote(ref->name, LOCK_TIME);
1747                 if (ref_lock == NULL) {
1748                         fprintf(stderr, "Unable to lock remote branch %s\n",
1749                                 ref->name);
1750                         rc = 1;
1751                         continue;
1752                 }
1753
1754                 /* Set up revision info for this refspec */
1755                 const char *commit_argv[4];
1756                 int commit_argc = 3;
1757                 char *new_sha1_hex = strdup(sha1_to_hex(ref->new_sha1));
1758                 char *old_sha1_hex = NULL;
1759                 commit_argv[1] = "--objects";
1760                 commit_argv[2] = new_sha1_hex;
1761                 if (!push_all && !is_zero_sha1(ref->old_sha1)) {
1762                         old_sha1_hex = xmalloc(42);
1763                         sprintf(old_sha1_hex, "^%s",
1764                                 sha1_to_hex(ref->old_sha1));
1765                         commit_argv[3] = old_sha1_hex;
1766                         commit_argc++;
1767                 }
1768                 setup_revisions(commit_argc, commit_argv, &revs, NULL);
1769                 free(new_sha1_hex);
1770                 if (old_sha1_hex) {
1771                         free(old_sha1_hex);
1772                         commit_argv[1] = NULL;
1773                 }
1774
1775                 /* Generate a list of objects that need to be pushed */
1776                 pushing = 0;
1777                 prepare_revision_walk(&revs);
1778                 mark_edges_uninteresting(revs.commits);
1779                 fetch_indices();
1780                 get_delta(&revs, ref_lock);
1781                 finish_all_active_slots();
1782
1783                 /* Push missing objects to remote, this would be a
1784                    convenient time to pack them first if appropriate. */
1785                 pushing = 1;
1786                 fill_active_slots();
1787                 finish_all_active_slots();
1788
1789                 /* Update the remote branch if all went well */
1790                 if (aborted || !update_remote(ref->new_sha1, ref_lock)) {
1791                         rc = 1;
1792                         goto unlock;
1793                 }
1794
1795         unlock:
1796                 if (!rc)
1797                         fprintf(stderr, "    done\n");
1798                 unlock_remote(ref_lock);
1799         }
1800
1801  cleanup:
1802         free(remote);
1803
1804         curl_slist_free_all(no_pragma_header);
1805         curl_slist_free_all(default_headers);
1806
1807         http_cleanup();
1808
1809         request = request_queue_head;
1810         while (request != NULL) {
1811                 next_request = request->next;
1812                 release_request(request);
1813                 request = next_request;
1814         }
1815
1816         return rc;
1817 }