fetch: refactor code that prepares a transport
[git/jrn.git] / remote-curl.c
blob5b3ce9eed299e312c132b590ea4926cfb019a271
1 #include "cache.h"
2 #include "remote.h"
3 #include "strbuf.h"
4 #include "walker.h"
5 #include "http.h"
6 #include "exec_cmd.h"
7 #include "run-command.h"
8 #include "pkt-line.h"
9 #include "sideband.h"
10 #include "argv-array.h"
12 static struct remote *remote;
13 static const char *url; /* always ends with a trailing slash */
15 struct options {
16 int verbosity;
17 unsigned long depth;
18 unsigned progress : 1,
19 followtags : 1,
20 dry_run : 1,
21 thin : 1;
23 static struct options options;
25 static int set_option(const char *name, const char *value)
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;
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;
42 return 0;
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;
50 return 0;
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;
59 return 0;
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;
70 else {
71 return 1 /* unsupported */;
75 struct discovery {
76 const char *service;
77 char *buf_alloc;
78 char *buf;
79 size_t len;
80 struct ref *refs;
81 unsigned proto_git : 1;
83 static struct discovery *last_discovery;
85 static struct ref *parse_git_refs(struct discovery *heads, int for_push)
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;
93 static struct ref *parse_info_refs(struct discovery *heads)
95 char *data, *start, *mid;
96 char *ref_name;
97 int i = 0;
99 struct ref *refs = NULL;
100 struct ref *ref = NULL;
101 struct ref *last_ref = NULL;
103 data = heads->buf;
104 start = NULL;
105 mid = data;
106 while (i < heads->len) {
107 if (!start) {
108 start = &data[i];
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;
129 i++;
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);
141 return refs;
144 static void free_discovery(struct discovery *d)
146 if (d) {
147 if (d == last_discovery)
148 last_discovery = NULL;
149 free(d->buf_alloc);
150 free_refs(d->refs);
151 free(d);
155 static int show_http_message(struct strbuf *type, struct strbuf *msg)
157 const char *p, *eol;
160 * We only show text/plain parts, as other types are likely
161 * to be ugly to look at on the user's terminal.
163 * TODO should handle "; charset=XXX", and re-encode into
164 * logoutputencoding
166 if (strcasecmp(type->buf, "text/plain"))
167 return -1;
169 strbuf_trim(msg);
170 if (!msg->len)
171 return -1;
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;
182 static struct discovery* discover_refs(const char *service, int for_push)
184 struct strbuf exp = STRBUF_INIT;
185 struct strbuf type = STRBUF_INIT;
186 struct strbuf buffer = STRBUF_INIT;
187 struct discovery *last = last_discovery;
188 char *refs_url;
189 int http_ret, maybe_smart = 0;
191 if (last && !strcmp(service, last->service))
192 return last;
193 free_discovery(last);
195 strbuf_addf(&buffer, "%sinfo/refs", url);
196 if ((!prefixcmp(url, "http://") || !prefixcmp(url, "https://")) &&
197 git_env_bool("GIT_SMART_HTTP", 1)) {
198 maybe_smart = 1;
199 if (!strchr(url, '?'))
200 strbuf_addch(&buffer, '?');
201 else
202 strbuf_addch(&buffer, '&');
203 strbuf_addf(&buffer, "service=%s", service);
205 refs_url = strbuf_detach(&buffer, NULL);
207 http_ret = http_get_strbuf(refs_url, &type, &buffer,
208 HTTP_NO_CACHE | HTTP_KEEP_ERROR);
209 switch (http_ret) {
210 case HTTP_OK:
211 break;
212 case HTTP_MISSING_TARGET:
213 show_http_message(&type, &buffer);
214 die("repository '%s' not found", url);
215 case HTTP_NOAUTH:
216 show_http_message(&type, &buffer);
217 die("Authentication failed for '%s'", url);
218 default:
219 show_http_message(&type, &buffer);
220 die("unable to access '%s': %s", url, curl_errorstr);
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;
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)) {
232 char *line;
235 * smart HTTP response; validate that the service
236 * pkt-line matches our request.
238 line = packet_read_line_buf(&last->buf, &last->len, NULL);
240 strbuf_reset(&exp);
241 strbuf_addf(&exp, "# service=%s", service);
242 if (strcmp(line, exp.buf))
243 die("invalid server response; got '%s'", line);
244 strbuf_release(&exp);
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.
250 while (packet_read_line_buf(&last->buf, &last->len, NULL))
253 last->proto_git = 1;
256 if (last->proto_git)
257 last->refs = parse_git_refs(last, for_push);
258 else
259 last->refs = parse_info_refs(last);
261 free(refs_url);
262 strbuf_release(&exp);
263 strbuf_release(&type);
264 strbuf_release(&buffer);
265 last_discovery = last;
266 return last;
269 static struct ref *get_refs(int for_push)
271 struct discovery *heads;
273 if (for_push)
274 heads = discover_refs("git-receive-pack", for_push);
275 else
276 heads = discover_refs("git-upload-pack", for_push);
278 return heads->refs;
281 static void output_refs(struct ref *refs)
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);
290 printf("\n");
291 fflush(stdout);
294 struct rpc_state {
295 const char *service_name;
296 const char **argv;
297 struct strbuf *stdin_preamble;
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;
308 unsigned gzip_request : 1;
309 unsigned initial_buffer : 1;
312 static size_t rpc_out(void *ptr, size_t eltsize,
313 size_t nmemb, void *buffer_)
315 size_t max = eltsize * nmemb;
316 struct rpc_state *rpc = buffer_;
317 size_t avail = rpc->len - rpc->pos;
319 if (!avail) {
320 rpc->initial_buffer = 0;
321 avail = packet_read(rpc->out, NULL, NULL, rpc->buf, rpc->alloc, 0);
322 if (!avail)
323 return 0;
324 rpc->pos = 0;
325 rpc->len = avail;
328 if (max < avail)
329 avail = max;
330 memcpy(ptr, rpc->buf + rpc->pos, avail);
331 rpc->pos += avail;
332 return avail;
335 #ifndef NO_CURL_IOCTL
336 static curlioerr rpc_ioctl(CURL *handle, int cmd, void *clientp)
338 struct rpc_state *rpc = clientp;
340 switch (cmd) {
341 case CURLIOCMD_NOP:
342 return CURLIOE_OK;
344 case CURLIOCMD_RESTARTREAD:
345 if (rpc->initial_buffer) {
346 rpc->pos = 0;
347 return CURLIOE_OK;
349 fprintf(stderr, "Unable to rewind rpc post data - try increasing http.postBuffer\n");
350 return CURLIOE_FAILRESTART;
352 default:
353 return CURLIOE_UNKNOWNCMD;
356 #endif
358 static size_t rpc_in(char *ptr, size_t eltsize,
359 size_t nmemb, void *buffer_)
361 size_t size = eltsize * nmemb;
362 struct rpc_state *rpc = buffer_;
363 write_or_die(rpc->in, ptr, size);
364 return size;
367 static int run_slot(struct active_request_slot *slot)
369 int err;
370 struct slot_results results;
372 slot->results = &results;
373 slot->curl_result = curl_easy_perform(slot->curl);
374 finish_active_slot(slot);
376 err = handle_curl_result(&results);
377 if (err != HTTP_OK && err != HTTP_REAUTH) {
378 error("RPC failed; result=%d, HTTP code = %ld",
379 results.curl_result, results.http_code);
382 return err;
385 static int probe_rpc(struct rpc_state *rpc)
387 struct active_request_slot *slot;
388 struct curl_slist *headers = NULL;
389 struct strbuf buf = STRBUF_INIT;
390 int err;
392 slot = get_active_slot();
394 headers = curl_slist_append(headers, rpc->hdr_content_type);
395 headers = curl_slist_append(headers, rpc->hdr_accept);
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);
400 curl_easy_setopt(slot->curl, CURLOPT_ENCODING, NULL);
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);
407 err = run_slot(slot);
409 curl_slist_free_all(headers);
410 strbuf_release(&buf);
411 return err;
414 static int post_rpc(struct rpc_state *rpc)
416 struct active_request_slot *slot;
417 struct curl_slist *headers = NULL;
418 int use_gzip = rpc->gzip_request;
419 char *gzip_body = NULL;
420 size_t gzip_size = 0;
421 int err, large_request = 0;
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.
427 while (1) {
428 size_t left = rpc->alloc - rpc->len;
429 char *buf = rpc->buf + rpc->len;
430 int n;
432 if (left < LARGE_PACKET_MAX) {
433 large_request = 1;
434 use_gzip = 0;
435 break;
438 n = packet_read(rpc->out, NULL, NULL, buf, left, 0);
439 if (!n)
440 break;
441 rpc->len += n;
444 if (large_request) {
445 do {
446 err = probe_rpc(rpc);
447 } while (err == HTTP_REAUTH);
448 if (err != HTTP_OK)
449 return -1;
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:");
456 retry:
457 slot = get_active_slot();
459 curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
460 curl_easy_setopt(slot->curl, CURLOPT_POST, 1);
461 curl_easy_setopt(slot->curl, CURLOPT_URL, rpc->service_url);
462 curl_easy_setopt(slot->curl, CURLOPT_ENCODING, "gzip");
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.
468 headers = curl_slist_append(headers, "Transfer-Encoding: chunked");
469 rpc->initial_buffer = 1;
470 curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, rpc_out);
471 curl_easy_setopt(slot->curl, CURLOPT_INFILE, rpc);
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
476 if (options.verbosity > 1) {
477 fprintf(stderr, "POST %s (chunked)\n", rpc->service_name);
478 fflush(stderr);
481 } else if (gzip_body) {
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.
487 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, gzip_body);
488 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, gzip_size);
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.
495 git_zstream stream;
496 int ret;
498 memset(&stream, 0, sizeof(stream));
499 git_deflate_init_gzip(&stream, Z_BEST_COMPRESSION);
500 gzip_size = git_deflate_bound(&stream, rpc->len);
501 gzip_body = xmalloc(gzip_size);
503 stream.next_in = (unsigned char *)rpc->buf;
504 stream.avail_in = rpc->len;
505 stream.next_out = (unsigned char *)gzip_body;
506 stream.avail_out = gzip_size;
508 ret = git_deflate(&stream, Z_FINISH);
509 if (ret != Z_STREAM_END)
510 die("cannot deflate request; zlib deflate error %d", ret);
512 ret = git_deflate_end_gently(&stream);
513 if (ret != Z_OK)
514 die("cannot deflate request; zlib end error %d", ret);
516 gzip_size = stream.total_out;
518 headers = curl_slist_append(headers, "Content-Encoding: gzip");
519 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, gzip_body);
520 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, gzip_size);
522 if (options.verbosity > 1) {
523 fprintf(stderr, "POST %s (gzip %lu to %lu bytes)\n",
524 rpc->service_name,
525 (unsigned long)rpc->len, (unsigned long)gzip_size);
526 fflush(stderr);
528 } else {
529 /* We know the complete request size in advance, use the
530 * more normal Content-Length approach.
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);
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);
545 err = run_slot(slot);
546 if (err == HTTP_REAUTH && !large_request)
547 goto retry;
548 if (err != HTTP_OK)
549 err = -1;
551 curl_slist_free_all(headers);
552 free(gzip_body);
553 return err;
556 static int rpc_service(struct rpc_state *rpc, struct discovery *heads)
558 const char *svc = rpc->service_name;
559 struct strbuf buf = STRBUF_INIT;
560 struct strbuf *preamble = rpc->stdin_preamble;
561 struct child_process client;
562 int err = 0;
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);
571 if (preamble)
572 write_or_die(client.in, preamble->buf, preamble->len);
573 if (heads)
574 write_or_die(client.in, heads->buf, heads->len);
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);
582 strbuf_addf(&buf, "%s%s", url, svc);
583 rpc->service_url = strbuf_detach(&buf, NULL);
585 strbuf_addf(&buf, "Content-Type: application/x-%s-request", svc);
586 rpc->hdr_content_type = strbuf_detach(&buf, NULL);
588 strbuf_addf(&buf, "Accept: application/x-%s-result", svc);
589 rpc->hdr_accept = strbuf_detach(&buf, NULL);
591 while (!err) {
592 int n = packet_read(rpc->out, NULL, NULL, rpc->buf, rpc->alloc, 0);
593 if (!n)
594 break;
595 rpc->pos = 0;
596 rpc->len = n;
597 err |= post_rpc(rpc);
600 close(client.in);
601 client.in = -1;
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;
611 close(client.out);
612 client.out = -1;
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;
623 static int fetch_dumb(int nr_heads, struct ref **to_fetch)
625 struct walker *walker;
626 char **targets = xmalloc(nr_heads * sizeof(char*));
627 int ret, i;
629 if (options.depth)
630 die("dumb http transport does not support --depth");
631 for (i = 0; i < nr_heads; i++)
632 targets[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
634 walker = get_http_walker(url);
635 walker->get_all = 1;
636 walker->get_tree = 1;
637 walker->get_history = 1;
638 walker->get_verbosely = options.verbosity >= 3;
639 walker->get_recover = 0;
640 ret = walker_fetch(walker, nr_heads, targets, NULL, NULL);
641 walker_free(walker);
643 for (i = 0; i < nr_heads; i++)
644 free(targets[i]);
645 free(targets);
647 return ret ? error("Fetch failed.") : 0;
650 static int fetch_git(struct discovery *heads,
651 int nr_heads, struct ref **to_fetch)
653 struct rpc_state rpc;
654 struct strbuf preamble = STRBUF_INIT;
655 char *depth_arg = NULL;
656 int argc = 0, i, err;
657 const char *argv[15];
659 argv[argc++] = "fetch-pack";
660 argv[argc++] = "--stateless-rpc";
661 argv[argc++] = "--stdin";
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";
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;
679 argv[argc++] = url;
680 argv[argc++] = NULL;
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");
686 packet_buf_write(&preamble, "%s\n", ref->name);
688 packet_buf_flush(&preamble);
690 memset(&rpc, 0, sizeof(rpc));
691 rpc.service_name = "git-upload-pack",
692 rpc.argv = argv;
693 rpc.stdin_preamble = &preamble;
694 rpc.gzip_request = 1;
696 err = rpc_service(&rpc, heads);
697 if (rpc.result.len)
698 write_or_die(1, rpc.result.buf, rpc.result.len);
699 strbuf_release(&rpc.result);
700 strbuf_release(&preamble);
701 free(depth_arg);
702 return err;
705 static int fetch(int nr_heads, struct ref **to_fetch)
707 struct discovery *d = discover_refs("git-upload-pack", 0);
708 if (d->proto_git)
709 return fetch_git(d, nr_heads, to_fetch);
710 else
711 return fetch_dumb(nr_heads, to_fetch);
714 static void parse_fetch(struct strbuf *buf)
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;
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];
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);
737 ref = alloc_ref(name);
738 hashcpy(ref->old_sha1, old_sha1);
740 *list = ref;
741 list = &ref->next;
743 ALLOC_GROW(to_fetch, nr_heads + 1, alloc_heads);
744 to_fetch[nr_heads++] = ref;
746 else
747 die("http transport does not support %s", buf->buf);
749 strbuf_reset(buf);
750 if (strbuf_getline(buf, stdin, '\n') == EOF)
751 return;
752 if (!*buf->buf)
753 break;
754 } while (1);
756 if (fetch(nr_heads, to_fetch))
757 exit(128); /* error already reported */
758 free_refs(list_head);
759 free(to_fetch);
761 printf("\n");
762 fflush(stdout);
763 strbuf_reset(buf);
766 static int push_dav(int nr_spec, char **specs)
768 const char **argv = xmalloc((10 + nr_spec) * sizeof(char*));
769 int argc = 0, i;
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;
782 if (run_command_v_opt(argv, RUN_GIT_CMD))
783 die("git-%s failed", argv[0]);
784 free(argv);
785 return 0;
788 static int push_git(struct discovery *heads, int nr_spec, char **specs)
790 struct rpc_state rpc;
791 int i, err;
792 struct argv_array args;
794 argv_array_init(&args);
795 argv_array_pushl(&args, "send-pack", "--stateless-rpc", "--helper-status",
796 NULL);
798 if (options.thin)
799 argv_array_push(&args, "--thin");
800 if (options.dry_run)
801 argv_array_push(&args, "--dry-run");
802 if (options.verbosity == 0)
803 argv_array_push(&args, "--quiet");
804 else if (options.verbosity > 1)
805 argv_array_push(&args, "--verbose");
806 argv_array_push(&args, options.progress ? "--progress" : "--no-progress");
807 argv_array_push(&args, url);
808 for (i = 0; i < nr_spec; i++)
809 argv_array_push(&args, specs[i]);
811 memset(&rpc, 0, sizeof(rpc));
812 rpc.service_name = "git-receive-pack",
813 rpc.argv = args.argv;
815 err = rpc_service(&rpc, heads);
816 if (rpc.result.len)
817 write_or_die(1, rpc.result.buf, rpc.result.len);
818 strbuf_release(&rpc.result);
819 argv_array_clear(&args);
820 return err;
823 static int push(int nr_spec, char **specs)
825 struct discovery *heads = discover_refs("git-receive-pack", 1);
826 int ret;
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;
836 static void parse_push(struct strbuf *buf)
838 char **specs = NULL;
839 int alloc_spec = 0, nr_spec = 0, i, ret;
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);
846 else
847 die("http transport does not support %s", buf->buf);
849 strbuf_reset(buf);
850 if (strbuf_getline(buf, stdin, '\n') == EOF)
851 goto free_specs;
852 if (!*buf->buf)
853 break;
854 } while (1);
856 ret = push(nr_spec, specs);
857 printf("\n");
858 fflush(stdout);
860 if (ret)
861 exit(128); /* error already reported */
863 free_specs:
864 for (i = 0; i < nr_spec; i++)
865 free(specs[i]);
866 free(specs);
869 int main(int argc, const char **argv)
871 struct strbuf buf = STRBUF_INIT;
872 int nongit;
874 git_extract_argv0_path(argv[0]);
875 setup_git_directory_gently(&nongit);
876 if (argc < 2) {
877 fprintf(stderr, "Remote needed\n");
878 return 1;
881 options.verbosity = 1;
882 options.progress = !!isatty(2);
883 options.thin = 1;
885 remote = remote_get(argv[1]);
887 if (argc > 2) {
888 end_url_with_slash(&buf, argv[2]);
889 } else {
890 end_url_with_slash(&buf, remote->url[0]);
893 url = strbuf_detach(&buf, NULL);
895 http_init(remote, url, 0);
897 do {
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;
905 if (buf.len == 0)
906 break;
907 if (!prefixcmp(buf.buf, "fetch ")) {
908 if (nongit)
909 die("Fetch attempted without a local repo");
910 parse_fetch(&buf);
912 } else if (!strcmp(buf.buf, "list") || !prefixcmp(buf.buf, "list ")) {
913 int for_push = !!strstr(buf.buf + 4, "for-push");
914 output_refs(get_refs(for_push));
916 } else if (!prefixcmp(buf.buf, "push ")) {
917 parse_push(&buf);
919 } else if (!prefixcmp(buf.buf, "option ")) {
920 char *name = buf.buf + strlen("option ");
921 char *value = strchr(name, ' ');
922 int result;
924 if (value)
925 *value++ = '\0';
926 else
927 value = "true";
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");
936 fflush(stdout);
938 } else if (!strcmp(buf.buf, "capabilities")) {
939 printf("fetch\n");
940 printf("option\n");
941 printf("push\n");
942 printf("\n");
943 fflush(stdout);
944 } else {
945 fprintf(stderr, "Unknown command '%s'\n", buf.buf);
946 return 1;
948 strbuf_reset(&buf);
949 } while (1);
951 http_cleanup();
953 return 0;