http: return curl's AUTHAVAIL via slot_results
[git/git.git] / remote-curl.c
CommitLineData
a2d725b7
DB
1#include "cache.h"
2#include "remote.h"
3#include "strbuf.h"
4#include "walker.h"
5#include "http.h"
d01a8e32 6#include "exec_cmd.h"
ae4efe19 7#include "run-command.h"
97cc7bc4 8#include "pkt-line.h"
de1a2fdd 9#include "sideband.h"
222b1212 10#include "argv-array.h"
a2d725b7 11
37a8768f 12static struct remote *remote;
d8fab072 13static const char *url; /* always ends with a trailing slash */
37a8768f 14
ef08ef9e
SP
15struct options {
16 int verbosity;
17 unsigned long depth;
18 unsigned progress : 1,
ae4efe19 19 followtags : 1,
de1a2fdd
SP
20 dry_run : 1,
21 thin : 1;
ef08ef9e
SP
22};
23static struct options options;
24
ef08ef9e
SP
25static int set_option(const char *name, const char *value)
26{
27 if (!strcmp(name, "verbosity")) {
28 char *end;
29 int v = strtol(value, &end, 10);
30 if (value == end || *end)
31 return -1;
32 options.verbosity = v;
33 return 0;
34 }
35 else if (!strcmp(name, "progress")) {
36 if (!strcmp(value, "true"))
37 options.progress = 1;
38 else if (!strcmp(value, "false"))
39 options.progress = 0;
40 else
41 return -1;
249b2004 42 return 0;
ef08ef9e
SP
43 }
44 else if (!strcmp(name, "depth")) {
45 char *end;
46 unsigned long v = strtoul(value, &end, 10);
47 if (value == end || *end)
48 return -1;
49 options.depth = v;
249b2004 50 return 0;
ef08ef9e
SP
51 }
52 else if (!strcmp(name, "followtags")) {
53 if (!strcmp(value, "true"))
54 options.followtags = 1;
55 else if (!strcmp(value, "false"))
56 options.followtags = 0;
57 else
58 return -1;
249b2004 59 return 0;
ef08ef9e 60 }
ae4efe19
SP
61 else if (!strcmp(name, "dry-run")) {
62 if (!strcmp(value, "true"))
63 options.dry_run = 1;
64 else if (!strcmp(value, "false"))
65 options.dry_run = 0;
66 else
67 return -1;
68 return 0;
69 }
ef08ef9e
SP
70 else {
71 return 1 /* unsupported */;
72 }
73}
74
97cc7bc4
SP
75struct discovery {
76 const char *service;
77 char *buf_alloc;
78 char *buf;
79 size_t len;
2a455202 80 struct ref *refs;
97cc7bc4
SP
81 unsigned proto_git : 1;
82};
83static struct discovery *last_discovery;
84
b8054bbe
JK
85static struct ref *parse_git_refs(struct discovery *heads, int for_push)
86{
87 struct ref *list = NULL;
88 get_remote_heads(-1, heads->buf, heads->len, &list,
89 for_push ? REF_NORMAL : 0, NULL);
90 return list;
91}
92
93static struct ref *parse_info_refs(struct discovery *heads)
94{
95 char *data, *start, *mid;
96 char *ref_name;
97 int i = 0;
98
99 struct ref *refs = NULL;
100 struct ref *ref = NULL;
101 struct ref *last_ref = NULL;
102
103 data = heads->buf;
104 start = NULL;
105 mid = data;
106 while (i < heads->len) {
107 if (!start) {
108 start = &data[i];
109 }
110 if (data[i] == '\t')
111 mid = &data[i];
112 if (data[i] == '\n') {
113 if (mid - start != 40)
114 die("%sinfo/refs not valid: is this a git repository?", url);
115 data[i] = 0;
116 ref_name = mid + 1;
117 ref = xmalloc(sizeof(struct ref) +
118 strlen(ref_name) + 1);
119 memset(ref, 0, sizeof(struct ref));
120 strcpy(ref->name, ref_name);
121 get_sha1_hex(start, ref->old_sha1);
122 if (!refs)
123 refs = ref;
124 if (last_ref)
125 last_ref->next = ref;
126 last_ref = ref;
127 start = NULL;
128 }
129 i++;
130 }
131
132 ref = alloc_ref("HEAD");
133 if (!http_fetch_ref(url, ref) &&
134 !resolve_remote_symref(ref, refs)) {
135 ref->next = refs;
136 refs = ref;
137 } else {
138 free(ref);
139 }
140
141 return refs;
142}
143
97cc7bc4
SP
144static void free_discovery(struct discovery *d)
145{
146 if (d) {
147 if (d == last_discovery)
148 last_discovery = NULL;
149 free(d->buf_alloc);
2a455202 150 free_refs(d->refs);
97cc7bc4
SP
151 free(d);
152 }
153}
154
426e70d4
JK
155static int show_http_message(struct strbuf *type, struct strbuf *msg)
156{
157 const char *p, *eol;
158
159 /*
160 * We only show text/plain parts, as other types are likely
161 * to be ugly to look at on the user's terminal.
162 *
163 * TODO should handle "; charset=XXX", and re-encode into
164 * logoutputencoding
165 */
166 if (strcasecmp(type->buf, "text/plain"))
167 return -1;
168
169 strbuf_trim(msg);
170 if (!msg->len)
171 return -1;
172
173 p = msg->buf;
174 do {
175 eol = strchrnul(p, '\n');
176 fprintf(stderr, "remote: %.*s\n", (int)(eol - p), p);
177 p = eol + 1;
178 } while(*eol);
179 return 0;
180}
181
2a455202 182static struct discovery* discover_refs(const char *service, int for_push)
a2d725b7 183{
4656bf47
SP
184 struct strbuf exp = STRBUF_INIT;
185 struct strbuf type = STRBUF_INIT;
a2d725b7 186 struct strbuf buffer = STRBUF_INIT;
97cc7bc4 187 struct discovery *last = last_discovery;
a2d725b7 188 char *refs_url;
243c329c 189 int http_ret, maybe_smart = 0;
a2d725b7 190
97cc7bc4
SP
191 if (last && !strcmp(service, last->service))
192 return last;
193 free_discovery(last);
a2d725b7 194
d8fab072 195 strbuf_addf(&buffer, "%sinfo/refs", url);
02572c2e
JK
196 if ((!prefixcmp(url, "http://") || !prefixcmp(url, "https://")) &&
197 git_env_bool("GIT_SMART_HTTP", 1)) {
243c329c 198 maybe_smart = 1;
97cc7bc4
SP
199 if (!strchr(url, '?'))
200 strbuf_addch(&buffer, '?');
201 else
202 strbuf_addch(&buffer, '&');
203 strbuf_addf(&buffer, "service=%s", service);
204 }
205 refs_url = strbuf_detach(&buffer, NULL);
a2d725b7 206
426e70d4
JK
207 http_ret = http_get_strbuf(refs_url, &type, &buffer,
208 HTTP_NO_CACHE | HTTP_KEEP_ERROR);
a2d725b7
DB
209 switch (http_ret) {
210 case HTTP_OK:
211 break;
212 case HTTP_MISSING_TARGET:
cfa0f404
JK
213 show_http_message(&type, &buffer);
214 die("repository '%s' not found", url);
42653c09 215 case HTTP_NOAUTH:
426e70d4 216 show_http_message(&type, &buffer);
d5ccbe4d 217 die("Authentication failed for '%s'", url);
a2d725b7 218 default:
426e70d4 219 show_http_message(&type, &buffer);
de89f0b2 220 die("unable to access '%s': %s", url, curl_errorstr);
a2d725b7
DB
221 }
222
97cc7bc4
SP
223 last= xcalloc(1, sizeof(*last_discovery));
224 last->service = service;
225 last->buf_alloc = strbuf_detach(&buffer, &last->len);
226 last->buf = last->buf_alloc;
227
4656bf47
SP
228 strbuf_addf(&exp, "application/x-%s-advertisement", service);
229 if (maybe_smart &&
230 (5 <= last->len && last->buf[4] == '#') &&
231 !strbuf_cmp(&exp, &type)) {
4981fe75
JK
232 char *line;
233
4656bf47
SP
234 /*
235 * smart HTTP response; validate that the service
97cc7bc4
SP
236 * pkt-line matches our request.
237 */
4981fe75 238 line = packet_read_line_buf(&last->buf, &last->len, NULL);
97cc7bc4 239
4656bf47 240 strbuf_reset(&exp);
97cc7bc4 241 strbuf_addf(&exp, "# service=%s", service);
4981fe75
JK
242 if (strcmp(line, exp.buf))
243 die("invalid server response; got '%s'", line);
97cc7bc4
SP
244 strbuf_release(&exp);
245
246 /* The header can include additional metadata lines, up
247 * until a packet flush marker. Ignore these now, but
248 * in the future we might start to scan them.
249 */
4981fe75
JK
250 while (packet_read_line_buf(&last->buf, &last->len, NULL))
251 ;
97cc7bc4
SP
252
253 last->proto_git = 1;
254 }
255
2a455202
JK
256 if (last->proto_git)
257 last->refs = parse_git_refs(last, for_push);
258 else
259 last->refs = parse_info_refs(last);
260
97cc7bc4 261 free(refs_url);
4656bf47
SP
262 strbuf_release(&exp);
263 strbuf_release(&type);
97cc7bc4
SP
264 strbuf_release(&buffer);
265 last_discovery = last;
266 return last;
267}
268
97cc7bc4
SP
269static struct ref *get_refs(int for_push)
270{
271 struct discovery *heads;
272
273 if (for_push)
2a455202 274 heads = discover_refs("git-receive-pack", for_push);
97cc7bc4 275 else
2a455202 276 heads = discover_refs("git-upload-pack", for_push);
97cc7bc4 277
2a455202 278 return heads->refs;
97cc7bc4
SP
279}
280
ae4efe19
SP
281static void output_refs(struct ref *refs)
282{
283 struct ref *posn;
284 for (posn = refs; posn; posn = posn->next) {
285 if (posn->symref)
286 printf("@%s %s\n", posn->symref, posn->name);
287 else
288 printf("%s %s\n", sha1_to_hex(posn->old_sha1), posn->name);
289 }
290 printf("\n");
291 fflush(stdout);
ae4efe19
SP
292}
293
de1a2fdd
SP
294struct rpc_state {
295 const char *service_name;
296 const char **argv;
8150749d 297 struct strbuf *stdin_preamble;
de1a2fdd
SP
298 char *service_url;
299 char *hdr_content_type;
300 char *hdr_accept;
301 char *buf;
302 size_t alloc;
303 size_t len;
304 size_t pos;
305 int in;
306 int out;
307 struct strbuf result;
b8538603 308 unsigned gzip_request : 1;
6c81a990 309 unsigned initial_buffer : 1;
de1a2fdd
SP
310};
311
312static size_t rpc_out(void *ptr, size_t eltsize,
313 size_t nmemb, void *buffer_)
314{
315 size_t max = eltsize * nmemb;
316 struct rpc_state *rpc = buffer_;
317 size_t avail = rpc->len - rpc->pos;
318
319 if (!avail) {
6c81a990 320 rpc->initial_buffer = 0;
4981fe75 321 avail = packet_read(rpc->out, NULL, NULL, rpc->buf, rpc->alloc, 0);
de1a2fdd
SP
322 if (!avail)
323 return 0;
324 rpc->pos = 0;
325 rpc->len = avail;
326 }
327
48310608 328 if (max < avail)
de1a2fdd
SP
329 avail = max;
330 memcpy(ptr, rpc->buf + rpc->pos, avail);
331 rpc->pos += avail;
332 return avail;
333}
334
6c81a990 335#ifndef NO_CURL_IOCTL
5092d3ec 336static curlioerr rpc_ioctl(CURL *handle, int cmd, void *clientp)
6c81a990
MS
337{
338 struct rpc_state *rpc = clientp;
339
340 switch (cmd) {
341 case CURLIOCMD_NOP:
342 return CURLIOE_OK;
343
344 case CURLIOCMD_RESTARTREAD:
345 if (rpc->initial_buffer) {
346 rpc->pos = 0;
347 return CURLIOE_OK;
348 }
349 fprintf(stderr, "Unable to rewind rpc post data - try increasing http.postBuffer\n");
350 return CURLIOE_FAILRESTART;
351
352 default:
353 return CURLIOE_UNKNOWNCMD;
354 }
355}
356#endif
357
a04ff3ec 358static size_t rpc_in(char *ptr, size_t eltsize,
de1a2fdd
SP
359 size_t nmemb, void *buffer_)
360{
361 size_t size = eltsize * nmemb;
362 struct rpc_state *rpc = buffer_;
363 write_or_die(rpc->in, ptr, size);
364 return size;
365}
366
206b099d
SP
367static int run_slot(struct active_request_slot *slot)
368{
b81401c1 369 int err;
206b099d
SP
370 struct slot_results results;
371
372 slot->results = &results;
373 slot->curl_result = curl_easy_perform(slot->curl);
374 finish_active_slot(slot);
375
1960897e 376 err = handle_curl_result(&results);
b81401c1
JK
377 if (err != HTTP_OK && err != HTTP_REAUTH) {
378 error("RPC failed; result=%d, HTTP code = %ld",
379 results.curl_result, results.http_code);
206b099d
SP
380 }
381
382 return err;
383}
384
385static int probe_rpc(struct rpc_state *rpc)
386{
387 struct active_request_slot *slot;
388 struct curl_slist *headers = NULL;
389 struct strbuf buf = STRBUF_INIT;
390 int err;
391
392 slot = get_active_slot();
393
394 headers = curl_slist_append(headers, rpc->hdr_content_type);
395 headers = curl_slist_append(headers, rpc->hdr_accept);
396
397 curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
398 curl_easy_setopt(slot->curl, CURLOPT_POST, 1);
399 curl_easy_setopt(slot->curl, CURLOPT_URL, rpc->service_url);
aa90b969 400 curl_easy_setopt(slot->curl, CURLOPT_ENCODING, NULL);
206b099d
SP
401 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, "0000");
402 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, 4);
403 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, headers);
404 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
405 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buf);
406
407 err = run_slot(slot);
408
409 curl_slist_free_all(headers);
410 strbuf_release(&buf);
411 return err;
412}
413
de1a2fdd
SP
414static int post_rpc(struct rpc_state *rpc)
415{
416 struct active_request_slot *slot;
de1a2fdd 417 struct curl_slist *headers = NULL;
b8538603
SP
418 int use_gzip = rpc->gzip_request;
419 char *gzip_body = NULL;
37711549 420 size_t gzip_size = 0;
206b099d 421 int err, large_request = 0;
de1a2fdd
SP
422
423 /* Try to load the entire request, if we can fit it into the
424 * allocated buffer space we can use HTTP/1.0 and avoid the
425 * chunked encoding mess.
426 */
427 while (1) {
428 size_t left = rpc->alloc - rpc->len;
429 char *buf = rpc->buf + rpc->len;
430 int n;
431
432 if (left < LARGE_PACKET_MAX) {
433 large_request = 1;
b8538603 434 use_gzip = 0;
de1a2fdd
SP
435 break;
436 }
437
4981fe75 438 n = packet_read(rpc->out, NULL, NULL, buf, left, 0);
de1a2fdd
SP
439 if (!n)
440 break;
441 rpc->len += n;
442 }
443
206b099d 444 if (large_request) {
b81401c1
JK
445 do {
446 err = probe_rpc(rpc);
447 } while (err == HTTP_REAUTH);
448 if (err != HTTP_OK)
449 return -1;
206b099d
SP
450 }
451
abf8df86
JK
452 headers = curl_slist_append(headers, rpc->hdr_content_type);
453 headers = curl_slist_append(headers, rpc->hdr_accept);
454 headers = curl_slist_append(headers, "Expect:");
455
456retry:
de1a2fdd 457 slot = get_active_slot();
de1a2fdd 458
de1a2fdd 459 curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
d21f9794 460 curl_easy_setopt(slot->curl, CURLOPT_POST, 1);
de1a2fdd 461 curl_easy_setopt(slot->curl, CURLOPT_URL, rpc->service_url);
aa90b969 462 curl_easy_setopt(slot->curl, CURLOPT_ENCODING, "gzip");
de1a2fdd 463
de1a2fdd
SP
464 if (large_request) {
465 /* The request body is large and the size cannot be predicted.
466 * We must use chunked encoding to send it.
467 */
de1a2fdd 468 headers = curl_slist_append(headers, "Transfer-Encoding: chunked");
6c81a990 469 rpc->initial_buffer = 1;
de1a2fdd
SP
470 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, rpc_out);
471 curl_easy_setopt(slot->curl, CURLOPT_INFILE, rpc);
6c81a990
MS
472#ifndef NO_CURL_IOCTL
473 curl_easy_setopt(slot->curl, CURLOPT_IOCTLFUNCTION, rpc_ioctl);
474 curl_easy_setopt(slot->curl, CURLOPT_IOCTLDATA, rpc);
475#endif
de1a2fdd
SP
476 if (options.verbosity > 1) {
477 fprintf(stderr, "POST %s (chunked)\n", rpc->service_name);
478 fflush(stderr);
479 }
480
2e736fd5
JK
481 } else if (gzip_body) {
482 /*
483 * If we are looping to retry authentication, then the previous
484 * run will have set up the headers and gzip buffer already,
485 * and we just need to send it.
486 */
487 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, gzip_body);
488 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, gzip_size);
489
b8538603
SP
490 } else if (use_gzip && 1024 < rpc->len) {
491 /* The client backend isn't giving us compressed data so
492 * we can try to deflate it ourselves, this may save on.
493 * the transfer time.
494 */
ef49a7a0 495 git_zstream stream;
b8538603
SP
496 int ret;
497
498 memset(&stream, 0, sizeof(stream));
55bb5c91 499 git_deflate_init_gzip(&stream, Z_BEST_COMPRESSION);
df126e10
JK
500 gzip_size = git_deflate_bound(&stream, rpc->len);
501 gzip_body = xmalloc(gzip_size);
b8538603
SP
502
503 stream.next_in = (unsigned char *)rpc->buf;
504 stream.avail_in = rpc->len;
505 stream.next_out = (unsigned char *)gzip_body;
df126e10 506 stream.avail_out = gzip_size;
b8538603 507
55bb5c91 508 ret = git_deflate(&stream, Z_FINISH);
b8538603
SP
509 if (ret != Z_STREAM_END)
510 die("cannot deflate request; zlib deflate error %d", ret);
511
55bb5c91 512 ret = git_deflate_end_gently(&stream);
b8538603
SP
513 if (ret != Z_OK)
514 die("cannot deflate request; zlib end error %d", ret);
515
df126e10 516 gzip_size = stream.total_out;
b8538603
SP
517
518 headers = curl_slist_append(headers, "Content-Encoding: gzip");
519 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, gzip_body);
df126e10 520 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, gzip_size);
b8538603
SP
521
522 if (options.verbosity > 1) {
523 fprintf(stderr, "POST %s (gzip %lu to %lu bytes)\n",
524 rpc->service_name,
df126e10 525 (unsigned long)rpc->len, (unsigned long)gzip_size);
b8538603
SP
526 fflush(stderr);
527 }
de1a2fdd
SP
528 } else {
529 /* We know the complete request size in advance, use the
530 * more normal Content-Length approach.
531 */
532 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, rpc->buf);
533 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, rpc->len);
534 if (options.verbosity > 1) {
535 fprintf(stderr, "POST %s (%lu bytes)\n",
536 rpc->service_name, (unsigned long)rpc->len);
537 fflush(stderr);
538 }
539 }
540
541 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, headers);
542 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, rpc_in);
543 curl_easy_setopt(slot->curl, CURLOPT_FILE, rpc);
544
abf8df86 545 err = run_slot(slot);
2e736fd5 546 if (err == HTTP_REAUTH && !large_request)
abf8df86 547 goto retry;
b81401c1
JK
548 if (err != HTTP_OK)
549 err = -1;
de1a2fdd
SP
550
551 curl_slist_free_all(headers);
b8538603 552 free(gzip_body);
de1a2fdd
SP
553 return err;
554}
555
556static int rpc_service(struct rpc_state *rpc, struct discovery *heads)
557{
558 const char *svc = rpc->service_name;
559 struct strbuf buf = STRBUF_INIT;
8150749d 560 struct strbuf *preamble = rpc->stdin_preamble;
de1a2fdd
SP
561 struct child_process client;
562 int err = 0;
563
de1a2fdd
SP
564 memset(&client, 0, sizeof(client));
565 client.in = -1;
566 client.out = -1;
567 client.git_cmd = 1;
568 client.argv = rpc->argv;
569 if (start_command(&client))
570 exit(1);
8150749d
IT
571 if (preamble)
572 write_or_die(client.in, preamble->buf, preamble->len);
de1a2fdd
SP
573 if (heads)
574 write_or_die(client.in, heads->buf, heads->len);
575
576 rpc->alloc = http_post_buffer;
577 rpc->buf = xmalloc(rpc->alloc);
578 rpc->in = client.in;
579 rpc->out = client.out;
580 strbuf_init(&rpc->result, 0);
581
d8fab072 582 strbuf_addf(&buf, "%s%s", url, svc);
de1a2fdd
SP
583 rpc->service_url = strbuf_detach(&buf, NULL);
584
585 strbuf_addf(&buf, "Content-Type: application/x-%s-request", svc);
586 rpc->hdr_content_type = strbuf_detach(&buf, NULL);
587
8efa5f62 588 strbuf_addf(&buf, "Accept: application/x-%s-result", svc);
de1a2fdd
SP
589 rpc->hdr_accept = strbuf_detach(&buf, NULL);
590
591 while (!err) {
4981fe75 592 int n = packet_read(rpc->out, NULL, NULL, rpc->buf, rpc->alloc, 0);
de1a2fdd
SP
593 if (!n)
594 break;
595 rpc->pos = 0;
596 rpc->len = n;
597 err |= post_rpc(rpc);
598 }
de1a2fdd
SP
599
600 close(client.in);
de1a2fdd 601 client.in = -1;
6cdf0223
SP
602 if (!err) {
603 strbuf_read(&rpc->result, client.out, 0);
604 } else {
605 char buf[4096];
606 for (;;)
607 if (xread(client.out, buf, sizeof(buf)) <= 0)
608 break;
609 }
b4ee10f6
SP
610
611 close(client.out);
de1a2fdd
SP
612 client.out = -1;
613
614 err |= finish_command(&client);
615 free(rpc->service_url);
616 free(rpc->hdr_content_type);
617 free(rpc->hdr_accept);
618 free(rpc->buf);
619 strbuf_release(&buf);
620 return err;
621}
622
292ce46b
SP
623static int fetch_dumb(int nr_heads, struct ref **to_fetch)
624{
26e1e0b2 625 struct walker *walker;
292ce46b
SP
626 char **targets = xmalloc(nr_heads * sizeof(char*));
627 int ret, i;
628
249b2004
SP
629 if (options.depth)
630 die("dumb http transport does not support --depth");
292ce46b
SP
631 for (i = 0; i < nr_heads; i++)
632 targets[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
633
26e1e0b2 634 walker = get_http_walker(url);
292ce46b
SP
635 walker->get_all = 1;
636 walker->get_tree = 1;
637 walker->get_history = 1;
ef08ef9e 638 walker->get_verbosely = options.verbosity >= 3;
292ce46b
SP
639 walker->get_recover = 0;
640 ret = walker_fetch(walker, nr_heads, targets, NULL, NULL);
26e1e0b2 641 walker_free(walker);
292ce46b
SP
642
643 for (i = 0; i < nr_heads; i++)
644 free(targets[i]);
645 free(targets);
646
647 return ret ? error("Fetch failed.") : 0;
648}
649
249b2004
SP
650static int fetch_git(struct discovery *heads,
651 int nr_heads, struct ref **to_fetch)
652{
653 struct rpc_state rpc;
8150749d 654 struct strbuf preamble = STRBUF_INIT;
249b2004 655 char *depth_arg = NULL;
249b2004 656 int argc = 0, i, err;
8150749d 657 const char *argv[15];
249b2004 658
249b2004
SP
659 argv[argc++] = "fetch-pack";
660 argv[argc++] = "--stateless-rpc";
8150749d 661 argv[argc++] = "--stdin";
249b2004
SP
662 argv[argc++] = "--lock-pack";
663 if (options.followtags)
664 argv[argc++] = "--include-tag";
665 if (options.thin)
666 argv[argc++] = "--thin";
667 if (options.verbosity >= 3) {
668 argv[argc++] = "-v";
669 argv[argc++] = "-v";
670 }
671 if (!options.progress)
672 argv[argc++] = "--no-progress";
673 if (options.depth) {
674 struct strbuf buf = STRBUF_INIT;
675 strbuf_addf(&buf, "--depth=%lu", options.depth);
676 depth_arg = strbuf_detach(&buf, NULL);
677 argv[argc++] = depth_arg;
678 }
679 argv[argc++] = url;
8150749d
IT
680 argv[argc++] = NULL;
681
249b2004
SP
682 for (i = 0; i < nr_heads; i++) {
683 struct ref *ref = to_fetch[i];
684 if (!ref->name || !*ref->name)
685 die("cannot fetch by sha1 over smart http");
8150749d 686 packet_buf_write(&preamble, "%s\n", ref->name);
249b2004 687 }
8150749d 688 packet_buf_flush(&preamble);
249b2004
SP
689
690 memset(&rpc, 0, sizeof(rpc));
691 rpc.service_name = "git-upload-pack",
692 rpc.argv = argv;
8150749d 693 rpc.stdin_preamble = &preamble;
b8538603 694 rpc.gzip_request = 1;
249b2004
SP
695
696 err = rpc_service(&rpc, heads);
697 if (rpc.result.len)
cdf4fb8e 698 write_or_die(1, rpc.result.buf, rpc.result.len);
249b2004 699 strbuf_release(&rpc.result);
8150749d 700 strbuf_release(&preamble);
249b2004
SP
701 free(depth_arg);
702 return err;
703}
704
705static int fetch(int nr_heads, struct ref **to_fetch)
706{
2a455202 707 struct discovery *d = discover_refs("git-upload-pack", 0);
249b2004
SP
708 if (d->proto_git)
709 return fetch_git(d, nr_heads, to_fetch);
710 else
711 return fetch_dumb(nr_heads, to_fetch);
712}
713
292ce46b
SP
714static void parse_fetch(struct strbuf *buf)
715{
716 struct ref **to_fetch = NULL;
717 struct ref *list_head = NULL;
718 struct ref **list = &list_head;
719 int alloc_heads = 0, nr_heads = 0;
720
721 do {
722 if (!prefixcmp(buf->buf, "fetch ")) {
723 char *p = buf->buf + strlen("fetch ");
724 char *name;
725 struct ref *ref;
726 unsigned char old_sha1[20];
727
728 if (strlen(p) < 40 || get_sha1_hex(p, old_sha1))
729 die("protocol error: expected sha/ref, got %s'", p);
730 if (p[40] == ' ')
731 name = p + 41;
732 else if (!p[40])
733 name = "";
734 else
735 die("protocol error: expected sha/ref, got %s'", p);
736
737 ref = alloc_ref(name);
738 hashcpy(ref->old_sha1, old_sha1);
739
740 *list = ref;
741 list = &ref->next;
742
743 ALLOC_GROW(to_fetch, nr_heads + 1, alloc_heads);
744 to_fetch[nr_heads++] = ref;
745 }
746 else
747 die("http transport does not support %s", buf->buf);
748
749 strbuf_reset(buf);
750 if (strbuf_getline(buf, stdin, '\n') == EOF)
751 return;
752 if (!*buf->buf)
753 break;
754 } while (1);
755
249b2004 756 if (fetch(nr_heads, to_fetch))
292ce46b
SP
757 exit(128); /* error already reported */
758 free_refs(list_head);
759 free(to_fetch);
760
761 printf("\n");
762 fflush(stdout);
763 strbuf_reset(buf);
764}
765
ae4efe19
SP
766static int push_dav(int nr_spec, char **specs)
767{
768 const char **argv = xmalloc((10 + nr_spec) * sizeof(char*));
769 int argc = 0, i;
770
771 argv[argc++] = "http-push";
772 argv[argc++] = "--helper-status";
773 if (options.dry_run)
774 argv[argc++] = "--dry-run";
775 if (options.verbosity > 1)
776 argv[argc++] = "--verbose";
777 argv[argc++] = url;
778 for (i = 0; i < nr_spec; i++)
779 argv[argc++] = specs[i];
780 argv[argc++] = NULL;
781
782 if (run_command_v_opt(argv, RUN_GIT_CMD))
783 die("git-%s failed", argv[0]);
784 free(argv);
785 return 0;
786}
787
de1a2fdd
SP
788static int push_git(struct discovery *heads, int nr_spec, char **specs)
789{
790 struct rpc_state rpc;
222b1212
JH
791 int i, err;
792 struct argv_array args;
793
794 argv_array_init(&args);
795 argv_array_pushl(&args, "send-pack", "--stateless-rpc", "--helper-status",
796 NULL);
de1a2fdd 797
de1a2fdd 798 if (options.thin)
222b1212 799 argv_array_push(&args, "--thin");
de1a2fdd 800 if (options.dry_run)
222b1212 801 argv_array_push(&args, "--dry-run");
c207e34f 802 if (options.verbosity == 0)
222b1212 803 argv_array_push(&args, "--quiet");
c207e34f 804 else if (options.verbosity > 1)
222b1212
JH
805 argv_array_push(&args, "--verbose");
806 argv_array_push(&args, options.progress ? "--progress" : "--no-progress");
807 argv_array_push(&args, url);
de1a2fdd 808 for (i = 0; i < nr_spec; i++)
222b1212 809 argv_array_push(&args, specs[i]);
de1a2fdd
SP
810
811 memset(&rpc, 0, sizeof(rpc));
812 rpc.service_name = "git-receive-pack",
222b1212 813 rpc.argv = args.argv;
de1a2fdd
SP
814
815 err = rpc_service(&rpc, heads);
816 if (rpc.result.len)
cdf4fb8e 817 write_or_die(1, rpc.result.buf, rpc.result.len);
de1a2fdd 818 strbuf_release(&rpc.result);
222b1212 819 argv_array_clear(&args);
de1a2fdd
SP
820 return err;
821}
822
823static int push(int nr_spec, char **specs)
824{
2a455202 825 struct discovery *heads = discover_refs("git-receive-pack", 1);
de1a2fdd
SP
826 int ret;
827
828 if (heads->proto_git)
829 ret = push_git(heads, nr_spec, specs);
830 else
831 ret = push_dav(nr_spec, specs);
832 free_discovery(heads);
833 return ret;
834}
835
ae4efe19
SP
836static void parse_push(struct strbuf *buf)
837{
838 char **specs = NULL;
5238cbf6 839 int alloc_spec = 0, nr_spec = 0, i, ret;
ae4efe19
SP
840
841 do {
842 if (!prefixcmp(buf->buf, "push ")) {
843 ALLOC_GROW(specs, nr_spec + 1, alloc_spec);
844 specs[nr_spec++] = xstrdup(buf->buf + 5);
845 }
846 else
847 die("http transport does not support %s", buf->buf);
848
849 strbuf_reset(buf);
850 if (strbuf_getline(buf, stdin, '\n') == EOF)
dc4cd767 851 goto free_specs;
ae4efe19
SP
852 if (!*buf->buf)
853 break;
854 } while (1);
855
5238cbf6 856 ret = push(nr_spec, specs);
ae4efe19
SP
857 printf("\n");
858 fflush(stdout);
dc4cd767 859
5238cbf6
SP
860 if (ret)
861 exit(128); /* error already reported */
862
dc4cd767
JM
863 free_specs:
864 for (i = 0; i < nr_spec; i++)
865 free(specs[i]);
866 free(specs);
ae4efe19
SP
867}
868
a2d725b7
DB
869int main(int argc, const char **argv)
870{
a2d725b7 871 struct strbuf buf = STRBUF_INIT;
a45d3d7e 872 int nongit;
a2d725b7 873
c6dfb399 874 git_extract_argv0_path(argv[0]);
a45d3d7e 875 setup_git_directory_gently(&nongit);
a2d725b7
DB
876 if (argc < 2) {
877 fprintf(stderr, "Remote needed\n");
878 return 1;
879 }
880
ef08ef9e
SP
881 options.verbosity = 1;
882 options.progress = !!isatty(2);
de1a2fdd 883 options.thin = 1;
ef08ef9e 884
a2d725b7
DB
885 remote = remote_get(argv[1]);
886
887 if (argc > 2) {
d8fab072 888 end_url_with_slash(&buf, argv[2]);
a2d725b7 889 } else {
d8fab072 890 end_url_with_slash(&buf, remote->url[0]);
a2d725b7
DB
891 }
892
d8fab072
TRC
893 url = strbuf_detach(&buf, NULL);
894
a4ddbc33 895 http_init(remote, url, 0);
888692b7 896
a2d725b7 897 do {
1843f0ce
SR
898 if (strbuf_getline(&buf, stdin, '\n') == EOF) {
899 if (ferror(stdin))
900 fprintf(stderr, "Error reading command stream\n");
901 else
902 fprintf(stderr, "Unexpected end of command stream\n");
903 return 1;
904 }
905 if (buf.len == 0)
a2d725b7
DB
906 break;
907 if (!prefixcmp(buf.buf, "fetch ")) {
a45d3d7e
DB
908 if (nongit)
909 die("Fetch attempted without a local repo");
292ce46b
SP
910 parse_fetch(&buf);
911
ae4efe19 912 } else if (!strcmp(buf.buf, "list") || !prefixcmp(buf.buf, "list ")) {
97cc7bc4
SP
913 int for_push = !!strstr(buf.buf + 4, "for-push");
914 output_refs(get_refs(for_push));
ae4efe19
SP
915
916 } else if (!prefixcmp(buf.buf, "push ")) {
917 parse_push(&buf);
918
ef08ef9e
SP
919 } else if (!prefixcmp(buf.buf, "option ")) {
920 char *name = buf.buf + strlen("option ");
921 char *value = strchr(name, ' ');
922 int result;
923
924 if (value)
925 *value++ = '\0';
926 else
927 value = "true";
928
929 result = set_option(name, value);
930 if (!result)
931 printf("ok\n");
932 else if (result < 0)
933 printf("error invalid value\n");
934 else
935 printf("unsupported\n");
a2d725b7 936 fflush(stdout);
ef08ef9e 937
a2d725b7
DB
938 } else if (!strcmp(buf.buf, "capabilities")) {
939 printf("fetch\n");
ef08ef9e 940 printf("option\n");
ae4efe19 941 printf("push\n");
a2d725b7
DB
942 printf("\n");
943 fflush(stdout);
944 } else {
1843f0ce 945 fprintf(stderr, "Unknown command '%s'\n", buf.buf);
a2d725b7
DB
946 return 1;
947 }
948 strbuf_reset(&buf);
949 } while (1);
888692b7
TRC
950
951 http_cleanup();
952
a2d725b7
DB
953 return 0;
954}