9 #if LIBCURL_VERSION_NUM >= 0x070908
10 #define USE_CURL_MULTI
11 #define DEFAULT_MAX_REQUESTS 5
14 #if LIBCURL_VERSION_NUM < 0x070704
15 #define curl_global_cleanup() do { /* nothing */ } while(0)
17 #if LIBCURL_VERSION_NUM < 0x070800
18 #define curl_global_init(a) do { /* nothing */ } while(0)
21 #define PREV_BUF_SIZE 4096
22 #define RANGE_HEADER_SIZE 30
24 static int active_requests = 0;
25 static int data_received;
28 static int max_requests = -1;
31 static CURL *curl_default;
32 static struct curl_slist *pragma_header;
33 static struct curl_slist *no_pragma_header;
34 static struct curl_slist *no_range_header;
35 static char curl_errorstr[CURL_ERROR_SIZE];
41 struct packed_git *packs;
42 struct alt_base *next;
45 static struct alt_base *alt = NULL;
54 struct transfer_request
56 unsigned char sha1[20];
57 struct alt_base *repo;
59 char filename[PATH_MAX];
60 char tmpfile[PATH_MAX];
62 enum transfer_state state;
64 char errorstr[CURL_ERROR_SIZE];
66 unsigned char real_sha1[20];
71 struct active_request_slot *slot;
72 struct transfer_request *next;
75 struct active_request_slot
82 struct active_request_slot *next;
85 static struct transfer_request *request_queue_head = NULL;
86 static struct active_request_slot *active_queue_head = NULL;
88 static int curl_ssl_verify = -1;
89 static char *ssl_cert = NULL;
90 static char *ssl_key = NULL;
91 static char *ssl_capath = NULL;
92 static char *ssl_cainfo = NULL;
101 static int http_options(const char *var, const char *value)
103 if (!strcmp("http.sslverify", var)) {
104 if (curl_ssl_verify == -1) {
105 curl_ssl_verify = git_config_bool(var, value);
110 if (!strcmp("http.sslcert", var)) {
111 if (ssl_cert == NULL) {
112 ssl_cert = xmalloc(strlen(value)+1);
113 strcpy(ssl_cert, value);
117 #if LIBCURL_VERSION_NUM >= 0x070902
118 if (!strcmp("http.sslkey", var)) {
119 if (ssl_key == NULL) {
120 ssl_key = xmalloc(strlen(value)+1);
121 strcpy(ssl_key, value);
126 #if LIBCURL_VERSION_NUM >= 0x070908
127 if (!strcmp("http.sslcapath", var)) {
128 if (ssl_capath == NULL) {
129 ssl_capath = xmalloc(strlen(value)+1);
130 strcpy(ssl_capath, value);
135 if (!strcmp("http.sslcainfo", var)) {
136 if (ssl_cainfo == NULL) {
137 ssl_cainfo = xmalloc(strlen(value)+1);
138 strcpy(ssl_cainfo, value);
143 #ifdef USE_CURL_MULTI
144 if (!strcmp("http.maxrequests", var)) {
145 if (max_requests == -1)
146 max_requests = git_config_int(var, value);
151 /* Fall back on the default ones */
152 return git_default_config(var, value);
155 static size_t fwrite_buffer(void *ptr, size_t eltsize, size_t nmemb,
156 struct buffer *buffer)
158 size_t size = eltsize * nmemb;
159 if (size > buffer->size - buffer->posn)
160 size = buffer->size - buffer->posn;
161 memcpy(buffer->buffer + buffer->posn, ptr, size);
162 buffer->posn += size;
167 static size_t fwrite_buffer_dynamic(const void *ptr, size_t eltsize,
168 size_t nmemb, struct buffer *buffer)
170 size_t size = eltsize * nmemb;
171 if (size > buffer->size - buffer->posn) {
172 buffer->size = buffer->size * 3 / 2;
173 if (buffer->size < buffer->posn + size)
174 buffer->size = buffer->posn + size;
175 buffer->buffer = xrealloc(buffer->buffer, buffer->size);
177 memcpy(buffer->buffer + buffer->posn, ptr, size);
178 buffer->posn += size;
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,
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 #ifdef USE_CURL_MULTI
212 void process_curl_messages();
213 void process_request_queue();
216 struct active_request_slot *get_active_slot()
218 struct active_request_slot *slot = active_queue_head;
219 struct active_request_slot *newslot;
221 #ifdef USE_CURL_MULTI
224 /* Wait for a slot to open up if the queue is full */
225 while (active_requests >= max_requests) {
226 curl_multi_perform(curlm, &num_transfers);
227 if (num_transfers < active_requests) {
228 process_curl_messages();
233 while (slot != NULL && slot->in_use) {
237 newslot = xmalloc(sizeof(*newslot));
238 newslot->curl = curl_easy_duphandle(curl_default);
240 newslot->next = NULL;
242 slot = active_queue_head;
244 active_queue_head = newslot;
246 while (slot->next != NULL) {
249 slot->next = newslot;
258 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, pragma_header);
259 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_range_header);
260 curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, curl_errorstr);
265 int start_active_slot(struct active_request_slot *slot)
267 #ifdef USE_CURL_MULTI
268 CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl);
270 if (curlm_result != CURLM_OK &&
271 curlm_result != CURLM_CALL_MULTI_PERFORM) {
280 void run_active_slot(struct active_request_slot *slot)
282 #ifdef USE_CURL_MULTI
290 struct timeval select_timeout;
291 CURLMcode curlm_result;
293 while (!slot->done) {
296 curlm_result = curl_multi_perform(curlm,
298 } while (curlm_result == CURLM_CALL_MULTI_PERFORM);
299 if (num_transfers < active_requests) {
300 process_curl_messages();
301 process_request_queue();
304 if (!data_received && slot->local != NULL) {
305 current_pos = ftell(slot->local);
306 if (current_pos > last_pos)
308 last_pos = current_pos;
311 if (!slot->done && !data_received) {
316 select_timeout.tv_sec = 0;
317 select_timeout.tv_usec = 50000;
318 select(max_fd, &readfds, &writefds,
319 &excfds, &select_timeout);
323 slot->curl_result = curl_easy_perform(slot->curl);
328 void start_request(struct transfer_request *request)
330 char *hex = sha1_to_hex(request->sha1);
331 char prevfile[PATH_MAX];
335 unsigned char prev_buf[PREV_BUF_SIZE];
336 ssize_t prev_read = 0;
338 char range[RANGE_HEADER_SIZE];
339 struct curl_slist *range_header = NULL;
340 struct active_request_slot *slot;
342 snprintf(prevfile, sizeof(prevfile), "%s.prev", request->filename);
344 rename(request->tmpfile, prevfile);
345 unlink(request->tmpfile);
347 request->local = open(request->tmpfile,
348 O_WRONLY | O_CREAT | O_EXCL, 0666);
349 /* This could have failed due to the "lazy directory creation";
350 * try to mkdir the last path component.
352 if (request->local < 0 && errno == ENOENT) {
353 char *dir = strrchr(request->tmpfile, '/');
356 mkdir(request->tmpfile, 0777);
359 request->local = open(request->tmpfile,
360 O_WRONLY | O_CREAT | O_EXCL, 0666);
363 if (request->local < 0) {
364 request->state = ABORTED;
365 error("Couldn't create temporary file %s for %s: %s\n",
366 request->tmpfile, request->filename, strerror(errno));
370 memset(&request->stream, 0, sizeof(request->stream));
372 inflateInit(&request->stream);
374 SHA1_Init(&request->c);
376 url = xmalloc(strlen(request->repo->base) + 50);
377 request->url = xmalloc(strlen(request->repo->base) + 50);
378 strcpy(url, request->repo->base);
379 posn = url + strlen(request->repo->base);
380 strcpy(posn, "objects/");
382 memcpy(posn, hex, 2);
385 strcpy(posn, hex + 2);
386 strcpy(request->url, url);
388 /* If a previous temp file is present, process what was already
390 prevlocal = open(prevfile, O_RDONLY);
391 if (prevlocal != -1) {
393 prev_read = read(prevlocal, prev_buf, PREV_BUF_SIZE);
395 if (fwrite_sha1_file(prev_buf,
398 request) == prev_read) {
399 prev_posn += prev_read;
404 } while (prev_read > 0);
409 /* Reset inflate/SHA1 if there was an error reading the previous temp
410 file; also rewind to the beginning of the local file. */
411 if (prev_read == -1) {
412 memset(&request->stream, 0, sizeof(request->stream));
413 inflateInit(&request->stream);
414 SHA1_Init(&request->c);
417 lseek(request->local, SEEK_SET, 0);
418 ftruncate(request->local, 0);
422 slot = get_active_slot();
423 curl_easy_setopt(slot->curl, CURLOPT_FILE, request);
424 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_sha1_file);
425 curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
426 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
427 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
429 /* If we have successfully processed data from a previous fetch
430 attempt, only fetch the data we don't already have. */
434 "Resuming fetch of object %s at byte %ld\n",
436 sprintf(range, "Range: bytes=%ld-", prev_posn);
437 range_header = curl_slist_append(range_header, range);
438 curl_easy_setopt(slot->curl,
439 CURLOPT_HTTPHEADER, range_header);
442 /* Try to get the request started, abort the request on error */
443 if (!start_active_slot(slot)) {
444 request->state = ABORTED;
445 close(request->local);
450 request->slot = slot;
451 request->state = ACTIVE;
454 void finish_request(struct transfer_request *request)
456 fchmod(request->local, 0444);
457 close(request->local);
459 if (request->http_code == 416) {
460 fprintf(stderr, "Warning: requested range invalid; we may already have all the data.\n");
461 } else if (request->curl_result != CURLE_OK) {
465 inflateEnd(&request->stream);
466 SHA1_Final(request->real_sha1, &request->c);
467 if (request->zret != Z_STREAM_END) {
468 unlink(request->tmpfile);
471 if (memcmp(request->sha1, request->real_sha1, 20)) {
472 unlink(request->tmpfile);
476 move_temp_to_file(request->tmpfile, request->filename);
478 if (request->rename == 0)
479 pull_say("got %s\n", sha1_to_hex(request->sha1));
482 void release_request(struct transfer_request *request)
484 struct transfer_request *entry = request_queue_head;
486 if (request == request_queue_head) {
487 request_queue_head = request->next;
489 while (entry->next != NULL && entry->next != request)
491 if (entry->next == request)
492 entry->next = entry->next->next;
499 #ifdef USE_CURL_MULTI
500 void process_curl_messages()
503 struct active_request_slot *slot;
504 struct transfer_request *request = NULL;
505 CURLMsg *curl_message = curl_multi_info_read(curlm, &num_messages);
507 while (curl_message != NULL) {
508 if (curl_message->msg == CURLMSG_DONE) {
509 slot = active_queue_head;
510 while (slot != NULL &&
511 slot->curl != curl_message->easy_handle)
514 curl_multi_remove_handle(curlm, slot->curl);
518 slot->curl_result = curl_message->data.result;
519 request = request_queue_head;
520 while (request != NULL &&
521 request->slot != slot)
522 request = request->next;
524 fprintf(stderr, "Received DONE message for unknown request!\n");
526 if (request != NULL) {
527 request->curl_result =
528 curl_message->data.result;
529 curl_easy_getinfo(slot->curl,
531 &request->http_code);
532 request->slot = NULL;
534 /* Use alternates if necessary */
535 if (request->http_code == 404 &&
536 request->repo->next != NULL) {
537 request->repo = request->repo->next;
538 start_request(request);
540 finish_request(request);
541 request->state = COMPLETE;
545 fprintf(stderr, "Unknown CURL message received: %d\n",
546 (int)curl_message->msg);
548 curl_message = curl_multi_info_read(curlm, &num_messages);
552 void process_request_queue()
554 struct transfer_request *request = request_queue_head;
557 while (active_requests < max_requests && request != NULL) {
558 if (request->state == WAITING) {
559 if (has_sha1_file(request->sha1))
560 release_request(request);
562 start_request(request);
563 curl_multi_perform(curlm, &num_transfers);
565 request = request->next;
570 void prefetch(unsigned char *sha1)
572 struct transfer_request *newreq;
573 struct transfer_request *tail;
574 char *filename = sha1_file_name(sha1);
576 newreq = xmalloc(sizeof(*newreq));
577 memcpy(newreq->sha1, sha1, 20);
581 newreq->state = WAITING;
582 snprintf(newreq->filename, sizeof(newreq->filename), "%s", filename);
583 snprintf(newreq->tmpfile, sizeof(newreq->tmpfile),
584 "%s.temp", filename);
587 if (request_queue_head == NULL) {
588 request_queue_head = newreq;
590 tail = request_queue_head;
591 while (tail->next != NULL) {
596 #ifdef USE_CURL_MULTI
597 process_request_queue();
598 process_curl_messages();
602 static int fetch_index(struct alt_base *repo, unsigned char *sha1)
604 char *hex = sha1_to_hex(sha1);
607 char tmpfile[PATH_MAX];
609 char range[RANGE_HEADER_SIZE];
610 struct curl_slist *range_header = NULL;
613 struct active_request_slot *slot;
615 if (has_pack_index(sha1))
619 fprintf(stderr, "Getting index for pack %s\n", hex);
621 url = xmalloc(strlen(repo->base) + 64);
622 sprintf(url, "%s/objects/pack/pack-%s.idx", repo->base, hex);
624 filename = sha1_pack_index_name(sha1);
625 snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
626 indexfile = fopen(tmpfile, "a");
628 return error("Unable to open local file %s for pack index",
631 slot = get_active_slot();
632 curl_easy_setopt(slot->curl, CURLOPT_FILE, indexfile);
633 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
634 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
635 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
636 slot->local = indexfile;
638 /* If there is data present from a previous transfer attempt,
639 resume where it left off */
640 prev_posn = ftell(indexfile);
644 "Resuming fetch of index for pack %s at byte %ld\n",
646 sprintf(range, "Range: bytes=%ld-", prev_posn);
647 range_header = curl_slist_append(range_header, range);
648 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
651 if (start_active_slot(slot)) {
652 run_active_slot(slot);
653 if (slot->curl_result != CURLE_OK) {
655 return error("Unable to get pack index %s\n%s", url,
659 return error("Unable to start request");
664 return move_temp_to_file(tmpfile, filename);
667 static int setup_index(struct alt_base *repo, unsigned char *sha1)
669 struct packed_git *new_pack;
670 if (has_pack_file(sha1))
671 return 0; // don't list this as something we can get
673 if (fetch_index(repo, sha1))
676 new_pack = parse_pack_index(sha1);
677 new_pack->next = repo->packs;
678 repo->packs = new_pack;
682 static int fetch_alternates(char *base)
685 struct buffer buffer;
689 int http_specific = 1;
690 struct alt_base *tail = alt;
691 static const char null_byte = '\0';
693 struct active_request_slot *slot;
695 data = xmalloc(4096);
698 buffer.buffer = data;
701 fprintf(stderr, "Getting alternates list\n");
703 url = xmalloc(strlen(base) + 31);
704 sprintf(url, "%s/objects/info/http-alternates", base);
706 slot = get_active_slot();
707 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
708 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
709 fwrite_buffer_dynamic);
710 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
711 if (start_active_slot(slot)) {
712 run_active_slot(slot);
713 if (slot->curl_result != CURLE_OK || !buffer.posn) {
716 sprintf(url, "%s/objects/info/alternates", base);
718 slot = get_active_slot();
719 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
720 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
721 fwrite_buffer_dynamic);
722 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
723 if (start_active_slot(slot)) {
724 run_active_slot(slot);
725 if (slot->curl_result != CURLE_OK) {
736 fwrite_buffer_dynamic(&null_byte, 1, 1, &buffer);
738 data = buffer.buffer;
740 while (i < buffer.posn) {
742 while (posn < buffer.posn && data[posn] != '\n')
744 if (data[posn] == '\n') {
747 struct alt_base *newalt;
749 if (data[i] == '/') {
750 serverlen = strchr(base + 8, '/') - base;
752 } else if (!memcmp(data + i, "../", 3)) {
754 serverlen = strlen(base);
755 while (i + 2 < posn &&
756 !memcmp(data + i, "../", 3)) {
759 } while (serverlen &&
760 base[serverlen - 1] != '/');
763 // If the server got removed, give up.
764 okay = strchr(base, ':') - base + 3 <
766 } else if (http_specific) {
767 char *colon = strchr(data + i, ':');
768 char *slash = strchr(data + i, '/');
769 if (colon && slash && colon < data + posn &&
770 slash < data + posn && colon < slash) {
774 // skip 'objects' at end
776 target = xmalloc(serverlen + posn - i - 6);
777 strncpy(target, base, serverlen);
778 strncpy(target + serverlen, data + i,
780 target[serverlen + posn - i - 7] = '\0';
783 "Also look at %s\n", target);
784 newalt = xmalloc(sizeof(*newalt));
786 newalt->base = target;
787 newalt->got_indices = 0;
788 newalt->packs = NULL;
789 while (tail->next != NULL)
802 static int fetch_indices(struct alt_base *repo)
804 unsigned char sha1[20];
806 struct buffer buffer;
810 struct active_request_slot *slot;
812 if (repo->got_indices)
815 data = xmalloc(4096);
818 buffer.buffer = data;
821 fprintf(stderr, "Getting pack list\n");
823 url = xmalloc(strlen(repo->base) + 21);
824 sprintf(url, "%s/objects/info/packs", repo->base);
826 slot = get_active_slot();
827 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
828 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
829 fwrite_buffer_dynamic);
830 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
831 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
832 if (start_active_slot(slot)) {
833 run_active_slot(slot);
834 if (slot->curl_result != CURLE_OK) {
836 return error("%s", curl_errorstr);
840 return error("Unable to start request");
843 data = buffer.buffer;
844 while (i < buffer.posn) {
848 if (i + 52 < buffer.posn &&
849 !strncmp(data + i, " pack-", 6) &&
850 !strncmp(data + i + 46, ".pack\n", 6)) {
851 get_sha1_hex(data + i + 6, sha1);
852 setup_index(repo, sha1);
857 while (data[i] != '\n')
864 repo->got_indices = 1;
868 static int fetch_pack(struct alt_base *repo, unsigned char *sha1)
871 struct packed_git *target;
872 struct packed_git **lst;
875 char tmpfile[PATH_MAX];
878 char range[RANGE_HEADER_SIZE];
879 struct curl_slist *range_header = NULL;
881 struct active_request_slot *slot;
883 if (fetch_indices(repo))
885 target = find_sha1_pack(sha1, repo->packs);
890 fprintf(stderr, "Getting pack %s\n",
891 sha1_to_hex(target->sha1));
892 fprintf(stderr, " which contains %s\n",
896 url = xmalloc(strlen(repo->base) + 65);
897 sprintf(url, "%s/objects/pack/pack-%s.pack",
898 repo->base, sha1_to_hex(target->sha1));
900 filename = sha1_pack_name(target->sha1);
901 snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
902 packfile = fopen(tmpfile, "a");
904 return error("Unable to open local file %s for pack",
907 slot = get_active_slot();
908 curl_easy_setopt(slot->curl, CURLOPT_FILE, packfile);
909 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
910 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
911 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
912 slot->local = packfile;
914 /* If there is data present from a previous transfer attempt,
915 resume where it left off */
916 prev_posn = ftell(packfile);
920 "Resuming fetch of pack %s at byte %ld\n",
921 sha1_to_hex(target->sha1), prev_posn);
922 sprintf(range, "Range: bytes=%ld-", prev_posn);
923 range_header = curl_slist_append(range_header, range);
924 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
927 if (start_active_slot(slot)) {
928 run_active_slot(slot);
929 if (slot->curl_result != CURLE_OK) {
931 return error("Unable to get pack file %s\n%s", url,
935 return error("Unable to start request");
940 ret = move_temp_to_file(tmpfile, filename);
945 while (*lst != target)
946 lst = &((*lst)->next);
949 if (verify_pack(target, 0))
951 install_packed_git(target);
956 static int fetch_object(struct alt_base *repo, unsigned char *sha1)
958 char *hex = sha1_to_hex(sha1);
960 struct transfer_request *request = request_queue_head;
962 while (request != NULL && memcmp(request->sha1, sha1, 20))
963 request = request->next;
965 return error("Couldn't find request for %s in the queue", hex);
967 if (has_sha1_file(request->sha1)) {
968 release_request(request);
972 #ifdef USE_CURL_MULTI
974 while (request->state == WAITING) {
975 curl_multi_perform(curlm, &num_transfers);
976 if (num_transfers < active_requests) {
977 process_curl_messages();
978 process_request_queue();
982 start_request(request);
985 while (request->state == ACTIVE) {
986 run_active_slot(request->slot);
987 #ifndef USE_CURL_MULTI
988 request->curl_result = request->slot->curl_result;
989 curl_easy_getinfo(request->slot->curl,
991 &request->http_code);
992 request->slot = NULL;
994 /* Use alternates if necessary */
995 if (request->http_code == 404 &&
996 request->repo->next != NULL) {
997 request->repo = request->repo->next;
998 start_request(request);
1000 finish_request(request);
1001 request->state = COMPLETE;
1006 if (request->state == ABORTED) {
1007 release_request(request);
1008 return error("Request for %s aborted", hex);
1011 if (request->curl_result != CURLE_OK && request->http_code != 416) {
1012 ret = error("%s", request->errorstr);
1013 release_request(request);
1017 if (request->zret != Z_STREAM_END) {
1018 ret = error("File %s (%s) corrupt\n", hex, request->url);
1019 release_request(request);
1023 if (memcmp(request->sha1, request->real_sha1, 20)) {
1024 release_request(request);
1025 return error("File %s has bad hash\n", hex);
1028 if (request->rename < 0) {
1029 ret = error("unable to write sha1 filename %s: %s",
1031 strerror(request->rename));
1032 release_request(request);
1036 release_request(request);
1040 int fetch(unsigned char *sha1)
1042 struct alt_base *altbase = alt;
1044 if (!fetch_object(altbase, sha1))
1047 if (!fetch_pack(altbase, sha1))
1049 altbase = altbase->next;
1051 return error("Unable to find %s under %s\n", sha1_to_hex(sha1),
1055 static inline int needs_quote(int ch)
1058 case '/': case '-': case '.':
1059 case 'A'...'Z': case 'a'...'z': case '0'...'9':
1066 static inline int hex(int v)
1068 if (v < 10) return '0' + v;
1069 else return 'A' + v - 10;
1072 static char *quote_ref_url(const char *base, const char *ref)
1076 int len, baselen, ch;
1078 baselen = strlen(base);
1079 len = baselen + 6; /* "refs/" + NUL */
1080 for (cp = ref; (ch = *cp) != 0; cp++, len++)
1081 if (needs_quote(ch))
1082 len += 2; /* extra two hex plus replacement % */
1083 qref = xmalloc(len);
1084 memcpy(qref, base, baselen);
1085 memcpy(qref + baselen, "refs/", 5);
1086 for (cp = ref, dp = qref + baselen + 5; (ch = *cp) != 0; cp++) {
1087 if (needs_quote(ch)) {
1089 *dp++ = hex((ch >> 4) & 0xF);
1090 *dp++ = hex(ch & 0xF);
1100 int fetch_ref(char *ref, unsigned char *sha1)
1104 struct buffer buffer;
1105 char *base = alt->base;
1106 struct active_request_slot *slot;
1109 buffer.buffer = hex;
1112 url = quote_ref_url(base, ref);
1113 slot = get_active_slot();
1114 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
1115 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1116 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
1117 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1118 if (start_active_slot(slot)) {
1119 run_active_slot(slot);
1120 if (slot->curl_result != CURLE_OK)
1121 return error("Couldn't get %s for %s\n%s",
1122 url, ref, curl_errorstr);
1124 return error("Unable to start request");
1128 get_sha1_hex(hex, sha1);
1132 int main(int argc, char **argv)
1137 struct active_request_slot *slot;
1139 while (arg < argc && argv[arg][0] == '-') {
1140 if (argv[arg][1] == 't') {
1142 } else if (argv[arg][1] == 'c') {
1144 } else if (argv[arg][1] == 'a') {
1148 } else if (argv[arg][1] == 'v') {
1150 } else if (argv[arg][1] == 'w') {
1151 write_ref = argv[arg + 1];
1153 } else if (!strcmp(argv[arg], "--recover")) {
1158 if (argc < arg + 2) {
1159 usage("git-http-fetch [-c] [-t] [-a] [-d] [-v] [--recover] [-w ref] commit-id url");
1162 commit_id = argv[arg];
1163 url = argv[arg + 1];
1165 curl_global_init(CURL_GLOBAL_ALL);
1167 #ifdef USE_CURL_MULTI
1168 char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
1169 if (http_max_requests != NULL)
1170 max_requests = atoi(http_max_requests);
1172 curlm = curl_multi_init();
1173 if (curlm == NULL) {
1174 fprintf(stderr, "Error creating curl multi handle.\n");
1179 if (getenv("GIT_SSL_NO_VERIFY"))
1180 curl_ssl_verify = 0;
1182 ssl_cert = getenv("GIT_SSL_CERT");
1183 #if LIBCURL_VERSION_NUM >= 0x070902
1184 ssl_key = getenv("GIT_SSL_KEY");
1186 #if LIBCURL_VERSION_NUM >= 0x070908
1187 ssl_capath = getenv("GIT_SSL_CAPATH");
1189 ssl_cainfo = getenv("GIT_SSL_CAINFO");
1191 git_config(http_options);
1193 if (curl_ssl_verify == -1)
1194 curl_ssl_verify = 1;
1196 #ifdef USE_CURL_MULTI
1197 if (max_requests < 1)
1198 max_requests = DEFAULT_MAX_REQUESTS;
1201 pragma_header = curl_slist_append(pragma_header, "Pragma: no-cache");
1202 no_pragma_header = curl_slist_append(no_pragma_header, "Pragma:");
1203 no_range_header = curl_slist_append(no_range_header, "Range:");
1205 curl_default = curl_easy_init();
1207 curl_easy_setopt(curl_default, CURLOPT_SSL_VERIFYPEER, curl_ssl_verify);
1208 #if LIBCURL_VERSION_NUM >= 0x070907
1209 curl_easy_setopt(curl_default, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
1212 if (ssl_cert != NULL)
1213 curl_easy_setopt(curl_default, CURLOPT_SSLCERT, ssl_cert);
1214 if (ssl_key != NULL)
1215 curl_easy_setopt(curl_default, CURLOPT_SSLKEY, ssl_key);
1216 if (ssl_capath != NULL)
1217 curl_easy_setopt(curl_default, CURLOPT_CAPATH, ssl_capath);
1218 if (ssl_cainfo != NULL)
1219 curl_easy_setopt(curl_default, CURLOPT_CAINFO, ssl_cainfo);
1221 curl_easy_setopt(curl_default, CURLOPT_FAILONERROR, 1);
1223 alt = xmalloc(sizeof(*alt));
1225 alt->got_indices = 0;
1228 fetch_alternates(alt->base);
1230 if (pull(commit_id))
1233 curl_slist_free_all(pragma_header);
1234 curl_slist_free_all(no_pragma_header);
1235 curl_slist_free_all(no_range_header);
1236 curl_easy_cleanup(curl_default);
1237 slot = active_queue_head;
1238 while (slot != NULL) {
1239 curl_easy_cleanup(slot->curl);
1242 #ifdef USE_CURL_MULTI
1243 curl_multi_cleanup(curlm);
1245 curl_global_cleanup();