13 static const char http_push_usage[] =
14 "git-http-push [--complete] [--force] [--verbose] <url> <ref> [<ref>...]\n";
21 #define XML_STATUS_OK 1
22 #define XML_STATUS_ERROR 0
25 #define PREV_BUF_SIZE 4096
26 #define RANGE_HEADER_SIZE 30
29 #define DAV_LOCK "LOCK"
30 #define DAV_MKCOL "MKCOL"
31 #define DAV_MOVE "MOVE"
32 #define DAV_PROPFIND "PROPFIND"
34 #define DAV_UNLOCK "UNLOCK"
37 #define DAV_PROP_LOCKWR (1u << 0)
38 #define DAV_PROP_LOCKEX (1u << 1)
39 #define DAV_LOCK_OK (1u << 2)
41 /* DAV XML properties */
42 #define DAV_CTX_LOCKENTRY ".multistatus.response.propstat.prop.supportedlock.lockentry"
43 #define DAV_CTX_LOCKTYPE_WRITE ".multistatus.response.propstat.prop.supportedlock.lockentry.locktype.write"
44 #define DAV_CTX_LOCKTYPE_EXCLUSIVE ".multistatus.response.propstat.prop.supportedlock.lockentry.lockscope.exclusive"
45 #define DAV_ACTIVELOCK_OWNER ".prop.lockdiscovery.activelock.owner.href"
46 #define DAV_ACTIVELOCK_TIMEOUT ".prop.lockdiscovery.activelock.timeout"
47 #define DAV_ACTIVELOCK_TOKEN ".prop.lockdiscovery.activelock.locktoken.href"
48 #define DAV_PROPFIND_RESP ".multistatus.response"
49 #define DAV_PROPFIND_NAME ".multistatus.response.href"
50 #define DAV_PROPFIND_COLLECTION ".multistatus.response.propstat.prop.resourcetype.collection"
52 /* DAV request body templates */
53 #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>"
54 #define PROPFIND_ALL_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/>\n</D:propfind>"
55 #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>"
58 #define LOCK_REFRESH 30
60 /* bits #0-4 in revision.h */
62 #define LOCAL (1u << 5)
63 #define REMOTE (1u << 6)
64 #define FETCHING (1u << 7)
65 #define PUSHING (1u << 8)
67 static int pushing = 0;
68 static int aborted = 0;
69 static char remote_dir_exists[256];
71 static struct curl_slist *no_pragma_header;
72 static struct curl_slist *default_headers;
74 static int push_verbosely = 0;
75 static int push_all = 0;
76 static int force_all = 0;
78 static struct object_list *objects = NULL;
85 int can_update_info_refs;
87 struct packed_git *packs;
88 struct remote_lock *locks;
91 static struct repo *remote = NULL;
105 struct transfer_request
110 struct remote_lock *lock;
111 struct curl_slist *headers;
112 struct buffer buffer;
113 char filename[PATH_MAX];
114 char tmpfile[PATH_MAX];
117 enum transfer_state state;
118 CURLcode curl_result;
119 char errorstr[CURL_ERROR_SIZE];
121 unsigned char real_sha1[20];
127 struct active_request_slot *slot;
128 struct transfer_request *next;
131 static struct transfer_request *request_queue_head = NULL;
138 void (*userFunc)(struct xml_ctx *ctx, int tag_closed);
150 struct remote_lock *next;
153 /* Flags that control remote_ls processing */
154 #define PROCESS_FILES (1u << 0)
155 #define PROCESS_DIRS (1u << 1)
156 #define RECURSIVE (1u << 2)
158 /* Flags that remote_ls passes to callback functions */
159 #define IS_DIR (1u << 0)
164 void (*userFunc)(struct remote_ls_ctx *ls);
169 struct remote_ls_ctx *parent;
172 static void finish_request(struct transfer_request *request);
173 static void release_request(struct transfer_request *request);
175 static void process_response(void *callback_data)
177 struct transfer_request *request =
178 (struct transfer_request *)callback_data;
180 finish_request(request);
183 static size_t fwrite_sha1_file(void *ptr, size_t eltsize, size_t nmemb,
186 unsigned char expn[4096];
187 size_t size = eltsize * nmemb;
189 struct transfer_request *request = (struct transfer_request *)data;
191 ssize_t retval = write(request->local_fileno,
192 ptr + posn, size - posn);
196 } while (posn < size);
198 request->stream.avail_in = size;
199 request->stream.next_in = ptr;
201 request->stream.next_out = expn;
202 request->stream.avail_out = sizeof(expn);
203 request->zret = inflate(&request->stream, Z_SYNC_FLUSH);
204 SHA1_Update(&request->c, expn,
205 sizeof(expn) - request->stream.avail_out);
206 } while (request->stream.avail_in && request->zret == Z_OK);
211 static void start_fetch_loose(struct transfer_request *request)
213 char *hex = sha1_to_hex(request->obj->sha1);
215 char prevfile[PATH_MAX];
219 unsigned char prev_buf[PREV_BUF_SIZE];
220 ssize_t prev_read = 0;
222 char range[RANGE_HEADER_SIZE];
223 struct curl_slist *range_header = NULL;
224 struct active_request_slot *slot;
226 filename = sha1_file_name(request->obj->sha1);
227 snprintf(request->filename, sizeof(request->filename), "%s", filename);
228 snprintf(request->tmpfile, sizeof(request->tmpfile),
229 "%s.temp", filename);
231 snprintf(prevfile, sizeof(prevfile), "%s.prev", request->filename);
233 rename(request->tmpfile, prevfile);
234 unlink(request->tmpfile);
236 if (request->local_fileno != -1)
237 error("fd leakage in start: %d", request->local_fileno);
238 request->local_fileno = open(request->tmpfile,
239 O_WRONLY | O_CREAT | O_EXCL, 0666);
240 /* This could have failed due to the "lazy directory creation";
241 * try to mkdir the last path component.
243 if (request->local_fileno < 0 && errno == ENOENT) {
244 char *dir = strrchr(request->tmpfile, '/');
247 mkdir(request->tmpfile, 0777);
250 request->local_fileno = open(request->tmpfile,
251 O_WRONLY | O_CREAT | O_EXCL, 0666);
254 if (request->local_fileno < 0) {
255 request->state = ABORTED;
256 error("Couldn't create temporary file %s for %s: %s",
257 request->tmpfile, request->filename, strerror(errno));
261 memset(&request->stream, 0, sizeof(request->stream));
263 inflateInit(&request->stream);
265 SHA1_Init(&request->c);
267 url = xmalloc(strlen(remote->url) + 50);
268 request->url = xmalloc(strlen(remote->url) + 50);
269 strcpy(url, remote->url);
270 posn = url + strlen(remote->url);
271 strcpy(posn, "objects/");
273 memcpy(posn, hex, 2);
276 strcpy(posn, hex + 2);
277 strcpy(request->url, url);
279 /* If a previous temp file is present, process what was already
281 prevlocal = open(prevfile, O_RDONLY);
282 if (prevlocal != -1) {
284 prev_read = read(prevlocal, prev_buf, PREV_BUF_SIZE);
286 if (fwrite_sha1_file(prev_buf,
289 request) == prev_read) {
290 prev_posn += prev_read;
295 } while (prev_read > 0);
300 /* Reset inflate/SHA1 if there was an error reading the previous temp
301 file; also rewind to the beginning of the local file. */
302 if (prev_read == -1) {
303 memset(&request->stream, 0, sizeof(request->stream));
304 inflateInit(&request->stream);
305 SHA1_Init(&request->c);
308 lseek(request->local_fileno, SEEK_SET, 0);
309 ftruncate(request->local_fileno, 0);
313 slot = get_active_slot();
314 slot->callback_func = process_response;
315 slot->callback_data = request;
316 request->slot = slot;
318 curl_easy_setopt(slot->curl, CURLOPT_FILE, request);
319 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_sha1_file);
320 curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
321 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
322 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
324 /* If we have successfully processed data from a previous fetch
325 attempt, only fetch the data we don't already have. */
329 "Resuming fetch of object %s at byte %ld\n",
331 sprintf(range, "Range: bytes=%ld-", prev_posn);
332 range_header = curl_slist_append(range_header, range);
333 curl_easy_setopt(slot->curl,
334 CURLOPT_HTTPHEADER, range_header);
337 /* Try to get the request started, abort the request on error */
338 request->state = RUN_FETCH_LOOSE;
339 if (!start_active_slot(slot)) {
340 fprintf(stderr, "Unable to start GET request\n");
341 remote->can_update_info_refs = 0;
342 release_request(request);
346 static void start_fetch_packed(struct transfer_request *request)
349 struct packed_git *target;
353 char range[RANGE_HEADER_SIZE];
354 struct curl_slist *range_header = NULL;
356 struct transfer_request *check_request = request_queue_head;
357 struct active_request_slot *slot;
359 target = find_sha1_pack(request->obj->sha1, remote->packs);
361 fprintf(stderr, "Unable to fetch %s, will not be able to update server info refs\n", sha1_to_hex(request->obj->sha1));
362 remote->can_update_info_refs = 0;
363 release_request(request);
367 fprintf(stderr, "Fetching pack %s\n", sha1_to_hex(target->sha1));
368 fprintf(stderr, " which contains %s\n", sha1_to_hex(request->obj->sha1));
370 filename = sha1_pack_name(target->sha1);
371 snprintf(request->filename, sizeof(request->filename), "%s", filename);
372 snprintf(request->tmpfile, sizeof(request->tmpfile),
373 "%s.temp", filename);
375 url = xmalloc(strlen(remote->url) + 64);
376 sprintf(url, "%sobjects/pack/pack-%s.pack",
377 remote->url, sha1_to_hex(target->sha1));
379 /* Make sure there isn't another open request for this pack */
380 while (check_request) {
381 if (check_request->state == RUN_FETCH_PACKED &&
382 !strcmp(check_request->url, url)) {
384 release_request(request);
387 check_request = check_request->next;
390 packfile = fopen(request->tmpfile, "a");
392 fprintf(stderr, "Unable to open local file %s for pack",
394 remote->can_update_info_refs = 0;
399 slot = get_active_slot();
400 slot->callback_func = process_response;
401 slot->callback_data = request;
402 request->slot = slot;
403 request->local_stream = packfile;
404 request->userData = target;
407 curl_easy_setopt(slot->curl, CURLOPT_FILE, packfile);
408 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
409 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
410 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
411 slot->local = packfile;
413 /* If there is data present from a previous transfer attempt,
414 resume where it left off */
415 prev_posn = ftell(packfile);
419 "Resuming fetch of pack %s at byte %ld\n",
420 sha1_to_hex(target->sha1), prev_posn);
421 sprintf(range, "Range: bytes=%ld-", prev_posn);
422 range_header = curl_slist_append(range_header, range);
423 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
426 /* Try to get the request started, abort the request on error */
427 request->state = RUN_FETCH_PACKED;
428 if (!start_active_slot(slot)) {
429 fprintf(stderr, "Unable to start GET request\n");
430 remote->can_update_info_refs = 0;
431 release_request(request);
435 static void start_mkcol(struct transfer_request *request)
437 char *hex = sha1_to_hex(request->obj->sha1);
438 struct active_request_slot *slot;
441 request->url = xmalloc(strlen(remote->url) + 13);
442 strcpy(request->url, remote->url);
443 posn = request->url + strlen(remote->url);
444 strcpy(posn, "objects/");
446 memcpy(posn, hex, 2);
450 slot = get_active_slot();
451 slot->callback_func = process_response;
452 slot->callback_data = request;
453 curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
454 curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
455 curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
456 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MKCOL);
457 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
459 if (start_active_slot(slot)) {
460 request->slot = slot;
461 request->state = RUN_MKCOL;
463 request->state = ABORTED;
469 static void start_put(struct transfer_request *request)
471 char *hex = sha1_to_hex(request->obj->sha1);
472 struct active_request_slot *slot;
482 unpacked = read_sha1_file(request->obj->sha1, type, &len);
483 hdrlen = sprintf(hdr, "%s %lu", type, len) + 1;
486 memset(&stream, 0, sizeof(stream));
487 deflateInit(&stream, Z_BEST_COMPRESSION);
488 size = deflateBound(&stream, len + hdrlen);
489 request->buffer.buffer = xmalloc(size);
492 stream.next_out = request->buffer.buffer;
493 stream.avail_out = size;
496 stream.next_in = (void *)hdr;
497 stream.avail_in = hdrlen;
498 while (deflate(&stream, 0) == Z_OK)
501 /* Then the data itself.. */
502 stream.next_in = unpacked;
503 stream.avail_in = len;
504 while (deflate(&stream, Z_FINISH) == Z_OK)
509 request->buffer.size = stream.total_out;
510 request->buffer.posn = 0;
512 request->url = xmalloc(strlen(remote->url) +
513 strlen(request->lock->token) + 51);
514 strcpy(request->url, remote->url);
515 posn = request->url + strlen(remote->url);
516 strcpy(posn, "objects/");
518 memcpy(posn, hex, 2);
521 strcpy(posn, hex + 2);
522 request->dest = xmalloc(strlen(request->url) + 14);
523 sprintf(request->dest, "Destination: %s", request->url);
526 strcpy(posn, request->lock->token);
528 slot = get_active_slot();
529 slot->callback_func = process_response;
530 slot->callback_data = request;
531 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &request->buffer);
532 curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, request->buffer.size);
533 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
534 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
535 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
536 curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
537 curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
538 curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
539 curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
541 if (start_active_slot(slot)) {
542 request->slot = slot;
543 request->state = RUN_PUT;
545 request->state = ABORTED;
551 static void start_move(struct transfer_request *request)
553 struct active_request_slot *slot;
554 struct curl_slist *dav_headers = NULL;
556 slot = get_active_slot();
557 slot->callback_func = process_response;
558 slot->callback_data = request;
559 curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
560 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MOVE);
561 dav_headers = curl_slist_append(dav_headers, request->dest);
562 dav_headers = curl_slist_append(dav_headers, "Overwrite: T");
563 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
564 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
565 curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
567 if (start_active_slot(slot)) {
568 request->slot = slot;
569 request->state = RUN_MOVE;
571 request->state = ABORTED;
577 static int refresh_lock(struct remote_lock *lock)
579 struct active_request_slot *slot;
580 struct slot_results results;
582 char timeout_header[25];
583 struct curl_slist *dav_headers = NULL;
586 lock->refreshing = 1;
588 if_header = xmalloc(strlen(lock->token) + 25);
589 sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
590 sprintf(timeout_header, "Timeout: Second-%ld", lock->timeout);
591 dav_headers = curl_slist_append(dav_headers, if_header);
592 dav_headers = curl_slist_append(dav_headers, timeout_header);
594 slot = get_active_slot();
595 slot->results = &results;
596 curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
597 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
598 curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
599 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
600 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
602 if (start_active_slot(slot)) {
603 run_active_slot(slot);
604 if (results.curl_result != CURLE_OK) {
605 fprintf(stderr, "LOCK HTTP error %ld\n",
608 lock->start_time = time(NULL);
613 lock->refreshing = 0;
614 curl_slist_free_all(dav_headers);
620 static void check_locks()
622 struct remote_lock *lock = remote->locks;
623 time_t current_time = time(NULL);
627 time_remaining = lock->start_time + lock->timeout -
629 if (!lock->refreshing && time_remaining < LOCK_REFRESH) {
630 if (!refresh_lock(lock)) {
632 "Unable to refresh lock for %s\n",
642 static void release_request(struct transfer_request *request)
644 struct transfer_request *entry = request_queue_head;
646 if (request == request_queue_head) {
647 request_queue_head = request->next;
649 while (entry->next != NULL && entry->next != request)
651 if (entry->next == request)
652 entry->next = entry->next->next;
655 if (request->local_fileno != -1)
656 close(request->local_fileno);
657 if (request->local_stream)
658 fclose(request->local_stream);
659 if (request->url != NULL)
664 static void finish_request(struct transfer_request *request)
667 struct packed_git *target;
668 struct packed_git **lst;
670 request->curl_result = request->slot->curl_result;
671 request->http_code = request->slot->http_code;
672 request->slot = NULL;
674 /* Keep locks active */
677 if (request->headers != NULL)
678 curl_slist_free_all(request->headers);
680 /* URL is reused for MOVE after PUT */
681 if (request->state != RUN_PUT) {
686 if (request->state == RUN_MKCOL) {
687 if (request->curl_result == CURLE_OK ||
688 request->http_code == 405) {
689 remote_dir_exists[request->obj->sha1[0]] = 1;
692 fprintf(stderr, "MKCOL %s failed, aborting (%d/%ld)\n",
693 sha1_to_hex(request->obj->sha1),
694 request->curl_result, request->http_code);
695 request->state = ABORTED;
698 } else if (request->state == RUN_PUT) {
699 if (request->curl_result == CURLE_OK) {
702 fprintf(stderr, "PUT %s failed, aborting (%d/%ld)\n",
703 sha1_to_hex(request->obj->sha1),
704 request->curl_result, request->http_code);
705 request->state = ABORTED;
708 } else if (request->state == RUN_MOVE) {
709 if (request->curl_result == CURLE_OK) {
710 fprintf(stderr, " sent %s\n",
711 sha1_to_hex(request->obj->sha1));
712 request->obj->flags |= REMOTE;
713 release_request(request);
715 fprintf(stderr, "MOVE %s failed, aborting (%d/%ld)\n",
716 sha1_to_hex(request->obj->sha1),
717 request->curl_result, request->http_code);
718 request->state = ABORTED;
721 } else if (request->state == RUN_FETCH_LOOSE) {
722 fchmod(request->local_fileno, 0444);
723 close(request->local_fileno); request->local_fileno = -1;
725 if (request->curl_result != CURLE_OK &&
726 request->http_code != 416) {
727 if (stat(request->tmpfile, &st) == 0) {
729 unlink(request->tmpfile);
732 if (request->http_code == 416)
733 fprintf(stderr, "Warning: requested range invalid; we may already have all the data.\n");
735 inflateEnd(&request->stream);
736 SHA1_Final(request->real_sha1, &request->c);
737 if (request->zret != Z_STREAM_END) {
738 unlink(request->tmpfile);
739 } else if (memcmp(request->obj->sha1, request->real_sha1, 20)) {
740 unlink(request->tmpfile);
746 if (request->rename == 0) {
747 request->obj->flags |= (LOCAL | REMOTE);
752 /* Try fetching packed if necessary */
753 if (request->obj->flags & LOCAL)
754 release_request(request);
756 start_fetch_packed(request);
758 } else if (request->state == RUN_FETCH_PACKED) {
759 if (request->curl_result != CURLE_OK) {
760 fprintf(stderr, "Unable to get pack file %s\n%s",
761 request->url, curl_errorstr);
762 remote->can_update_info_refs = 0;
764 fclose(request->local_stream);
765 request->local_stream = NULL;
766 if (!move_temp_to_file(request->tmpfile,
767 request->filename)) {
768 target = (struct packed_git *)request->userData;
769 lst = &remote->packs;
770 while (*lst != target)
771 lst = &((*lst)->next);
774 if (!verify_pack(target, 0))
775 install_packed_git(target);
777 remote->can_update_info_refs = 0;
780 release_request(request);
784 void fill_active_slots(void)
786 struct transfer_request *request = request_queue_head;
787 struct transfer_request *next;
788 struct active_request_slot *slot = active_queue_head;
794 while (active_requests < max_requests && request != NULL) {
795 next = request->next;
796 if (request->state == NEED_FETCH) {
797 start_fetch_loose(request);
798 } else if (pushing && request->state == NEED_PUSH) {
799 if (remote_dir_exists[request->obj->sha1[0]] == 1) {
802 start_mkcol(request);
804 curl_multi_perform(curlm, &num_transfers);
809 while (slot != NULL) {
810 if (!slot->in_use && slot->curl != NULL) {
811 curl_easy_cleanup(slot->curl);
818 static void get_remote_object_list(unsigned char parent);
820 static void add_fetch_request(struct object *obj)
822 struct transfer_request *request;
827 * Don't fetch the object if it's known to exist locally
828 * or is already in the request queue
830 if (remote_dir_exists[obj->sha1[0]] == -1)
831 get_remote_object_list(obj->sha1[0]);
832 if (obj->flags & (LOCAL | FETCHING))
835 obj->flags |= FETCHING;
836 request = xmalloc(sizeof(*request));
839 request->lock = NULL;
840 request->headers = NULL;
841 request->local_fileno = -1;
842 request->local_stream = NULL;
843 request->state = NEED_FETCH;
844 request->next = request_queue_head;
845 request_queue_head = request;
851 static void add_send_request(struct object *obj, struct remote_lock *lock)
853 struct transfer_request *request = request_queue_head;
854 struct packed_git *target;
856 /* Keep locks active */
860 * Don't push the object if it's known to exist on the remote
861 * or is already in the request queue
863 if (remote_dir_exists[obj->sha1[0]] == -1)
864 get_remote_object_list(obj->sha1[0]);
865 if (obj->flags & (REMOTE | PUSHING))
867 target = find_sha1_pack(obj->sha1, remote->packs);
869 obj->flags |= REMOTE;
873 obj->flags |= PUSHING;
874 request = xmalloc(sizeof(*request));
877 request->lock = lock;
878 request->headers = NULL;
879 request->local_fileno = -1;
880 request->local_stream = NULL;
881 request->state = NEED_PUSH;
882 request->next = request_queue_head;
883 request_queue_head = request;
889 static int fetch_index(unsigned char *sha1)
891 char *hex = sha1_to_hex(sha1);
894 char tmpfile[PATH_MAX];
896 char range[RANGE_HEADER_SIZE];
897 struct curl_slist *range_header = NULL;
900 struct active_request_slot *slot;
901 struct slot_results results;
903 /* Don't use the index if the pack isn't there */
904 url = xmalloc(strlen(remote->url) + 65);
905 sprintf(url, "%s/objects/pack/pack-%s.pack", remote->url, hex);
906 slot = get_active_slot();
907 slot->results = &results;
908 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
909 curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
910 if (start_active_slot(slot)) {
911 run_active_slot(slot);
912 if (results.curl_result != CURLE_OK) {
914 return error("Unable to verify pack %s is available",
918 return error("Unable to start request");
921 if (has_pack_index(sha1))
925 fprintf(stderr, "Getting index for pack %s\n", hex);
927 sprintf(url, "%s/objects/pack/pack-%s.idx", remote->url, hex);
929 filename = sha1_pack_index_name(sha1);
930 snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
931 indexfile = fopen(tmpfile, "a");
933 return error("Unable to open local file %s for pack index",
936 slot = get_active_slot();
937 slot->results = &results;
938 curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
939 curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
940 curl_easy_setopt(slot->curl, CURLOPT_FILE, indexfile);
941 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
942 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
943 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
944 slot->local = indexfile;
946 /* If there is data present from a previous transfer attempt,
947 resume where it left off */
948 prev_posn = ftell(indexfile);
952 "Resuming fetch of index for pack %s at byte %ld\n",
954 sprintf(range, "Range: bytes=%ld-", prev_posn);
955 range_header = curl_slist_append(range_header, range);
956 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
959 if (start_active_slot(slot)) {
960 run_active_slot(slot);
961 if (results.curl_result != CURLE_OK) {
964 return error("Unable to get pack index %s\n%s", url,
970 return error("Unable to start request");
976 return move_temp_to_file(tmpfile, filename);
979 static int setup_index(unsigned char *sha1)
981 struct packed_git *new_pack;
983 if (fetch_index(sha1))
986 new_pack = parse_pack_index(sha1);
987 new_pack->next = remote->packs;
988 remote->packs = new_pack;
992 static int fetch_indices(void)
994 unsigned char sha1[20];
996 struct buffer buffer;
1000 struct active_request_slot *slot;
1001 struct slot_results results;
1003 data = xmalloc(4096);
1004 memset(data, 0, 4096);
1007 buffer.buffer = data;
1010 fprintf(stderr, "Getting pack list\n");
1012 url = xmalloc(strlen(remote->url) + 21);
1013 sprintf(url, "%s/objects/info/packs", remote->url);
1015 slot = get_active_slot();
1016 slot->results = &results;
1017 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
1018 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1019 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1020 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
1021 if (start_active_slot(slot)) {
1022 run_active_slot(slot);
1023 if (results.curl_result != CURLE_OK) {
1024 free(buffer.buffer);
1026 if (results.http_code == 404)
1029 return error("%s", curl_errorstr);
1032 free(buffer.buffer);
1034 return error("Unable to start request");
1038 data = buffer.buffer;
1039 while (i < buffer.posn) {
1043 if (i + 52 < buffer.posn &&
1044 !strncmp(data + i, " pack-", 6) &&
1045 !strncmp(data + i + 46, ".pack\n", 6)) {
1046 get_sha1_hex(data + i + 6, sha1);
1052 while (data[i] != '\n')
1058 free(buffer.buffer);
1062 static inline int needs_quote(int ch)
1065 case '/': case '-': case '.':
1066 case 'A'...'Z': case 'a'...'z': case '0'...'9':
1073 static inline int hex(int v)
1075 if (v < 10) return '0' + v;
1076 else return 'A' + v - 10;
1079 static char *quote_ref_url(const char *base, const char *ref)
1083 int len, baselen, ch;
1085 baselen = strlen(base);
1087 for (cp = ref; (ch = *cp) != 0; cp++, len++)
1088 if (needs_quote(ch))
1089 len += 2; /* extra two hex plus replacement % */
1090 qref = xmalloc(len);
1091 memcpy(qref, base, baselen);
1092 for (cp = ref, dp = qref + baselen; (ch = *cp) != 0; cp++) {
1093 if (needs_quote(ch)) {
1095 *dp++ = hex((ch >> 4) & 0xF);
1096 *dp++ = hex(ch & 0xF);
1106 int fetch_ref(char *ref, unsigned char *sha1)
1110 struct buffer buffer;
1111 char *base = remote->url;
1112 struct active_request_slot *slot;
1113 struct slot_results results;
1116 buffer.buffer = hex;
1119 url = quote_ref_url(base, ref);
1120 slot = get_active_slot();
1121 slot->results = &results;
1122 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
1123 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1124 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
1125 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1126 if (start_active_slot(slot)) {
1127 run_active_slot(slot);
1128 if (results.curl_result != CURLE_OK)
1129 return error("Couldn't get %s for %s\n%s",
1130 url, ref, curl_errorstr);
1132 return error("Unable to start request");
1136 get_sha1_hex(hex, sha1);
1140 static void one_remote_object(const char *hex)
1142 unsigned char sha1[20];
1145 if (get_sha1_hex(hex, sha1) != 0)
1148 obj = lookup_object(sha1);
1150 obj = parse_object(sha1);
1152 /* Ignore remote objects that don't exist locally */
1156 obj->flags |= REMOTE;
1157 if (!object_list_contains(objects, obj))
1158 add_object(obj, &objects, NULL, "");
1161 static void handle_lockprop_ctx(struct xml_ctx *ctx, int tag_closed)
1163 int *lock_flags = (int *)ctx->userData;
1166 if (!strcmp(ctx->name, DAV_CTX_LOCKENTRY)) {
1167 if ((*lock_flags & DAV_PROP_LOCKEX) &&
1168 (*lock_flags & DAV_PROP_LOCKWR)) {
1169 *lock_flags |= DAV_LOCK_OK;
1171 *lock_flags &= DAV_LOCK_OK;
1172 } else if (!strcmp(ctx->name, DAV_CTX_LOCKTYPE_WRITE)) {
1173 *lock_flags |= DAV_PROP_LOCKWR;
1174 } else if (!strcmp(ctx->name, DAV_CTX_LOCKTYPE_EXCLUSIVE)) {
1175 *lock_flags |= DAV_PROP_LOCKEX;
1180 static void handle_new_lock_ctx(struct xml_ctx *ctx, int tag_closed)
1182 struct remote_lock *lock = (struct remote_lock *)ctx->userData;
1184 if (tag_closed && ctx->cdata) {
1185 if (!strcmp(ctx->name, DAV_ACTIVELOCK_OWNER)) {
1186 lock->owner = xmalloc(strlen(ctx->cdata) + 1);
1187 strcpy(lock->owner, ctx->cdata);
1188 } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TIMEOUT)) {
1189 if (!strncmp(ctx->cdata, "Second-", 7))
1191 strtol(ctx->cdata + 7, NULL, 10);
1192 } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TOKEN)) {
1193 if (!strncmp(ctx->cdata, "opaquelocktoken:", 16)) {
1194 lock->token = xmalloc(strlen(ctx->cdata) - 15);
1195 strcpy(lock->token, ctx->cdata + 16);
1201 static void one_remote_ref(char *refname);
1204 xml_start_tag(void *userData, const char *name, const char **atts)
1206 struct xml_ctx *ctx = (struct xml_ctx *)userData;
1207 const char *c = index(name, ':');
1215 new_len = strlen(ctx->name) + strlen(c) + 2;
1217 if (new_len > ctx->len) {
1218 ctx->name = xrealloc(ctx->name, new_len);
1221 strcat(ctx->name, ".");
1222 strcat(ctx->name, c);
1229 ctx->userFunc(ctx, 0);
1233 xml_end_tag(void *userData, const char *name)
1235 struct xml_ctx *ctx = (struct xml_ctx *)userData;
1236 const char *c = index(name, ':');
1239 ctx->userFunc(ctx, 1);
1246 ep = ctx->name + strlen(ctx->name) - strlen(c) - 1;
1251 xml_cdata(void *userData, const XML_Char *s, int len)
1253 struct xml_ctx *ctx = (struct xml_ctx *)userData;
1256 ctx->cdata = xcalloc(len+1, 1);
1257 strncpy(ctx->cdata, s, len);
1260 static struct remote_lock *lock_remote(char *path, long timeout)
1262 struct active_request_slot *slot;
1263 struct slot_results results;
1264 struct buffer out_buffer;
1265 struct buffer in_buffer;
1270 char timeout_header[25];
1271 struct remote_lock *lock = NULL;
1272 XML_Parser parser = XML_ParserCreate(NULL);
1273 enum XML_Status result;
1274 struct curl_slist *dav_headers = NULL;
1277 url = xmalloc(strlen(remote->url) + strlen(path) + 1);
1278 sprintf(url, "%s%s", remote->url, path);
1280 /* Make sure leading directories exist for the remote ref */
1281 ep = strchr(url + strlen(remote->url) + 11, '/');
1284 slot = get_active_slot();
1285 slot->results = &results;
1286 curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
1287 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1288 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MKCOL);
1289 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1290 if (start_active_slot(slot)) {
1291 run_active_slot(slot);
1292 if (results.curl_result != CURLE_OK &&
1293 results.http_code != 405) {
1295 "Unable to create branch path %s\n",
1301 fprintf(stderr, "Unable to start request\n");
1306 ep = strchr(ep + 1, '/');
1309 out_buffer.size = strlen(LOCK_REQUEST) + strlen(git_default_email) - 2;
1310 out_data = xmalloc(out_buffer.size + 1);
1311 snprintf(out_data, out_buffer.size + 1, LOCK_REQUEST, git_default_email);
1312 out_buffer.posn = 0;
1313 out_buffer.buffer = out_data;
1315 in_buffer.size = 4096;
1316 in_data = xmalloc(in_buffer.size);
1318 in_buffer.buffer = in_data;
1320 sprintf(timeout_header, "Timeout: Second-%ld", timeout);
1321 dav_headers = curl_slist_append(dav_headers, timeout_header);
1322 dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1324 slot = get_active_slot();
1325 slot->results = &results;
1326 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1327 curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1328 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1329 curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1330 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1331 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1332 curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1333 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
1334 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1336 lock = xcalloc(1, sizeof(*lock));
1339 if (start_active_slot(slot)) {
1340 run_active_slot(slot);
1341 if (results.curl_result == CURLE_OK) {
1342 ctx.name = xcalloc(10, 1);
1345 ctx.userFunc = handle_new_lock_ctx;
1346 ctx.userData = lock;
1347 XML_SetUserData(parser, &ctx);
1348 XML_SetElementHandler(parser, xml_start_tag,
1350 XML_SetCharacterDataHandler(parser, xml_cdata);
1351 result = XML_Parse(parser, in_buffer.buffer,
1354 if (result != XML_STATUS_OK) {
1355 fprintf(stderr, "XML error: %s\n",
1357 XML_GetErrorCode(parser)));
1362 fprintf(stderr, "Unable to start request\n");
1365 curl_slist_free_all(dav_headers);
1369 if (lock->token == NULL || lock->timeout <= 0) {
1370 if (lock->token != NULL)
1372 if (lock->owner != NULL)
1379 lock->start_time = time(NULL);
1380 lock->next = remote->locks;
1381 remote->locks = lock;
1387 static int unlock_remote(struct remote_lock *lock)
1389 struct active_request_slot *slot;
1390 struct slot_results results;
1391 struct remote_lock *prev = remote->locks;
1392 char *lock_token_header;
1393 struct curl_slist *dav_headers = NULL;
1396 lock_token_header = xmalloc(strlen(lock->token) + 31);
1397 sprintf(lock_token_header, "Lock-Token: <opaquelocktoken:%s>",
1399 dav_headers = curl_slist_append(dav_headers, lock_token_header);
1401 slot = get_active_slot();
1402 slot->results = &results;
1403 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1404 curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
1405 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_UNLOCK);
1406 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1408 if (start_active_slot(slot)) {
1409 run_active_slot(slot);
1410 if (results.curl_result == CURLE_OK)
1413 fprintf(stderr, "UNLOCK HTTP error %ld\n",
1416 fprintf(stderr, "Unable to start UNLOCK request\n");
1419 curl_slist_free_all(dav_headers);
1420 free(lock_token_header);
1422 if (remote->locks == lock) {
1423 remote->locks = lock->next;
1425 while (prev && prev->next != lock)
1428 prev->next = prev->next->next;
1431 if (lock->owner != NULL)
1440 static void remote_ls(const char *path, int flags,
1441 void (*userFunc)(struct remote_ls_ctx *ls),
1444 static void process_ls_object(struct remote_ls_ctx *ls)
1446 unsigned int *parent = (unsigned int *)ls->userData;
1447 char *path = ls->dentry_name;
1450 if (!strcmp(ls->path, ls->dentry_name) && (ls->flags & IS_DIR)) {
1451 remote_dir_exists[*parent] = 1;
1455 if (strlen(path) != 49)
1458 obj_hex = xmalloc(strlen(path));
1459 strncpy(obj_hex, path, 2);
1460 strcpy(obj_hex + 2, path + 3);
1461 one_remote_object(obj_hex);
1465 static void process_ls_ref(struct remote_ls_ctx *ls)
1467 if (!strcmp(ls->path, ls->dentry_name) && (ls->dentry_flags & IS_DIR)) {
1468 fprintf(stderr, " %s\n", ls->dentry_name);
1472 if (!(ls->dentry_flags & IS_DIR))
1473 one_remote_ref(ls->dentry_name);
1476 static void handle_remote_ls_ctx(struct xml_ctx *ctx, int tag_closed)
1478 struct remote_ls_ctx *ls = (struct remote_ls_ctx *)ctx->userData;
1481 if (!strcmp(ctx->name, DAV_PROPFIND_RESP) && ls->dentry_name) {
1482 if (ls->dentry_flags & IS_DIR) {
1483 if (ls->flags & PROCESS_DIRS) {
1486 if (strcmp(ls->dentry_name, ls->path) &&
1487 ls->flags & RECURSIVE) {
1488 remote_ls(ls->dentry_name,
1493 } else if (ls->flags & PROCESS_FILES) {
1496 } else if (!strcmp(ctx->name, DAV_PROPFIND_NAME) && ctx->cdata) {
1497 ls->dentry_name = xmalloc(strlen(ctx->cdata) -
1498 remote->path_len + 1);
1499 strcpy(ls->dentry_name, ctx->cdata + remote->path_len);
1500 } else if (!strcmp(ctx->name, DAV_PROPFIND_COLLECTION)) {
1501 ls->dentry_flags |= IS_DIR;
1503 } else if (!strcmp(ctx->name, DAV_PROPFIND_RESP)) {
1504 if (ls->dentry_name) {
1505 free(ls->dentry_name);
1507 ls->dentry_name = NULL;
1508 ls->dentry_flags = 0;
1512 static void remote_ls(const char *path, int flags,
1513 void (*userFunc)(struct remote_ls_ctx *ls),
1516 char *url = xmalloc(strlen(remote->url) + strlen(path) + 1);
1517 struct active_request_slot *slot;
1518 struct slot_results results;
1519 struct buffer in_buffer;
1520 struct buffer out_buffer;
1523 XML_Parser parser = XML_ParserCreate(NULL);
1524 enum XML_Status result;
1525 struct curl_slist *dav_headers = NULL;
1527 struct remote_ls_ctx ls;
1530 ls.path = strdup(path);
1531 ls.dentry_name = NULL;
1532 ls.dentry_flags = 0;
1533 ls.userData = userData;
1534 ls.userFunc = userFunc;
1536 sprintf(url, "%s%s", remote->url, path);
1538 out_buffer.size = strlen(PROPFIND_ALL_REQUEST);
1539 out_data = xmalloc(out_buffer.size + 1);
1540 snprintf(out_data, out_buffer.size + 1, PROPFIND_ALL_REQUEST);
1541 out_buffer.posn = 0;
1542 out_buffer.buffer = out_data;
1544 in_buffer.size = 4096;
1545 in_data = xmalloc(in_buffer.size);
1547 in_buffer.buffer = in_data;
1549 dav_headers = curl_slist_append(dav_headers, "Depth: 1");
1550 dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1552 slot = get_active_slot();
1553 slot->results = &results;
1554 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1555 curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1556 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1557 curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1558 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1559 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1560 curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1561 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
1562 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1564 if (start_active_slot(slot)) {
1565 run_active_slot(slot);
1566 if (results.curl_result == CURLE_OK) {
1567 ctx.name = xcalloc(10, 1);
1570 ctx.userFunc = handle_remote_ls_ctx;
1572 XML_SetUserData(parser, &ctx);
1573 XML_SetElementHandler(parser, xml_start_tag,
1575 XML_SetCharacterDataHandler(parser, xml_cdata);
1576 result = XML_Parse(parser, in_buffer.buffer,
1580 if (result != XML_STATUS_OK) {
1581 fprintf(stderr, "XML error: %s\n",
1583 XML_GetErrorCode(parser)));
1587 fprintf(stderr, "Unable to start PROPFIND request\n");
1593 free(in_buffer.buffer);
1594 curl_slist_free_all(dav_headers);
1597 static void get_remote_object_list(unsigned char parent)
1599 char path[] = "objects/XX/";
1600 static const char hex[] = "0123456789abcdef";
1601 unsigned int val = parent;
1603 path[8] = hex[val >> 4];
1604 path[9] = hex[val & 0xf];
1605 remote_dir_exists[val] = 0;
1606 remote_ls(path, (PROCESS_FILES | PROCESS_DIRS),
1607 process_ls_object, &val);
1610 static int locking_available(void)
1612 struct active_request_slot *slot;
1613 struct slot_results results;
1614 struct buffer in_buffer;
1615 struct buffer out_buffer;
1618 XML_Parser parser = XML_ParserCreate(NULL);
1619 enum XML_Status result;
1620 struct curl_slist *dav_headers = NULL;
1625 strlen(PROPFIND_SUPPORTEDLOCK_REQUEST) +
1626 strlen(remote->url) - 2;
1627 out_data = xmalloc(out_buffer.size + 1);
1628 snprintf(out_data, out_buffer.size + 1,
1629 PROPFIND_SUPPORTEDLOCK_REQUEST, remote->url);
1630 out_buffer.posn = 0;
1631 out_buffer.buffer = out_data;
1633 in_buffer.size = 4096;
1634 in_data = xmalloc(in_buffer.size);
1636 in_buffer.buffer = in_data;
1638 dav_headers = curl_slist_append(dav_headers, "Depth: 0");
1639 dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1641 slot = get_active_slot();
1642 slot->results = &results;
1643 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1644 curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1645 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1646 curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1647 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1648 curl_easy_setopt(slot->curl, CURLOPT_URL, remote->url);
1649 curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1650 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
1651 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1653 if (start_active_slot(slot)) {
1654 run_active_slot(slot);
1655 if (results.curl_result == CURLE_OK) {
1656 ctx.name = xcalloc(10, 1);
1659 ctx.userFunc = handle_lockprop_ctx;
1660 ctx.userData = &lock_flags;
1661 XML_SetUserData(parser, &ctx);
1662 XML_SetElementHandler(parser, xml_start_tag,
1664 result = XML_Parse(parser, in_buffer.buffer,
1668 if (result != XML_STATUS_OK) {
1669 fprintf(stderr, "XML error: %s\n",
1671 XML_GetErrorCode(parser)));
1676 fprintf(stderr, "Unable to start request\n");
1680 free(in_buffer.buffer);
1681 curl_slist_free_all(dav_headers);
1686 static struct object_list **process_blob(struct blob *blob,
1687 struct object_list **p,
1688 struct name_path *path,
1691 struct object *obj = &blob->object;
1693 obj->flags |= LOCAL;
1695 if (obj->flags & (UNINTERESTING | SEEN))
1699 return add_object(obj, p, path, name);
1702 static struct object_list **process_tree(struct tree *tree,
1703 struct object_list **p,
1704 struct name_path *path,
1707 struct object *obj = &tree->object;
1708 struct tree_entry_list *entry;
1709 struct name_path me;
1711 obj->flags |= LOCAL;
1713 if (obj->flags & (UNINTERESTING | SEEN))
1715 if (parse_tree(tree) < 0)
1716 die("bad tree object %s", sha1_to_hex(obj->sha1));
1719 p = add_object(obj, p, NULL, name);
1722 me.elem_len = strlen(name);
1723 entry = tree->entries;
1724 tree->entries = NULL;
1726 struct tree_entry_list *next = entry->next;
1727 if (entry->directory)
1728 p = process_tree(entry->item.tree, p, &me, entry->name);
1730 p = process_blob(entry->item.blob, p, &me, entry->name);
1737 static void get_delta(struct rev_info *revs, struct remote_lock *lock)
1739 struct commit *commit;
1740 struct object_list **p = &objects, *pending;
1742 while ((commit = get_revision(revs)) != NULL) {
1743 p = process_tree(commit->tree, p, NULL, "");
1744 commit->object.flags |= LOCAL;
1745 if (!(commit->object.flags & UNINTERESTING))
1746 add_send_request(&commit->object, lock);
1749 for (pending = revs->pending_objects; pending; pending = pending->next) {
1750 struct object *obj = pending->item;
1751 const char *name = pending->name;
1753 if (obj->flags & (UNINTERESTING | SEEN))
1755 if (obj->type == tag_type) {
1757 p = add_object(obj, p, NULL, name);
1760 if (obj->type == tree_type) {
1761 p = process_tree((struct tree *)obj, p, NULL, name);
1764 if (obj->type == blob_type) {
1765 p = process_blob((struct blob *)obj, p, NULL, name);
1768 die("unknown pending object %s (%s)", sha1_to_hex(obj->sha1), name);
1772 if (!(objects->item->flags & UNINTERESTING))
1773 add_send_request(objects->item, lock);
1774 objects = objects->next;
1778 static int update_remote(unsigned char *sha1, struct remote_lock *lock)
1780 struct active_request_slot *slot;
1781 struct slot_results results;
1784 struct buffer out_buffer;
1785 struct curl_slist *dav_headers = NULL;
1788 if_header = xmalloc(strlen(lock->token) + 25);
1789 sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
1790 dav_headers = curl_slist_append(dav_headers, if_header);
1792 out_buffer.size = 41;
1793 out_data = xmalloc(out_buffer.size + 1);
1794 i = snprintf(out_data, out_buffer.size + 1, "%s\n", sha1_to_hex(sha1));
1795 if (i != out_buffer.size) {
1796 fprintf(stderr, "Unable to initialize PUT request body\n");
1799 out_buffer.posn = 0;
1800 out_buffer.buffer = out_data;
1802 slot = get_active_slot();
1803 slot->results = &results;
1804 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1805 curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1806 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1807 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1808 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
1809 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1810 curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1811 curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
1812 curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
1814 if (start_active_slot(slot)) {
1815 run_active_slot(slot);
1818 if (results.curl_result != CURLE_OK) {
1820 "PUT error: curl result=%d, HTTP code=%ld\n",
1821 results.curl_result, results.http_code);
1822 /* We should attempt recovery? */
1828 fprintf(stderr, "Unable to start PUT request\n");
1835 static struct ref *local_refs, **local_tail;
1836 static struct ref *remote_refs, **remote_tail;
1838 static int one_local_ref(const char *refname, const unsigned char *sha1)
1841 int len = strlen(refname) + 1;
1842 ref = xcalloc(1, sizeof(*ref) + len);
1843 memcpy(ref->new_sha1, sha1, 20);
1844 memcpy(ref->name, refname, len);
1846 local_tail = &ref->next;
1850 static void one_remote_ref(char *refname)
1853 unsigned char remote_sha1[20];
1856 if (fetch_ref(refname, remote_sha1) != 0) {
1858 "Unable to fetch ref %s from %s\n",
1859 refname, remote->url);
1864 * Fetch a copy of the object if it doesn't exist locally - it
1865 * may be required for updating server info later.
1867 if (remote->can_update_info_refs && !has_sha1_file(remote_sha1)) {
1868 obj = lookup_unknown_object(remote_sha1);
1870 fprintf(stderr, " fetch %s for %s\n",
1871 sha1_to_hex(remote_sha1), refname);
1872 add_fetch_request(obj);
1876 int len = strlen(refname) + 1;
1877 ref = xcalloc(1, sizeof(*ref) + len);
1878 memcpy(ref->old_sha1, remote_sha1, 20);
1879 memcpy(ref->name, refname, len);
1881 remote_tail = &ref->next;
1884 static void get_local_heads(void)
1886 local_tail = &local_refs;
1887 for_each_ref(one_local_ref);
1890 static void get_dav_remote_heads(void)
1892 remote_tail = &remote_refs;
1893 remote_ls("refs/", (PROCESS_FILES | PROCESS_DIRS | RECURSIVE), process_ls_ref, NULL);
1896 static int is_zero_sha1(const unsigned char *sha1)
1900 for (i = 0; i < 20; i++) {
1907 static void unmark_and_free(struct commit_list *list, unsigned int mark)
1910 struct commit_list *temp = list;
1911 temp->item->object.flags &= ~mark;
1917 static int ref_newer(const unsigned char *new_sha1,
1918 const unsigned char *old_sha1)
1921 struct commit *old, *new;
1922 struct commit_list *list, *used;
1925 /* Both new and old must be commit-ish and new is descendant of
1926 * old. Otherwise we require --force.
1928 o = deref_tag(parse_object(old_sha1), NULL, 0);
1929 if (!o || o->type != commit_type)
1931 old = (struct commit *) o;
1933 o = deref_tag(parse_object(new_sha1), NULL, 0);
1934 if (!o || o->type != commit_type)
1936 new = (struct commit *) o;
1938 if (parse_commit(new) < 0)
1942 commit_list_insert(new, &list);
1944 new = pop_most_recent_commit(&list, TMP_MARK);
1945 commit_list_insert(new, &used);
1951 unmark_and_free(list, TMP_MARK);
1952 unmark_and_free(used, TMP_MARK);
1956 static void mark_edge_parents_uninteresting(struct commit *commit)
1958 struct commit_list *parents;
1960 for (parents = commit->parents; parents; parents = parents->next) {
1961 struct commit *parent = parents->item;
1962 if (!(parent->object.flags & UNINTERESTING))
1964 mark_tree_uninteresting(parent->tree);
1968 static void mark_edges_uninteresting(struct commit_list *list)
1970 for ( ; list; list = list->next) {
1971 struct commit *commit = list->item;
1973 if (commit->object.flags & UNINTERESTING) {
1974 mark_tree_uninteresting(commit->tree);
1977 mark_edge_parents_uninteresting(commit);
1981 static void add_remote_info_ref(struct remote_ls_ctx *ls)
1983 struct buffer *buf = (struct buffer *)ls->userData;
1984 unsigned char remote_sha1[20];
1989 if (fetch_ref(ls->dentry_name, remote_sha1) != 0) {
1991 "Unable to fetch ref %s from %s\n",
1992 ls->dentry_name, remote->url);
1997 o = parse_object(remote_sha1);
2000 "Unable to parse object %s for remote ref %s\n",
2001 sha1_to_hex(remote_sha1), ls->dentry_name);
2006 len = strlen(ls->dentry_name) + 42;
2007 ref_info = xcalloc(len + 1, 1);
2008 sprintf(ref_info, "%s %s\n",
2009 sha1_to_hex(remote_sha1), ls->dentry_name);
2010 fwrite_buffer(ref_info, 1, len, buf);
2013 if (o->type == tag_type) {
2014 o = deref_tag(o, ls->dentry_name, 0);
2016 len = strlen(ls->dentry_name) + 45;
2017 ref_info = xcalloc(len + 1, 1);
2018 sprintf(ref_info, "%s %s^{}\n",
2019 sha1_to_hex(o->sha1), ls->dentry_name);
2020 fwrite_buffer(ref_info, 1, len, buf);
2026 static void update_remote_info_refs(struct remote_lock *lock)
2028 struct buffer buffer;
2029 struct active_request_slot *slot;
2030 struct slot_results results;
2032 struct curl_slist *dav_headers = NULL;
2034 buffer.buffer = xmalloc(4096);
2035 memset(buffer.buffer, 0, 4096);
2038 remote_ls("refs/", (PROCESS_FILES | RECURSIVE),
2039 add_remote_info_ref, &buffer);
2041 if_header = xmalloc(strlen(lock->token) + 25);
2042 sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
2043 dav_headers = curl_slist_append(dav_headers, if_header);
2045 slot = get_active_slot();
2046 slot->results = &results;
2047 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &buffer);
2048 curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, buffer.posn);
2049 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
2050 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
2051 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
2052 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
2053 curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
2054 curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
2055 curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
2059 if (start_active_slot(slot)) {
2060 run_active_slot(slot);
2061 if (results.curl_result != CURLE_OK) {
2063 "PUT error: curl result=%d, HTTP code=%ld\n",
2064 results.curl_result, results.http_code);
2069 free(buffer.buffer);
2072 static int remote_exists(const char *path)
2074 char *url = xmalloc(strlen(remote->url) + strlen(path) + 1);
2075 struct active_request_slot *slot;
2076 struct slot_results results;
2078 sprintf(url, "%s%s", remote->url, path);
2080 slot = get_active_slot();
2081 slot->results = &results;
2082 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
2083 curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
2085 if (start_active_slot(slot)) {
2086 run_active_slot(slot);
2087 if (results.http_code == 404)
2089 else if (results.curl_result == CURLE_OK)
2092 fprintf(stderr, "HEAD HTTP error %ld\n", results.http_code);
2094 fprintf(stderr, "Unable to start HEAD request\n");
2100 int main(int argc, char **argv)
2102 struct transfer_request *request;
2103 struct transfer_request *next_request;
2105 char **refspec = NULL;
2106 struct remote_lock *ref_lock = NULL;
2107 struct remote_lock *info_ref_lock = NULL;
2108 struct rev_info revs;
2112 setup_git_directory();
2115 remote = xcalloc(sizeof(*remote), 1);
2118 for (i = 1; i < argc; i++, argv++) {
2122 if (!strcmp(arg, "--all")) {
2126 if (!strcmp(arg, "--force")) {
2130 if (!strcmp(arg, "--verbose")) {
2134 usage(http_push_usage);
2138 char *path = strstr(arg, "//");
2140 path = index(path+2, '/');
2142 remote->path_len = strlen(path);
2147 nr_refspec = argc - i;
2152 usage(http_push_usage);
2154 memset(remote_dir_exists, -1, 256);
2158 no_pragma_header = curl_slist_append(no_pragma_header, "Pragma:");
2159 default_headers = curl_slist_append(default_headers, "Range:");
2160 default_headers = curl_slist_append(default_headers, "Destination:");
2161 default_headers = curl_slist_append(default_headers, "If:");
2162 default_headers = curl_slist_append(default_headers,
2163 "Pragma: no-cache");
2165 /* Verify DAV compliance/lock support */
2166 if (!locking_available()) {
2167 fprintf(stderr, "Error: no DAV locking support on remote repo %s\n", remote->url);
2172 /* Check whether the remote has server info files */
2173 remote->can_update_info_refs = 0;
2174 remote->has_info_refs = remote_exists("info/refs");
2175 remote->has_info_packs = remote_exists("objects/info/packs");
2176 if (remote->has_info_refs) {
2177 info_ref_lock = lock_remote("info/refs", LOCK_TIME);
2179 remote->can_update_info_refs = 1;
2181 if (remote->has_info_packs)
2184 /* Get a list of all local and remote heads to validate refspecs */
2186 fprintf(stderr, "Fetching remote heads...\n");
2187 get_dav_remote_heads();
2191 remote_tail = &remote_refs;
2192 if (match_refs(local_refs, remote_refs, &remote_tail,
2193 nr_refspec, refspec, push_all))
2196 fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
2203 for (ref = remote_refs; ref; ref = ref->next) {
2204 char old_hex[60], *new_hex;
2207 if (!memcmp(ref->old_sha1, ref->peer_ref->new_sha1, 20)) {
2208 if (push_verbosely || 1)
2209 fprintf(stderr, "'%s': up-to-date\n", ref->name);
2214 !is_zero_sha1(ref->old_sha1) &&
2216 if (!has_sha1_file(ref->old_sha1) ||
2217 !ref_newer(ref->peer_ref->new_sha1,
2219 /* We do not have the remote ref, or
2220 * we know that the remote ref is not
2221 * an ancestor of what we are trying to
2222 * push. Either way this can be losing
2223 * commits at the remote end and likely
2224 * we were not up to date to begin with.
2226 error("remote '%s' is not a strict "
2227 "subset of local ref '%s'. "
2228 "maybe you are not up-to-date and "
2229 "need to pull first?",
2231 ref->peer_ref->name);
2236 memcpy(ref->new_sha1, ref->peer_ref->new_sha1, 20);
2237 if (is_zero_sha1(ref->new_sha1)) {
2238 error("cannot happen anymore");
2243 strcpy(old_hex, sha1_to_hex(ref->old_sha1));
2244 new_hex = sha1_to_hex(ref->new_sha1);
2246 fprintf(stderr, "updating '%s'", ref->name);
2247 if (strcmp(ref->name, ref->peer_ref->name))
2248 fprintf(stderr, " using '%s'", ref->peer_ref->name);
2249 fprintf(stderr, "\n from %s\n to %s\n", old_hex, new_hex);
2252 /* Lock remote branch ref */
2253 ref_lock = lock_remote(ref->name, LOCK_TIME);
2254 if (ref_lock == NULL) {
2255 fprintf(stderr, "Unable to lock remote branch %s\n",
2261 /* Set up revision info for this refspec */
2262 const char *commit_argv[4];
2263 int commit_argc = 3;
2264 char *new_sha1_hex = strdup(sha1_to_hex(ref->new_sha1));
2265 char *old_sha1_hex = NULL;
2266 commit_argv[1] = "--objects";
2267 commit_argv[2] = new_sha1_hex;
2268 if (!push_all && !is_zero_sha1(ref->old_sha1)) {
2269 old_sha1_hex = xmalloc(42);
2270 sprintf(old_sha1_hex, "^%s",
2271 sha1_to_hex(ref->old_sha1));
2272 commit_argv[3] = old_sha1_hex;
2275 setup_revisions(commit_argc, commit_argv, &revs, NULL);
2279 commit_argv[1] = NULL;
2282 /* Generate a list of objects that need to be pushed */
2284 prepare_revision_walk(&revs);
2285 mark_edges_uninteresting(revs.commits);
2286 get_delta(&revs, ref_lock);
2287 finish_all_active_slots();
2289 /* Push missing objects to remote, this would be a
2290 convenient time to pack them first if appropriate. */
2292 fill_active_slots();
2293 finish_all_active_slots();
2295 /* Update the remote branch if all went well */
2296 if (aborted || !update_remote(ref->new_sha1, ref_lock)) {
2303 fprintf(stderr, " done\n");
2304 unlock_remote(ref_lock);
2308 /* Update remote server info if appropriate */
2309 if (remote->has_info_refs && new_refs) {
2310 if (info_ref_lock && remote->can_update_info_refs) {
2311 fprintf(stderr, "Updating remote server info\n");
2312 update_remote_info_refs(info_ref_lock);
2314 fprintf(stderr, "Unable to update server info\n");
2318 unlock_remote(info_ref_lock);
2323 curl_slist_free_all(no_pragma_header);
2324 curl_slist_free_all(default_headers);
2328 request = request_queue_head;
2329 while (request != NULL) {
2330 next_request = request->next;
2331 release_request(request);
2332 request = next_request;