fe925609b4024119c6171dd32350a6570bea8516
[git.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
9 #include <expat.h>
10
11 static const char http_push_usage[] =
12 "git-http-push [--complete] [--force] [--verbose] <url> <ref> [<ref>...]\n";
13
14 #ifndef XML_STATUS_OK
15 enum XML_Status {
16   XML_STATUS_OK = 1,
17   XML_STATUS_ERROR = 0
18 };
19 #define XML_STATUS_OK    1
20 #define XML_STATUS_ERROR 0
21 #endif
22
23 #define RANGE_HEADER_SIZE 30
24
25 /* DAV methods */
26 #define DAV_LOCK "LOCK"
27 #define DAV_MKCOL "MKCOL"
28 #define DAV_MOVE "MOVE"
29 #define DAV_PROPFIND "PROPFIND"
30 #define DAV_PUT "PUT"
31 #define DAV_UNLOCK "UNLOCK"
32
33 /* DAV lock flags */
34 #define DAV_PROP_LOCKWR (1u << 0)
35 #define DAV_PROP_LOCKEX (1u << 1)
36 #define DAV_LOCK_OK (1u << 2)
37
38 /* DAV XML properties */
39 #define DAV_CTX_LOCKENTRY ".multistatus.response.propstat.prop.supportedlock.lockentry"
40 #define DAV_CTX_LOCKTYPE_WRITE ".multistatus.response.propstat.prop.supportedlock.lockentry.locktype.write"
41 #define DAV_CTX_LOCKTYPE_EXCLUSIVE ".multistatus.response.propstat.prop.supportedlock.lockentry.lockscope.exclusive"
42 #define DAV_ACTIVELOCK_OWNER ".prop.lockdiscovery.activelock.owner.href"
43 #define DAV_ACTIVELOCK_TIMEOUT ".prop.lockdiscovery.activelock.timeout"
44 #define DAV_ACTIVELOCK_TOKEN ".prop.lockdiscovery.activelock.locktoken.href"
45
46 /* DAV request body templates */
47 #define PROPFIND_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>"
48 #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>"
49
50 #define LOCK_TIME 600
51 #define LOCK_REFRESH 30
52
53 static int pushing = 0;
54 static int aborted = 0;
55 static char remote_dir_exists[256];
56
57 static struct curl_slist *no_pragma_header;
58 static struct curl_slist *default_headers;
59
60 static int push_verbosely = 0;
61 static int push_all = 0;
62 static int force_all = 0;
63
64 struct repo
65 {
66         char *url;
67         struct packed_git *packs;
68 };
69
70 static struct repo *remote = NULL;
71
72 enum transfer_state {
73         NEED_CHECK,
74         RUN_HEAD,
75         NEED_PUSH,
76         RUN_MKCOL,
77         RUN_PUT,
78         RUN_MOVE,
79         ABORTED,
80         COMPLETE,
81 };
82
83 struct transfer_request
84 {
85         unsigned char sha1[20];
86         char *url;
87         char *dest;
88         struct active_lock *lock;
89         struct curl_slist *headers;
90         struct buffer buffer;
91         char filename[PATH_MAX];
92         char tmpfile[PATH_MAX];
93         enum transfer_state state;
94         CURLcode curl_result;
95         char errorstr[CURL_ERROR_SIZE];
96         long http_code;
97         unsigned char real_sha1[20];
98         SHA_CTX c;
99         z_stream stream;
100         int zret;
101         int rename;
102         struct active_request_slot *slot;
103         struct transfer_request *next;
104 };
105
106 static struct transfer_request *request_queue_head = NULL;
107
108 struct xml_ctx
109 {
110         char *name;
111         int len;
112         char *cdata;
113         void (*userFunc)(struct xml_ctx *ctx, int tag_closed);
114         void *userData;
115 };
116
117 struct active_lock
118 {
119         char *url;
120         char *owner;
121         char *token;
122         time_t start_time;
123         long timeout;
124         int refreshing;
125 };
126
127 static void finish_request(struct transfer_request *request);
128
129 static void process_response(void *callback_data)
130 {
131         struct transfer_request *request =
132                 (struct transfer_request *)callback_data;
133
134         finish_request(request);
135 }
136
137 static void start_check(struct transfer_request *request)
138 {
139         char *hex = sha1_to_hex(request->sha1);
140         struct active_request_slot *slot;
141         char *posn;
142
143         request->url = xmalloc(strlen(remote->url) + 55);
144         strcpy(request->url, remote->url);
145         posn = request->url + strlen(remote->url);
146         strcpy(posn, "objects/");
147         posn += 8;
148         memcpy(posn, hex, 2);
149         posn += 2;
150         *(posn++) = '/';
151         strcpy(posn, hex + 2);
152
153         slot = get_active_slot();
154         slot->callback_func = process_response;
155         slot->callback_data = request;
156         curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
157         curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
158         curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
159
160         if (start_active_slot(slot)) {
161                 request->slot = slot;
162                 request->state = RUN_HEAD;
163         } else {
164                 request->state = ABORTED;
165                 free(request->url);
166                 request->url = NULL;
167         }
168 }
169
170 static void start_mkcol(struct transfer_request *request)
171 {
172         char *hex = sha1_to_hex(request->sha1);
173         struct active_request_slot *slot;
174         char *posn;
175
176         request->url = xmalloc(strlen(remote->url) + 13);
177         strcpy(request->url, remote->url);
178         posn = request->url + strlen(remote->url);
179         strcpy(posn, "objects/");
180         posn += 8;
181         memcpy(posn, hex, 2);
182         posn += 2;
183         strcpy(posn, "/");
184
185         slot = get_active_slot();
186         slot->callback_func = process_response;
187         slot->callback_data = request;
188         curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
189         curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
190         curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
191         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MKCOL);
192         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
193
194         if (start_active_slot(slot)) {
195                 request->slot = slot;
196                 request->state = RUN_MKCOL;
197         } else {
198                 request->state = ABORTED;
199                 free(request->url);
200                 request->url = NULL;
201         }
202 }
203
204 static void start_put(struct transfer_request *request)
205 {
206         char *hex = sha1_to_hex(request->sha1);
207         struct active_request_slot *slot;
208         char *posn;
209         char type[20];
210         char hdr[50];
211         void *unpacked;
212         unsigned long len;
213         int hdrlen;
214         ssize_t size;
215         z_stream stream;
216
217         unpacked = read_sha1_file(request->sha1, type, &len);
218         hdrlen = sprintf(hdr, "%s %lu", type, len) + 1;
219
220         /* Set it up */
221         memset(&stream, 0, sizeof(stream));
222         deflateInit(&stream, Z_BEST_COMPRESSION);
223         size = deflateBound(&stream, len + hdrlen);
224         request->buffer.buffer = xmalloc(size);
225
226         /* Compress it */
227         stream.next_out = request->buffer.buffer;
228         stream.avail_out = size;
229
230         /* First header.. */
231         stream.next_in = (void *)hdr;
232         stream.avail_in = hdrlen;
233         while (deflate(&stream, 0) == Z_OK)
234                 /* nothing */;
235
236         /* Then the data itself.. */
237         stream.next_in = unpacked;
238         stream.avail_in = len;
239         while (deflate(&stream, Z_FINISH) == Z_OK)
240                 /* nothing */;
241         deflateEnd(&stream);
242         free(unpacked);
243
244         request->buffer.size = stream.total_out;
245         request->buffer.posn = 0;
246
247         request->url = xmalloc(strlen(remote->url) + 
248                                strlen(request->lock->token) + 51);
249         strcpy(request->url, remote->url);
250         posn = request->url + strlen(remote->url);
251         strcpy(posn, "objects/");
252         posn += 8;
253         memcpy(posn, hex, 2);
254         posn += 2;
255         *(posn++) = '/';
256         strcpy(posn, hex + 2);
257         request->dest = xmalloc(strlen(request->url) + 14);
258         sprintf(request->dest, "Destination: %s", request->url);
259         posn += 38;
260         *(posn++) = '.';
261         strcpy(posn, request->lock->token);
262
263         slot = get_active_slot();
264         slot->callback_func = process_response;
265         slot->callback_data = request;
266         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &request->buffer);
267         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, request->buffer.size);
268         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
269         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
270         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
271         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
272         curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
273         curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
274         curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
275
276         if (start_active_slot(slot)) {
277                 request->slot = slot;
278                 request->state = RUN_PUT;
279         } else {
280                 request->state = ABORTED;
281                 free(request->url);
282                 request->url = NULL;
283         }
284 }
285
286 static void start_move(struct transfer_request *request)
287 {
288         struct active_request_slot *slot;
289         struct curl_slist *dav_headers = NULL;
290
291         slot = get_active_slot();
292         slot->callback_func = process_response;
293         slot->callback_data = request;
294         curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
295         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MOVE);
296         dav_headers = curl_slist_append(dav_headers, request->dest);
297         dav_headers = curl_slist_append(dav_headers, "Overwrite: T");
298         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
299         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
300         curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
301
302         if (start_active_slot(slot)) {
303                 request->slot = slot;
304                 request->state = RUN_MOVE;
305         } else {
306                 request->state = ABORTED;
307                 free(request->url);
308                 request->url = NULL;
309         }
310 }
311
312 static int refresh_lock(struct active_lock *lock)
313 {
314         struct active_request_slot *slot;
315         char *if_header;
316         char timeout_header[25];
317         struct curl_slist *dav_headers = NULL;
318         int rc = 0;
319
320         lock->refreshing = 1;
321
322         if_header = xmalloc(strlen(lock->token) + 25);
323         sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
324         sprintf(timeout_header, "Timeout: Second-%ld", lock->timeout);
325         dav_headers = curl_slist_append(dav_headers, if_header);
326         dav_headers = curl_slist_append(dav_headers, timeout_header);
327
328         slot = get_active_slot();
329         curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
330         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
331         curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
332         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
333         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
334
335         if (start_active_slot(slot)) {
336                 run_active_slot(slot);
337                 if (slot->curl_result != CURLE_OK) {
338                         fprintf(stderr, "Got HTTP error %ld\n", slot->http_code);
339                 } else {
340                         lock->start_time = time(NULL);
341                         rc = 1;
342                 }
343         }
344
345         lock->refreshing = 0;
346         curl_slist_free_all(dav_headers);
347         free(if_header);
348
349         return rc;
350 }
351
352 static void finish_request(struct transfer_request *request)
353 {
354         time_t current_time = time(NULL);
355         int time_remaining;
356
357         request->curl_result =  request->slot->curl_result;
358         request->http_code = request->slot->http_code;
359         request->slot = NULL;
360
361         /* Refresh the lock if it is close to timing out */
362         time_remaining = request->lock->start_time + request->lock->timeout
363                 - current_time;
364         if (time_remaining < LOCK_REFRESH && !request->lock->refreshing) {
365                 if (!refresh_lock(request->lock)) {
366                         fprintf(stderr, "Unable to refresh remote lock\n");
367                         aborted = 1;
368                 }
369         }
370
371         if (request->headers != NULL)
372                 curl_slist_free_all(request->headers);
373
374         /* URL is reused for MOVE after PUT */
375         if (request->state != RUN_PUT) {
376                 free(request->url);
377                 request->url = NULL;
378         }               
379
380         if (request->state == RUN_HEAD) {
381                 if (request->http_code == 404) {
382                         request->state = NEED_PUSH;
383                 } else if (request->curl_result == CURLE_OK) {
384                         remote_dir_exists[request->sha1[0]] = 1;
385                         request->state = COMPLETE;
386                 } else {
387                         fprintf(stderr, "HEAD %s failed, aborting (%d/%ld)\n",
388                                 sha1_to_hex(request->sha1),
389                                 request->curl_result, request->http_code);
390                         request->state = ABORTED;
391                         aborted = 1;
392                 }
393         } else if (request->state == RUN_MKCOL) {
394                 if (request->curl_result == CURLE_OK ||
395                     request->http_code == 405) {
396                         remote_dir_exists[request->sha1[0]] = 1;
397                         start_put(request);
398                 } else {
399                         fprintf(stderr, "MKCOL %s failed, aborting (%d/%ld)\n",
400                                 sha1_to_hex(request->sha1),
401                                 request->curl_result, request->http_code);
402                         request->state = ABORTED;
403                         aborted = 1;
404                 }
405         } else if (request->state == RUN_PUT) {
406                 if (request->curl_result == CURLE_OK) {
407                         start_move(request);
408                 } else {
409                         fprintf(stderr, "PUT %s failed, aborting (%d/%ld)\n",
410                                 sha1_to_hex(request->sha1),
411                                 request->curl_result, request->http_code);
412                         request->state = ABORTED;
413                         aborted = 1;
414                 }
415         } else if (request->state == RUN_MOVE) {
416                 if (request->curl_result == CURLE_OK) {
417                         if (push_verbosely)
418                                 fprintf(stderr,
419                                         "sent %s\n",
420                                         sha1_to_hex(request->sha1));
421                         request->state = COMPLETE;
422                 } else {
423                         fprintf(stderr, "MOVE %s failed, aborting (%d/%ld)\n",
424                                 sha1_to_hex(request->sha1),
425                                 request->curl_result, request->http_code);
426                         request->state = ABORTED;
427                         aborted = 1;
428                 }
429         }
430 }
431
432 static void release_request(struct transfer_request *request)
433 {
434         struct transfer_request *entry = request_queue_head;
435
436         if (request == request_queue_head) {
437                 request_queue_head = request->next;
438         } else {
439                 while (entry->next != NULL && entry->next != request)
440                         entry = entry->next;
441                 if (entry->next == request)
442                         entry->next = entry->next->next;
443         }
444
445         if (request->url != NULL)
446                 free(request->url);
447         free(request);
448 }
449
450 void fill_active_slots(void)
451 {
452         struct transfer_request *request = request_queue_head;
453         struct active_request_slot *slot = active_queue_head;
454         int num_transfers;
455
456         if (aborted)
457                 return;
458
459         while (active_requests < max_requests && request != NULL) {
460                 if (!pushing && request->state == NEED_CHECK) {
461                         start_check(request);
462                         curl_multi_perform(curlm, &num_transfers);
463                 } else if (pushing && request->state == NEED_PUSH) {
464                         if (remote_dir_exists[request->sha1[0]])
465                                 start_put(request);
466                         else
467                                 start_mkcol(request);
468                         curl_multi_perform(curlm, &num_transfers);
469                 }
470                 request = request->next;
471         }
472
473         while (slot != NULL) {
474                 if (!slot->in_use && slot->curl != NULL) {
475                         curl_easy_cleanup(slot->curl);
476                         slot->curl = NULL;
477                 }
478                 slot = slot->next;
479         }                               
480 }
481
482 static void add_request(unsigned char *sha1, struct active_lock *lock)
483 {
484         struct transfer_request *request = request_queue_head;
485         struct packed_git *target;
486         
487         while (request != NULL && memcmp(request->sha1, sha1, 20))
488                 request = request->next;
489         if (request != NULL)
490                 return;
491
492         target = find_sha1_pack(sha1, remote->packs);
493         if (target)
494                 return;
495
496         request = xmalloc(sizeof(*request));
497         memcpy(request->sha1, sha1, 20);
498         request->url = NULL;
499         request->lock = lock;
500         request->headers = NULL;
501         request->state = NEED_CHECK;
502         request->next = request_queue_head;
503         request_queue_head = request;
504
505         fill_active_slots();
506         step_active_slots();
507 }
508
509 static int fetch_index(unsigned char *sha1)
510 {
511         char *hex = sha1_to_hex(sha1);
512         char *filename;
513         char *url;
514         char tmpfile[PATH_MAX];
515         long prev_posn = 0;
516         char range[RANGE_HEADER_SIZE];
517         struct curl_slist *range_header = NULL;
518
519         FILE *indexfile;
520         struct active_request_slot *slot;
521
522         /* Don't use the index if the pack isn't there */
523         url = xmalloc(strlen(remote->url) + 65);
524         sprintf(url, "%s/objects/pack/pack-%s.pack", remote->url, hex);
525         slot = get_active_slot();
526         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
527         curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
528         if (start_active_slot(slot)) {
529                 run_active_slot(slot);
530                 if (slot->curl_result != CURLE_OK) {
531                         free(url);
532                         return error("Unable to verify pack %s is available",
533                                      hex);
534                 }
535         } else {
536                 return error("Unable to start request");
537         }
538
539         if (has_pack_index(sha1))
540                 return 0;
541
542         if (push_verbosely)
543                 fprintf(stderr, "Getting index for pack %s\n", hex);
544         
545         sprintf(url, "%s/objects/pack/pack-%s.idx", remote->url, hex);
546         
547         filename = sha1_pack_index_name(sha1);
548         snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
549         indexfile = fopen(tmpfile, "a");
550         if (!indexfile)
551                 return error("Unable to open local file %s for pack index",
552                              filename);
553
554         slot = get_active_slot();
555         curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
556         curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
557         curl_easy_setopt(slot->curl, CURLOPT_FILE, indexfile);
558         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
559         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
560         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
561         slot->local = indexfile;
562
563         /* If there is data present from a previous transfer attempt,
564            resume where it left off */
565         prev_posn = ftell(indexfile);
566         if (prev_posn>0) {
567                 if (push_verbosely)
568                         fprintf(stderr,
569                                 "Resuming fetch of index for pack %s at byte %ld\n",
570                                 hex, prev_posn);
571                 sprintf(range, "Range: bytes=%ld-", prev_posn);
572                 range_header = curl_slist_append(range_header, range);
573                 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
574         }
575
576         if (start_active_slot(slot)) {
577                 run_active_slot(slot);
578                 if (slot->curl_result != CURLE_OK) {
579                         free(url);
580                         fclose(indexfile);
581                         return error("Unable to get pack index %s\n%s", url,
582                                      curl_errorstr);
583                 }
584         } else {
585                 free(url);
586                 fclose(indexfile);
587                 return error("Unable to start request");
588         }
589
590         free(url);
591         fclose(indexfile);
592
593         return move_temp_to_file(tmpfile, filename);
594 }
595
596 static int setup_index(unsigned char *sha1)
597 {
598         struct packed_git *new_pack;
599
600         if (fetch_index(sha1))
601                 return -1;
602
603         new_pack = parse_pack_index(sha1);
604         new_pack->next = remote->packs;
605         remote->packs = new_pack;
606         return 0;
607 }
608
609 static int fetch_indices(void)
610 {
611         unsigned char sha1[20];
612         char *url;
613         struct buffer buffer;
614         char *data;
615         int i = 0;
616
617         struct active_request_slot *slot;
618
619         data = xmalloc(4096);
620         memset(data, 0, 4096);
621         buffer.size = 4096;
622         buffer.posn = 0;
623         buffer.buffer = data;
624
625         if (push_verbosely)
626                 fprintf(stderr, "Getting pack list\n");
627         
628         url = xmalloc(strlen(remote->url) + 21);
629         sprintf(url, "%s/objects/info/packs", remote->url);
630
631         slot = get_active_slot();
632         curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
633         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
634         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
635         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
636         if (start_active_slot(slot)) {
637                 run_active_slot(slot);
638                 if (slot->curl_result != CURLE_OK) {
639                         free(buffer.buffer);
640                         free(url);
641                         if (slot->http_code == 404)
642                                 return 0;
643                         else
644                                 return error("%s", curl_errorstr);
645                 }
646         } else {
647                 free(buffer.buffer);
648                 free(url);
649                 return error("Unable to start request");
650         }
651         free(url);
652
653         data = buffer.buffer;
654         while (i < buffer.posn) {
655                 switch (data[i]) {
656                 case 'P':
657                         i++;
658                         if (i + 52 < buffer.posn &&
659                             !strncmp(data + i, " pack-", 6) &&
660                             !strncmp(data + i + 46, ".pack\n", 6)) {
661                                 get_sha1_hex(data + i + 6, sha1);
662                                 setup_index(sha1);
663                                 i += 51;
664                                 break;
665                         }
666                 default:
667                         while (data[i] != '\n')
668                                 i++;
669                 }
670                 i++;
671         }
672
673         free(buffer.buffer);
674         return 0;
675 }
676
677 static inline int needs_quote(int ch)
678 {
679         switch (ch) {
680         case '/': case '-': case '.':
681         case 'A'...'Z': case 'a'...'z': case '0'...'9':
682                 return 0;
683         default:
684                 return 1;
685         }
686 }
687
688 static inline int hex(int v)
689 {
690         if (v < 10) return '0' + v;
691         else return 'A' + v - 10;
692 }
693
694 static char *quote_ref_url(const char *base, const char *ref)
695 {
696         const char *cp;
697         char *dp, *qref;
698         int len, baselen, ch;
699
700         baselen = strlen(base);
701         len = baselen + 12; /* "refs/heads/" + NUL */
702         for (cp = ref; (ch = *cp) != 0; cp++, len++)
703                 if (needs_quote(ch))
704                         len += 2; /* extra two hex plus replacement % */
705         qref = xmalloc(len);
706         memcpy(qref, base, baselen);
707         memcpy(qref + baselen, "refs/heads/", 11);
708         for (cp = ref, dp = qref + baselen + 11; (ch = *cp) != 0; cp++) {
709                 if (needs_quote(ch)) {
710                         *dp++ = '%';
711                         *dp++ = hex((ch >> 4) & 0xF);
712                         *dp++ = hex(ch & 0xF);
713                 }
714                 else
715                         *dp++ = ch;
716         }
717         *dp = 0;
718
719         return qref;
720 }
721
722 int fetch_ref(char *ref, unsigned char *sha1)
723 {
724         char *url;
725         char hex[42];
726         struct buffer buffer;
727         char *base = remote->url;
728         struct active_request_slot *slot;
729         buffer.size = 41;
730         buffer.posn = 0;
731         buffer.buffer = hex;
732         hex[41] = '\0';
733         
734         url = quote_ref_url(base, ref);
735         slot = get_active_slot();
736         curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
737         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
738         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
739         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
740         if (start_active_slot(slot)) {
741                 run_active_slot(slot);
742                 if (slot->curl_result != CURLE_OK)
743                         return error("Couldn't get %s for %s\n%s",
744                                      url, ref, curl_errorstr);
745         } else {
746                 return error("Unable to start request");
747         }
748
749         hex[40] = '\0';
750         get_sha1_hex(hex, sha1);
751         return 0;
752 }
753
754 static void handle_lockprop_ctx(struct xml_ctx *ctx, int tag_closed)
755 {
756         int *lock_flags = (int *)ctx->userData;
757
758         if (tag_closed) {
759                 if (!strcmp(ctx->name, DAV_CTX_LOCKENTRY)) {
760                         if ((*lock_flags & DAV_PROP_LOCKEX) &&
761                             (*lock_flags & DAV_PROP_LOCKWR)) {
762                                 *lock_flags |= DAV_LOCK_OK;
763                         }
764                         *lock_flags &= DAV_LOCK_OK;
765                 } else if (!strcmp(ctx->name, DAV_CTX_LOCKTYPE_WRITE)) {
766                         *lock_flags |= DAV_PROP_LOCKWR;
767                 } else if (!strcmp(ctx->name, DAV_CTX_LOCKTYPE_EXCLUSIVE)) {
768                         *lock_flags |= DAV_PROP_LOCKEX;
769                 }
770         }
771 }
772
773 static void handle_new_lock_ctx(struct xml_ctx *ctx, int tag_closed)
774 {
775         struct active_lock *lock = (struct active_lock *)ctx->userData;
776
777         if (tag_closed && ctx->cdata) {
778                 if (!strcmp(ctx->name, DAV_ACTIVELOCK_OWNER)) {
779                         lock->owner = xmalloc(strlen(ctx->cdata) + 1);
780                         strcpy(lock->owner, ctx->cdata);
781                 } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TIMEOUT)) {
782                         if (!strncmp(ctx->cdata, "Second-", 7))
783                                 lock->timeout =
784                                         strtol(ctx->cdata + 7, NULL, 10);
785                 } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TOKEN)) {
786                         if (!strncmp(ctx->cdata, "opaquelocktoken:", 16)) {
787                                 lock->token = xmalloc(strlen(ctx->cdata) - 15);
788                                 strcpy(lock->token, ctx->cdata + 16);
789                         }
790                 }
791         }
792 }
793
794 static void
795 xml_start_tag(void *userData, const char *name, const char **atts)
796 {
797         struct xml_ctx *ctx = (struct xml_ctx *)userData;
798         const char *c = index(name, ':');
799         int new_len;
800
801         if (c == NULL)
802                 c = name;
803         else
804                 c++;
805
806         new_len = strlen(ctx->name) + strlen(c) + 2;
807
808         if (new_len > ctx->len) {
809                 ctx->name = xrealloc(ctx->name, new_len);
810                 ctx->len = new_len;
811         }
812         strcat(ctx->name, ".");
813         strcat(ctx->name, c);
814
815         if (ctx->cdata) {
816                 free(ctx->cdata);
817                 ctx->cdata = NULL;
818         }
819
820         ctx->userFunc(ctx, 0);
821 }
822
823 static void
824 xml_end_tag(void *userData, const char *name)
825 {
826         struct xml_ctx *ctx = (struct xml_ctx *)userData;
827         const char *c = index(name, ':');
828         char *ep;
829
830         ctx->userFunc(ctx, 1);
831
832         if (c == NULL)
833                 c = name;
834         else
835                 c++;
836
837         ep = ctx->name + strlen(ctx->name) - strlen(c) - 1;
838         *ep = 0;
839 }
840
841 static void
842 xml_cdata(void *userData, const XML_Char *s, int len)
843 {
844         struct xml_ctx *ctx = (struct xml_ctx *)userData;
845         if (ctx->cdata)
846                 free(ctx->cdata);
847         ctx->cdata = xcalloc(len+1, 1);
848         strncpy(ctx->cdata, s, len);
849 }
850
851 static struct active_lock *lock_remote(char *file, long timeout)
852 {
853         struct active_request_slot *slot;
854         struct buffer out_buffer;
855         struct buffer in_buffer;
856         char *out_data;
857         char *in_data;
858         char *url;
859         char *ep;
860         char timeout_header[25];
861         struct active_lock *new_lock = NULL;
862         XML_Parser parser = XML_ParserCreate(NULL);
863         enum XML_Status result;
864         struct curl_slist *dav_headers = NULL;
865         struct xml_ctx ctx;
866
867         url = xmalloc(strlen(remote->url) + strlen(file) + 1);
868         sprintf(url, "%s%s", remote->url, file);
869
870         /* Make sure leading directories exist for the remote ref */
871         ep = strchr(url + strlen(remote->url) + 11, '/');
872         while (ep) {
873                 *ep = 0;
874                 slot = get_active_slot();
875                 curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
876                 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
877                 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MKCOL);
878                 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
879                 if (start_active_slot(slot)) {
880                         run_active_slot(slot);
881                         if (slot->curl_result != CURLE_OK &&
882                             slot->http_code != 405) {
883                                 fprintf(stderr,
884                                         "Unable to create branch path %s\n",
885                                         url);
886                                 free(url);
887                                 return NULL;
888                         }
889                 } else {
890                         fprintf(stderr, "Unable to start request\n");
891                         free(url);
892                         return NULL;
893                 }
894                 *ep = '/';
895                 ep = strchr(ep + 1, '/');
896         }
897
898         out_buffer.size = strlen(LOCK_REQUEST) + strlen(git_default_email) - 2;
899         out_data = xmalloc(out_buffer.size + 1);
900         snprintf(out_data, out_buffer.size + 1, LOCK_REQUEST, git_default_email);
901         out_buffer.posn = 0;
902         out_buffer.buffer = out_data;
903
904         in_buffer.size = 4096;
905         in_data = xmalloc(in_buffer.size);
906         in_buffer.posn = 0;
907         in_buffer.buffer = in_data;
908
909         sprintf(timeout_header, "Timeout: Second-%ld", timeout);
910         dav_headers = curl_slist_append(dav_headers, timeout_header);
911         dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
912
913         slot = get_active_slot();
914         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
915         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
916         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
917         curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
918         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
919         curl_easy_setopt(slot->curl, CURLOPT_URL, url);
920         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
921         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
922         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
923
924         new_lock = xcalloc(1, sizeof(*new_lock));
925         new_lock->owner = NULL;
926         new_lock->token = NULL;
927         new_lock->timeout = -1;
928         new_lock->refreshing = 0;
929
930         if (start_active_slot(slot)) {
931                 run_active_slot(slot);
932                 if (slot->curl_result == CURLE_OK) {
933                         ctx.name = xcalloc(10, 1);
934                         ctx.len = 0;
935                         ctx.cdata = NULL;
936                         ctx.userFunc = handle_new_lock_ctx;
937                         ctx.userData = new_lock;
938                         XML_SetUserData(parser, &ctx);
939                         XML_SetElementHandler(parser, xml_start_tag,
940                                               xml_end_tag);
941                         XML_SetCharacterDataHandler(parser, xml_cdata);
942                         result = XML_Parse(parser, in_buffer.buffer,
943                                            in_buffer.posn, 1);
944                         free(ctx.name);
945                         if (result != XML_STATUS_OK) {
946                                 fprintf(stderr, "XML error: %s\n",
947                                         XML_ErrorString(
948                                                 XML_GetErrorCode(parser)));
949                                 new_lock->timeout = -1;
950                         }
951                 }
952         } else {
953                 fprintf(stderr, "Unable to start request\n");
954         }
955
956         curl_slist_free_all(dav_headers);
957         free(out_data);
958         free(in_data);
959
960         if (new_lock->token == NULL || new_lock->timeout <= 0) {
961                 if (new_lock->token != NULL)
962                         free(new_lock->token);
963                 if (new_lock->owner != NULL)
964                         free(new_lock->owner);
965                 free(url);
966                 free(new_lock);
967                 new_lock = NULL;
968         } else {
969                 new_lock->url = url;
970                 new_lock->start_time = time(NULL);
971         }
972
973         return new_lock;
974 }
975
976 static int unlock_remote(struct active_lock *lock)
977 {
978         struct active_request_slot *slot;
979         char *lock_token_header;
980         struct curl_slist *dav_headers = NULL;
981         int rc = 0;
982
983         lock_token_header = xmalloc(strlen(lock->token) + 31);
984         sprintf(lock_token_header, "Lock-Token: <opaquelocktoken:%s>",
985                 lock->token);
986         dav_headers = curl_slist_append(dav_headers, lock_token_header);
987
988         slot = get_active_slot();
989         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
990         curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
991         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_UNLOCK);
992         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
993
994         if (start_active_slot(slot)) {
995                 run_active_slot(slot);
996                 if (slot->curl_result == CURLE_OK)
997                         rc = 1;
998                 else
999                         fprintf(stderr, "Got HTTP error %ld\n",
1000                                 slot->http_code);
1001         } else {
1002                 fprintf(stderr, "Unable to start request\n");
1003         }
1004
1005         curl_slist_free_all(dav_headers);
1006         free(lock_token_header);
1007
1008         if (lock->owner != NULL)
1009                 free(lock->owner);
1010         free(lock->url);
1011         free(lock->token);
1012         free(lock);
1013
1014         return rc;
1015 }
1016
1017 static int locking_available(void)
1018 {
1019         struct active_request_slot *slot;
1020         struct buffer in_buffer;
1021         struct buffer out_buffer;
1022         char *in_data;
1023         char *out_data;
1024         XML_Parser parser = XML_ParserCreate(NULL);
1025         enum XML_Status result;
1026         struct curl_slist *dav_headers = NULL;
1027         struct xml_ctx ctx;
1028         int lock_flags = 0;
1029
1030         out_buffer.size = strlen(PROPFIND_REQUEST) + strlen(remote->url) - 2;
1031         out_data = xmalloc(out_buffer.size + 1);
1032         snprintf(out_data, out_buffer.size + 1, PROPFIND_REQUEST, remote->url);
1033         out_buffer.posn = 0;
1034         out_buffer.buffer = out_data;
1035
1036         in_buffer.size = 4096;
1037         in_data = xmalloc(in_buffer.size);
1038         in_buffer.posn = 0;
1039         in_buffer.buffer = in_data;
1040
1041         dav_headers = curl_slist_append(dav_headers, "Depth: 0");
1042         dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1043         
1044         slot = get_active_slot();
1045         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1046         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1047         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1048         curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1049         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1050         curl_easy_setopt(slot->curl, CURLOPT_URL, remote->url);
1051         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1052         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
1053         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1054
1055         if (start_active_slot(slot)) {
1056                 run_active_slot(slot);
1057                 if (slot->curl_result == CURLE_OK) {
1058                         ctx.name = xcalloc(10, 1);
1059                         ctx.len = 0;
1060                         ctx.cdata = NULL;
1061                         ctx.userFunc = handle_lockprop_ctx;
1062                         ctx.userData = &lock_flags;
1063                         XML_SetUserData(parser, &ctx);
1064                         XML_SetElementHandler(parser, xml_start_tag,
1065                                               xml_end_tag);
1066                         result = XML_Parse(parser, in_buffer.buffer,
1067                                            in_buffer.posn, 1);
1068                         free(ctx.name);
1069
1070                         if (result != XML_STATUS_OK) {
1071                                 fprintf(stderr, "XML error: %s\n",
1072                                         XML_ErrorString(
1073                                                 XML_GetErrorCode(parser)));
1074                                 lock_flags = 0;
1075                         }
1076                 }
1077         } else {
1078                 fprintf(stderr, "Unable to start request\n");
1079         }
1080
1081         free(out_data);
1082         free(in_buffer.buffer);
1083         curl_slist_free_all(dav_headers);
1084
1085         return lock_flags;
1086 }
1087
1088 static int is_ancestor(unsigned char *sha1, struct commit *commit)
1089 {
1090         struct commit_list *parents;
1091
1092         if (parse_commit(commit))
1093                 return 0;
1094         parents = commit->parents;
1095         for (; parents; parents = parents->next) {
1096                 if (!memcmp(sha1, parents->item->object.sha1, 20)) {
1097                         return 1;
1098                 } else if (parents->item->object.type == commit_type) {
1099                         if (is_ancestor(
1100                                     sha1,
1101                                     (struct commit *)&parents->item->object
1102                                     ))
1103                                 return 1;
1104                 }
1105         }
1106         return 0;
1107 }
1108
1109 static void get_delta(unsigned char *sha1, struct object *obj,
1110                       struct active_lock *lock)
1111 {
1112         struct commit *commit;
1113         struct commit_list *parents;
1114         struct tree *tree;
1115         struct tree_entry_list *entry;
1116
1117         if (sha1 && !memcmp(sha1, obj->sha1, 20))
1118                 return;
1119
1120         if (aborted)
1121                 return;
1122
1123         if (obj->type == commit_type) {
1124                 if (push_verbosely)
1125                         fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
1126                 add_request(obj->sha1, lock);
1127                 commit = (struct commit *)obj;
1128                 if (parse_commit(commit)) {
1129                         fprintf(stderr, "Error parsing commit %s\n",
1130                                 sha1_to_hex(obj->sha1));
1131                         aborted = 1;
1132                         return;
1133                 }
1134                 parents = commit->parents;
1135                 for (; parents; parents = parents->next)
1136                         if (sha1 == NULL ||
1137                             memcmp(sha1, parents->item->object.sha1, 20))
1138                                 get_delta(sha1, &parents->item->object,
1139                                           lock);
1140                 get_delta(sha1, &commit->tree->object, lock);
1141         } else if (obj->type == tree_type) {
1142                 if (push_verbosely)
1143                         fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
1144                 add_request(obj->sha1, lock);
1145                 tree = (struct tree *)obj;
1146                 if (parse_tree(tree)) {
1147                         fprintf(stderr, "Error parsing tree %s\n",
1148                                 sha1_to_hex(obj->sha1));
1149                         aborted = 1;
1150                         return;
1151                 }
1152                 entry = tree->entries;
1153                 tree->entries = NULL;
1154                 while (entry) {
1155                         struct tree_entry_list *next = entry->next;
1156                         get_delta(sha1, entry->item.any, lock);
1157                         free(entry->name);
1158                         free(entry);
1159                         entry = next;
1160                 }
1161         } else if (obj->type == blob_type || obj->type == tag_type) {
1162                 add_request(obj->sha1, lock);
1163         }
1164 }
1165
1166 static int update_remote(unsigned char *sha1, struct active_lock *lock)
1167 {
1168         struct active_request_slot *slot;
1169         char *out_data;
1170         char *if_header;
1171         struct buffer out_buffer;
1172         struct curl_slist *dav_headers = NULL;
1173         int i;
1174
1175         if_header = xmalloc(strlen(lock->token) + 25);
1176         sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
1177         dav_headers = curl_slist_append(dav_headers, if_header);
1178
1179         out_buffer.size = 41;
1180         out_data = xmalloc(out_buffer.size + 1);
1181         i = snprintf(out_data, out_buffer.size + 1, "%s\n", sha1_to_hex(sha1));
1182         if (i != out_buffer.size) {
1183                 fprintf(stderr, "Unable to initialize PUT request body\n");
1184                 return 0;
1185         }
1186         out_buffer.posn = 0;
1187         out_buffer.buffer = out_data;
1188
1189         slot = get_active_slot();
1190         curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1191         curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1192         curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1193         curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1194         curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
1195         curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1196         curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1197         curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
1198         curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
1199
1200         if (start_active_slot(slot)) {
1201                 run_active_slot(slot);
1202                 free(out_data);
1203                 free(if_header);
1204                 if (slot->curl_result != CURLE_OK) {
1205                         fprintf(stderr,
1206                                 "PUT error: curl result=%d, HTTP code=%ld\n",
1207                                 slot->curl_result, slot->http_code);
1208                         /* We should attempt recovery? */
1209                         return 0;
1210                 }
1211         } else {
1212                 free(out_data);
1213                 free(if_header);
1214                 fprintf(stderr, "Unable to start PUT request\n");
1215                 return 0;
1216         }
1217
1218         return 1;
1219 }
1220
1221 int main(int argc, char **argv)
1222 {
1223         struct transfer_request *request;
1224         struct transfer_request *next_request;
1225         int nr_refspec = 0;
1226         char **refspec = NULL;
1227         int do_remote_update;
1228         int new_branch;
1229         int force_this;
1230         char *local_ref;
1231         unsigned char local_sha1[20];
1232         struct object *local_object = NULL;
1233         char *remote_ref = NULL;
1234         unsigned char remote_sha1[20];
1235         struct active_lock *remote_lock;
1236         char *remote_path = NULL;
1237         int rc = 0;
1238         int i;
1239
1240         setup_git_directory();
1241         setup_ident();
1242
1243         remote = xmalloc(sizeof(*remote));
1244         remote->url = NULL;
1245         remote->packs = NULL;
1246
1247         argv++;
1248         for (i = 1; i < argc; i++, argv++) {
1249                 char *arg = *argv;
1250
1251                 if (*arg == '-') {
1252                         if (!strcmp(arg, "--complete")) {
1253                                 push_all = 1;
1254                                 continue;
1255                         }
1256                         if (!strcmp(arg, "--force")) {
1257                                 force_all = 1;
1258                                 continue;
1259                         }
1260                         if (!strcmp(arg, "--verbose")) {
1261                                 push_verbosely = 1;
1262                                 continue;
1263                         }
1264                         usage(http_push_usage);
1265                 }
1266                 if (!remote->url) {
1267                         remote->url = arg;
1268                         continue;
1269                 }
1270                 refspec = argv;
1271                 nr_refspec = argc - i;
1272                 break;
1273         }
1274
1275         if (!remote->url)
1276                 usage(http_push_usage);
1277
1278         memset(remote_dir_exists, 0, 256);
1279
1280         http_init();
1281
1282         no_pragma_header = curl_slist_append(no_pragma_header, "Pragma:");
1283         default_headers = curl_slist_append(default_headers, "Range:");
1284         default_headers = curl_slist_append(default_headers, "Destination:");
1285         default_headers = curl_slist_append(default_headers, "If:");
1286         default_headers = curl_slist_append(default_headers,
1287                                             "Pragma: no-cache");
1288
1289         /* Verify DAV compliance/lock support */
1290         if (!locking_available()) {
1291                 fprintf(stderr, "Error: no DAV locking support on remote repo %s\n", remote->url);
1292                 rc = 1;
1293                 goto cleanup;
1294         }
1295
1296         /* Process each refspec */
1297         for (i = 0; i < nr_refspec; i++) {
1298                 char *ep;
1299                 force_this = 0;
1300                 do_remote_update = 0;
1301                 new_branch = 0;
1302                 local_ref = refspec[i];
1303                 if (*local_ref == '+') {
1304                         force_this = 1;
1305                         local_ref++;
1306                 }
1307                 ep = strchr(local_ref, ':');
1308                 if (ep) {
1309                         remote_ref = ep + 1;
1310                         *ep = 0;
1311                 }
1312                 else
1313                         remote_ref = local_ref;
1314
1315                 /* Lock remote branch ref */
1316                 if (remote_path)
1317                         free(remote_path);
1318                 remote_path = xmalloc(strlen(remote_ref) + 12);
1319                 sprintf(remote_path, "refs/heads/%s", remote_ref);
1320                 remote_lock = lock_remote(remote_path, LOCK_TIME);
1321                 if (remote_lock == NULL) {
1322                         fprintf(stderr, "Unable to lock remote branch %s\n",
1323                                 remote_ref);
1324                         rc = 1;
1325                         continue;
1326                 }
1327
1328                 /* Resolve local and remote refs */
1329                 if (fetch_ref(remote_ref, remote_sha1) != 0) {
1330                         fprintf(stderr,
1331                                 "Remote branch %s does not exist on %s\n",
1332                                 remote_ref, remote->url);
1333                         new_branch = 1;
1334                 }
1335                 if (get_sha1(local_ref, local_sha1) != 0) {
1336                         fprintf(stderr, "Error resolving local branch %s\n",
1337                                 local_ref);
1338                         rc = 1;
1339                         goto unlock;
1340                 }
1341         
1342                 /* Find relationship between local and remote */
1343                 local_object = parse_object(local_sha1);
1344                 if (!local_object) {
1345                         fprintf(stderr, "Unable to parse local object %s\n",
1346                                 sha1_to_hex(local_sha1));
1347                         rc = 1;
1348                         goto unlock;
1349                 } else if (new_branch) {
1350                         do_remote_update = 1;
1351                 } else {
1352                         if (!memcmp(local_sha1, remote_sha1, 20)) {
1353                                 fprintf(stderr,
1354                                         "* %s: same as branch '%s' of %s\n",
1355                                         local_ref, remote_ref, remote->url);
1356                         } else if (is_ancestor(remote_sha1,
1357                                                (struct commit *)local_object)) {
1358                                 fprintf(stderr,
1359                                         "Remote %s will fast-forward to local %s\n",
1360                                         remote_ref, local_ref);
1361                                 do_remote_update = 1;
1362                         } else if (force_all || force_this) {
1363                                 fprintf(stderr,
1364                                         "* %s on %s does not fast forward to local branch '%s', overwriting\n",
1365                                         remote_ref, remote->url, local_ref);
1366                                 do_remote_update = 1;
1367                         } else {
1368                                 fprintf(stderr,
1369                                         "* %s on %s does not fast forward to local branch '%s'\n",
1370                                         remote_ref, remote->url, local_ref);
1371                                 rc = 1;
1372                                 goto unlock;
1373                         }
1374                 }
1375
1376                 /* Generate and check list of required objects */
1377                 pushing = 0;
1378                 if (do_remote_update || push_all)
1379                         fetch_indices();
1380                 get_delta(push_all ? NULL : remote_sha1,
1381                           local_object, remote_lock);
1382                 finish_all_active_slots();
1383
1384                 /* Push missing objects to remote, this would be a
1385                    convenient time to pack them first if appropriate. */
1386                 pushing = 1;
1387                 fill_active_slots();
1388                 finish_all_active_slots();
1389
1390                 /* Update the remote branch if all went well */
1391                 if (do_remote_update) {
1392                         if (!aborted && update_remote(local_sha1,
1393                                                       remote_lock)) {
1394                                 fprintf(stderr, "%s remote branch %s\n",
1395                                         new_branch ? "Created" : "Updated",
1396                                         remote_ref);
1397                         } else {
1398                                 fprintf(stderr,
1399                                         "Unable to %s remote branch %s\n",
1400                                         new_branch ? "create" : "update",
1401                                         remote_ref);
1402                                 rc = 1;
1403                                 goto unlock;
1404                         }
1405                 }
1406
1407         unlock:
1408                 unlock_remote(remote_lock);
1409                 free(remote_path);
1410         }
1411
1412  cleanup:
1413         free(remote);
1414
1415         curl_slist_free_all(no_pragma_header);
1416         curl_slist_free_all(default_headers);
1417
1418         http_cleanup();
1419
1420         request = request_queue_head;
1421         while (request != NULL) {
1422                 next_request = request->next;
1423                 release_request(request);
1424                 request = next_request;
1425         }
1426
1427         return rc;
1428 }