2006-01-25 20:38:36 +00:00
|
|
|
#include "git-compat-util.h"
|
2005-07-04 18:57:58 +00:00
|
|
|
#include "cache.h"
|
2005-07-05 22:44:09 +00:00
|
|
|
#include "pkt-line.h"
|
2005-07-08 07:02:52 +00:00
|
|
|
#include "quote.h"
|
2005-10-16 07:25:26 +00:00
|
|
|
#include "refs.h"
|
2007-03-12 23:00:19 +00:00
|
|
|
#include "run-command.h"
|
2007-05-12 15:45:59 +00:00
|
|
|
#include "remote.h"
|
2010-05-23 09:19:44 +00:00
|
|
|
#include "url.h"
|
2005-07-04 18:57:58 +00:00
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static char *server_capabilities;
|
2005-10-28 02:48:54 +00:00
|
|
|
|
Improve git-peek-remote
This makes git-peek-remote able to basically do everything that
git-ls-remote does (but obviously just for the native protocol, so no
http[s]: or rsync: support).
The default behaviour is the same, but you can now give a mixture of
"--refs", "--tags" and "--heads" flags, where "--refs" forces
git-peek-remote to only show real refs (ie none of the fakey tag lookups,
but also not the special pseudo-refs like HEAD and MERGE_HEAD).
The "--tags" and "--heads" flags respectively limit the output to just
regular tags and heads, of course.
You can still also ask to limit them by name too.
You can combine the flags, so
git peek-remote --refs --tags .
will show all local _true_ tags, without the generated tag lookups
(compare the output without the "--refs" flag).
And "--tags --heads" will show both tags and heads, but will avoid (for
example) any special refs outside of the standard locations.
I'm also planning on adding a "--ignore-local" flag that allows us to ask
it to ignore any refs that we already have in the local tree, but that's
an independent thing.
All this is obviously gearing up to making "git fetch" cheaper.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-04 19:29:10 +00:00
|
|
|
static int check_ref(const char *name, int len, unsigned int flags)
|
|
|
|
{
|
|
|
|
if (!flags)
|
|
|
|
return 1;
|
|
|
|
|
2006-09-05 19:00:17 +00:00
|
|
|
if (len < 5 || memcmp(name, "refs/", 5))
|
Improve git-peek-remote
This makes git-peek-remote able to basically do everything that
git-ls-remote does (but obviously just for the native protocol, so no
http[s]: or rsync: support).
The default behaviour is the same, but you can now give a mixture of
"--refs", "--tags" and "--heads" flags, where "--refs" forces
git-peek-remote to only show real refs (ie none of the fakey tag lookups,
but also not the special pseudo-refs like HEAD and MERGE_HEAD).
The "--tags" and "--heads" flags respectively limit the output to just
regular tags and heads, of course.
You can still also ask to limit them by name too.
You can combine the flags, so
git peek-remote --refs --tags .
will show all local _true_ tags, without the generated tag lookups
(compare the output without the "--refs" flag).
And "--tags --heads" will show both tags and heads, but will avoid (for
example) any special refs outside of the standard locations.
I'm also planning on adding a "--ignore-local" flag that allows us to ask
it to ignore any refs that we already have in the local tree, but that's
an independent thing.
All this is obviously gearing up to making "git fetch" cheaper.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-04 19:29:10 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Skip the "refs/" part */
|
|
|
|
name += 5;
|
|
|
|
len -= 5;
|
|
|
|
|
|
|
|
/* REF_NORMAL means that we don't want the magic fake tag refs */
|
|
|
|
if ((flags & REF_NORMAL) && check_ref_format(name) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* REF_HEADS means that we want regular branch heads */
|
|
|
|
if ((flags & REF_HEADS) && !memcmp(name, "heads/", 6))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* REF_TAGS means that we want tags */
|
|
|
|
if ((flags & REF_TAGS) && !memcmp(name, "tags/", 5))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* All type bits clear means that we are ok with anything */
|
|
|
|
return !(flags & ~REF_NORMAL);
|
|
|
|
}
|
|
|
|
|
2007-10-30 01:05:40 +00:00
|
|
|
int check_ref_type(const struct ref *ref, int flags)
|
|
|
|
{
|
|
|
|
return check_ref(ref->name, strlen(ref->name), flags);
|
|
|
|
}
|
|
|
|
|
2008-09-09 08:27:09 +00:00
|
|
|
static void add_extra_have(struct extra_have_objects *extra, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
ALLOC_GROW(extra->array, extra->nr + 1, extra->alloc);
|
|
|
|
hashcpy(&(extra->array[extra->nr][0]), sha1);
|
|
|
|
extra->nr++;
|
|
|
|
}
|
|
|
|
|
2005-07-16 20:55:50 +00:00
|
|
|
/*
|
|
|
|
* Read all the refs from the other end
|
|
|
|
*/
|
2005-10-14 01:57:40 +00:00
|
|
|
struct ref **get_remote_heads(int in, struct ref **list,
|
Improve git-peek-remote
This makes git-peek-remote able to basically do everything that
git-ls-remote does (but obviously just for the native protocol, so no
http[s]: or rsync: support).
The default behaviour is the same, but you can now give a mixture of
"--refs", "--tags" and "--heads" flags, where "--refs" forces
git-peek-remote to only show real refs (ie none of the fakey tag lookups,
but also not the special pseudo-refs like HEAD and MERGE_HEAD).
The "--tags" and "--heads" flags respectively limit the output to just
regular tags and heads, of course.
You can still also ask to limit them by name too.
You can combine the flags, so
git peek-remote --refs --tags .
will show all local _true_ tags, without the generated tag lookups
(compare the output without the "--refs" flag).
And "--tags --heads" will show both tags and heads, but will avoid (for
example) any special refs outside of the standard locations.
I'm also planning on adding a "--ignore-local" flag that allows us to ask
it to ignore any refs that we already have in the local tree, but that's
an independent thing.
All this is obviously gearing up to making "git fetch" cheaper.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-04 19:29:10 +00:00
|
|
|
int nr_match, char **match,
|
2008-09-09 08:27:09 +00:00
|
|
|
unsigned int flags,
|
|
|
|
struct extra_have_objects *extra_have)
|
2005-07-16 20:55:50 +00:00
|
|
|
{
|
|
|
|
*list = NULL;
|
|
|
|
for (;;) {
|
|
|
|
struct ref *ref;
|
|
|
|
unsigned char old_sha1[20];
|
|
|
|
static char buffer[1000];
|
|
|
|
char *name;
|
2005-10-28 02:48:54 +00:00
|
|
|
int len, name_len;
|
2005-07-16 20:55:50 +00:00
|
|
|
|
|
|
|
len = packet_read_line(in, buffer, sizeof(buffer));
|
|
|
|
if (!len)
|
|
|
|
break;
|
|
|
|
if (buffer[len-1] == '\n')
|
|
|
|
buffer[--len] = 0;
|
|
|
|
|
2008-11-01 18:44:45 +00:00
|
|
|
if (len > 4 && !prefixcmp(buffer, "ERR "))
|
|
|
|
die("remote error: %s", buffer + 4);
|
|
|
|
|
2005-07-16 20:55:50 +00:00
|
|
|
if (len < 42 || get_sha1_hex(buffer, old_sha1) || buffer[40] != ' ')
|
|
|
|
die("protocol error: expected sha/ref, got '%s'", buffer);
|
|
|
|
name = buffer + 41;
|
2005-10-14 01:57:40 +00:00
|
|
|
|
2005-10-28 02:48:54 +00:00
|
|
|
name_len = strlen(name);
|
|
|
|
if (len != name_len + 41) {
|
Avoid unnecessary "if-before-free" tests.
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-31 17:26:32 +00:00
|
|
|
free(server_capabilities);
|
2006-09-02 04:16:31 +00:00
|
|
|
server_capabilities = xstrdup(name + name_len + 1);
|
2005-10-28 02:48:54 +00:00
|
|
|
}
|
|
|
|
|
2008-09-09 08:27:09 +00:00
|
|
|
if (extra_have &&
|
|
|
|
name_len == 5 && !memcmp(".have", name, 5)) {
|
|
|
|
add_extra_have(extra_have, old_sha1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
Improve git-peek-remote
This makes git-peek-remote able to basically do everything that
git-ls-remote does (but obviously just for the native protocol, so no
http[s]: or rsync: support).
The default behaviour is the same, but you can now give a mixture of
"--refs", "--tags" and "--heads" flags, where "--refs" forces
git-peek-remote to only show real refs (ie none of the fakey tag lookups,
but also not the special pseudo-refs like HEAD and MERGE_HEAD).
The "--tags" and "--heads" flags respectively limit the output to just
regular tags and heads, of course.
You can still also ask to limit them by name too.
You can combine the flags, so
git peek-remote --refs --tags .
will show all local _true_ tags, without the generated tag lookups
(compare the output without the "--refs" flag).
And "--tags --heads" will show both tags and heads, but will avoid (for
example) any special refs outside of the standard locations.
I'm also planning on adding a "--ignore-local" flag that allows us to ask
it to ignore any refs that we already have in the local tree, but that's
an independent thing.
All this is obviously gearing up to making "git fetch" cheaper.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-04 19:29:10 +00:00
|
|
|
if (!check_ref(name, name_len, flags))
|
2005-12-26 07:18:37 +00:00
|
|
|
continue;
|
2005-07-16 20:55:50 +00:00
|
|
|
if (nr_match && !path_match(name, nr_match, match))
|
|
|
|
continue;
|
2008-10-18 08:44:18 +00:00
|
|
|
ref = alloc_ref(buffer + 41);
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(ref->old_sha1, old_sha1);
|
2005-07-16 20:55:50 +00:00
|
|
|
*list = ref;
|
|
|
|
list = &ref->next;
|
|
|
|
}
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2005-10-28 02:48:54 +00:00
|
|
|
int server_supports(const char *feature)
|
|
|
|
{
|
2005-10-28 03:56:41 +00:00
|
|
|
return server_capabilities &&
|
|
|
|
strstr(server_capabilities, feature) != NULL;
|
2005-10-28 02:48:54 +00:00
|
|
|
}
|
|
|
|
|
2005-07-04 20:24:30 +00:00
|
|
|
int path_match(const char *path, int nr, char **match)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int pathlen = strlen(path);
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++) {
|
|
|
|
char *s = match[i];
|
|
|
|
int len = strlen(s);
|
|
|
|
|
|
|
|
if (!len || len > pathlen)
|
|
|
|
continue;
|
|
|
|
if (memcmp(path + pathlen - len, s, len))
|
|
|
|
continue;
|
|
|
|
if (pathlen > len && path[pathlen - len - 1] != '/')
|
|
|
|
continue;
|
|
|
|
*s = 0;
|
2006-05-11 22:28:44 +00:00
|
|
|
return (i + 1);
|
2005-07-04 20:24:30 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-07-14 01:46:20 +00:00
|
|
|
enum protocol {
|
|
|
|
PROTO_LOCAL = 1,
|
|
|
|
PROTO_SSH,
|
2010-05-14 09:31:35 +00:00
|
|
|
PROTO_GIT
|
2005-07-14 01:46:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static enum protocol get_protocol(const char *name)
|
|
|
|
{
|
|
|
|
if (!strcmp(name, "ssh"))
|
|
|
|
return PROTO_SSH;
|
|
|
|
if (!strcmp(name, "git"))
|
|
|
|
return PROTO_GIT;
|
2005-10-15 00:14:56 +00:00
|
|
|
if (!strcmp(name, "git+ssh"))
|
|
|
|
return PROTO_SSH;
|
|
|
|
if (!strcmp(name, "ssh+git"))
|
|
|
|
return PROTO_SSH;
|
2007-08-01 17:03:37 +00:00
|
|
|
if (!strcmp(name, "file"))
|
|
|
|
return PROTO_LOCAL;
|
2005-07-14 01:46:20 +00:00
|
|
|
die("I don't handle protocol '%s'", name);
|
|
|
|
}
|
|
|
|
|
2005-07-21 13:10:36 +00:00
|
|
|
#define STR_(s) # s
|
|
|
|
#define STR(s) STR_(s)
|
2005-07-14 01:46:20 +00:00
|
|
|
|
2010-02-17 20:56:02 +00:00
|
|
|
static void get_host_and_port(char **host, const char **port)
|
|
|
|
{
|
|
|
|
char *colon, *end;
|
|
|
|
|
|
|
|
if (*host[0] == '[') {
|
|
|
|
end = strchr(*host + 1, ']');
|
|
|
|
if (end) {
|
|
|
|
*end = 0;
|
|
|
|
end++;
|
|
|
|
(*host)++;
|
|
|
|
} else
|
|
|
|
end = *host;
|
|
|
|
} else
|
|
|
|
end = *host;
|
|
|
|
colon = strchr(end, ':');
|
|
|
|
|
|
|
|
if (colon) {
|
|
|
|
*colon = 0;
|
|
|
|
*port = colon + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-28 23:52:21 +00:00
|
|
|
#ifndef NO_IPV6
|
2005-09-28 23:37:58 +00:00
|
|
|
|
2007-05-23 21:34:27 +00:00
|
|
|
static const char *ai_name(const struct addrinfo *ai)
|
|
|
|
{
|
2009-04-24 12:16:41 +00:00
|
|
|
static char addr[NI_MAXHOST];
|
|
|
|
if (getnameinfo(ai->ai_addr, ai->ai_addrlen, addr, sizeof(addr), NULL, 0,
|
|
|
|
NI_NUMERICHOST) != 0)
|
2007-05-23 21:34:27 +00:00
|
|
|
strcpy(addr, "(unknown)");
|
2009-04-24 12:16:41 +00:00
|
|
|
|
2007-05-23 21:34:27 +00:00
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
2006-06-07 03:58:41 +00:00
|
|
|
/*
|
|
|
|
* Returns a connected socket() fd, or else die()s.
|
|
|
|
*/
|
2007-05-16 17:09:41 +00:00
|
|
|
static int git_tcp_connect_sock(char *host, int flags)
|
2005-07-14 01:46:20 +00:00
|
|
|
{
|
2011-07-12 16:28:34 +00:00
|
|
|
struct strbuf error_message = STRBUF_INIT;
|
|
|
|
int sockfd = -1;
|
2006-06-28 09:04:39 +00:00
|
|
|
const char *port = STR(DEFAULT_GIT_PORT);
|
2005-07-21 13:10:36 +00:00
|
|
|
struct addrinfo hints, *ai0, *ai;
|
|
|
|
int gai;
|
2007-05-23 21:34:27 +00:00
|
|
|
int cnt = 0;
|
2005-07-21 13:10:36 +00:00
|
|
|
|
2010-02-17 20:56:02 +00:00
|
|
|
get_host_and_port(&host, &port);
|
|
|
|
if (!*port)
|
|
|
|
port = "<none>";
|
2005-07-21 13:10:36 +00:00
|
|
|
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
hints.ai_protocol = IPPROTO_TCP;
|
|
|
|
|
2007-05-16 17:09:41 +00:00
|
|
|
if (flags & CONNECT_VERBOSE)
|
|
|
|
fprintf(stderr, "Looking up %s ... ", host);
|
|
|
|
|
2005-07-21 13:10:36 +00:00
|
|
|
gai = getaddrinfo(host, port, &hints, &ai);
|
|
|
|
if (gai)
|
Fix "getaddrinfo()" buglet
At least in Linux glibc, "getaddrinfo()" has a very irritating feature (or
bug, who knows..).
Namely if you pass it in an empty string for the service name, it will
happily and quietly consider it identical to a NULL port pointer, and
return port number zero and no errors. Which obviously will not work.
Maybe that's what it's really expected to do, although the man-page for
getaddrinfo() certainly implies that it's a bug.
So when somebody passes me a "please pull" request pointing to something
like the following
git://git.kernel.org:/pub/scm/linux/kernel/git/mchehab/v4l-dvb.git
(note the extraneous colon at the end of the host name), git would happily
try to connect to port 0, which would generally just cause the remote to
not even answer, and the "connect()" will take a long time to time out.
So to work around the glibc feature/bug, just notice this empty port case
automatically. Also, add the port information to the error information
when it fails to look up (maybe it's the host-name that fails, maybe it's
the port-name - we should print out both).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-27 16:50:20 +00:00
|
|
|
die("Unable to look up %s (port %s) (%s)", host, port, gai_strerror(gai));
|
2005-07-21 13:10:36 +00:00
|
|
|
|
2007-05-16 17:09:41 +00:00
|
|
|
if (flags & CONNECT_VERBOSE)
|
|
|
|
fprintf(stderr, "done.\nConnecting to %s (port %s) ... ", host, port);
|
|
|
|
|
2011-08-01 11:16:09 +00:00
|
|
|
for (ai0 = ai; ai; ai = ai->ai_next, cnt++) {
|
2006-06-07 03:58:41 +00:00
|
|
|
sockfd = socket(ai->ai_family,
|
|
|
|
ai->ai_socktype, ai->ai_protocol);
|
2011-07-12 16:28:34 +00:00
|
|
|
if ((sockfd < 0) ||
|
|
|
|
(connect(sockfd, ai->ai_addr, ai->ai_addrlen) < 0)) {
|
|
|
|
strbuf_addf(&error_message, "%s[%d: %s]: errno=%s\n",
|
|
|
|
host, cnt, ai_name(ai), strerror(errno));
|
|
|
|
if (0 <= sockfd)
|
|
|
|
close(sockfd);
|
2005-07-21 13:10:36 +00:00
|
|
|
sockfd = -1;
|
|
|
|
continue;
|
2005-07-14 01:46:20 +00:00
|
|
|
}
|
2007-05-23 21:34:27 +00:00
|
|
|
if (flags & CONNECT_VERBOSE)
|
|
|
|
fprintf(stderr, "%s ", ai_name(ai));
|
2005-07-21 13:10:36 +00:00
|
|
|
break;
|
2005-07-14 01:46:20 +00:00
|
|
|
}
|
|
|
|
|
2005-07-21 13:10:36 +00:00
|
|
|
freeaddrinfo(ai0);
|
2005-07-14 01:46:20 +00:00
|
|
|
|
|
|
|
if (sockfd < 0)
|
2011-07-12 16:28:34 +00:00
|
|
|
die("unable to connect to %s:\n%s", host, error_message.buf);
|
2005-07-21 13:10:36 +00:00
|
|
|
|
2007-05-16 17:09:41 +00:00
|
|
|
if (flags & CONNECT_VERBOSE)
|
|
|
|
fprintf(stderr, "done.\n");
|
|
|
|
|
2011-07-12 16:28:34 +00:00
|
|
|
strbuf_release(&error_message);
|
|
|
|
|
2006-06-07 03:58:41 +00:00
|
|
|
return sockfd;
|
2005-07-14 01:46:20 +00:00
|
|
|
}
|
|
|
|
|
2005-09-28 23:52:21 +00:00
|
|
|
#else /* NO_IPV6 */
|
2005-09-28 23:37:58 +00:00
|
|
|
|
2006-06-07 03:58:41 +00:00
|
|
|
/*
|
|
|
|
* Returns a connected socket() fd, or else die()s.
|
|
|
|
*/
|
2007-05-16 17:09:41 +00:00
|
|
|
static int git_tcp_connect_sock(char *host, int flags)
|
2005-09-28 23:37:58 +00:00
|
|
|
{
|
2011-08-01 11:16:10 +00:00
|
|
|
struct strbuf error_message = STRBUF_INIT;
|
|
|
|
int sockfd = -1;
|
2010-02-17 20:56:02 +00:00
|
|
|
const char *port = STR(DEFAULT_GIT_PORT);
|
|
|
|
char *ep;
|
2005-09-28 23:37:58 +00:00
|
|
|
struct hostent *he;
|
|
|
|
struct sockaddr_in sa;
|
|
|
|
char **ap;
|
|
|
|
unsigned int nport;
|
2007-05-23 21:34:27 +00:00
|
|
|
int cnt;
|
2005-09-28 23:37:58 +00:00
|
|
|
|
2010-02-17 20:56:02 +00:00
|
|
|
get_host_and_port(&host, &port);
|
2005-09-28 23:37:58 +00:00
|
|
|
|
2007-05-16 17:09:41 +00:00
|
|
|
if (flags & CONNECT_VERBOSE)
|
|
|
|
fprintf(stderr, "Looking up %s ... ", host);
|
|
|
|
|
2005-09-28 23:37:58 +00:00
|
|
|
he = gethostbyname(host);
|
|
|
|
if (!he)
|
|
|
|
die("Unable to look up %s (%s)", host, hstrerror(h_errno));
|
|
|
|
nport = strtoul(port, &ep, 10);
|
|
|
|
if ( ep == port || *ep ) {
|
|
|
|
/* Not numeric */
|
|
|
|
struct servent *se = getservbyname(port,"tcp");
|
|
|
|
if ( !se )
|
2009-01-04 18:38:41 +00:00
|
|
|
die("Unknown port %s", port);
|
2005-09-28 23:37:58 +00:00
|
|
|
nport = se->s_port;
|
|
|
|
}
|
|
|
|
|
2007-05-16 17:09:41 +00:00
|
|
|
if (flags & CONNECT_VERBOSE)
|
|
|
|
fprintf(stderr, "done.\nConnecting to %s (port %s) ... ", host, port);
|
|
|
|
|
2007-05-23 21:34:27 +00:00
|
|
|
for (cnt = 0, ap = he->h_addr_list; *ap; ap++, cnt++) {
|
2005-09-28 23:37:58 +00:00
|
|
|
memset(&sa, 0, sizeof sa);
|
|
|
|
sa.sin_family = he->h_addrtype;
|
2005-09-29 00:26:44 +00:00
|
|
|
sa.sin_port = htons(nport);
|
2005-11-22 13:54:23 +00:00
|
|
|
memcpy(&sa.sin_addr, *ap, he->h_length);
|
2005-09-28 23:37:58 +00:00
|
|
|
|
2011-08-01 11:16:10 +00:00
|
|
|
sockfd = socket(he->h_addrtype, SOCK_STREAM, 0);
|
|
|
|
if ((sockfd < 0) ||
|
|
|
|
connect(sockfd, (struct sockaddr *)&sa, sizeof sa) < 0) {
|
|
|
|
strbuf_addf(&error_message, "%s[%d: %s]: errno=%s\n",
|
2007-05-23 21:34:27 +00:00
|
|
|
host,
|
|
|
|
cnt,
|
|
|
|
inet_ntoa(*(struct in_addr *)&sa.sin_addr),
|
2011-08-01 11:16:10 +00:00
|
|
|
strerror(errno));
|
|
|
|
if (0 <= sockfd)
|
|
|
|
close(sockfd);
|
2005-09-28 23:37:58 +00:00
|
|
|
sockfd = -1;
|
|
|
|
continue;
|
|
|
|
}
|
2007-05-23 21:34:27 +00:00
|
|
|
if (flags & CONNECT_VERBOSE)
|
|
|
|
fprintf(stderr, "%s ",
|
|
|
|
inet_ntoa(*(struct in_addr *)&sa.sin_addr));
|
2005-09-28 23:37:58 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sockfd < 0)
|
2011-08-01 11:16:10 +00:00
|
|
|
die("unable to connect to %s:\n%s", host, error_message.buf);
|
2005-09-28 23:37:58 +00:00
|
|
|
|
2007-05-16 17:09:41 +00:00
|
|
|
if (flags & CONNECT_VERBOSE)
|
|
|
|
fprintf(stderr, "done.\n");
|
|
|
|
|
2006-06-07 03:58:41 +00:00
|
|
|
return sockfd;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* NO_IPV6 */
|
|
|
|
|
|
|
|
|
2007-05-16 17:09:41 +00:00
|
|
|
static void git_tcp_connect(int fd[2], char *host, int flags)
|
2006-06-07 03:58:41 +00:00
|
|
|
{
|
2007-05-16 17:09:41 +00:00
|
|
|
int sockfd = git_tcp_connect_sock(host, flags);
|
2006-06-07 03:58:41 +00:00
|
|
|
|
2005-09-28 23:37:58 +00:00
|
|
|
fd[0] = sockfd;
|
2007-01-22 01:10:51 +00:00
|
|
|
fd[1] = dup(sockfd);
|
2005-09-28 23:37:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static char *git_proxy_command;
|
2005-11-04 14:57:16 +00:00
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int git_proxy_command_options(const char *var, const char *value,
|
|
|
|
void *cb)
|
2005-11-04 14:57:16 +00:00
|
|
|
{
|
2005-11-19 11:48:56 +00:00
|
|
|
if (!strcmp(var, "core.gitproxy")) {
|
2005-11-22 03:18:23 +00:00
|
|
|
const char *for_pos;
|
|
|
|
int matchlen = -1;
|
|
|
|
int hostlen;
|
2009-03-11 02:38:12 +00:00
|
|
|
const char *rhost_name = cb;
|
|
|
|
int rhost_len = strlen(rhost_name);
|
2005-11-22 03:18:23 +00:00
|
|
|
|
2005-11-19 11:48:56 +00:00
|
|
|
if (git_proxy_command)
|
2005-11-04 14:57:16 +00:00
|
|
|
return 0;
|
2008-02-11 18:52:15 +00:00
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
2005-11-19 11:48:56 +00:00
|
|
|
/* [core]
|
|
|
|
* ;# matches www.kernel.org as well
|
|
|
|
* gitproxy = netcatter-1 for kernel.org
|
|
|
|
* gitproxy = netcatter-2 for sample.xz
|
|
|
|
* gitproxy = netcatter-default
|
|
|
|
*/
|
2005-11-22 03:18:23 +00:00
|
|
|
for_pos = strstr(value, " for ");
|
2005-11-19 11:48:56 +00:00
|
|
|
if (!for_pos)
|
|
|
|
/* matches everybody */
|
|
|
|
matchlen = strlen(value);
|
|
|
|
else {
|
|
|
|
hostlen = strlen(for_pos + 5);
|
|
|
|
if (rhost_len < hostlen)
|
|
|
|
matchlen = -1;
|
|
|
|
else if (!strncmp(for_pos + 5,
|
|
|
|
rhost_name + rhost_len - hostlen,
|
|
|
|
hostlen) &&
|
|
|
|
((rhost_len == hostlen) ||
|
|
|
|
rhost_name[rhost_len - hostlen -1] == '.'))
|
|
|
|
matchlen = for_pos - value;
|
|
|
|
else
|
|
|
|
matchlen = -1;
|
|
|
|
}
|
|
|
|
if (0 <= matchlen) {
|
|
|
|
/* core.gitproxy = none for kernel.org */
|
2007-06-07 07:04:01 +00:00
|
|
|
if (matchlen == 4 &&
|
2005-11-19 11:48:56 +00:00
|
|
|
!memcmp(value, "none", 4))
|
|
|
|
matchlen = 0;
|
2007-09-15 22:32:36 +00:00
|
|
|
git_proxy_command = xmemdupz(value, matchlen);
|
2005-11-04 14:57:16 +00:00
|
|
|
}
|
2005-11-19 11:48:56 +00:00
|
|
|
return 0;
|
2005-11-04 14:57:16 +00:00
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
return git_default_config(var, value, cb);
|
2005-11-04 14:57:16 +00:00
|
|
|
}
|
|
|
|
|
2005-11-19 11:48:56 +00:00
|
|
|
static int git_use_proxy(const char *host)
|
2005-11-04 14:57:16 +00:00
|
|
|
{
|
|
|
|
git_proxy_command = getenv("GIT_PROXY_COMMAND");
|
2009-03-11 02:38:12 +00:00
|
|
|
git_config(git_proxy_command_options, (void*)host);
|
2005-11-19 11:48:56 +00:00
|
|
|
return (git_proxy_command && *git_proxy_command);
|
2005-11-04 14:57:16 +00:00
|
|
|
}
|
|
|
|
|
connect: treat generic proxy processes like ssh processes
The git_connect function returns two ends of a pipe for
talking with a remote, plus a struct child_process
representing the other end of the pipe. If we have a direct
socket connection, then this points to a special "no_fork"
child process.
The code path for doing git-over-pipes or git-over-ssh sets
up this child process to point to the child git command or
the ssh process. When we call finish_connect eventually, we
check wait() on the command and report its return value.
The code path for git://, on the other hand, always sets it
to no_fork. In the case of a direct TCP connection, this
makes sense; we have no child process. But in the case of a
proxy command (configured by core.gitproxy), we do have a
child process, but we throw away its pid, and therefore
ignore its return code.
Instead, let's keep that information in the proxy case, and
respect its return code, which can help catch some errors
(though depending on your proxy command, it will be errors
reported by the proxy command itself, and not propagated
from git commands. Still, it is probably better to propagate
such errors than to ignore them).
It also means that the child_process field can reliably be
used to determine whether the returned descriptors are
actually a full-duplex socket, which means we should be
using shutdown() instead of a simple close.
Signed-off-by: Jeff King <peff@peff.net>
Helped-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-16 06:46:07 +00:00
|
|
|
static struct child_process *git_proxy_connect(int fd[2], char *host)
|
2005-11-04 14:57:16 +00:00
|
|
|
{
|
2006-06-28 09:04:39 +00:00
|
|
|
const char *port = STR(DEFAULT_GIT_PORT);
|
connect: treat generic proxy processes like ssh processes
The git_connect function returns two ends of a pipe for
talking with a remote, plus a struct child_process
representing the other end of the pipe. If we have a direct
socket connection, then this points to a special "no_fork"
child process.
The code path for doing git-over-pipes or git-over-ssh sets
up this child process to point to the child git command or
the ssh process. When we call finish_connect eventually, we
check wait() on the command and report its return value.
The code path for git://, on the other hand, always sets it
to no_fork. In the case of a direct TCP connection, this
makes sense; we have no child process. But in the case of a
proxy command (configured by core.gitproxy), we do have a
child process, but we throw away its pid, and therefore
ignore its return code.
Instead, let's keep that information in the proxy case, and
respect its return code, which can help catch some errors
(though depending on your proxy command, it will be errors
reported by the proxy command itself, and not propagated
from git commands. Still, it is probably better to propagate
such errors than to ignore them).
It also means that the child_process field can reliably be
used to determine whether the returned descriptors are
actually a full-duplex socket, which means we should be
using shutdown() instead of a simple close.
Signed-off-by: Jeff King <peff@peff.net>
Helped-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-16 06:46:07 +00:00
|
|
|
const char **argv;
|
|
|
|
struct child_process *proxy;
|
2005-11-04 14:57:16 +00:00
|
|
|
|
2010-02-17 20:56:02 +00:00
|
|
|
get_host_and_port(&host, &port);
|
2005-11-04 14:57:16 +00:00
|
|
|
|
connect: treat generic proxy processes like ssh processes
The git_connect function returns two ends of a pipe for
talking with a remote, plus a struct child_process
representing the other end of the pipe. If we have a direct
socket connection, then this points to a special "no_fork"
child process.
The code path for doing git-over-pipes or git-over-ssh sets
up this child process to point to the child git command or
the ssh process. When we call finish_connect eventually, we
check wait() on the command and report its return value.
The code path for git://, on the other hand, always sets it
to no_fork. In the case of a direct TCP connection, this
makes sense; we have no child process. But in the case of a
proxy command (configured by core.gitproxy), we do have a
child process, but we throw away its pid, and therefore
ignore its return code.
Instead, let's keep that information in the proxy case, and
respect its return code, which can help catch some errors
(though depending on your proxy command, it will be errors
reported by the proxy command itself, and not propagated
from git commands. Still, it is probably better to propagate
such errors than to ignore them).
It also means that the child_process field can reliably be
used to determine whether the returned descriptors are
actually a full-duplex socket, which means we should be
using shutdown() instead of a simple close.
Signed-off-by: Jeff King <peff@peff.net>
Helped-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-16 06:46:07 +00:00
|
|
|
argv = xmalloc(sizeof(*argv) * 4);
|
2007-03-12 23:00:19 +00:00
|
|
|
argv[0] = git_proxy_command;
|
|
|
|
argv[1] = host;
|
|
|
|
argv[2] = port;
|
|
|
|
argv[3] = NULL;
|
connect: treat generic proxy processes like ssh processes
The git_connect function returns two ends of a pipe for
talking with a remote, plus a struct child_process
representing the other end of the pipe. If we have a direct
socket connection, then this points to a special "no_fork"
child process.
The code path for doing git-over-pipes or git-over-ssh sets
up this child process to point to the child git command or
the ssh process. When we call finish_connect eventually, we
check wait() on the command and report its return value.
The code path for git://, on the other hand, always sets it
to no_fork. In the case of a direct TCP connection, this
makes sense; we have no child process. But in the case of a
proxy command (configured by core.gitproxy), we do have a
child process, but we throw away its pid, and therefore
ignore its return code.
Instead, let's keep that information in the proxy case, and
respect its return code, which can help catch some errors
(though depending on your proxy command, it will be errors
reported by the proxy command itself, and not propagated
from git commands. Still, it is probably better to propagate
such errors than to ignore them).
It also means that the child_process field can reliably be
used to determine whether the returned descriptors are
actually a full-duplex socket, which means we should be
using shutdown() instead of a simple close.
Signed-off-by: Jeff King <peff@peff.net>
Helped-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-16 06:46:07 +00:00
|
|
|
proxy = xcalloc(1, sizeof(*proxy));
|
|
|
|
proxy->argv = argv;
|
|
|
|
proxy->in = -1;
|
|
|
|
proxy->out = -1;
|
|
|
|
if (start_command(proxy))
|
2007-03-12 23:00:19 +00:00
|
|
|
die("cannot start proxy %s", argv[0]);
|
connect: treat generic proxy processes like ssh processes
The git_connect function returns two ends of a pipe for
talking with a remote, plus a struct child_process
representing the other end of the pipe. If we have a direct
socket connection, then this points to a special "no_fork"
child process.
The code path for doing git-over-pipes or git-over-ssh sets
up this child process to point to the child git command or
the ssh process. When we call finish_connect eventually, we
check wait() on the command and report its return value.
The code path for git://, on the other hand, always sets it
to no_fork. In the case of a direct TCP connection, this
makes sense; we have no child process. But in the case of a
proxy command (configured by core.gitproxy), we do have a
child process, but we throw away its pid, and therefore
ignore its return code.
Instead, let's keep that information in the proxy case, and
respect its return code, which can help catch some errors
(though depending on your proxy command, it will be errors
reported by the proxy command itself, and not propagated
from git commands. Still, it is probably better to propagate
such errors than to ignore them).
It also means that the child_process field can reliably be
used to determine whether the returned descriptors are
actually a full-duplex socket, which means we should be
using shutdown() instead of a simple close.
Signed-off-by: Jeff King <peff@peff.net>
Helped-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-16 06:46:07 +00:00
|
|
|
fd[0] = proxy->out; /* read from proxy stdout */
|
|
|
|
fd[1] = proxy->in; /* write to proxy stdin */
|
|
|
|
return proxy;
|
2005-11-04 14:57:16 +00:00
|
|
|
}
|
|
|
|
|
2006-09-11 05:04:50 +00:00
|
|
|
#define MAX_CMD_LEN 1024
|
|
|
|
|
2009-06-18 17:28:43 +00:00
|
|
|
static char *get_port(char *host)
|
2007-09-01 09:36:31 +00:00
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
char *p = strchr(host, ':');
|
|
|
|
|
|
|
|
if (p) {
|
2008-12-21 01:12:11 +00:00
|
|
|
long port = strtol(p + 1, &end, 10);
|
|
|
|
if (end != p + 1 && *end == '\0' && 0 <= port && port < 65536) {
|
2007-09-01 09:36:31 +00:00
|
|
|
*p = '\0';
|
|
|
|
return p+1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-10 03:06:57 +00:00
|
|
|
static struct child_process no_fork;
|
|
|
|
|
2005-07-04 18:57:58 +00:00
|
|
|
/*
|
2008-02-10 03:06:57 +00:00
|
|
|
* This returns a dummy child_process if the transport protocol does not
|
|
|
|
* need fork(2), or a struct child_process object if it does. Once done,
|
|
|
|
* finish the connection with finish_connect() with the value returned from
|
|
|
|
* this function (it is safe to call finish_connect() with NULL to support
|
|
|
|
* the former case).
|
2006-09-12 09:00:13 +00:00
|
|
|
*
|
2008-02-10 03:06:57 +00:00
|
|
|
* If it returns, the connect is successful; it just dies on errors (this
|
|
|
|
* will hopefully be changed in a libification effort, to return NULL when
|
|
|
|
* the connection failed).
|
2005-07-04 18:57:58 +00:00
|
|
|
*/
|
2007-10-30 01:05:40 +00:00
|
|
|
struct child_process *git_connect(int fd[2], const char *url_orig,
|
2007-10-19 19:47:53 +00:00
|
|
|
const char *prog, int flags)
|
2005-07-04 18:57:58 +00:00
|
|
|
{
|
2010-05-23 09:19:44 +00:00
|
|
|
char *url;
|
2009-03-13 12:51:33 +00:00
|
|
|
char *host, *path;
|
2005-12-21 10:23:42 +00:00
|
|
|
char *end;
|
|
|
|
int c;
|
connect: treat generic proxy processes like ssh processes
The git_connect function returns two ends of a pipe for
talking with a remote, plus a struct child_process
representing the other end of the pipe. If we have a direct
socket connection, then this points to a special "no_fork"
child process.
The code path for doing git-over-pipes or git-over-ssh sets
up this child process to point to the child git command or
the ssh process. When we call finish_connect eventually, we
check wait() on the command and report its return value.
The code path for git://, on the other hand, always sets it
to no_fork. In the case of a direct TCP connection, this
makes sense; we have no child process. But in the case of a
proxy command (configured by core.gitproxy), we do have a
child process, but we throw away its pid, and therefore
ignore its return code.
Instead, let's keep that information in the proxy case, and
respect its return code, which can help catch some errors
(though depending on your proxy command, it will be errors
reported by the proxy command itself, and not propagated
from git commands. Still, it is probably better to propagate
such errors than to ignore them).
It also means that the child_process field can reliably be
used to determine whether the returned descriptors are
actually a full-duplex socket, which means we should be
using shutdown() instead of a simple close.
Signed-off-by: Jeff King <peff@peff.net>
Helped-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-16 06:46:07 +00:00
|
|
|
struct child_process *conn = &no_fork;
|
2005-11-17 19:37:14 +00:00
|
|
|
enum protocol protocol = PROTO_LOCAL;
|
2006-04-17 15:14:47 +00:00
|
|
|
int free_path = 0;
|
2007-09-01 09:36:31 +00:00
|
|
|
char *port = NULL;
|
2007-10-19 19:47:54 +00:00
|
|
|
const char **arg;
|
|
|
|
struct strbuf cmd;
|
2005-11-17 19:37:14 +00:00
|
|
|
|
2006-06-20 01:25:21 +00:00
|
|
|
/* Without this we cannot rely on waitpid() to tell
|
|
|
|
* what happened to our children.
|
|
|
|
*/
|
|
|
|
signal(SIGCHLD, SIG_DFL);
|
|
|
|
|
2010-05-23 09:19:44 +00:00
|
|
|
if (is_url(url_orig))
|
|
|
|
url = url_decode(url_orig);
|
|
|
|
else
|
|
|
|
url = xstrdup(url_orig);
|
|
|
|
|
2005-11-17 19:37:14 +00:00
|
|
|
host = strstr(url, "://");
|
2009-09-01 05:35:10 +00:00
|
|
|
if (host) {
|
2005-11-17 19:37:14 +00:00
|
|
|
*host = '\0';
|
|
|
|
protocol = get_protocol(url);
|
|
|
|
host += 3;
|
2005-12-21 10:23:42 +00:00
|
|
|
c = '/';
|
|
|
|
} else {
|
2005-07-04 18:57:58 +00:00
|
|
|
host = url;
|
2005-12-21 10:23:42 +00:00
|
|
|
c = ':';
|
|
|
|
}
|
|
|
|
|
2010-01-26 18:24:42 +00:00
|
|
|
/*
|
|
|
|
* Don't do destructive transforms with git:// as that
|
2010-02-04 05:23:18 +00:00
|
|
|
* protocol code does '[]' unwrapping of its own.
|
2010-01-26 18:24:42 +00:00
|
|
|
*/
|
2005-12-21 10:23:42 +00:00
|
|
|
if (host[0] == '[') {
|
|
|
|
end = strchr(host + 1, ']');
|
|
|
|
if (end) {
|
2010-01-26 18:24:42 +00:00
|
|
|
if (protocol != PROTO_GIT) {
|
|
|
|
*end = 0;
|
|
|
|
host++;
|
|
|
|
}
|
2005-12-21 10:23:42 +00:00
|
|
|
end++;
|
|
|
|
} else
|
|
|
|
end = host;
|
|
|
|
} else
|
|
|
|
end = host;
|
|
|
|
|
|
|
|
path = strchr(end, c);
|
2007-11-30 21:51:10 +00:00
|
|
|
if (path && !has_dos_drive_prefix(end)) {
|
2007-08-01 17:03:37 +00:00
|
|
|
if (c == ':') {
|
2005-11-17 19:37:14 +00:00
|
|
|
protocol = PROTO_SSH;
|
2005-12-21 10:23:42 +00:00
|
|
|
*path++ = '\0';
|
2007-08-01 17:03:37 +00:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
path = end;
|
2005-07-14 01:46:20 +00:00
|
|
|
|
2005-11-17 19:37:14 +00:00
|
|
|
if (!path || !*path)
|
|
|
|
die("No path specified. See 'man git-pull' for valid url syntax");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* null-terminate hostname and point path to ~ for URL's like this:
|
|
|
|
* ssh://host.xz/~user/repo
|
|
|
|
*/
|
|
|
|
if (protocol != PROTO_LOCAL && host != url) {
|
|
|
|
char *ptr = path;
|
|
|
|
if (path[1] == '~')
|
|
|
|
path++;
|
2006-04-17 15:14:47 +00:00
|
|
|
else {
|
2006-09-02 04:16:31 +00:00
|
|
|
path = xstrdup(ptr);
|
2006-04-17 15:14:47 +00:00
|
|
|
free_path = 1;
|
|
|
|
}
|
2005-11-17 19:37:14 +00:00
|
|
|
|
|
|
|
*ptr = '\0';
|
|
|
|
}
|
|
|
|
|
2007-09-01 09:36:31 +00:00
|
|
|
/*
|
|
|
|
* Add support for ssh port: ssh://host.xy:<port>/...
|
|
|
|
*/
|
|
|
|
if (protocol == PROTO_SSH && host != url)
|
|
|
|
port = get_port(host);
|
|
|
|
|
2005-11-04 14:57:16 +00:00
|
|
|
if (protocol == PROTO_GIT) {
|
2006-06-07 03:58:41 +00:00
|
|
|
/* These underlying connection commands die() if they
|
|
|
|
* cannot connect.
|
|
|
|
*/
|
2006-09-02 04:16:31 +00:00
|
|
|
char *target_host = xstrdup(host);
|
2005-11-19 11:48:56 +00:00
|
|
|
if (git_use_proxy(host))
|
connect: treat generic proxy processes like ssh processes
The git_connect function returns two ends of a pipe for
talking with a remote, plus a struct child_process
representing the other end of the pipe. If we have a direct
socket connection, then this points to a special "no_fork"
child process.
The code path for doing git-over-pipes or git-over-ssh sets
up this child process to point to the child git command or
the ssh process. When we call finish_connect eventually, we
check wait() on the command and report its return value.
The code path for git://, on the other hand, always sets it
to no_fork. In the case of a direct TCP connection, this
makes sense; we have no child process. But in the case of a
proxy command (configured by core.gitproxy), we do have a
child process, but we throw away its pid, and therefore
ignore its return code.
Instead, let's keep that information in the proxy case, and
respect its return code, which can help catch some errors
(though depending on your proxy command, it will be errors
reported by the proxy command itself, and not propagated
from git commands. Still, it is probably better to propagate
such errors than to ignore them).
It also means that the child_process field can reliably be
used to determine whether the returned descriptors are
actually a full-duplex socket, which means we should be
using shutdown() instead of a simple close.
Signed-off-by: Jeff King <peff@peff.net>
Helped-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-16 06:46:07 +00:00
|
|
|
conn = git_proxy_connect(fd, host);
|
2006-04-17 15:14:47 +00:00
|
|
|
else
|
2007-05-16 17:09:41 +00:00
|
|
|
git_tcp_connect(fd, host, flags);
|
2006-06-07 03:58:41 +00:00
|
|
|
/*
|
|
|
|
* Separate original protocol components prog and path
|
2009-06-05 01:33:32 +00:00
|
|
|
* from extended host header with a NUL byte.
|
|
|
|
*
|
|
|
|
* Note: Do not add any other headers here! Doing so
|
|
|
|
* will cause older git-daemon servers to crash.
|
2006-06-07 03:58:41 +00:00
|
|
|
*/
|
|
|
|
packet_write(fd[1],
|
|
|
|
"%s %s%chost=%s%c",
|
|
|
|
prog, path, 0,
|
|
|
|
target_host, 0);
|
|
|
|
free(target_host);
|
2007-10-30 01:05:40 +00:00
|
|
|
free(url);
|
2006-04-17 15:14:47 +00:00
|
|
|
if (free_path)
|
|
|
|
free(path);
|
connect: treat generic proxy processes like ssh processes
The git_connect function returns two ends of a pipe for
talking with a remote, plus a struct child_process
representing the other end of the pipe. If we have a direct
socket connection, then this points to a special "no_fork"
child process.
The code path for doing git-over-pipes or git-over-ssh sets
up this child process to point to the child git command or
the ssh process. When we call finish_connect eventually, we
check wait() on the command and report its return value.
The code path for git://, on the other hand, always sets it
to no_fork. In the case of a direct TCP connection, this
makes sense; we have no child process. But in the case of a
proxy command (configured by core.gitproxy), we do have a
child process, but we throw away its pid, and therefore
ignore its return code.
Instead, let's keep that information in the proxy case, and
respect its return code, which can help catch some errors
(though depending on your proxy command, it will be errors
reported by the proxy command itself, and not propagated
from git commands. Still, it is probably better to propagate
such errors than to ignore them).
It also means that the child_process field can reliably be
used to determine whether the returned descriptors are
actually a full-duplex socket, which means we should be
using shutdown() instead of a simple close.
Signed-off-by: Jeff King <peff@peff.net>
Helped-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-16 06:46:07 +00:00
|
|
|
return conn;
|
2005-11-04 14:57:16 +00:00
|
|
|
}
|
2005-07-14 01:46:20 +00:00
|
|
|
|
2007-10-19 19:47:53 +00:00
|
|
|
conn = xcalloc(1, sizeof(*conn));
|
2007-09-01 09:36:31 +00:00
|
|
|
|
2007-10-19 19:47:54 +00:00
|
|
|
strbuf_init(&cmd, MAX_CMD_LEN);
|
|
|
|
strbuf_addstr(&cmd, prog);
|
|
|
|
strbuf_addch(&cmd, ' ');
|
|
|
|
sq_quote_buf(&cmd, path);
|
|
|
|
if (cmd.len >= MAX_CMD_LEN)
|
|
|
|
die("command line too long");
|
|
|
|
|
|
|
|
conn->in = conn->out = -1;
|
2009-05-31 16:15:21 +00:00
|
|
|
conn->argv = arg = xcalloc(7, sizeof(*arg));
|
2007-10-19 19:47:54 +00:00
|
|
|
if (protocol == PROTO_SSH) {
|
|
|
|
const char *ssh = getenv("GIT_SSH");
|
2009-05-31 16:15:21 +00:00
|
|
|
int putty = ssh && strcasestr(ssh, "plink");
|
2007-10-19 19:47:54 +00:00
|
|
|
if (!ssh) ssh = "ssh";
|
|
|
|
|
|
|
|
*arg++ = ssh;
|
2009-05-31 16:15:21 +00:00
|
|
|
if (putty && !strcasestr(ssh, "tortoiseplink"))
|
|
|
|
*arg++ = "-batch";
|
2007-10-19 19:47:54 +00:00
|
|
|
if (port) {
|
2009-05-31 16:15:21 +00:00
|
|
|
/* P is for PuTTY, p is for OpenSSH */
|
|
|
|
*arg++ = putty ? "-P" : "-p";
|
2007-10-19 19:47:54 +00:00
|
|
|
*arg++ = port;
|
2005-08-03 15:15:42 +00:00
|
|
|
}
|
2007-10-19 19:47:54 +00:00
|
|
|
*arg++ = host;
|
|
|
|
}
|
|
|
|
else {
|
2010-02-24 23:34:14 +00:00
|
|
|
/* remove repo-local variables from the environment */
|
|
|
|
conn->env = local_repo_env;
|
2010-01-25 12:32:44 +00:00
|
|
|
conn->use_shell = 1;
|
2006-01-19 20:58:03 +00:00
|
|
|
}
|
2007-10-19 19:47:54 +00:00
|
|
|
*arg++ = cmd.buf;
|
|
|
|
*arg = NULL;
|
|
|
|
|
|
|
|
if (start_command(conn))
|
|
|
|
die("unable to fork");
|
|
|
|
|
|
|
|
fd[0] = conn->out; /* read from child's stdout */
|
|
|
|
fd[1] = conn->in; /* write to child's stdin */
|
|
|
|
strbuf_release(&cmd);
|
2007-10-30 01:05:40 +00:00
|
|
|
free(url);
|
2006-04-17 15:14:47 +00:00
|
|
|
if (free_path)
|
|
|
|
free(path);
|
2007-10-19 19:47:53 +00:00
|
|
|
return conn;
|
2005-07-04 18:57:58 +00:00
|
|
|
}
|
|
|
|
|
2011-05-16 06:52:11 +00:00
|
|
|
int git_connection_is_socket(struct child_process *conn)
|
|
|
|
{
|
|
|
|
return conn == &no_fork;
|
|
|
|
}
|
|
|
|
|
2007-10-19 19:47:53 +00:00
|
|
|
int finish_connect(struct child_process *conn)
|
2005-07-04 18:57:58 +00:00
|
|
|
{
|
2007-10-19 19:47:54 +00:00
|
|
|
int code;
|
2011-05-16 06:52:11 +00:00
|
|
|
if (!conn || git_connection_is_socket(conn))
|
2006-09-12 09:00:13 +00:00
|
|
|
return 0;
|
|
|
|
|
2007-10-19 19:47:54 +00:00
|
|
|
code = finish_command(conn);
|
|
|
|
free(conn->argv);
|
2007-10-19 19:47:53 +00:00
|
|
|
free(conn);
|
2007-10-19 19:47:54 +00:00
|
|
|
return code;
|
2005-07-04 18:57:58 +00:00
|
|
|
}
|
2010-03-04 19:59:50 +00:00
|
|
|
|
|
|
|
char *git_getpass(const char *prompt)
|
|
|
|
{
|
2010-08-30 13:38:38 +00:00
|
|
|
const char *askpass;
|
2010-03-04 19:59:50 +00:00
|
|
|
struct child_process pass;
|
|
|
|
const char *args[3];
|
|
|
|
static struct strbuf buffer = STRBUF_INIT;
|
|
|
|
|
|
|
|
askpass = getenv("GIT_ASKPASS");
|
2010-08-30 13:38:38 +00:00
|
|
|
if (!askpass)
|
|
|
|
askpass = askpass_program;
|
2010-08-30 13:39:38 +00:00
|
|
|
if (!askpass)
|
|
|
|
askpass = getenv("SSH_ASKPASS");
|
2010-09-29 22:22:32 +00:00
|
|
|
if (!askpass || !(*askpass)) {
|
|
|
|
char *result = getpass(prompt);
|
|
|
|
if (!result)
|
|
|
|
die_errno("Could not read password");
|
|
|
|
return result;
|
|
|
|
}
|
2010-03-04 19:59:50 +00:00
|
|
|
|
|
|
|
args[0] = askpass;
|
|
|
|
args[1] = prompt;
|
|
|
|
args[2] = NULL;
|
|
|
|
|
|
|
|
memset(&pass, 0, sizeof(pass));
|
|
|
|
pass.argv = args;
|
|
|
|
pass.out = -1;
|
|
|
|
|
|
|
|
if (start_command(&pass))
|
|
|
|
exit(1);
|
|
|
|
|
|
|
|
strbuf_reset(&buffer);
|
|
|
|
if (strbuf_read(&buffer, pass.out, 20) < 0)
|
|
|
|
die("failed to read password from %s\n", askpass);
|
|
|
|
|
|
|
|
close(pass.out);
|
|
|
|
|
|
|
|
if (finish_command(&pass))
|
|
|
|
exit(1);
|
|
|
|
|
|
|
|
strbuf_setlen(&buffer, strcspn(buffer.buf, "\r\n"));
|
|
|
|
|
|
|
|
return buffer.buf;
|
|
|
|
}
|