contrib/vim: add syntax highlighting file for commits
[git/git.git] / http-fetch.c
CommitLineData
6eb7ed54
DB
1#include "cache.h"
2#include "commit.h"
271421cd 3#include "pack.h"
215a7ad1 4#include "fetch.h"
29508e1e 5#include "http.h"
7baa3e86 6
8d9fbe57
NH
7#ifndef NO_EXPAT
8#include <expat.h>
9
10/* Definitions for DAV requests */
11#define DAV_PROPFIND "PROPFIND"
12#define DAV_PROPFIND_RESP ".multistatus.response"
13#define DAV_PROPFIND_NAME ".multistatus.response.href"
14#define DAV_PROPFIND_COLLECTION ".multistatus.response.propstat.prop.resourcetype.collection"
15#define PROPFIND_ALL_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/>\n</D:propfind>"
16
17/* Definitions for processing XML DAV responses */
18#ifndef XML_STATUS_OK
19enum XML_Status {
20 XML_STATUS_OK = 1,
21 XML_STATUS_ERROR = 0
22};
23#define XML_STATUS_OK 1
24#define XML_STATUS_ERROR 0
25#endif
26
27/* Flags that control remote_ls processing */
28#define PROCESS_FILES (1u << 0)
29#define PROCESS_DIRS (1u << 1)
30#define RECURSIVE (1u << 2)
31
32/* Flags that remote_ls passes to callback functions */
33#define IS_DIR (1u << 0)
34#endif
35
49a0f240
NH
36#define PREV_BUF_SIZE 4096
37#define RANGE_HEADER_SIZE 30
38
96f1e58f 39static int commits_on_stdin;
8e29f6a0 40
acc075a8 41static int got_alternates = -1;
96f1e58f 42static int corrupt_object_found;
1d389ab6 43
1db69b57 44static struct curl_slist *no_pragma_header;
6eb7ed54 45
b3661567
DB
46struct alt_base
47{
8e29f6a0 48 const char *base;
8d9fbe57 49 int path_len;
b3661567
DB
50 int got_indices;
51 struct packed_git *packs;
52 struct alt_base *next;
53};
54
96f1e58f 55static struct alt_base *alt;
6eb7ed54 56
e388ab74 57enum object_request_state {
1d389ab6
NH
58 WAITING,
59 ABORTED,
60 ACTIVE,
61 COMPLETE,
62};
6eb7ed54 63
e388ab74 64struct object_request
1d389ab6
NH
65{
66 unsigned char sha1[20];
67 struct alt_base *repo;
68 char *url;
69 char filename[PATH_MAX];
70 char tmpfile[PATH_MAX];
71 int local;
e388ab74 72 enum object_request_state state;
1d389ab6
NH
73 CURLcode curl_result;
74 char errorstr[CURL_ERROR_SIZE];
75 long http_code;
76 unsigned char real_sha1[20];
77 SHA_CTX c;
78 z_stream stream;
79 int zret;
80 int rename;
81 struct active_request_slot *slot;
e388ab74 82 struct object_request *next;
1d389ab6
NH
83};
84
e388ab74 85struct alternates_request {
8e29f6a0 86 const char *base;
acc075a8
NH
87 char *url;
88 struct buffer *buffer;
89 struct active_request_slot *slot;
90 int http_specific;
91};
92
8d9fbe57
NH
93#ifndef NO_EXPAT
94struct xml_ctx
95{
96 char *name;
97 int len;
98 char *cdata;
99 void (*userFunc)(struct xml_ctx *ctx, int tag_closed);
100 void *userData;
101};
102
103struct remote_ls_ctx
104{
105 struct alt_base *repo;
106 char *path;
107 void (*userFunc)(struct remote_ls_ctx *ls);
108 void *userData;
109 int flags;
110 char *dentry_name;
111 int dentry_flags;
112 int rc;
113 struct remote_ls_ctx *parent;
114};
115#endif
116
96f1e58f 117static struct object_request *object_queue_head;
bc8f2652 118
182005b9
DB
119static size_t fwrite_sha1_file(void *ptr, size_t eltsize, size_t nmemb,
120 void *data)
121{
bf0f910d 122 unsigned char expn[4096];
6eb7ed54
DB
123 size_t size = eltsize * nmemb;
124 int posn = 0;
e388ab74 125 struct object_request *obj_req = (struct object_request *)data;
6eb7ed54 126 do {
e388ab74 127 ssize_t retval = write(obj_req->local,
1d7f171c 128 (char *) ptr + posn, size - posn);
6eb7ed54
DB
129 if (retval < 0)
130 return posn;
131 posn += retval;
132 } while (posn < size);
133
e388ab74
NH
134 obj_req->stream.avail_in = size;
135 obj_req->stream.next_in = ptr;
6eb7ed54 136 do {
e388ab74
NH
137 obj_req->stream.next_out = expn;
138 obj_req->stream.avail_out = sizeof(expn);
139 obj_req->zret = inflate(&obj_req->stream, Z_SYNC_FLUSH);
140 SHA1_Update(&obj_req->c, expn,
141 sizeof(expn) - obj_req->stream.avail_out);
142 } while (obj_req->stream.avail_in && obj_req->zret == Z_OK);
1d389ab6 143 data_received++;
6eb7ed54
DB
144 return size;
145}
146
8e29f6a0 147static void fetch_alternates(const char *base);
1d389ab6 148
29508e1e 149static void process_object_response(void *callback_data);
1d389ab6 150
e388ab74 151static void start_object_request(struct object_request *obj_req)
1d389ab6 152{
e388ab74 153 char *hex = sha1_to_hex(obj_req->sha1);
1d389ab6
NH
154 char prevfile[PATH_MAX];
155 char *url;
156 char *posn;
157 int prevlocal;
158 unsigned char prev_buf[PREV_BUF_SIZE];
159 ssize_t prev_read = 0;
160 long prev_posn = 0;
161 char range[RANGE_HEADER_SIZE];
162 struct curl_slist *range_header = NULL;
163 struct active_request_slot *slot;
164
e388ab74 165 snprintf(prevfile, sizeof(prevfile), "%s.prev", obj_req->filename);
1d389ab6 166 unlink(prevfile);
e388ab74
NH
167 rename(obj_req->tmpfile, prevfile);
168 unlink(obj_req->tmpfile);
1d389ab6 169
e388ab74
NH
170 if (obj_req->local != -1)
171 error("fd leakage in start: %d", obj_req->local);
172 obj_req->local = open(obj_req->tmpfile,
1d389ab6 173 O_WRONLY | O_CREAT | O_EXCL, 0666);
b721e01f
JH
174 /* This could have failed due to the "lazy directory creation";
175 * try to mkdir the last path component.
176 */
e388ab74
NH
177 if (obj_req->local < 0 && errno == ENOENT) {
178 char *dir = strrchr(obj_req->tmpfile, '/');
b721e01f
JH
179 if (dir) {
180 *dir = 0;
e388ab74 181 mkdir(obj_req->tmpfile, 0777);
b721e01f
JH
182 *dir = '/';
183 }
e388ab74 184 obj_req->local = open(obj_req->tmpfile,
b721e01f
JH
185 O_WRONLY | O_CREAT | O_EXCL, 0666);
186 }
187
e388ab74
NH
188 if (obj_req->local < 0) {
189 obj_req->state = ABORTED;
bd2afde8 190 error("Couldn't create temporary file %s for %s: %s",
e388ab74 191 obj_req->tmpfile, obj_req->filename, strerror(errno));
1d389ab6
NH
192 return;
193 }
194
e388ab74 195 memset(&obj_req->stream, 0, sizeof(obj_req->stream));
1d389ab6 196
e388ab74 197 inflateInit(&obj_req->stream);
1d389ab6 198
e388ab74 199 SHA1_Init(&obj_req->c);
1d389ab6 200
e388ab74
NH
201 url = xmalloc(strlen(obj_req->repo->base) + 50);
202 obj_req->url = xmalloc(strlen(obj_req->repo->base) + 50);
203 strcpy(url, obj_req->repo->base);
204 posn = url + strlen(obj_req->repo->base);
1d389ab6
NH
205 strcpy(posn, "objects/");
206 posn += 8;
207 memcpy(posn, hex, 2);
208 posn += 2;
209 *(posn++) = '/';
210 strcpy(posn, hex + 2);
e388ab74 211 strcpy(obj_req->url, url);
1d389ab6
NH
212
213 /* If a previous temp file is present, process what was already
214 fetched. */
215 prevlocal = open(prevfile, O_RDONLY);
216 if (prevlocal != -1) {
217 do {
218 prev_read = read(prevlocal, prev_buf, PREV_BUF_SIZE);
219 if (prev_read>0) {
220 if (fwrite_sha1_file(prev_buf,
221 1,
222 prev_read,
e388ab74 223 obj_req) == prev_read) {
1d389ab6
NH
224 prev_posn += prev_read;
225 } else {
226 prev_read = -1;
227 }
228 }
229 } while (prev_read > 0);
230 close(prevlocal);
231 }
232 unlink(prevfile);
233
234 /* Reset inflate/SHA1 if there was an error reading the previous temp
235 file; also rewind to the beginning of the local file. */
236 if (prev_read == -1) {
e388ab74
NH
237 memset(&obj_req->stream, 0, sizeof(obj_req->stream));
238 inflateInit(&obj_req->stream);
239 SHA1_Init(&obj_req->c);
1d389ab6
NH
240 if (prev_posn>0) {
241 prev_posn = 0;
e388ab74
NH
242 lseek(obj_req->local, SEEK_SET, 0);
243 ftruncate(obj_req->local, 0);
1d389ab6
NH
244 }
245 }
246
247 slot = get_active_slot();
29508e1e 248 slot->callback_func = process_object_response;
e388ab74
NH
249 slot->callback_data = obj_req;
250 obj_req->slot = slot;
29508e1e 251
e388ab74 252 curl_easy_setopt(slot->curl, CURLOPT_FILE, obj_req);
1d389ab6 253 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_sha1_file);
e388ab74 254 curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, obj_req->errorstr);
1d389ab6 255 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
03126006 256 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
1d389ab6
NH
257
258 /* If we have successfully processed data from a previous fetch
259 attempt, only fetch the data we don't already have. */
260 if (prev_posn>0) {
261 if (get_verbosely)
262 fprintf(stderr,
263 "Resuming fetch of object %s at byte %ld\n",
264 hex, prev_posn);
265 sprintf(range, "Range: bytes=%ld-", prev_posn);
266 range_header = curl_slist_append(range_header, range);
267 curl_easy_setopt(slot->curl,
268 CURLOPT_HTTPHEADER, range_header);
269 }
270
a7a8d378 271 /* Try to get the request started, abort the request on error */
e388ab74 272 obj_req->state = ACTIVE;
1d389ab6 273 if (!start_active_slot(slot)) {
e388ab74
NH
274 obj_req->state = ABORTED;
275 obj_req->slot = NULL;
276 close(obj_req->local); obj_req->local = -1;
277 free(obj_req->url);
278 return;
1d389ab6 279 }
1d389ab6
NH
280}
281
e388ab74 282static void finish_object_request(struct object_request *obj_req)
1d389ab6 283{
50496b21
NH
284 struct stat st;
285
e388ab74
NH
286 fchmod(obj_req->local, 0444);
287 close(obj_req->local); obj_req->local = -1;
1d389ab6 288
e388ab74 289 if (obj_req->http_code == 416) {
1d389ab6 290 fprintf(stderr, "Warning: requested range invalid; we may already have all the data.\n");
e388ab74
NH
291 } else if (obj_req->curl_result != CURLE_OK) {
292 if (stat(obj_req->tmpfile, &st) == 0)
50496b21 293 if (st.st_size == 0)
e388ab74 294 unlink(obj_req->tmpfile);
1d389ab6
NH
295 return;
296 }
297
e388ab74
NH
298 inflateEnd(&obj_req->stream);
299 SHA1_Final(obj_req->real_sha1, &obj_req->c);
300 if (obj_req->zret != Z_STREAM_END) {
301 unlink(obj_req->tmpfile);
1d389ab6
NH
302 return;
303 }
a89fccd2 304 if (hashcmp(obj_req->sha1, obj_req->real_sha1)) {
e388ab74 305 unlink(obj_req->tmpfile);
1d389ab6
NH
306 return;
307 }
e388ab74
NH
308 obj_req->rename =
309 move_temp_to_file(obj_req->tmpfile, obj_req->filename);
1d389ab6 310
e388ab74
NH
311 if (obj_req->rename == 0)
312 pull_say("got %s\n", sha1_to_hex(obj_req->sha1));
1d389ab6
NH
313}
314
29508e1e
NH
315static void process_object_response(void *callback_data)
316{
e388ab74
NH
317 struct object_request *obj_req =
318 (struct object_request *)callback_data;
29508e1e 319
e388ab74
NH
320 obj_req->curl_result = obj_req->slot->curl_result;
321 obj_req->http_code = obj_req->slot->http_code;
322 obj_req->slot = NULL;
323 obj_req->state = COMPLETE;
29508e1e
NH
324
325 /* Use alternates if necessary */
a14c2256
NH
326 if (obj_req->http_code == 404 ||
327 obj_req->curl_result == CURLE_FILE_COULDNT_READ_FILE) {
29508e1e 328 fetch_alternates(alt->base);
e388ab74
NH
329 if (obj_req->repo->next != NULL) {
330 obj_req->repo =
331 obj_req->repo->next;
332 close(obj_req->local);
333 obj_req->local = -1;
334 start_object_request(obj_req);
29508e1e
NH
335 return;
336 }
337 }
338
e388ab74 339 finish_object_request(obj_req);
29508e1e
NH
340}
341
e388ab74 342static void release_object_request(struct object_request *obj_req)
1d389ab6 343{
e388ab74 344 struct object_request *entry = object_queue_head;
1d389ab6 345
e388ab74
NH
346 if (obj_req->local != -1)
347 error("fd leakage in release: %d", obj_req->local);
348 if (obj_req == object_queue_head) {
349 object_queue_head = obj_req->next;
1d389ab6 350 } else {
e388ab74 351 while (entry->next != NULL && entry->next != obj_req)
1d389ab6 352 entry = entry->next;
e388ab74 353 if (entry->next == obj_req)
1d389ab6
NH
354 entry->next = entry->next->next;
355 }
356
e388ab74
NH
357 free(obj_req->url);
358 free(obj_req);
1d389ab6
NH
359}
360
a7a8d378 361#ifdef USE_CURL_MULTI
29508e1e 362void fill_active_slots(void)
1d389ab6 363{
e388ab74 364 struct object_request *obj_req = object_queue_head;
f1a906a3 365 struct active_request_slot *slot = active_queue_head;
1d389ab6
NH
366 int num_transfers;
367
e388ab74
NH
368 while (active_requests < max_requests && obj_req != NULL) {
369 if (obj_req->state == WAITING) {
370 if (has_sha1_file(obj_req->sha1))
09db444f 371 obj_req->state = COMPLETE;
11f0dafe 372 else
e388ab74 373 start_object_request(obj_req);
1d389ab6
NH
374 curl_multi_perform(curlm, &num_transfers);
375 }
e388ab74 376 obj_req = obj_req->next;
1d389ab6 377 }
f1a906a3
NH
378
379 while (slot != NULL) {
380 if (!slot->in_use && slot->curl != NULL) {
381 curl_easy_cleanup(slot->curl);
382 slot->curl = NULL;
383 }
384 slot = slot->next;
8fcf7f9a 385 }
1d389ab6 386}
a7a8d378 387#endif
1d389ab6
NH
388
389void prefetch(unsigned char *sha1)
390{
e388ab74
NH
391 struct object_request *newreq;
392 struct object_request *tail;
1d389ab6
NH
393 char *filename = sha1_file_name(sha1);
394
395 newreq = xmalloc(sizeof(*newreq));
e702496e 396 hashcpy(newreq->sha1, sha1);
1d389ab6
NH
397 newreq->repo = alt;
398 newreq->url = NULL;
399 newreq->local = -1;
400 newreq->state = WAITING;
401 snprintf(newreq->filename, sizeof(newreq->filename), "%s", filename);
402 snprintf(newreq->tmpfile, sizeof(newreq->tmpfile),
403 "%s.temp", filename);
e8dff6ba 404 newreq->slot = NULL;
1d389ab6
NH
405 newreq->next = NULL;
406
e388ab74
NH
407 if (object_queue_head == NULL) {
408 object_queue_head = newreq;
1d389ab6 409 } else {
e388ab74 410 tail = object_queue_head;
1d389ab6
NH
411 while (tail->next != NULL) {
412 tail = tail->next;
413 }
414 tail->next = newreq;
415 }
29508e1e 416
a7a8d378 417#ifdef USE_CURL_MULTI
29508e1e
NH
418 fill_active_slots();
419 step_active_slots();
a7a8d378 420#endif
1d389ab6
NH
421}
422
b3661567 423static int fetch_index(struct alt_base *repo, unsigned char *sha1)
182005b9 424{
1d389ab6 425 char *hex = sha1_to_hex(sha1);
182005b9
DB
426 char *filename;
427 char *url;
49a0f240 428 char tmpfile[PATH_MAX];
49a0f240
NH
429 long prev_posn = 0;
430 char range[RANGE_HEADER_SIZE];
431 struct curl_slist *range_header = NULL;
182005b9
DB
432
433 FILE *indexfile;
1d389ab6 434 struct active_request_slot *slot;
cb754fdf 435 struct slot_results results;
182005b9
DB
436
437 if (has_pack_index(sha1))
438 return 0;
439
440 if (get_verbosely)
1d389ab6 441 fprintf(stderr, "Getting index for pack %s\n", hex);
8fcf7f9a 442
b3661567 443 url = xmalloc(strlen(repo->base) + 64);
1d389ab6 444 sprintf(url, "%s/objects/pack/pack-%s.idx", repo->base, hex);
8fcf7f9a 445
182005b9 446 filename = sha1_pack_index_name(sha1);
49a0f240
NH
447 snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
448 indexfile = fopen(tmpfile, "a");
182005b9
DB
449 if (!indexfile)
450 return error("Unable to open local file %s for pack index",
451 filename);
452
1d389ab6 453 slot = get_active_slot();
c8568e13 454 slot->results = &results;
1d389ab6
NH
455 curl_easy_setopt(slot->curl, CURLOPT_FILE, indexfile);
456 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
457 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
03126006 458 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
1d389ab6
NH
459 slot->local = indexfile;
460
49a0f240
NH
461 /* If there is data present from a previous transfer attempt,
462 resume where it left off */
463 prev_posn = ftell(indexfile);
464 if (prev_posn>0) {
465 if (get_verbosely)
466 fprintf(stderr,
467 "Resuming fetch of index for pack %s at byte %ld\n",
1d389ab6 468 hex, prev_posn);
49a0f240
NH
469 sprintf(range, "Range: bytes=%ld-", prev_posn);
470 range_header = curl_slist_append(range_header, range);
1d389ab6 471 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
49a0f240
NH
472 }
473
1d389ab6
NH
474 if (start_active_slot(slot)) {
475 run_active_slot(slot);
c8568e13 476 if (results.curl_result != CURLE_OK) {
1d389ab6
NH
477 fclose(indexfile);
478 return error("Unable to get pack index %s\n%s", url,
479 curl_errorstr);
480 }
481 } else {
313c4714 482 fclose(indexfile);
1d389ab6 483 return error("Unable to start request");
182005b9
DB
484 }
485
486 fclose(indexfile);
49a0f240 487
b721e01f 488 return move_temp_to_file(tmpfile, filename);
182005b9
DB
489}
490
b3661567 491static int setup_index(struct alt_base *repo, unsigned char *sha1)
182005b9
DB
492{
493 struct packed_git *new_pack;
494 if (has_pack_file(sha1))
a9486b02 495 return 0; /* don't list this as something we can get */
182005b9 496
b3661567 497 if (fetch_index(repo, sha1))
182005b9
DB
498 return -1;
499
500 new_pack = parse_pack_index(sha1);
b3661567
DB
501 new_pack->next = repo->packs;
502 repo->packs = new_pack;
182005b9
DB
503 return 0;
504}
505
e388ab74 506static void process_alternates_response(void *callback_data)
b3661567 507{
e388ab74
NH
508 struct alternates_request *alt_req =
509 (struct alternates_request *)callback_data;
acc075a8 510 struct active_request_slot *slot = alt_req->slot;
1d389ab6 511 struct alt_base *tail = alt;
8e29f6a0 512 const char *base = alt_req->base;
bc8f2652 513 static const char null_byte = '\0';
acc075a8
NH
514 char *data;
515 int i = 0;
1d389ab6 516
acc075a8
NH
517 if (alt_req->http_specific) {
518 if (slot->curl_result != CURLE_OK ||
519 !alt_req->buffer->posn) {
520
521 /* Try reusing the slot to get non-http alternates */
522 alt_req->http_specific = 0;
523 sprintf(alt_req->url, "%s/objects/info/alternates",
524 base);
525 curl_easy_setopt(slot->curl, CURLOPT_URL,
526 alt_req->url);
527 active_requests++;
528 slot->in_use = 1;
c9826473
NH
529 if (slot->finished != NULL)
530 (*slot->finished) = 0;
a3f583cb 531 if (!start_active_slot(slot)) {
acc075a8 532 got_alternates = -1;
29508e1e 533 slot->in_use = 0;
c9826473
NH
534 if (slot->finished != NULL)
535 (*slot->finished) = 1;
1d389ab6 536 }
a3f583cb 537 return;
b3661567 538 }
acc075a8 539 } else if (slot->curl_result != CURLE_OK) {
a14c2256
NH
540 if (slot->http_code != 404 &&
541 slot->curl_result != CURLE_FILE_COULDNT_READ_FILE) {
acc075a8
NH
542 got_alternates = -1;
543 return;
544 }
b3661567
DB
545 }
546
29508e1e 547 fwrite_buffer(&null_byte, 1, 1, alt_req->buffer);
acc075a8
NH
548 alt_req->buffer->posn--;
549 data = alt_req->buffer->buffer;
1b0c1e67 550
acc075a8 551 while (i < alt_req->buffer->posn) {
b3661567 552 int posn = i;
acc075a8 553 while (posn < alt_req->buffer->posn && data[posn] != '\n')
b3661567
DB
554 posn++;
555 if (data[posn] == '\n') {
1b0c1e67
DB
556 int okay = 0;
557 int serverlen = 0;
558 struct alt_base *newalt;
559 char *target = NULL;
8d9fbe57 560 char *path;
b3661567 561 if (data[i] == '/') {
1b0c1e67
DB
562 serverlen = strchr(base + 8, '/') - base;
563 okay = 1;
564 } else if (!memcmp(data + i, "../", 3)) {
565 i += 3;
566 serverlen = strlen(base);
8fcf7f9a 567 while (i + 2 < posn &&
1b0c1e67
DB
568 !memcmp(data + i, "../", 3)) {
569 do {
570 serverlen--;
571 } while (serverlen &&
572 base[serverlen - 1] != '/');
573 i += 3;
574 }
a9486b02 575 /* If the server got removed, give up. */
8fcf7f9a 576 okay = strchr(base, ':') - base + 3 <
1b0c1e67 577 serverlen;
acc075a8 578 } else if (alt_req->http_specific) {
1b0c1e67
DB
579 char *colon = strchr(data + i, ':');
580 char *slash = strchr(data + i, '/');
581 if (colon && slash && colon < data + posn &&
582 slash < data + posn && colon < slash) {
583 okay = 1;
584 }
585 }
a9486b02 586 /* skip 'objects' at end */
1b0c1e67
DB
587 if (okay) {
588 target = xmalloc(serverlen + posn - i - 6);
817151e6
PE
589 strlcpy(target, base, serverlen);
590 strlcpy(target + serverlen, data + i, posn - i - 6);
b3661567 591 if (get_verbosely)
8fcf7f9a 592 fprintf(stderr,
b3661567
DB
593 "Also look at %s\n", target);
594 newalt = xmalloc(sizeof(*newalt));
1d389ab6 595 newalt->next = NULL;
b3661567
DB
596 newalt->base = target;
597 newalt->got_indices = 0;
598 newalt->packs = NULL;
8d9fbe57
NH
599 path = strstr(target, "//");
600 if (path) {
ef9e58c8 601 path = strchr(path+2, '/');
8d9fbe57
NH
602 if (path)
603 newalt->path_len = strlen(path);
604 }
605
1d389ab6
NH
606 while (tail->next != NULL)
607 tail = tail->next;
608 tail->next = newalt;
b3661567
DB
609 }
610 }
611 i = posn + 1;
612 }
bc8f2652 613
f7eb290f 614 got_alternates = 1;
acc075a8
NH
615}
616
8e29f6a0 617static void fetch_alternates(const char *base)
acc075a8
NH
618{
619 struct buffer buffer;
620 char *url;
621 char *data;
622 struct active_request_slot *slot;
cb754fdf 623 struct alternates_request alt_req;
acc075a8
NH
624
625 /* If another request has already started fetching alternates,
626 wait for them to arrive and return to processing this request's
627 curl message */
29508e1e 628#ifdef USE_CURL_MULTI
acc075a8 629 while (got_alternates == 0) {
29508e1e 630 step_active_slots();
acc075a8 631 }
29508e1e 632#endif
acc075a8
NH
633
634 /* Nothing to do if they've already been fetched */
635 if (got_alternates == 1)
636 return;
637
638 /* Start the fetch */
639 got_alternates = 0;
640
641 data = xmalloc(4096);
642 buffer.size = 4096;
643 buffer.posn = 0;
644 buffer.buffer = data;
645
646 if (get_verbosely)
647 fprintf(stderr, "Getting alternates list for %s\n", base);
8fcf7f9a 648
acc075a8
NH
649 url = xmalloc(strlen(base) + 31);
650 sprintf(url, "%s/objects/info/http-alternates", base);
651
652 /* Use a callback to process the result, since another request
653 may fail and need to have alternates loaded before continuing */
654 slot = get_active_slot();
e388ab74 655 slot->callback_func = process_alternates_response;
acc075a8
NH
656 slot->callback_data = &alt_req;
657
658 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
29508e1e 659 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
acc075a8
NH
660 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
661
662 alt_req.base = base;
663 alt_req.url = url;
664 alt_req.buffer = &buffer;
665 alt_req.http_specific = 1;
666 alt_req.slot = slot;
667
668 if (start_active_slot(slot))
669 run_active_slot(slot);
670 else
671 got_alternates = -1;
672
673 free(data);
674 free(url);
b3661567
DB
675}
676
8d9fbe57
NH
677#ifndef NO_EXPAT
678static void
679xml_start_tag(void *userData, const char *name, const char **atts)
680{
681 struct xml_ctx *ctx = (struct xml_ctx *)userData;
ef9e58c8 682 const char *c = strchr(name, ':');
8d9fbe57
NH
683 int new_len;
684
685 if (c == NULL)
686 c = name;
687 else
688 c++;
689
690 new_len = strlen(ctx->name) + strlen(c) + 2;
691
692 if (new_len > ctx->len) {
693 ctx->name = xrealloc(ctx->name, new_len);
694 ctx->len = new_len;
695 }
696 strcat(ctx->name, ".");
697 strcat(ctx->name, c);
698
4cac42b1
JH
699 free(ctx->cdata);
700 ctx->cdata = NULL;
8d9fbe57
NH
701
702 ctx->userFunc(ctx, 0);
703}
704
705static void
706xml_end_tag(void *userData, const char *name)
707{
708 struct xml_ctx *ctx = (struct xml_ctx *)userData;
ef9e58c8 709 const char *c = strchr(name, ':');
8d9fbe57
NH
710 char *ep;
711
712 ctx->userFunc(ctx, 1);
713
714 if (c == NULL)
715 c = name;
716 else
717 c++;
718
719 ep = ctx->name + strlen(ctx->name) - strlen(c) - 1;
720 *ep = 0;
721}
722
723static void
724xml_cdata(void *userData, const XML_Char *s, int len)
725{
726 struct xml_ctx *ctx = (struct xml_ctx *)userData;
4cac42b1 727 free(ctx->cdata);
bfbd0bb6 728 ctx->cdata = xmalloc(len + 1);
817151e6 729 strlcpy(ctx->cdata, s, len + 1);
8d9fbe57
NH
730}
731
732static int remote_ls(struct alt_base *repo, const char *path, int flags,
733 void (*userFunc)(struct remote_ls_ctx *ls),
734 void *userData);
735
736static void handle_remote_ls_ctx(struct xml_ctx *ctx, int tag_closed)
737{
738 struct remote_ls_ctx *ls = (struct remote_ls_ctx *)ctx->userData;
739
740 if (tag_closed) {
741 if (!strcmp(ctx->name, DAV_PROPFIND_RESP) && ls->dentry_name) {
742 if (ls->dentry_flags & IS_DIR) {
743 if (ls->flags & PROCESS_DIRS) {
744 ls->userFunc(ls);
745 }
746 if (strcmp(ls->dentry_name, ls->path) &&
747 ls->flags & RECURSIVE) {
748 ls->rc = remote_ls(ls->repo,
749 ls->dentry_name,
750 ls->flags,
751 ls->userFunc,
752 ls->userData);
753 }
754 } else if (ls->flags & PROCESS_FILES) {
755 ls->userFunc(ls);
756 }
757 } else if (!strcmp(ctx->name, DAV_PROPFIND_NAME) && ctx->cdata) {
758 ls->dentry_name = xmalloc(strlen(ctx->cdata) -
759 ls->repo->path_len + 1);
760 strcpy(ls->dentry_name, ctx->cdata + ls->repo->path_len);
761 } else if (!strcmp(ctx->name, DAV_PROPFIND_COLLECTION)) {
762 ls->dentry_flags |= IS_DIR;
763 }
764 } else if (!strcmp(ctx->name, DAV_PROPFIND_RESP)) {
4cac42b1 765 free(ls->dentry_name);
8d9fbe57
NH
766 ls->dentry_name = NULL;
767 ls->dentry_flags = 0;
768 }
769}
770
771static int remote_ls(struct alt_base *repo, const char *path, int flags,
772 void (*userFunc)(struct remote_ls_ctx *ls),
773 void *userData)
774{
775 char *url = xmalloc(strlen(repo->base) + strlen(path) + 1);
776 struct active_request_slot *slot;
777 struct slot_results results;
778 struct buffer in_buffer;
779 struct buffer out_buffer;
780 char *in_data;
781 char *out_data;
782 XML_Parser parser = XML_ParserCreate(NULL);
783 enum XML_Status result;
784 struct curl_slist *dav_headers = NULL;
785 struct xml_ctx ctx;
786 struct remote_ls_ctx ls;
787
788 ls.flags = flags;
789 ls.repo = repo;
9befac47 790 ls.path = xstrdup(path);
8d9fbe57
NH
791 ls.dentry_name = NULL;
792 ls.dentry_flags = 0;
793 ls.userData = userData;
794 ls.userFunc = userFunc;
795 ls.rc = 0;
796
797 sprintf(url, "%s%s", repo->base, path);
798
799 out_buffer.size = strlen(PROPFIND_ALL_REQUEST);
800 out_data = xmalloc(out_buffer.size + 1);
801 snprintf(out_data, out_buffer.size + 1, PROPFIND_ALL_REQUEST);
802 out_buffer.posn = 0;
803 out_buffer.buffer = out_data;
804
805 in_buffer.size = 4096;
806 in_data = xmalloc(in_buffer.size);
807 in_buffer.posn = 0;
808 in_buffer.buffer = in_data;
809
810 dav_headers = curl_slist_append(dav_headers, "Depth: 1");
811 dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
812
813 slot = get_active_slot();
814 slot->results = &results;
815 curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
816 curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
817 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
818 curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
819 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
820 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
821 curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
822 curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
823 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
824
825 if (start_active_slot(slot)) {
826 run_active_slot(slot);
827 if (results.curl_result == CURLE_OK) {
828 ctx.name = xcalloc(10, 1);
829 ctx.len = 0;
830 ctx.cdata = NULL;
831 ctx.userFunc = handle_remote_ls_ctx;
832 ctx.userData = &ls;
833 XML_SetUserData(parser, &ctx);
834 XML_SetElementHandler(parser, xml_start_tag,
835 xml_end_tag);
836 XML_SetCharacterDataHandler(parser, xml_cdata);
837 result = XML_Parse(parser, in_buffer.buffer,
838 in_buffer.posn, 1);
839 free(ctx.name);
840
841 if (result != XML_STATUS_OK) {
842 ls.rc = error("XML error: %s",
843 XML_ErrorString(
844 XML_GetErrorCode(parser)));
845 }
846 } else {
847 ls.rc = -1;
848 }
849 } else {
850 ls.rc = error("Unable to start PROPFIND request");
851 }
852
853 free(ls.path);
854 free(url);
855 free(out_data);
856 free(in_buffer.buffer);
857 curl_slist_free_all(dav_headers);
858
859 return ls.rc;
860}
861
862static void process_ls_pack(struct remote_ls_ctx *ls)
863{
864 unsigned char sha1[20];
865
866 if (strlen(ls->dentry_name) == 63 &&
867 !strncmp(ls->dentry_name, "objects/pack/pack-", 18) &&
5bb1cda5 868 has_extension(ls->dentry_name, ".pack")) {
8d9fbe57
NH
869 get_sha1_hex(ls->dentry_name + 18, sha1);
870 setup_index(ls->repo, sha1);
871 }
872}
873#endif
874
b3661567 875static int fetch_indices(struct alt_base *repo)
182005b9
DB
876{
877 unsigned char sha1[20];
878 char *url;
879 struct buffer buffer;
880 char *data;
881 int i = 0;
882
1d389ab6 883 struct active_request_slot *slot;
cb754fdf 884 struct slot_results results;
1d389ab6 885
b3661567 886 if (repo->got_indices)
182005b9
DB
887 return 0;
888
889 data = xmalloc(4096);
890 buffer.size = 4096;
891 buffer.posn = 0;
892 buffer.buffer = data;
893
894 if (get_verbosely)
6fd72e39 895 fprintf(stderr, "Getting pack list for %s\n", repo->base);
8fcf7f9a 896
8d9fbe57
NH
897#ifndef NO_EXPAT
898 if (remote_ls(repo, "objects/pack/", PROCESS_FILES,
899 process_ls_pack, NULL) == 0)
900 return 0;
901#endif
902
b3661567
DB
903 url = xmalloc(strlen(repo->base) + 21);
904 sprintf(url, "%s/objects/info/packs", repo->base);
182005b9 905
1d389ab6 906 slot = get_active_slot();
c8568e13 907 slot->results = &results;
1d389ab6 908 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
29508e1e 909 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1d389ab6
NH
910 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
911 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
912 if (start_active_slot(slot)) {
913 run_active_slot(slot);
c8568e13
NH
914 if (results.curl_result != CURLE_OK) {
915 if (results.http_code == 404 ||
916 results.curl_result == CURLE_FILE_COULDNT_READ_FILE) {
5e3a7691
NH
917 repo->got_indices = 1;
918 free(buffer.buffer);
919 return 0;
920 } else {
921 repo->got_indices = 0;
922 free(buffer.buffer);
923 return error("%s", curl_errorstr);
924 }
bc8f2652 925 }
1d389ab6 926 } else {
5e3a7691 927 repo->got_indices = 0;
bc8f2652 928 free(buffer.buffer);
1d389ab6
NH
929 return error("Unable to start request");
930 }
182005b9 931
bc8f2652 932 data = buffer.buffer;
b3661567 933 while (i < buffer.posn) {
182005b9
DB
934 switch (data[i]) {
935 case 'P':
936 i++;
455c161c 937 if (i + 52 <= buffer.posn &&
182005b9
DB
938 !strncmp(data + i, " pack-", 6) &&
939 !strncmp(data + i + 46, ".pack\n", 6)) {
940 get_sha1_hex(data + i + 6, sha1);
b3661567 941 setup_index(repo, sha1);
182005b9
DB
942 i += 51;
943 break;
944 }
945 default:
455c161c 946 while (i < buffer.posn && data[i] != '\n')
182005b9
DB
947 i++;
948 }
949 i++;
b3661567 950 }
182005b9 951
bc8f2652 952 free(buffer.buffer);
b3661567 953 repo->got_indices = 1;
182005b9
DB
954 return 0;
955}
956
b3661567 957static int fetch_pack(struct alt_base *repo, unsigned char *sha1)
182005b9
DB
958{
959 char *url;
960 struct packed_git *target;
961 struct packed_git **lst;
962 FILE *packfile;
963 char *filename;
49a0f240
NH
964 char tmpfile[PATH_MAX];
965 int ret;
966 long prev_posn = 0;
967 char range[RANGE_HEADER_SIZE];
968 struct curl_slist *range_header = NULL;
1d389ab6
NH
969
970 struct active_request_slot *slot;
cb754fdf 971 struct slot_results results;
182005b9 972
b3661567 973 if (fetch_indices(repo))
182005b9 974 return -1;
b3661567 975 target = find_sha1_pack(sha1, repo->packs);
182005b9 976 if (!target)
b3661567 977 return -1;
182005b9
DB
978
979 if (get_verbosely) {
980 fprintf(stderr, "Getting pack %s\n",
981 sha1_to_hex(target->sha1));
982 fprintf(stderr, " which contains %s\n",
983 sha1_to_hex(sha1));
984 }
985
b3661567 986 url = xmalloc(strlen(repo->base) + 65);
182005b9 987 sprintf(url, "%s/objects/pack/pack-%s.pack",
b3661567 988 repo->base, sha1_to_hex(target->sha1));
182005b9
DB
989
990 filename = sha1_pack_name(target->sha1);
49a0f240
NH
991 snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
992 packfile = fopen(tmpfile, "a");
182005b9
DB
993 if (!packfile)
994 return error("Unable to open local file %s for pack",
995 filename);
996
1d389ab6 997 slot = get_active_slot();
c8568e13 998 slot->results = &results;
1d389ab6
NH
999 curl_easy_setopt(slot->curl, CURLOPT_FILE, packfile);
1000 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
1001 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
03126006 1002 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
1d389ab6 1003 slot->local = packfile;
1ddea77e 1004
49a0f240
NH
1005 /* If there is data present from a previous transfer attempt,
1006 resume where it left off */
1007 prev_posn = ftell(packfile);
1008 if (prev_posn>0) {
1009 if (get_verbosely)
1010 fprintf(stderr,
1011 "Resuming fetch of pack %s at byte %ld\n",
1012 sha1_to_hex(target->sha1), prev_posn);
1013 sprintf(range, "Range: bytes=%ld-", prev_posn);
1014 range_header = curl_slist_append(range_header, range);
1d389ab6 1015 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
49a0f240
NH
1016 }
1017
1d389ab6
NH
1018 if (start_active_slot(slot)) {
1019 run_active_slot(slot);
c8568e13 1020 if (results.curl_result != CURLE_OK) {
1d389ab6
NH
1021 fclose(packfile);
1022 return error("Unable to get pack file %s\n%s", url,
1023 curl_errorstr);
1024 }
1025 } else {
313c4714 1026 fclose(packfile);
1d389ab6 1027 return error("Unable to start request");
182005b9
DB
1028 }
1029
1030 fclose(packfile);
1031
b721e01f 1032 ret = move_temp_to_file(tmpfile, filename);
49a0f240 1033 if (ret)
b721e01f 1034 return ret;
49a0f240 1035
b3661567 1036 lst = &repo->packs;
182005b9
DB
1037 while (*lst != target)
1038 lst = &((*lst)->next);
1039 *lst = (*lst)->next;
1040
271421cd
JH
1041 if (verify_pack(target, 0))
1042 return -1;
182005b9
DB
1043 install_packed_git(target);
1044
1045 return 0;
1046}
1047
53f31389
MW
1048static void abort_object_request(struct object_request *obj_req)
1049{
1050 if (obj_req->local >= 0) {
1051 close(obj_req->local);
1052 obj_req->local = -1;
1053 }
1054 unlink(obj_req->tmpfile);
1055 if (obj_req->slot) {
1056 release_active_slot(obj_req->slot);
1057 obj_req->slot = NULL;
1058 }
1059 release_object_request(obj_req);
1060}
1061
a7928f8e 1062static int fetch_object(struct alt_base *repo, unsigned char *sha1)
6eb7ed54
DB
1063{
1064 char *hex = sha1_to_hex(sha1);
29508e1e 1065 int ret = 0;
e388ab74 1066 struct object_request *obj_req = object_queue_head;
1d389ab6 1067
a89fccd2 1068 while (obj_req != NULL && hashcmp(obj_req->sha1, sha1))
e388ab74
NH
1069 obj_req = obj_req->next;
1070 if (obj_req == NULL)
1d389ab6
NH
1071 return error("Couldn't find request for %s in the queue", hex);
1072
e388ab74 1073 if (has_sha1_file(obj_req->sha1)) {
53f31389 1074 abort_object_request(obj_req);
11f0dafe
NH
1075 return 0;
1076 }
1077
a7a8d378 1078#ifdef USE_CURL_MULTI
e388ab74 1079 while (obj_req->state == WAITING) {
29508e1e 1080 step_active_slots();
1d389ab6 1081 }
a7a8d378 1082#else
e388ab74 1083 start_object_request(obj_req);
a7a8d378 1084#endif
6eb7ed54 1085
e388ab74
NH
1086 while (obj_req->state == ACTIVE) {
1087 run_active_slot(obj_req->slot);
a7a8d378 1088 }
e388ab74
NH
1089 if (obj_req->local != -1) {
1090 close(obj_req->local); obj_req->local = -1;
313c4714 1091 }
6eb7ed54 1092
e388ab74 1093 if (obj_req->state == ABORTED) {
29508e1e 1094 ret = error("Request for %s aborted", hex);
e388ab74
NH
1095 } else if (obj_req->curl_result != CURLE_OK &&
1096 obj_req->http_code != 416) {
a14c2256
NH
1097 if (obj_req->http_code == 404 ||
1098 obj_req->curl_result == CURLE_FILE_COULDNT_READ_FILE)
e2029eb9
PB
1099 ret = -1; /* Be silent, it is probably in a pack. */
1100 else
1101 ret = error("%s (curl_result = %d, http_code = %ld, sha1 = %s)",
e388ab74
NH
1102 obj_req->errorstr, obj_req->curl_result,
1103 obj_req->http_code, hex);
1104 } else if (obj_req->zret != Z_STREAM_END) {
bb528079 1105 corrupt_object_found++;
bd2afde8 1106 ret = error("File %s (%s) corrupt", hex, obj_req->url);
a89fccd2 1107 } else if (hashcmp(obj_req->sha1, obj_req->real_sha1)) {
bd2afde8 1108 ret = error("File %s has bad hash", hex);
e388ab74 1109 } else if (obj_req->rename < 0) {
7b934ec0
MW
1110 ret = error("unable to write sha1 filename %s",
1111 obj_req->filename);
6eb7ed54 1112 }
49a0f240 1113
e388ab74 1114 release_object_request(obj_req);
29508e1e 1115 return ret;
6eb7ed54
DB
1116}
1117
b3661567
DB
1118int fetch(unsigned char *sha1)
1119{
1120 struct alt_base *altbase = alt;
1d389ab6
NH
1121
1122 if (!fetch_object(altbase, sha1))
1123 return 0;
b3661567 1124 while (altbase) {
b3661567
DB
1125 if (!fetch_pack(altbase, sha1))
1126 return 0;
f7eb290f 1127 fetch_alternates(alt->base);
b3661567
DB
1128 altbase = altbase->next;
1129 }
bd2afde8 1130 return error("Unable to find %s under %s", sha1_to_hex(sha1),
1d389ab6 1131 alt->base);
b3661567
DB
1132}
1133
94fa447a
JH
1134static inline int needs_quote(int ch)
1135{
cfd432e6
FF
1136 if (((ch >= 'A') && (ch <= 'Z'))
1137 || ((ch >= 'a') && (ch <= 'z'))
1138 || ((ch >= '0') && (ch <= '9'))
1139 || (ch == '/')
1140 || (ch == '-')
1141 || (ch == '.'))
94fa447a 1142 return 0;
cfd432e6 1143 return 1;
94fa447a
JH
1144}
1145
1146static inline int hex(int v)
1147{
1148 if (v < 10) return '0' + v;
1149 else return 'A' + v - 10;
1150}
1151
1152static char *quote_ref_url(const char *base, const char *ref)
1153{
1154 const char *cp;
1155 char *dp, *qref;
1156 int len, baselen, ch;
1157
1158 baselen = strlen(base);
1159 len = baselen + 6; /* "refs/" + NUL */
1160 for (cp = ref; (ch = *cp) != 0; cp++, len++)
1161 if (needs_quote(ch))
1162 len += 2; /* extra two hex plus replacement % */
1163 qref = xmalloc(len);
1164 memcpy(qref, base, baselen);
1165 memcpy(qref + baselen, "refs/", 5);
1166 for (cp = ref, dp = qref + baselen + 5; (ch = *cp) != 0; cp++) {
1167 if (needs_quote(ch)) {
1168 *dp++ = '%';
1169 *dp++ = hex((ch >> 4) & 0xF);
1170 *dp++ = hex(ch & 0xF);
1171 }
1172 else
1173 *dp++ = ch;
1174 }
1175 *dp = 0;
1176
1177 return qref;
1178}
1179
cd541a68
DB
1180int fetch_ref(char *ref, unsigned char *sha1)
1181{
94fa447a 1182 char *url;
fa3e0655
DB
1183 char hex[42];
1184 struct buffer buffer;
8e29f6a0 1185 const char *base = alt->base;
1d389ab6 1186 struct active_request_slot *slot;
cb754fdf 1187 struct slot_results results;
fa3e0655
DB
1188 buffer.size = 41;
1189 buffer.posn = 0;
1190 buffer.buffer = hex;
1191 hex[41] = '\0';
8fcf7f9a 1192
94fa447a 1193 url = quote_ref_url(base, ref);
1d389ab6 1194 slot = get_active_slot();
c8568e13 1195 slot->results = &results;
1d389ab6
NH
1196 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
1197 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
1198 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
1199 curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1200 if (start_active_slot(slot)) {
1201 run_active_slot(slot);
c8568e13 1202 if (results.curl_result != CURLE_OK)
1d389ab6
NH
1203 return error("Couldn't get %s for %s\n%s",
1204 url, ref, curl_errorstr);
1205 } else {
1206 return error("Unable to start request");
1207 }
fa3e0655
DB
1208
1209 hex[40] = '\0';
1210 get_sha1_hex(hex, sha1);
1211 return 0;
cd541a68
DB
1212}
1213
8e29f6a0 1214int main(int argc, const char **argv)
6eb7ed54 1215{
8e29f6a0
PB
1216 int commits;
1217 const char **write_ref = NULL;
1218 char **commit_id;
1219 const char *url;
8d9fbe57 1220 char *path;
6eb7ed54 1221 int arg = 1;
7b9ae53e 1222 int rc = 0;
6eb7ed54 1223
19c45881 1224 setup_ident();
5a327713 1225 setup_git_directory();
d0740d92 1226 git_config(git_default_config);
5a327713 1227
6eb7ed54
DB
1228 while (arg < argc && argv[arg][0] == '-') {
1229 if (argv[arg][1] == 't') {
4250a5e5 1230 get_tree = 1;
6eb7ed54 1231 } else if (argv[arg][1] == 'c') {
4250a5e5 1232 get_history = 1;
6eb7ed54 1233 } else if (argv[arg][1] == 'a') {
4250a5e5
DB
1234 get_all = 1;
1235 get_tree = 1;
1236 get_history = 1;
e78d9772
JH
1237 } else if (argv[arg][1] == 'v') {
1238 get_verbosely = 1;
fa3e0655 1239 } else if (argv[arg][1] == 'w') {
8e29f6a0 1240 write_ref = &argv[arg + 1];
fa3e0655 1241 arg++;
820eca68
DB
1242 } else if (!strcmp(argv[arg], "--recover")) {
1243 get_recover = 1;
8e29f6a0
PB
1244 } else if (!strcmp(argv[arg], "--stdin")) {
1245 commits_on_stdin = 1;
6eb7ed54
DB
1246 }
1247 arg++;
1248 }
8e29f6a0
PB
1249 if (argc < arg + 2 - commits_on_stdin) {
1250 usage("git-http-fetch [-c] [-t] [-a] [-v] [--recover] [-w ref] [--stdin] commit-id url");
6eb7ed54
DB
1251 return 1;
1252 }
8e29f6a0
PB
1253 if (commits_on_stdin) {
1254 commits = pull_targets_stdin(&commit_id, &write_ref);
1255 } else {
1256 commit_id = (char **) &argv[arg++];
1257 commits = 1;
1258 }
1259 url = argv[arg];
6eb7ed54 1260
29508e1e 1261 http_init();
d402d556 1262
1db69b57 1263 no_pragma_header = curl_slist_append(no_pragma_header, "Pragma:");
3dcb90f5 1264
b3661567
DB
1265 alt = xmalloc(sizeof(*alt));
1266 alt->base = url;
1267 alt->got_indices = 0;
1268 alt->packs = NULL;
1269 alt->next = NULL;
8d9fbe57
NH
1270 path = strstr(url, "//");
1271 if (path) {
ef9e58c8 1272 path = strchr(path+2, '/');
8d9fbe57
NH
1273 if (path)
1274 alt->path_len = strlen(path);
1275 }
6eb7ed54 1276
8e29f6a0 1277 if (pull(commits, commit_id, write_ref, url))
7b9ae53e 1278 rc = 1;
6eb7ed54 1279
29508e1e
NH
1280 http_cleanup();
1281
07001f95
SE
1282 curl_slist_free_all(no_pragma_header);
1283
8e29f6a0
PB
1284 if (commits_on_stdin)
1285 pull_targets_free(commits, commit_id, write_ref);
1286
bb528079
JH
1287 if (corrupt_object_found) {
1288 fprintf(stderr,
1289"Some loose object were found to be corrupt, but they might be just\n"
1290"a false '404 Not Found' error message sent with incorrect HTTP\n"
1291"status code. Suggest running git fsck-objects.\n");
1292 }
7b9ae53e 1293 return rc;
6eb7ed54 1294}