9 #include "run-command.h"
11 #include "string-list.h"
13 #include "argv-array.h"
14 #include "credential.h"
15 #include "sha1-array.h"
16 #include "send-pack.h"
20 static struct remote
*remote
;
21 /* always ends with a trailing slash */
22 static struct strbuf url
= STRBUF_INIT
;
28 struct string_list deepen_not
;
29 struct string_list push_options
;
31 unsigned progress
: 1,
32 check_self_contained_and_connected
: 1,
38 /* One of the SEND_PACK_PUSH_CERT_* constants. */
44 static struct options options
;
45 static struct string_list cas_options
= STRING_LIST_INIT_DUP
;
47 static int set_option(const char *name
, const char *value
)
49 if (!strcmp(name
, "verbosity")) {
51 int v
= strtol(value
, &end
, 10);
52 if (value
== end
|| *end
)
54 options
.verbosity
= v
;
57 else if (!strcmp(name
, "progress")) {
58 if (!strcmp(value
, "true"))
60 else if (!strcmp(value
, "false"))
66 else if (!strcmp(name
, "depth")) {
68 unsigned long v
= strtoul(value
, &end
, 10);
69 if (value
== end
|| *end
)
74 else if (!strcmp(name
, "deepen-since")) {
75 options
.deepen_since
= xstrdup(value
);
78 else if (!strcmp(name
, "deepen-not")) {
79 string_list_append(&options
.deepen_not
, value
);
82 else if (!strcmp(name
, "deepen-relative")) {
83 if (!strcmp(value
, "true"))
84 options
.deepen_relative
= 1;
85 else if (!strcmp(value
, "false"))
86 options
.deepen_relative
= 0;
91 else if (!strcmp(name
, "followtags")) {
92 if (!strcmp(value
, "true"))
93 options
.followtags
= 1;
94 else if (!strcmp(value
, "false"))
95 options
.followtags
= 0;
100 else if (!strcmp(name
, "dry-run")) {
101 if (!strcmp(value
, "true"))
103 else if (!strcmp(value
, "false"))
109 else if (!strcmp(name
, "check-connectivity")) {
110 if (!strcmp(value
, "true"))
111 options
.check_self_contained_and_connected
= 1;
112 else if (!strcmp(value
, "false"))
113 options
.check_self_contained_and_connected
= 0;
118 else if (!strcmp(name
, "cas")) {
119 struct strbuf val
= STRBUF_INIT
;
120 strbuf_addf(&val
, "--" CAS_OPT_NAME
"=%s", value
);
121 string_list_append(&cas_options
, val
.buf
);
122 strbuf_release(&val
);
124 } else if (!strcmp(name
, "cloning")) {
125 if (!strcmp(value
, "true"))
127 else if (!strcmp(value
, "false"))
132 } else if (!strcmp(name
, "update-shallow")) {
133 if (!strcmp(value
, "true"))
134 options
.update_shallow
= 1;
135 else if (!strcmp(value
, "false"))
136 options
.update_shallow
= 0;
140 } else if (!strcmp(name
, "pushcert")) {
141 if (!strcmp(value
, "true"))
142 options
.push_cert
= SEND_PACK_PUSH_CERT_ALWAYS
;
143 else if (!strcmp(value
, "false"))
144 options
.push_cert
= SEND_PACK_PUSH_CERT_NEVER
;
145 else if (!strcmp(value
, "if-asked"))
146 options
.push_cert
= SEND_PACK_PUSH_CERT_IF_ASKED
;
150 } else if (!strcmp(name
, "push-option")) {
152 string_list_append(&options
.push_options
, value
);
154 struct strbuf unquoted
= STRBUF_INIT
;
155 if (unquote_c_style(&unquoted
, value
, NULL
) < 0)
156 die("invalid quoting in push-option value");
157 string_list_append_nodup(&options
.push_options
,
158 strbuf_detach(&unquoted
, NULL
));
162 #if LIBCURL_VERSION_NUM >= 0x070a08
163 } else if (!strcmp(name
, "family")) {
164 if (!strcmp(value
, "ipv4"))
165 git_curl_ipresolve
= CURL_IPRESOLVE_V4
;
166 else if (!strcmp(value
, "ipv6"))
167 git_curl_ipresolve
= CURL_IPRESOLVE_V6
;
168 else if (!strcmp(value
, "all"))
169 git_curl_ipresolve
= CURL_IPRESOLVE_WHATEVER
;
173 #endif /* LIBCURL_VERSION_NUM >= 0x070a08 */
174 } else if (!strcmp(name
, "from-promisor")) {
175 options
.from_promisor
= 1;
177 } else if (!strcmp(name
, "no-dependents")) {
178 options
.no_dependents
= 1;
180 } else if (!strcmp(name
, "filter")) {
181 options
.filter
= xstrdup(value
);;
184 return 1 /* unsupported */;
194 struct oid_array shallow
;
195 enum protocol_version version
;
196 unsigned proto_git
: 1;
198 static struct discovery
*last_discovery
;
200 static struct ref
*parse_git_refs(struct discovery
*heads
, int for_push
)
202 struct ref
*list
= NULL
;
203 struct packet_reader reader
;
205 packet_reader_init(&reader
, -1, heads
->buf
, heads
->len
,
206 PACKET_READ_CHOMP_NEWLINE
|
207 PACKET_READ_GENTLE_ON_EOF
);
209 heads
->version
= discover_version(&reader
);
210 switch (heads
->version
) {
213 * Do nothing. This isn't a list of refs but rather a
214 * capability advertisement. Client would have run
215 * 'stateless-connect' so we'll dump this capability listing
216 * and let them request the refs themselves.
221 get_remote_heads(&reader
, &list
, for_push
? REF_NORMAL
: 0,
222 NULL
, &heads
->shallow
);
224 case protocol_unknown_version
:
225 BUG("unknown protocol version");
231 static struct ref
*parse_info_refs(struct discovery
*heads
)
233 char *data
, *start
, *mid
;
237 struct ref
*refs
= NULL
;
238 struct ref
*ref
= NULL
;
239 struct ref
*last_ref
= NULL
;
244 while (i
< heads
->len
) {
250 if (data
[i
] == '\n') {
251 if (mid
- start
!= 40)
252 die("%sinfo/refs not valid: is this a git repository?",
256 ref
= alloc_ref(ref_name
);
257 get_oid_hex(start
, &ref
->old_oid
);
261 last_ref
->next
= ref
;
268 ref
= alloc_ref("HEAD");
269 if (!http_fetch_ref(url
.buf
, ref
) &&
270 !resolve_remote_symref(ref
, refs
)) {
280 static void free_discovery(struct discovery
*d
)
283 if (d
== last_discovery
)
284 last_discovery
= NULL
;
285 free(d
->shallow
.oid
);
293 static int show_http_message(struct strbuf
*type
, struct strbuf
*charset
,
299 * We only show text/plain parts, as other types are likely
300 * to be ugly to look at on the user's terminal.
302 if (strcmp(type
->buf
, "text/plain"))
305 strbuf_reencode(msg
, charset
->buf
, get_log_output_encoding());
313 eol
= strchrnul(p
, '\n');
314 fprintf(stderr
, "remote: %.*s\n", (int)(eol
- p
), p
);
320 static int get_protocol_http_header(enum protocol_version version
,
321 struct strbuf
*header
)
324 strbuf_addf(header
, GIT_PROTOCOL_HEADER
": version=%d",
333 static struct discovery
*discover_refs(const char *service
, int for_push
)
335 struct strbuf exp
= STRBUF_INIT
;
336 struct strbuf type
= STRBUF_INIT
;
337 struct strbuf charset
= STRBUF_INIT
;
338 struct strbuf buffer
= STRBUF_INIT
;
339 struct strbuf refs_url
= STRBUF_INIT
;
340 struct strbuf effective_url
= STRBUF_INIT
;
341 struct strbuf protocol_header
= STRBUF_INIT
;
342 struct string_list extra_headers
= STRING_LIST_INIT_DUP
;
343 struct discovery
*last
= last_discovery
;
344 int http_ret
, maybe_smart
= 0;
345 struct http_get_options http_options
;
346 enum protocol_version version
= get_protocol_version_config();
348 if (last
&& !strcmp(service
, last
->service
))
350 free_discovery(last
);
352 strbuf_addf(&refs_url
, "%sinfo/refs", url
.buf
);
353 if ((starts_with(url
.buf
, "http://") || starts_with(url
.buf
, "https://")) &&
354 git_env_bool("GIT_SMART_HTTP", 1)) {
356 if (!strchr(url
.buf
, '?'))
357 strbuf_addch(&refs_url
, '?');
359 strbuf_addch(&refs_url
, '&');
360 strbuf_addf(&refs_url
, "service=%s", service
);
364 * NEEDSWORK: If we are trying to use protocol v2 and we are planning
365 * to perform a push, then fallback to v0 since the client doesn't know
366 * how to push yet using v2.
368 if (version
== protocol_v2
&& !strcmp("git-receive-pack", service
))
369 version
= protocol_v0
;
371 /* Add the extra Git-Protocol header */
372 if (get_protocol_http_header(version
, &protocol_header
))
373 string_list_append(&extra_headers
, protocol_header
.buf
);
375 memset(&http_options
, 0, sizeof(http_options
));
376 http_options
.content_type
= &type
;
377 http_options
.charset
= &charset
;
378 http_options
.effective_url
= &effective_url
;
379 http_options
.base_url
= &url
;
380 http_options
.extra_headers
= &extra_headers
;
381 http_options
.initial_request
= 1;
382 http_options
.no_cache
= 1;
383 http_options
.keep_error
= 1;
385 http_ret
= http_get_strbuf(refs_url
.buf
, &buffer
, &http_options
);
389 case HTTP_MISSING_TARGET
:
390 show_http_message(&type
, &charset
, &buffer
);
391 die("repository '%s' not found", url
.buf
);
393 show_http_message(&type
, &charset
, &buffer
);
394 die("Authentication failed for '%s'", url
.buf
);
396 show_http_message(&type
, &charset
, &buffer
);
397 die("unable to access '%s': %s", url
.buf
, curl_errorstr
);
400 if (options
.verbosity
&& !starts_with(refs_url
.buf
, url
.buf
))
401 warning(_("redirecting to %s"), url
.buf
);
403 last
= xcalloc(1, sizeof(*last_discovery
));
404 last
->service
= xstrdup(service
);
405 last
->buf_alloc
= strbuf_detach(&buffer
, &last
->len
);
406 last
->buf
= last
->buf_alloc
;
408 strbuf_addf(&exp
, "application/x-%s-advertisement", service
);
410 (5 <= last
->len
&& last
->buf
[4] == '#') &&
411 !strbuf_cmp(&exp
, &type
)) {
415 * smart HTTP response; validate that the service
416 * pkt-line matches our request.
418 line
= packet_read_line_buf(&last
->buf
, &last
->len
, NULL
);
420 die("invalid server response; expected service, got flush packet");
423 strbuf_addf(&exp
, "# service=%s", service
);
424 if (strcmp(line
, exp
.buf
))
425 die("invalid server response; got '%s'", line
);
426 strbuf_release(&exp
);
428 /* The header can include additional metadata lines, up
429 * until a packet flush marker. Ignore these now, but
430 * in the future we might start to scan them.
432 while (packet_read_line_buf(&last
->buf
, &last
->len
, NULL
))
436 } else if (maybe_smart
&&
437 last
->len
> 5 && starts_with(last
->buf
+ 4, "version 2")) {
442 last
->refs
= parse_git_refs(last
, for_push
);
444 last
->refs
= parse_info_refs(last
);
446 strbuf_release(&refs_url
);
447 strbuf_release(&exp
);
448 strbuf_release(&type
);
449 strbuf_release(&charset
);
450 strbuf_release(&effective_url
);
451 strbuf_release(&buffer
);
452 strbuf_release(&protocol_header
);
453 string_list_clear(&extra_headers
, 0);
454 last_discovery
= last
;
458 static struct ref
*get_refs(int for_push
)
460 struct discovery
*heads
;
463 heads
= discover_refs("git-receive-pack", for_push
);
465 heads
= discover_refs("git-upload-pack", for_push
);
470 static void output_refs(struct ref
*refs
)
473 for (posn
= refs
; posn
; posn
= posn
->next
) {
475 printf("@%s %s\n", posn
->symref
, posn
->name
);
477 printf("%s %s\n", oid_to_hex(&posn
->old_oid
), posn
->name
);
484 const char *service_name
;
486 struct strbuf
*stdin_preamble
;
488 char *hdr_content_type
;
490 char *protocol_header
;
498 struct strbuf result
;
499 unsigned gzip_request
: 1;
500 unsigned initial_buffer
: 1;
503 static size_t rpc_out(void *ptr
, size_t eltsize
,
504 size_t nmemb
, void *buffer_
)
506 size_t max
= eltsize
* nmemb
;
507 struct rpc_state
*rpc
= buffer_
;
508 size_t avail
= rpc
->len
- rpc
->pos
;
511 rpc
->initial_buffer
= 0;
512 avail
= packet_read(rpc
->out
, NULL
, NULL
, rpc
->buf
, rpc
->alloc
, 0);
521 memcpy(ptr
, rpc
->buf
+ rpc
->pos
, avail
);
526 #ifndef NO_CURL_IOCTL
527 static curlioerr
rpc_ioctl(CURL
*handle
, int cmd
, void *clientp
)
529 struct rpc_state
*rpc
= clientp
;
535 case CURLIOCMD_RESTARTREAD
:
536 if (rpc
->initial_buffer
) {
540 error("unable to rewind rpc post data - try increasing http.postBuffer");
541 return CURLIOE_FAILRESTART
;
544 return CURLIOE_UNKNOWNCMD
;
549 static size_t rpc_in(char *ptr
, size_t eltsize
,
550 size_t nmemb
, void *buffer_
)
552 size_t size
= eltsize
* nmemb
;
553 struct rpc_state
*rpc
= buffer_
;
555 rpc
->any_written
= 1;
556 write_or_die(rpc
->in
, ptr
, size
);
560 static int run_slot(struct active_request_slot
*slot
,
561 struct slot_results
*results
)
564 struct slot_results results_buf
;
567 results
= &results_buf
;
569 err
= run_one_slot(slot
, results
);
571 if (err
!= HTTP_OK
&& err
!= HTTP_REAUTH
) {
572 struct strbuf msg
= STRBUF_INIT
;
573 if (results
->http_code
&& results
->http_code
!= 200)
574 strbuf_addf(&msg
, "HTTP %ld", results
->http_code
);
575 if (results
->curl_result
!= CURLE_OK
) {
577 strbuf_addch(&msg
, ' ');
578 strbuf_addf(&msg
, "curl %d", results
->curl_result
);
579 if (curl_errorstr
[0]) {
580 strbuf_addch(&msg
, ' ');
581 strbuf_addstr(&msg
, curl_errorstr
);
584 error("RPC failed; %s", msg
.buf
);
585 strbuf_release(&msg
);
591 static int probe_rpc(struct rpc_state
*rpc
, struct slot_results
*results
)
593 struct active_request_slot
*slot
;
594 struct curl_slist
*headers
= http_copy_default_headers();
595 struct strbuf buf
= STRBUF_INIT
;
598 slot
= get_active_slot();
600 headers
= curl_slist_append(headers
, rpc
->hdr_content_type
);
601 headers
= curl_slist_append(headers
, rpc
->hdr_accept
);
603 curl_easy_setopt(slot
->curl
, CURLOPT_NOBODY
, 0);
604 curl_easy_setopt(slot
->curl
, CURLOPT_POST
, 1);
605 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, rpc
->service_url
);
606 curl_easy_setopt(slot
->curl
, CURLOPT_ENCODING
, NULL
);
607 curl_easy_setopt(slot
->curl
, CURLOPT_POSTFIELDS
, "0000");
608 curl_easy_setopt(slot
->curl
, CURLOPT_POSTFIELDSIZE
, 4);
609 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, headers
);
610 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
611 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &buf
);
613 err
= run_slot(slot
, results
);
615 curl_slist_free_all(headers
);
616 strbuf_release(&buf
);
620 static curl_off_t
xcurl_off_t(ssize_t len
) {
621 if (len
> maximum_signed_value_of_type(curl_off_t
))
622 die("cannot handle pushes this big");
623 return (curl_off_t
) len
;
626 static int post_rpc(struct rpc_state
*rpc
)
628 struct active_request_slot
*slot
;
629 struct curl_slist
*headers
= http_copy_default_headers();
630 int use_gzip
= rpc
->gzip_request
;
631 char *gzip_body
= NULL
;
632 size_t gzip_size
= 0;
633 int err
, large_request
= 0;
634 int needs_100_continue
= 0;
636 /* Try to load the entire request, if we can fit it into the
637 * allocated buffer space we can use HTTP/1.0 and avoid the
638 * chunked encoding mess.
641 size_t left
= rpc
->alloc
- rpc
->len
;
642 char *buf
= rpc
->buf
+ rpc
->len
;
645 if (left
< LARGE_PACKET_MAX
) {
651 n
= packet_read(rpc
->out
, NULL
, NULL
, buf
, left
, 0);
658 struct slot_results results
;
661 err
= probe_rpc(rpc
, &results
);
662 if (err
== HTTP_REAUTH
)
663 credential_fill(&http_auth
);
664 } while (err
== HTTP_REAUTH
);
668 if (results
.auth_avail
& CURLAUTH_GSSNEGOTIATE
)
669 needs_100_continue
= 1;
672 headers
= curl_slist_append(headers
, rpc
->hdr_content_type
);
673 headers
= curl_slist_append(headers
, rpc
->hdr_accept
);
674 headers
= curl_slist_append(headers
, needs_100_continue
?
675 "Expect: 100-continue" : "Expect:");
677 /* Add the extra Git-Protocol header */
678 if (rpc
->protocol_header
)
679 headers
= curl_slist_append(headers
, rpc
->protocol_header
);
682 slot
= get_active_slot();
684 curl_easy_setopt(slot
->curl
, CURLOPT_NOBODY
, 0);
685 curl_easy_setopt(slot
->curl
, CURLOPT_POST
, 1);
686 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, rpc
->service_url
);
687 curl_easy_setopt(slot
->curl
, CURLOPT_ENCODING
, "");
690 /* The request body is large and the size cannot be predicted.
691 * We must use chunked encoding to send it.
693 headers
= curl_slist_append(headers
, "Transfer-Encoding: chunked");
694 rpc
->initial_buffer
= 1;
695 curl_easy_setopt(slot
->curl
, CURLOPT_READFUNCTION
, rpc_out
);
696 curl_easy_setopt(slot
->curl
, CURLOPT_INFILE
, rpc
);
697 #ifndef NO_CURL_IOCTL
698 curl_easy_setopt(slot
->curl
, CURLOPT_IOCTLFUNCTION
, rpc_ioctl
);
699 curl_easy_setopt(slot
->curl
, CURLOPT_IOCTLDATA
, rpc
);
701 if (options
.verbosity
> 1) {
702 fprintf(stderr
, "POST %s (chunked)\n", rpc
->service_name
);
706 } else if (gzip_body
) {
708 * If we are looping to retry authentication, then the previous
709 * run will have set up the headers and gzip buffer already,
710 * and we just need to send it.
712 curl_easy_setopt(slot
->curl
, CURLOPT_POSTFIELDS
, gzip_body
);
713 curl_easy_setopt(slot
->curl
, CURLOPT_POSTFIELDSIZE_LARGE
, xcurl_off_t(gzip_size
));
715 } else if (use_gzip
&& 1024 < rpc
->len
) {
716 /* The client backend isn't giving us compressed data so
717 * we can try to deflate it ourselves, this may save on.
723 git_deflate_init_gzip(&stream
, Z_BEST_COMPRESSION
);
724 gzip_size
= git_deflate_bound(&stream
, rpc
->len
);
725 gzip_body
= xmalloc(gzip_size
);
727 stream
.next_in
= (unsigned char *)rpc
->buf
;
728 stream
.avail_in
= rpc
->len
;
729 stream
.next_out
= (unsigned char *)gzip_body
;
730 stream
.avail_out
= gzip_size
;
732 ret
= git_deflate(&stream
, Z_FINISH
);
733 if (ret
!= Z_STREAM_END
)
734 die("cannot deflate request; zlib deflate error %d", ret
);
736 ret
= git_deflate_end_gently(&stream
);
738 die("cannot deflate request; zlib end error %d", ret
);
740 gzip_size
= stream
.total_out
;
742 headers
= curl_slist_append(headers
, "Content-Encoding: gzip");
743 curl_easy_setopt(slot
->curl
, CURLOPT_POSTFIELDS
, gzip_body
);
744 curl_easy_setopt(slot
->curl
, CURLOPT_POSTFIELDSIZE_LARGE
, xcurl_off_t(gzip_size
));
746 if (options
.verbosity
> 1) {
747 fprintf(stderr
, "POST %s (gzip %lu to %lu bytes)\n",
749 (unsigned long)rpc
->len
, (unsigned long)gzip_size
);
753 /* We know the complete request size in advance, use the
754 * more normal Content-Length approach.
756 curl_easy_setopt(slot
->curl
, CURLOPT_POSTFIELDS
, rpc
->buf
);
757 curl_easy_setopt(slot
->curl
, CURLOPT_POSTFIELDSIZE_LARGE
, xcurl_off_t(rpc
->len
));
758 if (options
.verbosity
> 1) {
759 fprintf(stderr
, "POST %s (%lu bytes)\n",
760 rpc
->service_name
, (unsigned long)rpc
->len
);
765 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, headers
);
766 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, rpc_in
);
767 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, rpc
);
770 rpc
->any_written
= 0;
771 err
= run_slot(slot
, NULL
);
772 if (err
== HTTP_REAUTH
&& !large_request
) {
773 credential_fill(&http_auth
);
779 if (!rpc
->any_written
)
782 curl_slist_free_all(headers
);
787 static int rpc_service(struct rpc_state
*rpc
, struct discovery
*heads
)
789 const char *svc
= rpc
->service_name
;
790 struct strbuf buf
= STRBUF_INIT
;
791 struct strbuf
*preamble
= rpc
->stdin_preamble
;
792 struct child_process client
= CHILD_PROCESS_INIT
;
798 client
.argv
= rpc
->argv
;
799 if (start_command(&client
))
802 write_or_die(client
.in
, preamble
->buf
, preamble
->len
);
804 write_or_die(client
.in
, heads
->buf
, heads
->len
);
806 rpc
->alloc
= http_post_buffer
;
807 rpc
->buf
= xmalloc(rpc
->alloc
);
809 rpc
->out
= client
.out
;
810 strbuf_init(&rpc
->result
, 0);
812 strbuf_addf(&buf
, "%s%s", url
.buf
, svc
);
813 rpc
->service_url
= strbuf_detach(&buf
, NULL
);
815 strbuf_addf(&buf
, "Content-Type: application/x-%s-request", svc
);
816 rpc
->hdr_content_type
= strbuf_detach(&buf
, NULL
);
818 strbuf_addf(&buf
, "Accept: application/x-%s-result", svc
);
819 rpc
->hdr_accept
= strbuf_detach(&buf
, NULL
);
821 if (get_protocol_http_header(heads
->version
, &buf
))
822 rpc
->protocol_header
= strbuf_detach(&buf
, NULL
);
824 rpc
->protocol_header
= NULL
;
827 int n
= packet_read(rpc
->out
, NULL
, NULL
, rpc
->buf
, rpc
->alloc
, 0);
832 err
|= post_rpc(rpc
);
838 strbuf_read(&rpc
->result
, client
.out
, 0);
842 if (xread(client
.out
, buf
, sizeof(buf
)) <= 0)
849 err
|= finish_command(&client
);
850 free(rpc
->service_url
);
851 free(rpc
->hdr_content_type
);
852 free(rpc
->hdr_accept
);
853 free(rpc
->protocol_header
);
855 strbuf_release(&buf
);
859 static int fetch_dumb(int nr_heads
, struct ref
**to_fetch
)
861 struct walker
*walker
;
865 ALLOC_ARRAY(targets
, nr_heads
);
866 if (options
.depth
|| options
.deepen_since
)
867 die("dumb http transport does not support shallow capabilities");
868 for (i
= 0; i
< nr_heads
; i
++)
869 targets
[i
] = xstrdup(oid_to_hex(&to_fetch
[i
]->old_oid
));
871 walker
= get_http_walker(url
.buf
);
872 walker
->get_verbosely
= options
.verbosity
>= 3;
873 walker
->get_recover
= 0;
874 ret
= walker_fetch(walker
, nr_heads
, targets
, NULL
, NULL
);
877 for (i
= 0; i
< nr_heads
; i
++)
881 return ret
? error("fetch failed.") : 0;
884 static int fetch_git(struct discovery
*heads
,
885 int nr_heads
, struct ref
**to_fetch
)
887 struct rpc_state rpc
;
888 struct strbuf preamble
= STRBUF_INIT
;
890 struct argv_array args
= ARGV_ARRAY_INIT
;
892 argv_array_pushl(&args
, "fetch-pack", "--stateless-rpc",
893 "--stdin", "--lock-pack", NULL
);
894 if (options
.followtags
)
895 argv_array_push(&args
, "--include-tag");
897 argv_array_push(&args
, "--thin");
898 if (options
.verbosity
>= 3)
899 argv_array_pushl(&args
, "-v", "-v", NULL
);
900 if (options
.check_self_contained_and_connected
)
901 argv_array_push(&args
, "--check-self-contained-and-connected");
903 argv_array_push(&args
, "--cloning");
904 if (options
.update_shallow
)
905 argv_array_push(&args
, "--update-shallow");
906 if (!options
.progress
)
907 argv_array_push(&args
, "--no-progress");
909 argv_array_pushf(&args
, "--depth=%lu", options
.depth
);
910 if (options
.deepen_since
)
911 argv_array_pushf(&args
, "--shallow-since=%s", options
.deepen_since
);
912 for (i
= 0; i
< options
.deepen_not
.nr
; i
++)
913 argv_array_pushf(&args
, "--shallow-exclude=%s",
914 options
.deepen_not
.items
[i
].string
);
915 if (options
.deepen_relative
&& options
.depth
)
916 argv_array_push(&args
, "--deepen-relative");
917 if (options
.from_promisor
)
918 argv_array_push(&args
, "--from-promisor");
919 if (options
.no_dependents
)
920 argv_array_push(&args
, "--no-dependents");
922 argv_array_pushf(&args
, "--filter=%s", options
.filter
);
923 argv_array_push(&args
, url
.buf
);
925 for (i
= 0; i
< nr_heads
; i
++) {
926 struct ref
*ref
= to_fetch
[i
];
928 die("cannot fetch by sha1 over smart http");
929 packet_buf_write(&preamble
, "%s %s\n",
930 oid_to_hex(&ref
->old_oid
), ref
->name
);
932 packet_buf_flush(&preamble
);
934 memset(&rpc
, 0, sizeof(rpc
));
935 rpc
.service_name
= "git-upload-pack",
936 rpc
.argv
= args
.argv
;
937 rpc
.stdin_preamble
= &preamble
;
938 rpc
.gzip_request
= 1;
940 err
= rpc_service(&rpc
, heads
);
942 write_or_die(1, rpc
.result
.buf
, rpc
.result
.len
);
943 strbuf_release(&rpc
.result
);
944 strbuf_release(&preamble
);
945 argv_array_clear(&args
);
949 static int fetch(int nr_heads
, struct ref
**to_fetch
)
951 struct discovery
*d
= discover_refs("git-upload-pack", 0);
953 return fetch_git(d
, nr_heads
, to_fetch
);
955 return fetch_dumb(nr_heads
, to_fetch
);
958 static void parse_fetch(struct strbuf
*buf
)
960 struct ref
**to_fetch
= NULL
;
961 struct ref
*list_head
= NULL
;
962 struct ref
**list
= &list_head
;
963 int alloc_heads
= 0, nr_heads
= 0;
967 if (skip_prefix(buf
->buf
, "fetch ", &p
)) {
970 struct object_id old_oid
;
972 if (get_oid_hex(p
, &old_oid
))
973 die("protocol error: expected sha/ref, got %s'", p
);
974 if (p
[GIT_SHA1_HEXSZ
] == ' ')
975 name
= p
+ GIT_SHA1_HEXSZ
+ 1;
976 else if (!p
[GIT_SHA1_HEXSZ
])
979 die("protocol error: expected sha/ref, got %s'", p
);
981 ref
= alloc_ref(name
);
982 oidcpy(&ref
->old_oid
, &old_oid
);
987 ALLOC_GROW(to_fetch
, nr_heads
+ 1, alloc_heads
);
988 to_fetch
[nr_heads
++] = ref
;
991 die("http transport does not support %s", buf
->buf
);
994 if (strbuf_getline_lf(buf
, stdin
) == EOF
)
1000 if (fetch(nr_heads
, to_fetch
))
1001 exit(128); /* error already reported */
1002 free_refs(list_head
);
1010 static int push_dav(int nr_spec
, char **specs
)
1012 struct child_process child
= CHILD_PROCESS_INIT
;
1016 argv_array_push(&child
.args
, "http-push");
1017 argv_array_push(&child
.args
, "--helper-status");
1018 if (options
.dry_run
)
1019 argv_array_push(&child
.args
, "--dry-run");
1020 if (options
.verbosity
> 1)
1021 argv_array_push(&child
.args
, "--verbose");
1022 argv_array_push(&child
.args
, url
.buf
);
1023 for (i
= 0; i
< nr_spec
; i
++)
1024 argv_array_push(&child
.args
, specs
[i
]);
1026 if (run_command(&child
))
1027 die("git-http-push failed");
1031 static int push_git(struct discovery
*heads
, int nr_spec
, char **specs
)
1033 struct rpc_state rpc
;
1035 struct argv_array args
;
1036 struct string_list_item
*cas_option
;
1037 struct strbuf preamble
= STRBUF_INIT
;
1039 argv_array_init(&args
);
1040 argv_array_pushl(&args
, "send-pack", "--stateless-rpc", "--helper-status",
1044 argv_array_push(&args
, "--thin");
1045 if (options
.dry_run
)
1046 argv_array_push(&args
, "--dry-run");
1047 if (options
.push_cert
== SEND_PACK_PUSH_CERT_ALWAYS
)
1048 argv_array_push(&args
, "--signed=yes");
1049 else if (options
.push_cert
== SEND_PACK_PUSH_CERT_IF_ASKED
)
1050 argv_array_push(&args
, "--signed=if-asked");
1051 if (options
.verbosity
== 0)
1052 argv_array_push(&args
, "--quiet");
1053 else if (options
.verbosity
> 1)
1054 argv_array_push(&args
, "--verbose");
1055 for (i
= 0; i
< options
.push_options
.nr
; i
++)
1056 argv_array_pushf(&args
, "--push-option=%s",
1057 options
.push_options
.items
[i
].string
);
1058 argv_array_push(&args
, options
.progress
? "--progress" : "--no-progress");
1059 for_each_string_list_item(cas_option
, &cas_options
)
1060 argv_array_push(&args
, cas_option
->string
);
1061 argv_array_push(&args
, url
.buf
);
1063 argv_array_push(&args
, "--stdin");
1064 for (i
= 0; i
< nr_spec
; i
++)
1065 packet_buf_write(&preamble
, "%s\n", specs
[i
]);
1066 packet_buf_flush(&preamble
);
1068 memset(&rpc
, 0, sizeof(rpc
));
1069 rpc
.service_name
= "git-receive-pack",
1070 rpc
.argv
= args
.argv
;
1071 rpc
.stdin_preamble
= &preamble
;
1073 err
= rpc_service(&rpc
, heads
);
1075 write_or_die(1, rpc
.result
.buf
, rpc
.result
.len
);
1076 strbuf_release(&rpc
.result
);
1077 strbuf_release(&preamble
);
1078 argv_array_clear(&args
);
1082 static int push(int nr_spec
, char **specs
)
1084 struct discovery
*heads
= discover_refs("git-receive-pack", 1);
1087 if (heads
->proto_git
)
1088 ret
= push_git(heads
, nr_spec
, specs
);
1090 ret
= push_dav(nr_spec
, specs
);
1091 free_discovery(heads
);
1095 static void parse_push(struct strbuf
*buf
)
1097 char **specs
= NULL
;
1098 int alloc_spec
= 0, nr_spec
= 0, i
, ret
;
1101 if (starts_with(buf
->buf
, "push ")) {
1102 ALLOC_GROW(specs
, nr_spec
+ 1, alloc_spec
);
1103 specs
[nr_spec
++] = xstrdup(buf
->buf
+ 5);
1106 die("http transport does not support %s", buf
->buf
);
1109 if (strbuf_getline_lf(buf
, stdin
) == EOF
)
1115 ret
= push(nr_spec
, specs
);
1120 exit(128); /* error already reported */
1123 for (i
= 0; i
< nr_spec
; i
++)
1129 * Used to represent the state of a connection to an HTTP server when
1130 * communicating using git's wire-protocol version 2.
1132 struct proxy_state
{
1135 struct curl_slist
*headers
;
1136 struct strbuf request_buffer
;
1139 struct packet_reader reader
;
1144 static void proxy_state_init(struct proxy_state
*p
, const char *service_name
,
1145 enum protocol_version version
)
1147 struct strbuf buf
= STRBUF_INIT
;
1149 memset(p
, 0, sizeof(*p
));
1150 p
->service_name
= xstrdup(service_name
);
1154 strbuf_init(&p
->request_buffer
, 0);
1156 strbuf_addf(&buf
, "%s%s", url
.buf
, p
->service_name
);
1157 p
->service_url
= strbuf_detach(&buf
, NULL
);
1159 p
->headers
= http_copy_default_headers();
1161 strbuf_addf(&buf
, "Content-Type: application/x-%s-request", p
->service_name
);
1162 p
->headers
= curl_slist_append(p
->headers
, buf
.buf
);
1165 strbuf_addf(&buf
, "Accept: application/x-%s-result", p
->service_name
);
1166 p
->headers
= curl_slist_append(p
->headers
, buf
.buf
);
1169 p
->headers
= curl_slist_append(p
->headers
, "Transfer-Encoding: chunked");
1171 /* Add the Git-Protocol header */
1172 if (get_protocol_http_header(version
, &buf
))
1173 p
->headers
= curl_slist_append(p
->headers
, buf
.buf
);
1175 packet_reader_init(&p
->reader
, p
->in
, NULL
, 0,
1176 PACKET_READ_GENTLE_ON_EOF
);
1178 strbuf_release(&buf
);
1181 static void proxy_state_clear(struct proxy_state
*p
)
1183 free(p
->service_name
);
1184 free(p
->service_url
);
1185 curl_slist_free_all(p
->headers
);
1186 strbuf_release(&p
->request_buffer
);
1190 * CURLOPT_READFUNCTION callback function.
1191 * Attempts to copy over a single packet-line at a time into the
1192 * curl provided buffer.
1194 static size_t proxy_in(char *buffer
, size_t eltsize
,
1195 size_t nmemb
, void *userdata
)
1198 struct proxy_state
*p
= userdata
;
1199 size_t avail
= p
->request_buffer
.len
- p
->pos
;
1203 BUG("curl read callback called with size = %"PRIuMAX
" != 1",
1204 (uintmax_t)eltsize
);
1208 if (p
->seen_flush
) {
1213 strbuf_reset(&p
->request_buffer
);
1214 switch (packet_reader_read(&p
->reader
)) {
1215 case PACKET_READ_EOF
:
1216 die("unexpected EOF when reading from parent process");
1217 case PACKET_READ_NORMAL
:
1218 packet_buf_write_len(&p
->request_buffer
, p
->reader
.line
,
1221 case PACKET_READ_DELIM
:
1222 packet_buf_delim(&p
->request_buffer
);
1224 case PACKET_READ_FLUSH
:
1225 packet_buf_flush(&p
->request_buffer
);
1230 avail
= p
->request_buffer
.len
;
1235 memcpy(buffer
, p
->request_buffer
.buf
+ p
->pos
, avail
);
1240 static size_t proxy_out(char *buffer
, size_t eltsize
,
1241 size_t nmemb
, void *userdata
)
1244 struct proxy_state
*p
= userdata
;
1247 BUG("curl read callback called with size = %"PRIuMAX
" != 1",
1248 (uintmax_t)eltsize
);
1251 write_or_die(p
->out
, buffer
, size
);
1255 /* Issues a request to the HTTP server configured in `p` */
1256 static int proxy_request(struct proxy_state
*p
)
1258 struct active_request_slot
*slot
;
1260 slot
= get_active_slot();
1262 curl_easy_setopt(slot
->curl
, CURLOPT_ENCODING
, "");
1263 curl_easy_setopt(slot
->curl
, CURLOPT_NOBODY
, 0);
1264 curl_easy_setopt(slot
->curl
, CURLOPT_POST
, 1);
1265 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, p
->service_url
);
1266 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, p
->headers
);
1268 /* Setup function to read request from client */
1269 curl_easy_setopt(slot
->curl
, CURLOPT_READFUNCTION
, proxy_in
);
1270 curl_easy_setopt(slot
->curl
, CURLOPT_READDATA
, p
);
1272 /* Setup function to write server response to client */
1273 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, proxy_out
);
1274 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEDATA
, p
);
1276 if (run_slot(slot
, NULL
) != HTTP_OK
)
1282 static int stateless_connect(const char *service_name
)
1284 struct discovery
*discover
;
1285 struct proxy_state p
;
1288 * Run the info/refs request and see if the server supports protocol
1289 * v2. If and only if the server supports v2 can we successfully
1290 * establish a stateless connection, otherwise we need to tell the
1291 * client to fallback to using other transport helper functions to
1292 * complete their request.
1294 discover
= discover_refs(service_name
, 0);
1295 if (discover
->version
!= protocol_v2
) {
1296 printf("fallback\n");
1300 /* Stateless Connection established */
1305 proxy_state_init(&p
, service_name
, discover
->version
);
1308 * Dump the capability listing that we got from the server earlier
1309 * during the info/refs request.
1311 write_or_die(p
.out
, discover
->buf
, discover
->len
);
1313 /* Peek the next packet line. Until we see EOF keep sending POSTs */
1314 while (packet_reader_peek(&p
.reader
) != PACKET_READ_EOF
) {
1315 if (proxy_request(&p
)) {
1316 /* We would have an err here */
1321 proxy_state_clear(&p
);
1325 int cmd_main(int argc
, const char **argv
)
1327 struct strbuf buf
= STRBUF_INIT
;
1330 setup_git_directory_gently(&nongit
);
1332 error("remote-curl: usage: git remote-curl <remote> [<url>]");
1336 options
.verbosity
= 1;
1337 options
.progress
= !!isatty(2);
1339 string_list_init(&options
.deepen_not
, 1);
1340 string_list_init(&options
.push_options
, 1);
1342 remote
= remote_get(argv
[1]);
1345 end_url_with_slash(&url
, argv
[2]);
1347 end_url_with_slash(&url
, remote
->url
[0]);
1350 http_init(remote
, url
.buf
, 0);
1355 if (strbuf_getline_lf(&buf
, stdin
) == EOF
) {
1357 error("remote-curl: error reading command stream from git");
1362 if (starts_with(buf
.buf
, "fetch ")) {
1364 die("remote-curl: fetch attempted without a local repo");
1367 } else if (!strcmp(buf
.buf
, "list") || starts_with(buf
.buf
, "list ")) {
1368 int for_push
= !!strstr(buf
.buf
+ 4, "for-push");
1369 output_refs(get_refs(for_push
));
1371 } else if (starts_with(buf
.buf
, "push ")) {
1374 } else if (skip_prefix(buf
.buf
, "option ", &arg
)) {
1375 char *value
= strchr(arg
, ' ');
1383 result
= set_option(arg
, value
);
1386 else if (result
< 0)
1387 printf("error invalid value\n");
1389 printf("unsupported\n");
1392 } else if (!strcmp(buf
.buf
, "capabilities")) {
1393 printf("stateless-connect\n");
1397 printf("check-connectivity\n");
1400 } else if (skip_prefix(buf
.buf
, "stateless-connect ", &arg
)) {
1401 if (!stateless_connect(arg
))
1404 error("remote-curl: unknown command '%s' from git", buf
.buf
);