1 #include "git-compat-util.h"
6 #include "run-command.h"
10 #include "string-list.h"
11 #include "sha1-array.h"
12 #include "transport.h"
14 static char *server_capabilities
;
15 static const char *parse_feature_value(const char *, const char *, int *);
17 static int check_ref(const char *name
, unsigned int flags
)
22 if (!skip_prefix(name
, "refs/", &name
))
25 /* REF_NORMAL means that we don't want the magic fake tag refs */
26 if ((flags
& REF_NORMAL
) && check_refname_format(name
, 0))
29 /* REF_HEADS means that we want regular branch heads */
30 if ((flags
& REF_HEADS
) && starts_with(name
, "heads/"))
33 /* REF_TAGS means that we want tags */
34 if ((flags
& REF_TAGS
) && starts_with(name
, "tags/"))
37 /* All type bits clear means that we are ok with anything */
38 return !(flags
& ~REF_NORMAL
);
41 int check_ref_type(const struct ref
*ref
, int flags
)
43 return check_ref(ref
->name
, flags
);
46 static void die_initial_contact(int unexpected
)
49 die("The remote end hung up upon initial contact");
51 die("Could not read from remote repository.\n\n"
52 "Please make sure you have the correct access rights\n"
53 "and the repository exists.");
56 static void parse_one_symref_info(struct string_list
*symref
, const char *val
, int len
)
59 struct string_list_item
*item
;
62 return; /* just "symref" */
63 /* e.g. "symref=HEAD:refs/heads/master" */
64 sym
= xmemdupz(val
, len
);
65 target
= strchr(sym
, ':');
67 /* just "symref=something" */
70 if (check_refname_format(sym
, REFNAME_ALLOW_ONELEVEL
) ||
71 check_refname_format(target
, REFNAME_ALLOW_ONELEVEL
))
72 /* "symref=bogus:pair */
74 item
= string_list_append(symref
, sym
);
82 static void annotate_refs_with_symref_info(struct ref
*ref
)
84 struct string_list symref
= STRING_LIST_INIT_DUP
;
85 const char *feature_list
= server_capabilities
;
87 while (feature_list
) {
91 val
= parse_feature_value(feature_list
, "symref", &len
);
94 parse_one_symref_info(&symref
, val
, len
);
95 feature_list
= val
+ 1;
97 string_list_sort(&symref
);
99 for (; ref
; ref
= ref
->next
) {
100 struct string_list_item
*item
;
101 item
= string_list_lookup(&symref
, ref
->name
);
104 ref
->symref
= xstrdup((char *)item
->util
);
106 string_list_clear(&symref
, 0);
110 * Read all the refs from the other end
112 struct ref
**get_remote_heads(int in
, char *src_buf
, size_t src_len
,
113 struct ref
**list
, unsigned int flags
,
114 struct sha1_array
*extra_have
,
115 struct sha1_array
*shallow_points
)
117 struct ref
**orig_list
= list
;
120 * A hang-up after seeing some response from the other end
121 * means that it is unexpected, as we know the other end is
122 * willing to talk to us. A hang-up before seeing any
123 * response does not necessarily mean an ACL problem, though.
128 for (saw_response
= 0; ; saw_response
= 1) {
130 struct object_id old_oid
;
133 char *buffer
= packet_buffer
;
136 len
= packet_read(in
, &src_buf
, &src_len
,
137 packet_buffer
, sizeof(packet_buffer
),
138 PACKET_READ_GENTLE_ON_EOF
|
139 PACKET_READ_CHOMP_NEWLINE
);
141 die_initial_contact(saw_response
);
146 if (len
> 4 && skip_prefix(buffer
, "ERR ", &arg
))
147 die("remote error: %s", arg
);
149 if (len
== GIT_SHA1_HEXSZ
+ strlen("shallow ") &&
150 skip_prefix(buffer
, "shallow ", &arg
)) {
151 if (get_oid_hex(arg
, &old_oid
))
152 die("protocol error: expected shallow sha-1, got '%s'", arg
);
154 die("repository on the other end cannot be shallow");
155 sha1_array_append(shallow_points
, old_oid
.hash
);
159 if (len
< GIT_SHA1_HEXSZ
+ 2 || get_oid_hex(buffer
, &old_oid
) ||
160 buffer
[GIT_SHA1_HEXSZ
] != ' ')
161 die("protocol error: expected sha/ref, got '%s'", buffer
);
162 name
= buffer
+ GIT_SHA1_HEXSZ
+ 1;
164 name_len
= strlen(name
);
165 if (len
!= name_len
+ GIT_SHA1_HEXSZ
+ 1) {
166 free(server_capabilities
);
167 server_capabilities
= xstrdup(name
+ name_len
+ 1);
170 if (extra_have
&& !strcmp(name
, ".have")) {
171 sha1_array_append(extra_have
, old_oid
.hash
);
175 if (!check_ref(name
, flags
))
177 ref
= alloc_ref(buffer
+ GIT_SHA1_HEXSZ
+ 1);
178 oidcpy(&ref
->old_oid
, &old_oid
);
183 annotate_refs_with_symref_info(*orig_list
);
188 static const char *parse_feature_value(const char *feature_list
, const char *feature
, int *lenp
)
195 len
= strlen(feature
);
196 while (*feature_list
) {
197 const char *found
= strstr(feature_list
, feature
);
200 if (feature_list
== found
|| isspace(found
[-1])) {
201 const char *value
= found
+ len
;
202 /* feature with no value (e.g., "thin-pack") */
203 if (!*value
|| isspace(*value
)) {
208 /* feature with a value (e.g., "agent=git/1.2.3") */
209 else if (*value
== '=') {
212 *lenp
= strcspn(value
, " \t\n");
216 * otherwise we matched a substring of another feature;
220 feature_list
= found
+ 1;
225 int parse_feature_request(const char *feature_list
, const char *feature
)
227 return !!parse_feature_value(feature_list
, feature
, NULL
);
230 const char *server_feature_value(const char *feature
, int *len
)
232 return parse_feature_value(server_capabilities
, feature
, len
);
235 int server_supports(const char *feature
)
237 return !!server_feature_value(feature
, NULL
);
247 int url_is_local_not_ssh(const char *url
)
249 const char *colon
= strchr(url
, ':');
250 const char *slash
= strchr(url
, '/');
251 return !colon
|| (slash
&& slash
< colon
) ||
252 has_dos_drive_prefix(url
);
255 static const char *prot_name(enum protocol protocol
)
266 return "unknown protocol";
270 static enum protocol
get_protocol(const char *name
)
272 if (!strcmp(name
, "ssh"))
274 if (!strcmp(name
, "git"))
276 if (!strcmp(name
, "git+ssh")) /* deprecated - do not use */
278 if (!strcmp(name
, "ssh+git")) /* deprecated - do not use */
280 if (!strcmp(name
, "file"))
282 die("I don't handle protocol '%s'", name
);
285 static char *host_end(char **hoststart
, int removebrackets
)
287 char *host
= *hoststart
;
289 char *start
= strstr(host
, "@[");
291 start
++; /* Jump over '@' */
294 if (start
[0] == '[') {
295 end
= strchr(start
+ 1, ']');
297 if (removebrackets
) {
299 memmove(start
, start
+ 1, end
- start
);
310 #define STR(s) STR_(s)
312 static void get_host_and_port(char **host
, const char **port
)
315 end
= host_end(host
, 1);
316 colon
= strchr(end
, ':');
318 long portnr
= strtol(colon
+ 1, &end
, 10);
319 if (end
!= colon
+ 1 && *end
== '\0' && 0 <= portnr
&& portnr
< 65536) {
322 } else if (!colon
[1]) {
328 static void enable_keepalive(int sockfd
)
332 if (setsockopt(sockfd
, SOL_SOCKET
, SO_KEEPALIVE
, &ka
, sizeof(ka
)) < 0)
333 fprintf(stderr
, "unable to set SO_KEEPALIVE on socket: %s\n",
339 static const char *ai_name(const struct addrinfo
*ai
)
341 static char addr
[NI_MAXHOST
];
342 if (getnameinfo(ai
->ai_addr
, ai
->ai_addrlen
, addr
, sizeof(addr
), NULL
, 0,
343 NI_NUMERICHOST
) != 0)
344 xsnprintf(addr
, sizeof(addr
), "(unknown)");
350 * Returns a connected socket() fd, or else die()s.
352 static int git_tcp_connect_sock(char *host
, int flags
)
354 struct strbuf error_message
= STRBUF_INIT
;
356 const char *port
= STR(DEFAULT_GIT_PORT
);
357 struct addrinfo hints
, *ai0
, *ai
;
361 get_host_and_port(&host
, &port
);
365 memset(&hints
, 0, sizeof(hints
));
366 if (flags
& CONNECT_IPV4
)
367 hints
.ai_family
= AF_INET
;
368 else if (flags
& CONNECT_IPV6
)
369 hints
.ai_family
= AF_INET6
;
370 hints
.ai_socktype
= SOCK_STREAM
;
371 hints
.ai_protocol
= IPPROTO_TCP
;
373 if (flags
& CONNECT_VERBOSE
)
374 fprintf(stderr
, "Looking up %s ... ", host
);
376 gai
= getaddrinfo(host
, port
, &hints
, &ai
);
378 die("Unable to look up %s (port %s) (%s)", host
, port
, gai_strerror(gai
));
380 if (flags
& CONNECT_VERBOSE
)
381 fprintf(stderr
, "done.\nConnecting to %s (port %s) ... ", host
, port
);
383 for (ai0
= ai
; ai
; ai
= ai
->ai_next
, cnt
++) {
384 sockfd
= socket(ai
->ai_family
,
385 ai
->ai_socktype
, ai
->ai_protocol
);
387 (connect(sockfd
, ai
->ai_addr
, ai
->ai_addrlen
) < 0)) {
388 strbuf_addf(&error_message
, "%s[%d: %s]: errno=%s\n",
389 host
, cnt
, ai_name(ai
), strerror(errno
));
395 if (flags
& CONNECT_VERBOSE
)
396 fprintf(stderr
, "%s ", ai_name(ai
));
403 die("unable to connect to %s:\n%s", host
, error_message
.buf
);
405 enable_keepalive(sockfd
);
407 if (flags
& CONNECT_VERBOSE
)
408 fprintf(stderr
, "done.\n");
410 strbuf_release(&error_message
);
418 * Returns a connected socket() fd, or else die()s.
420 static int git_tcp_connect_sock(char *host
, int flags
)
422 struct strbuf error_message
= STRBUF_INIT
;
424 const char *port
= STR(DEFAULT_GIT_PORT
);
427 struct sockaddr_in sa
;
432 get_host_and_port(&host
, &port
);
434 if (flags
& CONNECT_VERBOSE
)
435 fprintf(stderr
, "Looking up %s ... ", host
);
437 he
= gethostbyname(host
);
439 die("Unable to look up %s (%s)", host
, hstrerror(h_errno
));
440 nport
= strtoul(port
, &ep
, 10);
441 if ( ep
== port
|| *ep
) {
443 struct servent
*se
= getservbyname(port
,"tcp");
445 die("Unknown port %s", port
);
449 if (flags
& CONNECT_VERBOSE
)
450 fprintf(stderr
, "done.\nConnecting to %s (port %s) ... ", host
, port
);
452 for (cnt
= 0, ap
= he
->h_addr_list
; *ap
; ap
++, cnt
++) {
453 memset(&sa
, 0, sizeof sa
);
454 sa
.sin_family
= he
->h_addrtype
;
455 sa
.sin_port
= htons(nport
);
456 memcpy(&sa
.sin_addr
, *ap
, he
->h_length
);
458 sockfd
= socket(he
->h_addrtype
, SOCK_STREAM
, 0);
460 connect(sockfd
, (struct sockaddr
*)&sa
, sizeof sa
) < 0) {
461 strbuf_addf(&error_message
, "%s[%d: %s]: errno=%s\n",
464 inet_ntoa(*(struct in_addr
*)&sa
.sin_addr
),
471 if (flags
& CONNECT_VERBOSE
)
472 fprintf(stderr
, "%s ",
473 inet_ntoa(*(struct in_addr
*)&sa
.sin_addr
));
478 die("unable to connect to %s:\n%s", host
, error_message
.buf
);
480 enable_keepalive(sockfd
);
482 if (flags
& CONNECT_VERBOSE
)
483 fprintf(stderr
, "done.\n");
491 static void git_tcp_connect(int fd
[2], char *host
, int flags
)
493 int sockfd
= git_tcp_connect_sock(host
, flags
);
500 static char *git_proxy_command
;
502 static int git_proxy_command_options(const char *var
, const char *value
,
505 if (!strcmp(var
, "core.gitproxy")) {
509 const char *rhost_name
= cb
;
510 int rhost_len
= strlen(rhost_name
);
512 if (git_proxy_command
)
515 return config_error_nonbool(var
);
517 * ;# matches www.kernel.org as well
518 * gitproxy = netcatter-1 for kernel.org
519 * gitproxy = netcatter-2 for sample.xz
520 * gitproxy = netcatter-default
522 for_pos
= strstr(value
, " for ");
524 /* matches everybody */
525 matchlen
= strlen(value
);
527 hostlen
= strlen(for_pos
+ 5);
528 if (rhost_len
< hostlen
)
530 else if (!strncmp(for_pos
+ 5,
531 rhost_name
+ rhost_len
- hostlen
,
533 ((rhost_len
== hostlen
) ||
534 rhost_name
[rhost_len
- hostlen
-1] == '.'))
535 matchlen
= for_pos
- value
;
540 /* core.gitproxy = none for kernel.org */
542 !memcmp(value
, "none", 4))
544 git_proxy_command
= xmemdupz(value
, matchlen
);
549 return git_default_config(var
, value
, cb
);
552 static int git_use_proxy(const char *host
)
554 git_proxy_command
= getenv("GIT_PROXY_COMMAND");
555 git_config(git_proxy_command_options
, (void*)host
);
556 return (git_proxy_command
&& *git_proxy_command
);
559 static struct child_process
*git_proxy_connect(int fd
[2], char *host
)
561 const char *port
= STR(DEFAULT_GIT_PORT
);
562 struct child_process
*proxy
;
564 get_host_and_port(&host
, &port
);
566 proxy
= xmalloc(sizeof(*proxy
));
567 child_process_init(proxy
);
568 argv_array_push(&proxy
->args
, git_proxy_command
);
569 argv_array_push(&proxy
->args
, host
);
570 argv_array_push(&proxy
->args
, port
);
573 if (start_command(proxy
))
574 die("cannot start proxy %s", git_proxy_command
);
575 fd
[0] = proxy
->out
; /* read from proxy stdout */
576 fd
[1] = proxy
->in
; /* write to proxy stdin */
580 static char *get_port(char *host
)
583 char *p
= strchr(host
, ':');
586 long port
= strtol(p
+ 1, &end
, 10);
587 if (end
!= p
+ 1 && *end
== '\0' && 0 <= port
&& port
< 65536) {
597 * Extract protocol and relevant parts from the specified connection URL.
598 * The caller must free() the returned strings.
600 static enum protocol
parse_connect_url(const char *url_orig
, char **ret_host
,
607 enum protocol protocol
= PROTO_LOCAL
;
609 if (is_url(url_orig
))
610 url
= url_decode(url_orig
);
612 url
= xstrdup(url_orig
);
614 host
= strstr(url
, "://");
617 protocol
= get_protocol(url
);
621 if (!url_is_local_not_ssh(url
)) {
622 protocol
= PROTO_SSH
;
628 * Don't do destructive transforms as protocol code does
629 * '[]' unwrapping in get_host_and_port()
631 end
= host_end(&host
, 0);
633 if (protocol
== PROTO_LOCAL
)
635 else if (protocol
== PROTO_FILE
&& has_dos_drive_prefix(end
))
636 path
= end
; /* "file://$(pwd)" may be "file://C:/projects/repo" */
638 path
= strchr(end
, separator
);
641 die("No path specified. See 'man git-pull' for valid url syntax");
644 * null-terminate hostname and point path to ~ for URL's like this:
645 * ssh://host.xz/~user/repo
648 end
= path
; /* Need to \0 terminate host here */
649 if (separator
== ':')
650 path
++; /* path starts after ':' */
651 if (protocol
== PROTO_GIT
|| protocol
== PROTO_SSH
) {
656 path
= xstrdup(path
);
659 *ret_host
= xstrdup(host
);
665 static struct child_process no_fork
= CHILD_PROCESS_INIT
;
668 * This returns a dummy child_process if the transport protocol does not
669 * need fork(2), or a struct child_process object if it does. Once done,
670 * finish the connection with finish_connect() with the value returned from
671 * this function (it is safe to call finish_connect() with NULL to support
674 * If it returns, the connect is successful; it just dies on errors (this
675 * will hopefully be changed in a libification effort, to return NULL when
676 * the connection failed).
678 struct child_process
*git_connect(int fd
[2], const char *url
,
679 const char *prog
, int flags
)
681 char *hostandport
, *path
;
682 struct child_process
*conn
= &no_fork
;
683 enum protocol protocol
;
684 struct strbuf cmd
= STRBUF_INIT
;
686 /* Without this we cannot rely on waitpid() to tell
687 * what happened to our children.
689 signal(SIGCHLD
, SIG_DFL
);
691 protocol
= parse_connect_url(url
, &hostandport
, &path
);
692 if ((flags
& CONNECT_DIAG_URL
) && (protocol
!= PROTO_SSH
)) {
693 printf("Diag: url=%s\n", url
? url
: "NULL");
694 printf("Diag: protocol=%s\n", prot_name(protocol
));
695 printf("Diag: hostandport=%s\n", hostandport
? hostandport
: "NULL");
696 printf("Diag: path=%s\n", path
? path
: "NULL");
698 } else if (protocol
== PROTO_GIT
) {
700 * Set up virtual host information based on where we will
701 * connect, unless the user has overridden us in
704 char *target_host
= getenv("GIT_OVERRIDE_VIRTUAL_HOST");
706 target_host
= xstrdup(target_host
);
708 target_host
= xstrdup(hostandport
);
710 transport_check_allowed("git");
712 /* These underlying connection commands die() if they
715 if (git_use_proxy(hostandport
))
716 conn
= git_proxy_connect(fd
, hostandport
);
718 git_tcp_connect(fd
, hostandport
, flags
);
720 * Separate original protocol components prog and path
721 * from extended host header with a NUL byte.
723 * Note: Do not add any other headers here! Doing so
724 * will cause older git-daemon servers to crash.
732 conn
= xmalloc(sizeof(*conn
));
733 child_process_init(conn
);
735 strbuf_addstr(&cmd
, prog
);
736 strbuf_addch(&cmd
, ' ');
737 sq_quote_buf(&cmd
, path
);
739 /* remove repo-local variables from the environment */
740 conn
->env
= local_repo_env
;
742 conn
->in
= conn
->out
= -1;
743 if (protocol
== PROTO_SSH
) {
745 int putty
= 0, tortoiseplink
= 0;
746 char *ssh_host
= hostandport
;
747 const char *port
= NULL
;
748 transport_check_allowed("ssh");
749 get_host_and_port(&ssh_host
, &port
);
752 port
= get_port(ssh_host
);
754 if (flags
& CONNECT_DIAG_URL
) {
755 printf("Diag: url=%s\n", url
? url
: "NULL");
756 printf("Diag: protocol=%s\n", prot_name(protocol
));
757 printf("Diag: userandhost=%s\n", ssh_host
? ssh_host
: "NULL");
758 printf("Diag: port=%s\n", port
? port
: "NONE");
759 printf("Diag: path=%s\n", path
? path
: "NULL");
767 ssh
= getenv("GIT_SSH_COMMAND");
773 * GIT_SSH is the no-shell version of
774 * GIT_SSH_COMMAND (and must remain so for
775 * historical compatibility).
779 ssh
= getenv("GIT_SSH");
783 ssh_dup
= xstrdup(ssh
);
784 base
= basename(ssh_dup
);
786 tortoiseplink
= !strcasecmp(base
, "tortoiseplink") ||
787 !strcasecmp(base
, "tortoiseplink.exe");
788 putty
= tortoiseplink
||
789 !strcasecmp(base
, "plink") ||
790 !strcasecmp(base
, "plink.exe");
795 argv_array_push(&conn
->args
, ssh
);
796 if (flags
& CONNECT_IPV4
)
797 argv_array_push(&conn
->args
, "-4");
798 else if (flags
& CONNECT_IPV6
)
799 argv_array_push(&conn
->args
, "-6");
801 argv_array_push(&conn
->args
, "-batch");
803 /* P is for PuTTY, p is for OpenSSH */
804 argv_array_push(&conn
->args
, putty
? "-P" : "-p");
805 argv_array_push(&conn
->args
, port
);
807 argv_array_push(&conn
->args
, ssh_host
);
809 transport_check_allowed("file");
811 argv_array_push(&conn
->args
, cmd
.buf
);
813 if (start_command(conn
))
814 die("unable to fork");
816 fd
[0] = conn
->out
; /* read from child's stdout */
817 fd
[1] = conn
->in
; /* write to child's stdin */
818 strbuf_release(&cmd
);
825 int git_connection_is_socket(struct child_process
*conn
)
827 return conn
== &no_fork
;
830 int finish_connect(struct child_process
*conn
)
833 if (!conn
|| git_connection_is_socket(conn
))
836 code
= finish_command(conn
);