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"
|
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);
|
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
unsigned int flags)
|
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;
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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;
|
2007-09-28 08:46:13 +00:00
|
|
|
ref = alloc_ref(name_len + 1);
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(ref->old_sha1, old_sha1);
|
2007-09-28 08:46:13 +00:00
|
|
|
memcpy(ref->name, buffer + 41, name_len + 1);
|
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-05 22:44:09 +00:00
|
|
|
int get_ack(int fd, unsigned char *result_sha1)
|
|
|
|
{
|
|
|
|
static char line[1000];
|
|
|
|
int len = packet_read_line(fd, line, sizeof(line));
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
die("git-fetch-pack: expected ACK/NAK, got EOF");
|
|
|
|
if (line[len-1] == '\n')
|
|
|
|
line[--len] = 0;
|
|
|
|
if (!strcmp(line, "NAK"))
|
|
|
|
return 0;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(line, "ACK ")) {
|
2005-10-28 02:50:26 +00:00
|
|
|
if (!get_sha1_hex(line+4, result_sha1)) {
|
|
|
|
if (strstr(line+45, "continue"))
|
|
|
|
return 2;
|
2005-07-05 22:44:09 +00:00
|
|
|
return 1;
|
2005-10-28 02:50:26 +00:00
|
|
|
}
|
2005-07-05 22:44:09 +00:00
|
|
|
}
|
|
|
|
die("git-fetch_pack: expected ACK/NAK, got '%s'", line);
|
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
PROTO_GIT,
|
|
|
|
};
|
|
|
|
|
|
|
|
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
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
static char addr[INET_ADDRSTRLEN];
|
|
|
|
if ( AF_INET == ai->ai_family ) {
|
|
|
|
struct sockaddr_in *in;
|
|
|
|
in = (struct sockaddr_in *)ai->ai_addr;
|
|
|
|
inet_ntop(ai->ai_family, &in->sin_addr, addr, sizeof(addr));
|
|
|
|
} else if ( AF_INET6 == ai->ai_family ) {
|
|
|
|
struct sockaddr_in6 *in;
|
|
|
|
in = (struct sockaddr_in6 *)ai->ai_addr;
|
|
|
|
inet_ntop(ai->ai_family, &in->sin6_addr, addr, sizeof(addr));
|
|
|
|
} else {
|
|
|
|
strcpy(addr, "(unknown)");
|
|
|
|
}
|
|
|
|
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
|
|
|
{
|
2006-07-01 21:56:26 +00:00
|
|
|
int sockfd = -1, saved_errno = 0;
|
2005-07-21 13:10:36 +00:00
|
|
|
char *colon, *end;
|
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
|
|
|
|
|
|
|
if (host[0] == '[') {
|
|
|
|
end = strchr(host + 1, ']');
|
|
|
|
if (end) {
|
|
|
|
*end = 0;
|
|
|
|
end++;
|
|
|
|
host++;
|
|
|
|
} else
|
|
|
|
end = host;
|
|
|
|
} else
|
|
|
|
end = host;
|
|
|
|
colon = strchr(end, ':');
|
|
|
|
|
2005-07-23 18:10:21 +00:00
|
|
|
if (colon) {
|
|
|
|
*colon = 0;
|
2005-07-21 13:10:36 +00:00
|
|
|
port = colon + 1;
|
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
|
|
|
if (!*port)
|
|
|
|
port = "<none>";
|
2005-07-23 18:10:21 +00:00
|
|
|
}
|
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);
|
|
|
|
|
2005-07-21 13:10:36 +00:00
|
|
|
for (ai0 = ai; ai; ai = ai->ai_next) {
|
2006-06-07 03:58:41 +00:00
|
|
|
sockfd = socket(ai->ai_family,
|
|
|
|
ai->ai_socktype, ai->ai_protocol);
|
2006-07-01 21:56:26 +00:00
|
|
|
if (sockfd < 0) {
|
|
|
|
saved_errno = errno;
|
2005-07-21 13:10:36 +00:00
|
|
|
continue;
|
2006-07-01 21:56:26 +00:00
|
|
|
}
|
2005-07-21 13:10:36 +00:00
|
|
|
if (connect(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) {
|
2006-07-01 21:56:26 +00:00
|
|
|
saved_errno = errno;
|
2007-06-12 20:52:10 +00:00
|
|
|
fprintf(stderr, "%s[%d: %s]: errno=%s\n",
|
2007-05-23 21:34:27 +00:00
|
|
|
host,
|
|
|
|
cnt,
|
|
|
|
ai_name(ai),
|
|
|
|
strerror(saved_errno));
|
2005-07-21 13:10:36 +00:00
|
|
|
close(sockfd);
|
|
|
|
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)
|
2006-07-01 21:56:26 +00:00
|
|
|
die("unable to connect a socket (%s)", strerror(saved_errno));
|
2005-07-21 13:10:36 +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;
|
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
|
|
|
{
|
2006-07-01 21:56:26 +00:00
|
|
|
int sockfd = -1, saved_errno = 0;
|
2005-09-28 23:37:58 +00:00
|
|
|
char *colon, *end;
|
|
|
|
char *port = STR(DEFAULT_GIT_PORT), *ep;
|
|
|
|
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
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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 )
|
|
|
|
die("Unknown port %s\n", port);
|
|
|
|
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
|
|
|
sockfd = socket(he->h_addrtype, SOCK_STREAM, 0);
|
2006-07-01 21:56:26 +00:00
|
|
|
if (sockfd < 0) {
|
|
|
|
saved_errno = errno;
|
2005-09-28 23:37:58 +00:00
|
|
|
continue;
|
2006-07-01 21:56:26 +00:00
|
|
|
}
|
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
|
|
|
|
|
|
|
if (connect(sockfd, (struct sockaddr *)&sa, sizeof sa) < 0) {
|
2006-07-01 21:56:26 +00:00
|
|
|
saved_errno = errno;
|
2007-06-12 20:52:10 +00:00
|
|
|
fprintf(stderr, "%s[%d: %s]: errno=%s\n",
|
2007-05-23 21:34:27 +00:00
|
|
|
host,
|
|
|
|
cnt,
|
|
|
|
inet_ntoa(*(struct in_addr *)&sa.sin_addr),
|
|
|
|
strerror(saved_errno));
|
2005-09-28 23:37:58 +00:00
|
|
|
close(sockfd);
|
|
|
|
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)
|
2006-07-01 21:56:26 +00:00
|
|
|
die("unable to connect a socket (%s)", strerror(saved_errno));
|
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;
|
|
|
|
static const char *rhost_name;
|
2005-11-19 11:48:56 +00:00
|
|
|
static int rhost_len;
|
2005-11-04 14:57:16 +00:00
|
|
|
|
|
|
|
static int git_proxy_command_options(const char *var, const char *value)
|
|
|
|
{
|
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;
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
return git_default_config(var, value);
|
|
|
|
}
|
|
|
|
|
2005-11-19 11:48:56 +00:00
|
|
|
static int git_use_proxy(const char *host)
|
2005-11-04 14:57:16 +00:00
|
|
|
{
|
2005-11-19 11:48:56 +00:00
|
|
|
rhost_name = host;
|
|
|
|
rhost_len = strlen(host);
|
2005-11-04 14:57:16 +00:00
|
|
|
git_proxy_command = getenv("GIT_PROXY_COMMAND");
|
|
|
|
git_config(git_proxy_command_options);
|
2005-11-19 11:48:56 +00:00
|
|
|
rhost_name = NULL;
|
|
|
|
return (git_proxy_command && *git_proxy_command);
|
2005-11-04 14:57:16 +00:00
|
|
|
}
|
|
|
|
|
2006-06-28 10:50:33 +00:00
|
|
|
static void 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);
|
2005-11-04 14:57:16 +00:00
|
|
|
char *colon, *end;
|
2007-03-12 23:00:19 +00:00
|
|
|
const char *argv[4];
|
|
|
|
struct child_process proxy;
|
2005-11-04 14:57:16 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-03-12 23:00:19 +00:00
|
|
|
argv[0] = git_proxy_command;
|
|
|
|
argv[1] = host;
|
|
|
|
argv[2] = port;
|
|
|
|
argv[3] = NULL;
|
|
|
|
memset(&proxy, 0, sizeof(proxy));
|
|
|
|
proxy.argv = argv;
|
|
|
|
proxy.in = -1;
|
|
|
|
proxy.out = -1;
|
|
|
|
if (start_command(&proxy))
|
|
|
|
die("cannot start proxy %s", argv[0]);
|
|
|
|
fd[0] = proxy.out; /* read from proxy stdout */
|
|
|
|
fd[1] = proxy.in; /* write to proxy stdin */
|
2005-11-04 14:57:16 +00:00
|
|
|
}
|
|
|
|
|
2006-09-11 05:04:50 +00:00
|
|
|
#define MAX_CMD_LEN 1024
|
|
|
|
|
2007-09-01 09:36:31 +00:00
|
|
|
char *get_port(char *host)
|
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
char *p = strchr(host, ':');
|
|
|
|
|
|
|
|
if (p) {
|
|
|
|
strtol(p+1, &end, 10);
|
|
|
|
if (*end == '\0') {
|
|
|
|
*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
|
|
|
{
|
2007-10-30 01:05:40 +00:00
|
|
|
char *url = xstrdup(url_orig);
|
2005-11-17 19:37:14 +00:00
|
|
|
char *host, *path = url;
|
2005-12-21 10:23:42 +00:00
|
|
|
char *end;
|
|
|
|
int c;
|
2007-10-19 19:47:53 +00:00
|
|
|
struct child_process *conn;
|
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);
|
|
|
|
|
2005-11-17 19:37:14 +00:00
|
|
|
host = strstr(url, "://");
|
|
|
|
if(host) {
|
|
|
|
*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 = ':';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (host[0] == '[') {
|
|
|
|
end = strchr(host + 1, ']');
|
|
|
|
if (end) {
|
|
|
|
*end = 0;
|
|
|
|
end++;
|
|
|
|
host++;
|
|
|
|
} else
|
|
|
|
end = host;
|
|
|
|
} else
|
|
|
|
end = host;
|
|
|
|
|
|
|
|
path = strchr(end, c);
|
2007-08-01 17:03:37 +00:00
|
|
|
if (path) {
|
|
|
|
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))
|
2006-06-28 10:50:33 +00:00
|
|
|
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
|
|
|
|
* from extended components with a NUL byte.
|
|
|
|
*/
|
|
|
|
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);
|
2008-02-10 03:06:57 +00:00
|
|
|
return &no_fork;
|
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;
|
|
|
|
conn->argv = arg = xcalloc(6, sizeof(*arg));
|
|
|
|
if (protocol == PROTO_SSH) {
|
|
|
|
const char *ssh = getenv("GIT_SSH");
|
|
|
|
if (!ssh) ssh = "ssh";
|
|
|
|
|
|
|
|
*arg++ = ssh;
|
|
|
|
if (port) {
|
|
|
|
*arg++ = "-p";
|
|
|
|
*arg++ = port;
|
2005-08-03 15:15:42 +00:00
|
|
|
}
|
2007-10-19 19:47:54 +00:00
|
|
|
*arg++ = host;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* remove these from the environment */
|
|
|
|
const char *env[] = {
|
|
|
|
ALTERNATE_DB_ENVIRONMENT,
|
|
|
|
DB_ENVIRONMENT,
|
|
|
|
GIT_DIR_ENVIRONMENT,
|
|
|
|
GIT_WORK_TREE_ENVIRONMENT,
|
|
|
|
GRAFT_ENVIRONMENT,
|
|
|
|
INDEX_ENVIRONMENT,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
conn->env = env;
|
|
|
|
*arg++ = "sh";
|
|
|
|
*arg++ = "-c";
|
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
|
|
|
}
|
|
|
|
|
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;
|
2008-02-10 03:06:57 +00:00
|
|
|
if (!conn || conn == &no_fork)
|
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
|
|
|
}
|