7 #define PREV_BUF_SIZE 4096
8 #define RANGE_HEADER_SIZE 30
10 static int got_alternates
= -1;
12 static struct curl_slist
*no_pragma_header
;
18 struct packed_git
*packs
;
19 struct alt_base
*next
;
22 static struct alt_base
*alt
= NULL
;
24 enum object_request_state
{
33 unsigned char sha1
[20];
34 struct alt_base
*repo
;
36 char filename
[PATH_MAX
];
37 char tmpfile
[PATH_MAX
];
39 enum object_request_state state
;
41 char errorstr
[CURL_ERROR_SIZE
];
43 unsigned char real_sha1
[20];
48 struct active_request_slot
*slot
;
49 struct object_request
*next
;
52 struct alternates_request
{
55 struct buffer
*buffer
;
56 struct active_request_slot
*slot
;
60 static struct object_request
*object_queue_head
= NULL
;
62 static size_t fwrite_sha1_file(void *ptr
, size_t eltsize
, size_t nmemb
,
65 unsigned char expn
[4096];
66 size_t size
= eltsize
* nmemb
;
68 struct object_request
*obj_req
= (struct object_request
*)data
;
70 ssize_t retval
= write(obj_req
->local
,
71 ptr
+ posn
, size
- posn
);
75 } while (posn
< size
);
77 obj_req
->stream
.avail_in
= size
;
78 obj_req
->stream
.next_in
= ptr
;
80 obj_req
->stream
.next_out
= expn
;
81 obj_req
->stream
.avail_out
= sizeof(expn
);
82 obj_req
->zret
= inflate(&obj_req
->stream
, Z_SYNC_FLUSH
);
83 SHA1_Update(&obj_req
->c
, expn
,
84 sizeof(expn
) - obj_req
->stream
.avail_out
);
85 } while (obj_req
->stream
.avail_in
&& obj_req
->zret
== Z_OK
);
90 static void fetch_alternates(char *base
);
92 static void process_object_response(void *callback_data
);
94 static void start_object_request(struct object_request
*obj_req
)
96 char *hex
= sha1_to_hex(obj_req
->sha1
);
97 char prevfile
[PATH_MAX
];
101 unsigned char prev_buf
[PREV_BUF_SIZE
];
102 ssize_t prev_read
= 0;
104 char range
[RANGE_HEADER_SIZE
];
105 struct curl_slist
*range_header
= NULL
;
106 struct active_request_slot
*slot
;
108 snprintf(prevfile
, sizeof(prevfile
), "%s.prev", obj_req
->filename
);
110 rename(obj_req
->tmpfile
, prevfile
);
111 unlink(obj_req
->tmpfile
);
113 if (obj_req
->local
!= -1)
114 error("fd leakage in start: %d", obj_req
->local
);
115 obj_req
->local
= open(obj_req
->tmpfile
,
116 O_WRONLY
| O_CREAT
| O_EXCL
, 0666);
117 /* This could have failed due to the "lazy directory creation";
118 * try to mkdir the last path component.
120 if (obj_req
->local
< 0 && errno
== ENOENT
) {
121 char *dir
= strrchr(obj_req
->tmpfile
, '/');
124 mkdir(obj_req
->tmpfile
, 0777);
127 obj_req
->local
= open(obj_req
->tmpfile
,
128 O_WRONLY
| O_CREAT
| O_EXCL
, 0666);
131 if (obj_req
->local
< 0) {
132 obj_req
->state
= ABORTED
;
133 error("Couldn't create temporary file %s for %s: %s\n",
134 obj_req
->tmpfile
, obj_req
->filename
, strerror(errno
));
138 memset(&obj_req
->stream
, 0, sizeof(obj_req
->stream
));
140 inflateInit(&obj_req
->stream
);
142 SHA1_Init(&obj_req
->c
);
144 url
= xmalloc(strlen(obj_req
->repo
->base
) + 50);
145 obj_req
->url
= xmalloc(strlen(obj_req
->repo
->base
) + 50);
146 strcpy(url
, obj_req
->repo
->base
);
147 posn
= url
+ strlen(obj_req
->repo
->base
);
148 strcpy(posn
, "objects/");
150 memcpy(posn
, hex
, 2);
153 strcpy(posn
, hex
+ 2);
154 strcpy(obj_req
->url
, url
);
156 /* If a previous temp file is present, process what was already
158 prevlocal
= open(prevfile
, O_RDONLY
);
159 if (prevlocal
!= -1) {
161 prev_read
= read(prevlocal
, prev_buf
, PREV_BUF_SIZE
);
163 if (fwrite_sha1_file(prev_buf
,
166 obj_req
) == prev_read
) {
167 prev_posn
+= prev_read
;
172 } while (prev_read
> 0);
177 /* Reset inflate/SHA1 if there was an error reading the previous temp
178 file; also rewind to the beginning of the local file. */
179 if (prev_read
== -1) {
180 memset(&obj_req
->stream
, 0, sizeof(obj_req
->stream
));
181 inflateInit(&obj_req
->stream
);
182 SHA1_Init(&obj_req
->c
);
185 lseek(obj_req
->local
, SEEK_SET
, 0);
186 ftruncate(obj_req
->local
, 0);
190 slot
= get_active_slot();
191 slot
->callback_func
= process_object_response
;
192 slot
->callback_data
= obj_req
;
193 obj_req
->slot
= slot
;
195 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, obj_req
);
196 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_sha1_file
);
197 curl_easy_setopt(slot
->curl
, CURLOPT_ERRORBUFFER
, obj_req
->errorstr
);
198 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
199 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, no_pragma_header
);
201 /* If we have successfully processed data from a previous fetch
202 attempt, only fetch the data we don't already have. */
206 "Resuming fetch of object %s at byte %ld\n",
208 sprintf(range
, "Range: bytes=%ld-", prev_posn
);
209 range_header
= curl_slist_append(range_header
, range
);
210 curl_easy_setopt(slot
->curl
,
211 CURLOPT_HTTPHEADER
, range_header
);
214 /* Try to get the request started, abort the request on error */
215 obj_req
->state
= ACTIVE
;
216 if (!start_active_slot(slot
)) {
217 obj_req
->state
= ABORTED
;
218 obj_req
->slot
= NULL
;
219 close(obj_req
->local
); obj_req
->local
= -1;
225 static void finish_object_request(struct object_request
*obj_req
)
229 fchmod(obj_req
->local
, 0444);
230 close(obj_req
->local
); obj_req
->local
= -1;
232 if (obj_req
->http_code
== 416) {
233 fprintf(stderr
, "Warning: requested range invalid; we may already have all the data.\n");
234 } else if (obj_req
->curl_result
!= CURLE_OK
) {
235 if (stat(obj_req
->tmpfile
, &st
) == 0)
237 unlink(obj_req
->tmpfile
);
241 inflateEnd(&obj_req
->stream
);
242 SHA1_Final(obj_req
->real_sha1
, &obj_req
->c
);
243 if (obj_req
->zret
!= Z_STREAM_END
) {
244 unlink(obj_req
->tmpfile
);
247 if (memcmp(obj_req
->sha1
, obj_req
->real_sha1
, 20)) {
248 unlink(obj_req
->tmpfile
);
252 move_temp_to_file(obj_req
->tmpfile
, obj_req
->filename
);
254 if (obj_req
->rename
== 0)
255 pull_say("got %s\n", sha1_to_hex(obj_req
->sha1
));
258 static void process_object_response(void *callback_data
)
260 struct object_request
*obj_req
=
261 (struct object_request
*)callback_data
;
263 obj_req
->curl_result
= obj_req
->slot
->curl_result
;
264 obj_req
->http_code
= obj_req
->slot
->http_code
;
265 obj_req
->slot
= NULL
;
266 obj_req
->state
= COMPLETE
;
268 /* Use alternates if necessary */
269 if (obj_req
->http_code
== 404 ||
270 obj_req
->curl_result
== CURLE_FILE_COULDNT_READ_FILE
) {
271 fetch_alternates(alt
->base
);
272 if (obj_req
->repo
->next
!= NULL
) {
275 close(obj_req
->local
);
277 start_object_request(obj_req
);
282 finish_object_request(obj_req
);
285 static void release_object_request(struct object_request
*obj_req
)
287 struct object_request
*entry
= object_queue_head
;
289 if (obj_req
->local
!= -1)
290 error("fd leakage in release: %d", obj_req
->local
);
291 if (obj_req
== object_queue_head
) {
292 object_queue_head
= obj_req
->next
;
294 while (entry
->next
!= NULL
&& entry
->next
!= obj_req
)
296 if (entry
->next
== obj_req
)
297 entry
->next
= entry
->next
->next
;
304 #ifdef USE_CURL_MULTI
305 void fill_active_slots(void)
307 struct object_request
*obj_req
= object_queue_head
;
308 struct active_request_slot
*slot
= active_queue_head
;
311 while (active_requests
< max_requests
&& obj_req
!= NULL
) {
312 if (obj_req
->state
== WAITING
) {
313 if (has_sha1_file(obj_req
->sha1
))
314 obj_req
->state
= COMPLETE
;
316 start_object_request(obj_req
);
317 curl_multi_perform(curlm
, &num_transfers
);
319 obj_req
= obj_req
->next
;
322 while (slot
!= NULL
) {
323 if (!slot
->in_use
&& slot
->curl
!= NULL
) {
324 curl_easy_cleanup(slot
->curl
);
332 void prefetch(unsigned char *sha1
)
334 struct object_request
*newreq
;
335 struct object_request
*tail
;
336 char *filename
= sha1_file_name(sha1
);
338 newreq
= xmalloc(sizeof(*newreq
));
339 memcpy(newreq
->sha1
, sha1
, 20);
343 newreq
->state
= WAITING
;
344 snprintf(newreq
->filename
, sizeof(newreq
->filename
), "%s", filename
);
345 snprintf(newreq
->tmpfile
, sizeof(newreq
->tmpfile
),
346 "%s.temp", filename
);
349 if (object_queue_head
== NULL
) {
350 object_queue_head
= newreq
;
352 tail
= object_queue_head
;
353 while (tail
->next
!= NULL
) {
359 #ifdef USE_CURL_MULTI
365 static int fetch_index(struct alt_base
*repo
, unsigned char *sha1
)
367 char *hex
= sha1_to_hex(sha1
);
370 char tmpfile
[PATH_MAX
];
372 char range
[RANGE_HEADER_SIZE
];
373 struct curl_slist
*range_header
= NULL
;
376 struct active_request_slot
*slot
;
377 struct slot_results results
;
379 if (has_pack_index(sha1
))
383 fprintf(stderr
, "Getting index for pack %s\n", hex
);
385 url
= xmalloc(strlen(repo
->base
) + 64);
386 sprintf(url
, "%s/objects/pack/pack-%s.idx", repo
->base
, hex
);
388 filename
= sha1_pack_index_name(sha1
);
389 snprintf(tmpfile
, sizeof(tmpfile
), "%s.temp", filename
);
390 indexfile
= fopen(tmpfile
, "a");
392 return error("Unable to open local file %s for pack index",
395 slot
= get_active_slot();
396 slot
->results
= &results
;
397 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, indexfile
);
398 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite
);
399 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
400 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, no_pragma_header
);
401 slot
->local
= indexfile
;
403 /* If there is data present from a previous transfer attempt,
404 resume where it left off */
405 prev_posn
= ftell(indexfile
);
409 "Resuming fetch of index for pack %s at byte %ld\n",
411 sprintf(range
, "Range: bytes=%ld-", prev_posn
);
412 range_header
= curl_slist_append(range_header
, range
);
413 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, range_header
);
416 if (start_active_slot(slot
)) {
417 run_active_slot(slot
);
418 if (results
.curl_result
!= CURLE_OK
) {
420 return error("Unable to get pack index %s\n%s", url
,
425 return error("Unable to start request");
430 return move_temp_to_file(tmpfile
, filename
);
433 static int setup_index(struct alt_base
*repo
, unsigned char *sha1
)
435 struct packed_git
*new_pack
;
436 if (has_pack_file(sha1
))
437 return 0; // don't list this as something we can get
439 if (fetch_index(repo
, sha1
))
442 new_pack
= parse_pack_index(sha1
);
443 new_pack
->next
= repo
->packs
;
444 repo
->packs
= new_pack
;
448 static void process_alternates_response(void *callback_data
)
450 struct alternates_request
*alt_req
=
451 (struct alternates_request
*)callback_data
;
452 struct active_request_slot
*slot
= alt_req
->slot
;
453 struct alt_base
*tail
= alt
;
454 char *base
= alt_req
->base
;
455 static const char null_byte
= '\0';
459 if (alt_req
->http_specific
) {
460 if (slot
->curl_result
!= CURLE_OK
||
461 !alt_req
->buffer
->posn
) {
463 /* Try reusing the slot to get non-http alternates */
464 alt_req
->http_specific
= 0;
465 sprintf(alt_req
->url
, "%s/objects/info/alternates",
467 curl_easy_setopt(slot
->curl
, CURLOPT_URL
,
471 if (!start_active_slot(slot
)) {
477 } else if (slot
->curl_result
!= CURLE_OK
) {
478 if (slot
->http_code
!= 404 &&
479 slot
->curl_result
!= CURLE_FILE_COULDNT_READ_FILE
) {
485 fwrite_buffer(&null_byte
, 1, 1, alt_req
->buffer
);
486 alt_req
->buffer
->posn
--;
487 data
= alt_req
->buffer
->buffer
;
489 while (i
< alt_req
->buffer
->posn
) {
491 while (posn
< alt_req
->buffer
->posn
&& data
[posn
] != '\n')
493 if (data
[posn
] == '\n') {
496 struct alt_base
*newalt
;
498 if (data
[i
] == '/') {
499 serverlen
= strchr(base
+ 8, '/') - base
;
501 } else if (!memcmp(data
+ i
, "../", 3)) {
503 serverlen
= strlen(base
);
504 while (i
+ 2 < posn
&&
505 !memcmp(data
+ i
, "../", 3)) {
508 } while (serverlen
&&
509 base
[serverlen
- 1] != '/');
512 // If the server got removed, give up.
513 okay
= strchr(base
, ':') - base
+ 3 <
515 } else if (alt_req
->http_specific
) {
516 char *colon
= strchr(data
+ i
, ':');
517 char *slash
= strchr(data
+ i
, '/');
518 if (colon
&& slash
&& colon
< data
+ posn
&&
519 slash
< data
+ posn
&& colon
< slash
) {
523 // skip 'objects' at end
525 target
= xmalloc(serverlen
+ posn
- i
- 6);
526 strncpy(target
, base
, serverlen
);
527 strncpy(target
+ serverlen
, data
+ i
,
529 target
[serverlen
+ posn
- i
- 7] = '\0';
532 "Also look at %s\n", target
);
533 newalt
= xmalloc(sizeof(*newalt
));
535 newalt
->base
= target
;
536 newalt
->got_indices
= 0;
537 newalt
->packs
= NULL
;
538 while (tail
->next
!= NULL
)
549 static void fetch_alternates(char *base
)
551 struct buffer buffer
;
554 struct active_request_slot
*slot
;
555 struct alternates_request alt_req
;
557 /* If another request has already started fetching alternates,
558 wait for them to arrive and return to processing this request's
560 #ifdef USE_CURL_MULTI
561 while (got_alternates
== 0) {
566 /* Nothing to do if they've already been fetched */
567 if (got_alternates
== 1)
570 /* Start the fetch */
573 data
= xmalloc(4096);
576 buffer
.buffer
= data
;
579 fprintf(stderr
, "Getting alternates list for %s\n", base
);
581 url
= xmalloc(strlen(base
) + 31);
582 sprintf(url
, "%s/objects/info/http-alternates", base
);
584 /* Use a callback to process the result, since another request
585 may fail and need to have alternates loaded before continuing */
586 slot
= get_active_slot();
587 slot
->callback_func
= process_alternates_response
;
588 slot
->callback_data
= &alt_req
;
590 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &buffer
);
591 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
592 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
596 alt_req
.buffer
= &buffer
;
597 alt_req
.http_specific
= 1;
600 if (start_active_slot(slot
))
601 run_active_slot(slot
);
609 static int fetch_indices(struct alt_base
*repo
)
611 unsigned char sha1
[20];
613 struct buffer buffer
;
617 struct active_request_slot
*slot
;
618 struct slot_results results
;
620 if (repo
->got_indices
)
623 data
= xmalloc(4096);
626 buffer
.buffer
= data
;
629 fprintf(stderr
, "Getting pack list for %s\n", repo
->base
);
631 url
= xmalloc(strlen(repo
->base
) + 21);
632 sprintf(url
, "%s/objects/info/packs", repo
->base
);
634 slot
= get_active_slot();
635 slot
->results
= &results
;
636 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &buffer
);
637 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
638 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
639 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, NULL
);
640 if (start_active_slot(slot
)) {
641 run_active_slot(slot
);
642 if (results
.curl_result
!= CURLE_OK
) {
643 if (results
.http_code
== 404 ||
644 results
.curl_result
== CURLE_FILE_COULDNT_READ_FILE
) {
645 repo
->got_indices
= 1;
649 repo
->got_indices
= 0;
651 return error("%s", curl_errorstr
);
655 repo
->got_indices
= 0;
657 return error("Unable to start request");
660 data
= buffer
.buffer
;
661 while (i
< buffer
.posn
) {
665 if (i
+ 52 <= buffer
.posn
&&
666 !strncmp(data
+ i
, " pack-", 6) &&
667 !strncmp(data
+ i
+ 46, ".pack\n", 6)) {
668 get_sha1_hex(data
+ i
+ 6, sha1
);
669 setup_index(repo
, sha1
);
674 while (i
< buffer
.posn
&& data
[i
] != '\n')
681 repo
->got_indices
= 1;
685 static int fetch_pack(struct alt_base
*repo
, unsigned char *sha1
)
688 struct packed_git
*target
;
689 struct packed_git
**lst
;
692 char tmpfile
[PATH_MAX
];
695 char range
[RANGE_HEADER_SIZE
];
696 struct curl_slist
*range_header
= NULL
;
698 struct active_request_slot
*slot
;
699 struct slot_results results
;
701 if (fetch_indices(repo
))
703 target
= find_sha1_pack(sha1
, repo
->packs
);
708 fprintf(stderr
, "Getting pack %s\n",
709 sha1_to_hex(target
->sha1
));
710 fprintf(stderr
, " which contains %s\n",
714 url
= xmalloc(strlen(repo
->base
) + 65);
715 sprintf(url
, "%s/objects/pack/pack-%s.pack",
716 repo
->base
, sha1_to_hex(target
->sha1
));
718 filename
= sha1_pack_name(target
->sha1
);
719 snprintf(tmpfile
, sizeof(tmpfile
), "%s.temp", filename
);
720 packfile
= fopen(tmpfile
, "a");
722 return error("Unable to open local file %s for pack",
725 slot
= get_active_slot();
726 slot
->results
= &results
;
727 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, packfile
);
728 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite
);
729 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
730 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, no_pragma_header
);
731 slot
->local
= packfile
;
733 /* If there is data present from a previous transfer attempt,
734 resume where it left off */
735 prev_posn
= ftell(packfile
);
739 "Resuming fetch of pack %s at byte %ld\n",
740 sha1_to_hex(target
->sha1
), prev_posn
);
741 sprintf(range
, "Range: bytes=%ld-", prev_posn
);
742 range_header
= curl_slist_append(range_header
, range
);
743 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, range_header
);
746 if (start_active_slot(slot
)) {
747 run_active_slot(slot
);
748 if (results
.curl_result
!= CURLE_OK
) {
750 return error("Unable to get pack file %s\n%s", url
,
755 return error("Unable to start request");
760 ret
= move_temp_to_file(tmpfile
, filename
);
765 while (*lst
!= target
)
766 lst
= &((*lst
)->next
);
769 if (verify_pack(target
, 0))
771 install_packed_git(target
);
776 static int fetch_object(struct alt_base
*repo
, unsigned char *sha1
)
778 char *hex
= sha1_to_hex(sha1
);
780 struct object_request
*obj_req
= object_queue_head
;
782 while (obj_req
!= NULL
&& memcmp(obj_req
->sha1
, sha1
, 20))
783 obj_req
= obj_req
->next
;
785 return error("Couldn't find request for %s in the queue", hex
);
787 if (has_sha1_file(obj_req
->sha1
)) {
788 release_object_request(obj_req
);
792 #ifdef USE_CURL_MULTI
793 while (obj_req
->state
== WAITING
) {
797 start_object_request(obj_req
);
800 while (obj_req
->state
== ACTIVE
) {
801 run_active_slot(obj_req
->slot
);
803 if (obj_req
->local
!= -1) {
804 close(obj_req
->local
); obj_req
->local
= -1;
807 if (obj_req
->state
== ABORTED
) {
808 ret
= error("Request for %s aborted", hex
);
809 } else if (obj_req
->curl_result
!= CURLE_OK
&&
810 obj_req
->http_code
!= 416) {
811 if (obj_req
->http_code
== 404 ||
812 obj_req
->curl_result
== CURLE_FILE_COULDNT_READ_FILE
)
813 ret
= -1; /* Be silent, it is probably in a pack. */
815 ret
= error("%s (curl_result = %d, http_code = %ld, sha1 = %s)",
816 obj_req
->errorstr
, obj_req
->curl_result
,
817 obj_req
->http_code
, hex
);
818 } else if (obj_req
->zret
!= Z_STREAM_END
) {
819 ret
= error("File %s (%s) corrupt\n", hex
, obj_req
->url
);
820 } else if (memcmp(obj_req
->sha1
, obj_req
->real_sha1
, 20)) {
821 ret
= error("File %s has bad hash\n", hex
);
822 } else if (obj_req
->rename
< 0) {
823 ret
= error("unable to write sha1 filename %s",
827 release_object_request(obj_req
);
831 int fetch(unsigned char *sha1
)
833 struct alt_base
*altbase
= alt
;
835 if (!fetch_object(altbase
, sha1
))
838 if (!fetch_pack(altbase
, sha1
))
840 fetch_alternates(alt
->base
);
841 altbase
= altbase
->next
;
843 return error("Unable to find %s under %s\n", sha1_to_hex(sha1
),
847 static inline int needs_quote(int ch
)
850 case '/': case '-': case '.':
851 case 'A'...'Z': case 'a'...'z': case '0'...'9':
858 static inline int hex(int v
)
860 if (v
< 10) return '0' + v
;
861 else return 'A' + v
- 10;
864 static char *quote_ref_url(const char *base
, const char *ref
)
868 int len
, baselen
, ch
;
870 baselen
= strlen(base
);
871 len
= baselen
+ 6; /* "refs/" + NUL */
872 for (cp
= ref
; (ch
= *cp
) != 0; cp
++, len
++)
874 len
+= 2; /* extra two hex plus replacement % */
876 memcpy(qref
, base
, baselen
);
877 memcpy(qref
+ baselen
, "refs/", 5);
878 for (cp
= ref
, dp
= qref
+ baselen
+ 5; (ch
= *cp
) != 0; cp
++) {
879 if (needs_quote(ch
)) {
881 *dp
++ = hex((ch
>> 4) & 0xF);
882 *dp
++ = hex(ch
& 0xF);
892 int fetch_ref(char *ref
, unsigned char *sha1
)
896 struct buffer buffer
;
897 char *base
= alt
->base
;
898 struct active_request_slot
*slot
;
899 struct slot_results results
;
905 url
= quote_ref_url(base
, ref
);
906 slot
= get_active_slot();
907 slot
->results
= &results
;
908 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &buffer
);
909 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
910 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, NULL
);
911 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
912 if (start_active_slot(slot
)) {
913 run_active_slot(slot
);
914 if (results
.curl_result
!= CURLE_OK
)
915 return error("Couldn't get %s for %s\n%s",
916 url
, ref
, curl_errorstr
);
918 return error("Unable to start request");
922 get_sha1_hex(hex
, sha1
);
926 int main(int argc
, char **argv
)
933 setup_git_directory();
935 while (arg
< argc
&& argv
[arg
][0] == '-') {
936 if (argv
[arg
][1] == 't') {
938 } else if (argv
[arg
][1] == 'c') {
940 } else if (argv
[arg
][1] == 'a') {
944 } else if (argv
[arg
][1] == 'v') {
946 } else if (argv
[arg
][1] == 'w') {
947 write_ref
= argv
[arg
+ 1];
949 } else if (!strcmp(argv
[arg
], "--recover")) {
954 if (argc
< arg
+ 2) {
955 usage("git-http-fetch [-c] [-t] [-a] [-d] [-v] [--recover] [-w ref] commit-id url");
958 commit_id
= argv
[arg
];
963 no_pragma_header
= curl_slist_append(no_pragma_header
, "Pragma:");
965 alt
= xmalloc(sizeof(*alt
));
967 alt
->got_indices
= 0;
974 curl_slist_free_all(no_pragma_header
);