2005-10-25 23:29:09 +00:00
|
|
|
#include "cache.h"
|
2006-12-19 22:34:12 +00:00
|
|
|
#include "pkt-line.h"
|
2006-01-11 02:12:17 +00:00
|
|
|
#include "exec_cmd.h"
|
2009-06-14 20:38:51 +00:00
|
|
|
#include "run-command.h"
|
|
|
|
#include "strbuf.h"
|
2010-08-30 11:30:51 +00:00
|
|
|
#include "string-list.h"
|
2005-09-22 09:25:28 +00:00
|
|
|
|
2006-09-28 10:00:35 +00:00
|
|
|
#ifndef HOST_NAME_MAX
|
|
|
|
#define HOST_NAME_MAX 256
|
|
|
|
#endif
|
|
|
|
|
2010-10-27 08:39:52 +00:00
|
|
|
#ifdef NO_INITGROUPS
|
|
|
|
#define initgroups(x, y) (0) /* nothing */
|
|
|
|
#endif
|
|
|
|
|
2005-09-24 14:13:01 +00:00
|
|
|
static int log_syslog;
|
2005-09-22 09:25:28 +00:00
|
|
|
static int verbose;
|
2006-02-03 20:27:04 +00:00
|
|
|
static int reuseaddr;
|
2011-10-14 21:19:21 +00:00
|
|
|
static int informative_errors;
|
2005-09-22 09:25:28 +00:00
|
|
|
|
2005-10-19 21:27:01 +00:00
|
|
|
static const char daemon_usage[] =
|
2008-07-13 13:36:15 +00:00
|
|
|
"git daemon [--verbose] [--syslog] [--export-all]\n"
|
2010-10-08 17:31:15 +00:00
|
|
|
" [--timeout=<n>] [--init-timeout=<n>] [--max-connections=<n>]\n"
|
|
|
|
" [--strict-paths] [--base-path=<path>] [--base-path-relaxed]\n"
|
|
|
|
" [--user-path | --user-path=<path>]\n"
|
|
|
|
" [--interpolated-path=<path>]\n"
|
2010-11-04 01:35:23 +00:00
|
|
|
" [--reuseaddr] [--pid-file=<file>]\n"
|
2010-10-08 17:31:15 +00:00
|
|
|
" [--(enable|disable|allow-override|forbid-override)=<service>]\n"
|
2012-08-14 18:37:51 +00:00
|
|
|
" [--access-hook=<path>]\n"
|
2010-10-08 17:31:15 +00:00
|
|
|
" [--inetd | [--listen=<host_or_ipaddr>] [--port=<n>]\n"
|
2010-11-04 01:35:23 +00:00
|
|
|
" [--detach] [--user=<user> [--group=<group>]]\n"
|
2010-10-08 17:31:15 +00:00
|
|
|
" [<directory>...]";
|
2005-09-27 02:10:55 +00:00
|
|
|
|
|
|
|
/* List of acceptable pathname prefixes */
|
2006-08-15 17:23:48 +00:00
|
|
|
static char **ok_paths;
|
|
|
|
static int strict_paths;
|
2005-09-27 02:10:55 +00:00
|
|
|
|
|
|
|
/* If this is set, git-daemon-export-ok is not required */
|
2006-08-15 17:23:48 +00:00
|
|
|
static int export_all_trees;
|
2005-09-22 09:25:28 +00:00
|
|
|
|
2005-12-23 01:27:40 +00:00
|
|
|
/* Take all paths relative to this one if non-NULL */
|
2006-08-15 17:23:48 +00:00
|
|
|
static char *base_path;
|
2006-09-20 01:31:51 +00:00
|
|
|
static char *interpolated_path;
|
2007-07-27 21:00:29 +00:00
|
|
|
static int base_path_relaxed;
|
2006-09-20 01:31:51 +00:00
|
|
|
|
|
|
|
/* Flag indicating client sent extra args. */
|
|
|
|
static int saw_extended_args;
|
2005-12-23 01:27:40 +00:00
|
|
|
|
2006-02-05 06:27:29 +00:00
|
|
|
/* If defined, ~user notation is allowed and the string is inserted
|
|
|
|
* after ~user/. E.g. a request to git://host/~alice/frotz would
|
|
|
|
* go to /home/alice/pub_git/frotz with --user-path=pub_git.
|
|
|
|
*/
|
2006-08-15 17:23:48 +00:00
|
|
|
static const char *user_path;
|
2006-02-05 06:27:29 +00:00
|
|
|
|
2005-10-19 21:27:01 +00:00
|
|
|
/* Timeout, and initial timeout */
|
2006-08-15 17:23:48 +00:00
|
|
|
static unsigned int timeout;
|
|
|
|
static unsigned int init_timeout;
|
2005-09-22 09:25:28 +00:00
|
|
|
|
2008-11-22 23:15:01 +00:00
|
|
|
static char *hostname;
|
|
|
|
static char *canon_hostname;
|
|
|
|
static char *ip_address;
|
|
|
|
static char *tcp_port;
|
2006-09-20 01:31:51 +00:00
|
|
|
|
2005-09-24 14:13:01 +00:00
|
|
|
static void logreport(int priority, const char *err, va_list params)
|
2005-09-22 09:25:28 +00:00
|
|
|
{
|
2005-09-24 14:13:01 +00:00
|
|
|
if (log_syslog) {
|
2008-08-14 18:02:20 +00:00
|
|
|
char buf[1024];
|
|
|
|
vsnprintf(buf, sizeof(buf), err, params);
|
2005-09-24 14:13:01 +00:00
|
|
|
syslog(priority, "%s", buf);
|
2008-08-24 20:27:10 +00:00
|
|
|
} else {
|
|
|
|
/*
|
2010-11-04 01:35:17 +00:00
|
|
|
* Since stderr is set to buffered mode, the
|
2008-08-14 18:02:20 +00:00
|
|
|
* logging of different processes will not overlap
|
2010-11-04 01:35:17 +00:00
|
|
|
* unless they overflow the (rather big) buffers.
|
2008-08-14 18:02:20 +00:00
|
|
|
*/
|
2008-08-31 12:09:39 +00:00
|
|
|
fprintf(stderr, "[%"PRIuMAX"] ", (uintmax_t)getpid());
|
2008-08-14 18:02:20 +00:00
|
|
|
vfprintf(stderr, err, params);
|
|
|
|
fputc('\n', stderr);
|
2010-11-04 01:35:17 +00:00
|
|
|
fflush(stderr);
|
2008-08-14 18:02:20 +00:00
|
|
|
}
|
2005-09-22 09:25:28 +00:00
|
|
|
}
|
|
|
|
|
2009-11-14 21:33:13 +00:00
|
|
|
__attribute__((format (printf, 1, 2)))
|
2005-09-29 20:53:14 +00:00
|
|
|
static void logerror(const char *err, ...)
|
2005-09-22 09:25:28 +00:00
|
|
|
{
|
|
|
|
va_list params;
|
|
|
|
va_start(params, err);
|
2005-09-24 14:13:01 +00:00
|
|
|
logreport(LOG_ERR, err, params);
|
2005-09-22 09:25:28 +00:00
|
|
|
va_end(params);
|
|
|
|
}
|
|
|
|
|
2009-11-14 21:33:13 +00:00
|
|
|
__attribute__((format (printf, 1, 2)))
|
2005-09-29 20:53:14 +00:00
|
|
|
static void loginfo(const char *err, ...)
|
2005-09-22 09:25:28 +00:00
|
|
|
{
|
|
|
|
va_list params;
|
|
|
|
if (!verbose)
|
|
|
|
return;
|
|
|
|
va_start(params, err);
|
2005-09-24 14:13:01 +00:00
|
|
|
logreport(LOG_INFO, err, params);
|
2005-09-22 09:25:28 +00:00
|
|
|
va_end(params);
|
|
|
|
}
|
2005-07-14 02:45:26 +00:00
|
|
|
|
2006-07-13 10:02:29 +00:00
|
|
|
static void NORETURN daemon_die(const char *err, va_list params)
|
|
|
|
{
|
|
|
|
logreport(LOG_ERR, err, params);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2011-10-04 20:02:00 +00:00
|
|
|
static const char *path_ok(char *directory)
|
2005-09-27 02:10:55 +00:00
|
|
|
{
|
2006-02-05 06:27:29 +00:00
|
|
|
static char rpath[PATH_MAX];
|
2006-09-20 01:31:51 +00:00
|
|
|
static char interp_path[PATH_MAX];
|
2011-10-04 20:02:00 +00:00
|
|
|
const char *path;
|
2006-09-20 01:31:51 +00:00
|
|
|
char *dir;
|
|
|
|
|
2008-11-22 23:15:01 +00:00
|
|
|
dir = directory;
|
[PATCH] daemon.c and path.enter_repo(): revamp path validation.
The whitelist of git-daemon is checked against return value from
enter_repo(), and enter_repo() used to return the value obtained
from getcwd() to avoid directory aliasing issues as discussed
earier (mid October 2005).
Unfortunately, it did not go well as we hoped.
For example, /pub on a kernel.org public machine is a symlink to
its real mountpoint, and it is understandable that the
administrator does not want to adjust the whitelist every time
/pub needs to point at a different partition for storage
allcation or whatever reasons. Being able to keep using
/pub/scm as the whitelist is a desirable property.
So this version of enter_repo() reports what it used to chdir()
and validate, but does not use getcwd() to canonicalize the
directory name. When it sees a user relative path ~user/path,
it internally resolves it to try chdir() there, but it still
reports ~user/path (possibly after appending .git if allowed to
do so, in which case it would report ~user/path.git).
What this means is that if a whitelist wants to allow a user
relative path, it needs to say "~" (for all users) or list user
home directories like "~alice" "~bob". And no, you cannot say
/home if the advertised way to access user home directories are
~alice,~bob, etc. The whole point of this is to avoid
unnecessary aliasing issues.
Anyway, because of this, daemon needs to do a bit more work to
guard itself. Namely, it needs to make sure that the accessor
does not try to exploit its leading path match rule by inserting
/../ in the middle or hanging /.. at the end. I resurrected the
belts and suspender paranoia code HPA did for this purpose.
This check cannot be done in the enter_repo() unconditionally,
because there are valid callers of enter_repo() that want to
honor /../; authorized users coming over ssh to run send-pack
and fetch-pack should be allowed to do so.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-03 09:45:57 +00:00
|
|
|
|
2009-11-09 19:26:43 +00:00
|
|
|
if (daemon_avoid_alias(dir)) {
|
[PATCH] daemon.c and path.enter_repo(): revamp path validation.
The whitelist of git-daemon is checked against return value from
enter_repo(), and enter_repo() used to return the value obtained
from getcwd() to avoid directory aliasing issues as discussed
earier (mid October 2005).
Unfortunately, it did not go well as we hoped.
For example, /pub on a kernel.org public machine is a symlink to
its real mountpoint, and it is understandable that the
administrator does not want to adjust the whitelist every time
/pub needs to point at a different partition for storage
allcation or whatever reasons. Being able to keep using
/pub/scm as the whitelist is a desirable property.
So this version of enter_repo() reports what it used to chdir()
and validate, but does not use getcwd() to canonicalize the
directory name. When it sees a user relative path ~user/path,
it internally resolves it to try chdir() there, but it still
reports ~user/path (possibly after appending .git if allowed to
do so, in which case it would report ~user/path.git).
What this means is that if a whitelist wants to allow a user
relative path, it needs to say "~" (for all users) or list user
home directories like "~alice" "~bob". And no, you cannot say
/home if the advertised way to access user home directories are
~alice,~bob, etc. The whole point of this is to avoid
unnecessary aliasing issues.
Anyway, because of this, daemon needs to do a bit more work to
guard itself. Namely, it needs to make sure that the accessor
does not try to exploit its leading path match rule by inserting
/../ in the middle or hanging /.. at the end. I resurrected the
belts and suspender paranoia code HPA did for this purpose.
This check cannot be done in the enter_repo() unconditionally,
because there are valid callers of enter_repo() that want to
honor /../; authorized users coming over ssh to run send-pack
and fetch-pack should be allowed to do so.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-03 09:45:57 +00:00
|
|
|
logerror("'%s': aliased", dir);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-02-05 06:27:29 +00:00
|
|
|
if (*dir == '~') {
|
|
|
|
if (!user_path) {
|
|
|
|
logerror("'%s': User-path not allowed", dir);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (*user_path) {
|
|
|
|
/* Got either "~alice" or "~alice/foo";
|
|
|
|
* rewrite them to "~alice/%s" or
|
|
|
|
* "~alice/%s/foo".
|
|
|
|
*/
|
|
|
|
int namlen, restlen = strlen(dir);
|
|
|
|
char *slash = strchr(dir, '/');
|
|
|
|
if (!slash)
|
|
|
|
slash = dir + restlen;
|
|
|
|
namlen = slash - dir;
|
|
|
|
restlen -= namlen;
|
|
|
|
loginfo("userpath <%s>, request <%s>, namlen %d, restlen %d, slash <%s>", user_path, dir, namlen, restlen, slash);
|
|
|
|
snprintf(rpath, PATH_MAX, "%.*s/%s%.*s",
|
|
|
|
namlen, dir, user_path, restlen, slash);
|
|
|
|
dir = rpath;
|
|
|
|
}
|
|
|
|
}
|
2006-09-20 01:31:51 +00:00
|
|
|
else if (interpolated_path && saw_extended_args) {
|
2008-11-22 23:15:01 +00:00
|
|
|
struct strbuf expanded_path = STRBUF_INIT;
|
2010-05-14 09:31:33 +00:00
|
|
|
struct strbuf_expand_dict_entry dict[6];
|
|
|
|
|
|
|
|
dict[0].placeholder = "H"; dict[0].value = hostname;
|
|
|
|
dict[1].placeholder = "CH"; dict[1].value = canon_hostname;
|
|
|
|
dict[2].placeholder = "IP"; dict[2].value = ip_address;
|
|
|
|
dict[3].placeholder = "P"; dict[3].value = tcp_port;
|
|
|
|
dict[4].placeholder = "D"; dict[4].value = directory;
|
|
|
|
dict[5].placeholder = NULL; dict[5].value = NULL;
|
2006-09-20 01:31:51 +00:00
|
|
|
if (*dir != '/') {
|
|
|
|
/* Allow only absolute */
|
|
|
|
logerror("'%s': Non-absolute path denied (interpolated-path active)", dir);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-11-22 23:15:01 +00:00
|
|
|
strbuf_expand(&expanded_path, interpolated_path,
|
|
|
|
strbuf_expand_dict_cb, &dict);
|
|
|
|
strlcpy(interp_path, expanded_path.buf, PATH_MAX);
|
|
|
|
strbuf_release(&expanded_path);
|
2006-09-20 01:31:51 +00:00
|
|
|
loginfo("Interpolated dir '%s'", interp_path);
|
|
|
|
|
|
|
|
dir = interp_path;
|
|
|
|
}
|
2006-02-05 06:27:29 +00:00
|
|
|
else if (base_path) {
|
|
|
|
if (*dir != '/') {
|
|
|
|
/* Allow only absolute */
|
2006-02-03 20:27:02 +00:00
|
|
|
logerror("'%s': Non-absolute path denied (base-path active)", dir);
|
2005-12-23 01:27:40 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2006-09-20 01:31:51 +00:00
|
|
|
snprintf(rpath, PATH_MAX, "%s%s", base_path, dir);
|
|
|
|
dir = rpath;
|
2005-12-23 01:27:40 +00:00
|
|
|
}
|
|
|
|
|
2008-12-26 10:01:57 +00:00
|
|
|
path = enter_repo(dir, strict_paths);
|
|
|
|
if (!path && base_path && base_path_relaxed) {
|
2007-07-27 21:00:29 +00:00
|
|
|
/*
|
|
|
|
* if we fail and base_path_relaxed is enabled, try without
|
|
|
|
* prefixing the base path
|
|
|
|
*/
|
2008-12-26 10:01:57 +00:00
|
|
|
dir = directory;
|
|
|
|
path = enter_repo(dir, strict_paths);
|
|
|
|
}
|
2005-10-19 01:26:52 +00:00
|
|
|
|
2005-11-17 19:37:14 +00:00
|
|
|
if (!path) {
|
2009-03-04 08:32:29 +00:00
|
|
|
logerror("'%s' does not appear to be a git repository", dir);
|
2005-11-17 19:37:14 +00:00
|
|
|
return NULL;
|
2005-09-27 02:10:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ( ok_paths && *ok_paths ) {
|
2005-11-21 09:21:18 +00:00
|
|
|
char **pp;
|
2005-11-17 19:37:14 +00:00
|
|
|
int pathlen = strlen(path);
|
2005-09-27 02:10:55 +00:00
|
|
|
|
2005-11-21 09:21:18 +00:00
|
|
|
/* The validation is done on the paths after enter_repo
|
2007-06-07 07:04:01 +00:00
|
|
|
* appends optional {.git,.git/.git} and friends, but
|
[PATCH] daemon.c and path.enter_repo(): revamp path validation.
The whitelist of git-daemon is checked against return value from
enter_repo(), and enter_repo() used to return the value obtained
from getcwd() to avoid directory aliasing issues as discussed
earier (mid October 2005).
Unfortunately, it did not go well as we hoped.
For example, /pub on a kernel.org public machine is a symlink to
its real mountpoint, and it is understandable that the
administrator does not want to adjust the whitelist every time
/pub needs to point at a different partition for storage
allcation or whatever reasons. Being able to keep using
/pub/scm as the whitelist is a desirable property.
So this version of enter_repo() reports what it used to chdir()
and validate, but does not use getcwd() to canonicalize the
directory name. When it sees a user relative path ~user/path,
it internally resolves it to try chdir() there, but it still
reports ~user/path (possibly after appending .git if allowed to
do so, in which case it would report ~user/path.git).
What this means is that if a whitelist wants to allow a user
relative path, it needs to say "~" (for all users) or list user
home directories like "~alice" "~bob". And no, you cannot say
/home if the advertised way to access user home directories are
~alice,~bob, etc. The whole point of this is to avoid
unnecessary aliasing issues.
Anyway, because of this, daemon needs to do a bit more work to
guard itself. Namely, it needs to make sure that the accessor
does not try to exploit its leading path match rule by inserting
/../ in the middle or hanging /.. at the end. I resurrected the
belts and suspender paranoia code HPA did for this purpose.
This check cannot be done in the enter_repo() unconditionally,
because there are valid callers of enter_repo() that want to
honor /../; authorized users coming over ssh to run send-pack
and fetch-pack should be allowed to do so.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-03 09:45:57 +00:00
|
|
|
* it does not use getcwd(). So if your /pub is
|
|
|
|
* a symlink to /mnt/pub, you can whitelist /pub and
|
|
|
|
* do not have to say /mnt/pub.
|
|
|
|
* Do not say /pub/.
|
2005-11-21 09:21:18 +00:00
|
|
|
*/
|
2005-09-27 02:10:55 +00:00
|
|
|
for ( pp = ok_paths ; *pp ; pp++ ) {
|
|
|
|
int len = strlen(*pp);
|
2005-11-21 09:21:18 +00:00
|
|
|
if (len <= pathlen &&
|
|
|
|
!memcmp(*pp, path, len) &&
|
|
|
|
(path[len] == '\0' ||
|
|
|
|
(!strict_paths && path[len] == '/')))
|
|
|
|
return path;
|
2005-09-27 02:10:55 +00:00
|
|
|
}
|
2005-11-17 19:37:14 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* be backwards compatible */
|
|
|
|
if (!strict_paths)
|
|
|
|
return path;
|
2005-09-27 02:10:55 +00:00
|
|
|
}
|
|
|
|
|
2005-11-17 19:37:14 +00:00
|
|
|
logerror("'%s': not in whitelist", path);
|
|
|
|
return NULL; /* Fallthrough. Deny by default */
|
2005-09-27 02:10:55 +00:00
|
|
|
}
|
2005-07-14 02:45:26 +00:00
|
|
|
|
2006-08-21 02:03:13 +00:00
|
|
|
typedef int (*daemon_service_fn)(void);
|
|
|
|
struct daemon_service {
|
|
|
|
const char *name;
|
|
|
|
const char *config_name;
|
|
|
|
daemon_service_fn fn;
|
|
|
|
int enabled;
|
|
|
|
int overridable;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct daemon_service *service_looking_at;
|
|
|
|
static int service_enabled;
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int git_daemon_config(const char *var, const char *value, void *cb)
|
2006-08-21 02:03:13 +00:00
|
|
|
{
|
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(var, "daemon.") &&
|
2006-08-21 02:03:13 +00:00
|
|
|
!strcmp(var + 7, service_looking_at->config_name)) {
|
|
|
|
service_enabled = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we are not interested in parsing any other configuration here */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-14 21:19:21 +00:00
|
|
|
static int daemon_error(const char *dir, const char *msg)
|
|
|
|
{
|
|
|
|
if (!informative_errors)
|
|
|
|
msg = "access denied or repository not exported";
|
|
|
|
packet_write(1, "ERR %s: %s", msg, dir);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-08-14 18:37:51 +00:00
|
|
|
static char *access_hook;
|
|
|
|
|
|
|
|
static int run_access_hook(struct daemon_service *service, const char *dir, const char *path)
|
|
|
|
{
|
|
|
|
struct child_process child;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
const char *argv[8];
|
|
|
|
const char **arg = argv;
|
|
|
|
char *eol;
|
|
|
|
int seen_errors = 0;
|
|
|
|
|
|
|
|
#define STRARG(x) ((x) ? (x) : "")
|
|
|
|
*arg++ = access_hook;
|
|
|
|
*arg++ = service->name;
|
|
|
|
*arg++ = path;
|
|
|
|
*arg++ = STRARG(hostname);
|
|
|
|
*arg++ = STRARG(canon_hostname);
|
|
|
|
*arg++ = STRARG(ip_address);
|
|
|
|
*arg++ = STRARG(tcp_port);
|
|
|
|
*arg = NULL;
|
|
|
|
#undef STRARG
|
|
|
|
|
|
|
|
memset(&child, 0, sizeof(child));
|
|
|
|
child.use_shell = 1;
|
|
|
|
child.argv = argv;
|
|
|
|
child.no_stdin = 1;
|
|
|
|
child.no_stderr = 1;
|
|
|
|
child.out = -1;
|
|
|
|
if (start_command(&child)) {
|
|
|
|
logerror("daemon access hook '%s' failed to start",
|
|
|
|
access_hook);
|
|
|
|
goto error_return;
|
|
|
|
}
|
|
|
|
if (strbuf_read(&buf, child.out, 0) < 0) {
|
|
|
|
logerror("failed to read from pipe to daemon access hook '%s'",
|
|
|
|
access_hook);
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
seen_errors = 1;
|
|
|
|
}
|
|
|
|
if (close(child.out) < 0) {
|
|
|
|
logerror("failed to close pipe to daemon access hook '%s'",
|
|
|
|
access_hook);
|
|
|
|
seen_errors = 1;
|
|
|
|
}
|
|
|
|
if (finish_command(&child))
|
|
|
|
seen_errors = 1;
|
|
|
|
|
|
|
|
if (!seen_errors) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
error_return:
|
|
|
|
strbuf_ltrim(&buf);
|
|
|
|
if (!buf.len)
|
|
|
|
strbuf_addstr(&buf, "service rejected");
|
|
|
|
eol = strchr(buf.buf, '\n');
|
|
|
|
if (eol)
|
|
|
|
*eol = '\0';
|
|
|
|
errno = EACCES;
|
|
|
|
daemon_error(dir, buf.buf);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-11-22 23:21:52 +00:00
|
|
|
static int run_service(char *dir, struct daemon_service *service)
|
2005-07-14 02:45:26 +00:00
|
|
|
{
|
2005-11-17 19:37:14 +00:00
|
|
|
const char *path;
|
2006-08-21 02:03:13 +00:00
|
|
|
int enabled = service->enabled;
|
|
|
|
|
2008-11-22 23:21:52 +00:00
|
|
|
loginfo("Request %s for '%s'", service->name, dir);
|
2005-11-17 19:37:14 +00:00
|
|
|
|
2006-08-21 02:03:13 +00:00
|
|
|
if (!enabled && !service->overridable) {
|
|
|
|
logerror("'%s': service not enabled.", service->name);
|
|
|
|
errno = EACCES;
|
2011-10-14 21:19:21 +00:00
|
|
|
return daemon_error(dir, "service not enabled");
|
2006-08-21 02:03:13 +00:00
|
|
|
}
|
2005-09-27 02:10:55 +00:00
|
|
|
|
2008-11-22 23:21:52 +00:00
|
|
|
if (!(path = path_ok(dir)))
|
2011-10-14 21:19:21 +00:00
|
|
|
return daemon_error(dir, "no such repository");
|
2005-09-27 15:49:40 +00:00
|
|
|
|
2005-07-14 02:45:26 +00:00
|
|
|
/*
|
|
|
|
* Security on the cheap.
|
|
|
|
*
|
2005-10-21 06:19:36 +00:00
|
|
|
* We want a readable HEAD, usable "objects" directory, and
|
2005-07-14 02:45:26 +00:00
|
|
|
* a "git-daemon-export-ok" flag that says that the other side
|
|
|
|
* is ok with us doing this.
|
2005-11-17 19:37:14 +00:00
|
|
|
*
|
|
|
|
* path_ok() uses enter_repo() and does whitelist checking.
|
|
|
|
* We only need to make sure the repository is exported.
|
2005-07-14 02:45:26 +00:00
|
|
|
*/
|
2005-11-17 19:37:14 +00:00
|
|
|
|
2005-10-19 01:26:52 +00:00
|
|
|
if (!export_all_trees && access("git-daemon-export-ok", F_OK)) {
|
2005-11-17 19:37:14 +00:00
|
|
|
logerror("'%s': repository not exported.", path);
|
2005-10-19 01:26:52 +00:00
|
|
|
errno = EACCES;
|
2011-10-14 21:19:21 +00:00
|
|
|
return daemon_error(dir, "repository not exported");
|
2005-10-19 01:26:52 +00:00
|
|
|
}
|
|
|
|
|
2006-08-21 02:03:13 +00:00
|
|
|
if (service->overridable) {
|
|
|
|
service_looking_at = service;
|
|
|
|
service_enabled = -1;
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_daemon_config, NULL);
|
2006-08-21 02:03:13 +00:00
|
|
|
if (0 <= service_enabled)
|
|
|
|
enabled = service_enabled;
|
|
|
|
}
|
|
|
|
if (!enabled) {
|
|
|
|
logerror("'%s': service not enabled for '%s'",
|
|
|
|
service->name, path);
|
|
|
|
errno = EACCES;
|
2011-10-14 21:19:21 +00:00
|
|
|
return daemon_error(dir, "service not enabled");
|
2006-08-21 02:03:13 +00:00
|
|
|
}
|
|
|
|
|
2012-08-14 18:37:51 +00:00
|
|
|
/*
|
|
|
|
* Optionally, a hook can choose to deny access to the
|
|
|
|
* repository depending on the phase of the moon.
|
|
|
|
*/
|
|
|
|
if (access_hook && run_access_hook(service, dir, path))
|
|
|
|
return -1;
|
|
|
|
|
2005-07-16 05:53:31 +00:00
|
|
|
/*
|
|
|
|
* We'll ignore SIGTERM from now on, we have a
|
|
|
|
* good client.
|
|
|
|
*/
|
|
|
|
signal(SIGTERM, SIG_IGN);
|
|
|
|
|
2006-08-21 02:03:13 +00:00
|
|
|
return service->fn();
|
|
|
|
}
|
|
|
|
|
2009-06-14 20:38:51 +00:00
|
|
|
static void copy_to_log(int fd)
|
|
|
|
{
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
FILE *fp;
|
|
|
|
|
|
|
|
fp = fdopen(fd, "r");
|
|
|
|
if (fp == NULL) {
|
|
|
|
logerror("fdopen of error channel failed");
|
|
|
|
close(fd);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (strbuf_getline(&line, fp, '\n') != EOF) {
|
|
|
|
logerror("%s", line.buf);
|
|
|
|
strbuf_setlen(&line, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_release(&line);
|
|
|
|
fclose(fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int run_service_command(const char **argv)
|
|
|
|
{
|
|
|
|
struct child_process cld;
|
|
|
|
|
|
|
|
memset(&cld, 0, sizeof(cld));
|
|
|
|
cld.argv = argv;
|
|
|
|
cld.git_cmd = 1;
|
|
|
|
cld.err = -1;
|
|
|
|
if (start_command(&cld))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
close(0);
|
|
|
|
close(1);
|
|
|
|
|
|
|
|
copy_to_log(cld.err);
|
|
|
|
|
|
|
|
return finish_command(&cld);
|
|
|
|
}
|
|
|
|
|
2006-08-21 02:03:13 +00:00
|
|
|
static int upload_pack(void)
|
|
|
|
{
|
|
|
|
/* Timeout as string */
|
|
|
|
char timeout_buf[64];
|
2010-05-14 09:31:33 +00:00
|
|
|
const char *argv[] = { "upload-pack", "--strict", NULL, ".", NULL };
|
|
|
|
|
|
|
|
argv[2] = timeout_buf;
|
2006-08-21 02:03:13 +00:00
|
|
|
|
2005-10-19 21:27:01 +00:00
|
|
|
snprintf(timeout_buf, sizeof timeout_buf, "--timeout=%u", timeout);
|
2009-06-14 20:38:51 +00:00
|
|
|
return run_service_command(argv);
|
2005-07-14 02:45:26 +00:00
|
|
|
}
|
|
|
|
|
2006-09-07 13:12:05 +00:00
|
|
|
static int upload_archive(void)
|
|
|
|
{
|
2009-06-14 20:38:51 +00:00
|
|
|
static const char *argv[] = { "upload-archive", ".", NULL };
|
|
|
|
return run_service_command(argv);
|
2006-09-07 13:12:05 +00:00
|
|
|
}
|
|
|
|
|
2007-01-21 19:04:13 +00:00
|
|
|
static int receive_pack(void)
|
|
|
|
{
|
2009-06-14 20:38:51 +00:00
|
|
|
static const char *argv[] = { "receive-pack", ".", NULL };
|
|
|
|
return run_service_command(argv);
|
2007-01-21 19:04:13 +00:00
|
|
|
}
|
|
|
|
|
2006-08-21 02:03:13 +00:00
|
|
|
static struct daemon_service daemon_service[] = {
|
2006-09-07 13:12:05 +00:00
|
|
|
{ "upload-archive", "uploadarch", upload_archive, 0, 1 },
|
2006-08-21 02:03:13 +00:00
|
|
|
{ "upload-pack", "uploadpack", upload_pack, 1, 1 },
|
2007-01-21 19:04:13 +00:00
|
|
|
{ "receive-pack", "receivepack", receive_pack, 0, 1 },
|
2006-08-21 02:03:13 +00:00
|
|
|
};
|
|
|
|
|
2007-11-08 23:35:32 +00:00
|
|
|
static void enable_service(const char *name, int ena)
|
|
|
|
{
|
2006-08-21 02:03:13 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(daemon_service); i++) {
|
|
|
|
if (!strcmp(daemon_service[i].name, name)) {
|
|
|
|
daemon_service[i].enabled = ena;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
die("No such service %s", name);
|
|
|
|
}
|
|
|
|
|
2007-11-08 23:35:32 +00:00
|
|
|
static void make_service_overridable(const char *name, int ena)
|
|
|
|
{
|
2006-08-21 02:03:13 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(daemon_service); i++) {
|
|
|
|
if (!strcmp(daemon_service[i].name, name)) {
|
|
|
|
daemon_service[i].overridable = ena;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
die("No such service %s", name);
|
|
|
|
}
|
|
|
|
|
2008-12-26 10:12:15 +00:00
|
|
|
static char *xstrdup_tolower(const char *str)
|
|
|
|
{
|
|
|
|
char *p, *dup = xstrdup(str);
|
|
|
|
for (p = dup; *p; p++)
|
|
|
|
*p = tolower(*p);
|
|
|
|
return dup;
|
|
|
|
}
|
|
|
|
|
2010-01-26 18:24:41 +00:00
|
|
|
static void parse_host_and_port(char *hostport, char **host,
|
|
|
|
char **port)
|
|
|
|
{
|
|
|
|
if (*hostport == '[') {
|
|
|
|
char *end;
|
|
|
|
|
|
|
|
end = strchr(hostport, ']');
|
|
|
|
if (!end)
|
2010-02-04 05:23:18 +00:00
|
|
|
die("Invalid request ('[' without ']')");
|
2010-01-26 18:24:41 +00:00
|
|
|
*end = '\0';
|
|
|
|
*host = hostport + 1;
|
|
|
|
if (!end[1])
|
|
|
|
*port = NULL;
|
|
|
|
else if (end[1] == ':')
|
|
|
|
*port = end + 2;
|
|
|
|
else
|
|
|
|
die("Garbage after end of host part");
|
|
|
|
} else {
|
|
|
|
*host = hostport;
|
|
|
|
*port = strrchr(hostport, ':');
|
|
|
|
if (*port) {
|
2010-03-20 02:23:58 +00:00
|
|
|
**port = '\0';
|
2010-01-26 18:24:41 +00:00
|
|
|
++*port;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-27 16:16:10 +00:00
|
|
|
/*
|
2009-06-05 01:33:32 +00:00
|
|
|
* Read the host as supplied by the client connection.
|
2006-09-27 16:16:10 +00:00
|
|
|
*/
|
2009-06-05 01:33:32 +00:00
|
|
|
static void parse_host_arg(char *extra_args, int buflen)
|
2006-09-20 01:31:51 +00:00
|
|
|
{
|
|
|
|
char *val;
|
|
|
|
int vallen;
|
|
|
|
char *end = extra_args + buflen;
|
|
|
|
|
2009-06-05 01:33:32 +00:00
|
|
|
if (extra_args < end && *extra_args) {
|
2006-09-20 01:31:51 +00:00
|
|
|
saw_extended_args = 1;
|
|
|
|
if (strncasecmp("host=", extra_args, 5) == 0) {
|
|
|
|
val = extra_args + 5;
|
|
|
|
vallen = strlen(val) + 1;
|
|
|
|
if (*val) {
|
2006-09-27 16:16:10 +00:00
|
|
|
/* Split <host>:<port> at colon. */
|
2010-01-26 18:24:41 +00:00
|
|
|
char *host;
|
|
|
|
char *port;
|
|
|
|
parse_host_and_port(val, &host, &port);
|
2006-09-26 14:47:43 +00:00
|
|
|
if (port) {
|
2008-11-22 23:15:01 +00:00
|
|
|
free(tcp_port);
|
|
|
|
tcp_port = xstrdup(port);
|
2006-09-26 14:47:43 +00:00
|
|
|
}
|
2008-11-22 23:15:01 +00:00
|
|
|
free(hostname);
|
2008-12-26 10:12:15 +00:00
|
|
|
hostname = xstrdup_tolower(host);
|
2006-09-20 01:31:51 +00:00
|
|
|
}
|
2006-09-27 16:16:10 +00:00
|
|
|
|
2006-09-20 01:31:51 +00:00
|
|
|
/* On to the next one */
|
|
|
|
extra_args = val + vallen;
|
|
|
|
}
|
2009-06-05 01:33:32 +00:00
|
|
|
if (extra_args < end && *extra_args)
|
|
|
|
die("Invalid request");
|
2006-09-20 01:31:51 +00:00
|
|
|
}
|
2006-09-26 14:47:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Locate canonical hostname and its IP address.
|
|
|
|
*/
|
2008-12-26 10:12:15 +00:00
|
|
|
if (hostname) {
|
2006-09-26 14:47:43 +00:00
|
|
|
#ifndef NO_IPV6
|
|
|
|
struct addrinfo hints;
|
2009-04-27 13:59:49 +00:00
|
|
|
struct addrinfo *ai;
|
2006-09-26 14:47:43 +00:00
|
|
|
int gai;
|
|
|
|
static char addrbuf[HOST_NAME_MAX + 1];
|
|
|
|
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_flags = AI_CANONNAME;
|
|
|
|
|
2009-06-18 17:28:43 +00:00
|
|
|
gai = getaddrinfo(hostname, NULL, &hints, &ai);
|
2006-09-26 14:47:43 +00:00
|
|
|
if (!gai) {
|
2009-04-27 13:59:49 +00:00
|
|
|
struct sockaddr_in *sin_addr = (void *)ai->ai_addr;
|
|
|
|
|
|
|
|
inet_ntop(AF_INET, &sin_addr->sin_addr,
|
|
|
|
addrbuf, sizeof(addrbuf));
|
|
|
|
free(ip_address);
|
|
|
|
ip_address = xstrdup(addrbuf);
|
|
|
|
|
|
|
|
free(canon_hostname);
|
|
|
|
canon_hostname = xstrdup(ai->ai_canonname ?
|
|
|
|
ai->ai_canonname : ip_address);
|
|
|
|
|
|
|
|
freeaddrinfo(ai);
|
2006-09-26 14:47:43 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
struct hostent *hent;
|
|
|
|
struct sockaddr_in sa;
|
|
|
|
char **ap;
|
|
|
|
static char addrbuf[HOST_NAME_MAX + 1];
|
|
|
|
|
2008-11-22 23:15:01 +00:00
|
|
|
hent = gethostbyname(hostname);
|
2006-09-26 14:47:43 +00:00
|
|
|
|
|
|
|
ap = hent->h_addr_list;
|
|
|
|
memset(&sa, 0, sizeof sa);
|
|
|
|
sa.sin_family = hent->h_addrtype;
|
|
|
|
sa.sin_port = htons(0);
|
|
|
|
memcpy(&sa.sin_addr, *ap, hent->h_length);
|
|
|
|
|
|
|
|
inet_ntop(hent->h_addrtype, &sa.sin_addr,
|
|
|
|
addrbuf, sizeof(addrbuf));
|
2006-09-27 16:16:10 +00:00
|
|
|
|
2008-11-22 23:15:01 +00:00
|
|
|
free(canon_hostname);
|
|
|
|
canon_hostname = xstrdup(hent->h_name);
|
|
|
|
free(ip_address);
|
|
|
|
ip_address = xstrdup(addrbuf);
|
2006-09-26 14:47:43 +00:00
|
|
|
#endif
|
2008-12-26 10:12:15 +00:00
|
|
|
}
|
2006-09-26 14:47:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-04 01:35:19 +00:00
|
|
|
static int execute(void)
|
2005-07-14 02:45:26 +00:00
|
|
|
{
|
pkt-line: provide a LARGE_PACKET_MAX static buffer
Most of the callers of packet_read_line just read into a
static 1000-byte buffer (callers which handle arbitrary
binary data already use LARGE_PACKET_MAX). This works fine
in practice, because:
1. The only variable-sized data in these lines is a ref
name, and refs tend to be a lot shorter than 1000
characters.
2. When sending ref lines, git-core always limits itself
to 1000 byte packets.
However, the only limit given in the protocol specification
in Documentation/technical/protocol-common.txt is
LARGE_PACKET_MAX; the 1000 byte limit is mentioned only in
pack-protocol.txt, and then only describing what we write,
not as a specific limit for readers.
This patch lets us bump the 1000-byte limit to
LARGE_PACKET_MAX. Even though git-core will never write a
packet where this makes a difference, there are two good
reasons to do this:
1. Other git implementations may have followed
protocol-common.txt and used a larger maximum size. We
don't bump into it in practice because it would involve
very long ref names.
2. We may want to increase the 1000-byte limit one day.
Since packets are transferred before any capabilities,
it's difficult to do this in a backwards-compatible
way. But if we bump the size of buffer the readers can
handle, eventually older versions of git will be
obsolete enough that we can justify bumping the
writers, as well. We don't have plans to do this
anytime soon, but there is no reason not to start the
clock ticking now.
Just bumping all of the reading bufs to LARGE_PACKET_MAX
would waste memory. Instead, since most readers just read
into a temporary buffer anyway, let's provide a single
static buffer that all callers can use. We can further wrap
this detail away by having the packet_read_line wrapper just
use the buffer transparently and return a pointer to the
static storage. That covers most of the cases, and the
remaining ones already read into their own LARGE_PACKET_MAX
buffers.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 20:02:57 +00:00
|
|
|
char *line = packet_buffer;
|
2006-08-21 02:03:13 +00:00
|
|
|
int pktlen, len, i;
|
2010-11-04 01:35:19 +00:00
|
|
|
char *addr = getenv("REMOTE_ADDR"), *port = getenv("REMOTE_PORT");
|
2005-07-15 16:27:05 +00:00
|
|
|
|
2010-11-04 01:35:19 +00:00
|
|
|
if (addr)
|
|
|
|
loginfo("Connection from %s:%s", addr, port);
|
2006-06-20 14:38:13 +00:00
|
|
|
|
2005-10-19 21:27:01 +00:00
|
|
|
alarm(init_timeout ? init_timeout : timeout);
|
pkt-line: share buffer/descriptor reading implementation
The packet_read function reads from a descriptor. The
packet_get_line function is similar, but reads from an
in-memory buffer, and uses a completely separate
implementation. This patch teaches the generic packet_read
function to accept either source, and we can do away with
packet_get_line's implementation.
There are two other differences to account for between the
old and new functions. The first is that we used to read
into a strbuf, but now read into a fixed size buffer. The
only two callers are fine with that, and in fact it
simplifies their code, since they can use the same
static-buffer interface as the rest of the packet_read_line
callers (and we provide a similar convenience wrapper for
reading from a buffer rather than a descriptor).
This is technically an externally-visible behavior change in
that we used to accept arbitrary sized packets up to 65532
bytes, and now cap out at LARGE_PACKET_MAX, 65520. In
practice this doesn't matter, as we use it only for parsing
smart-http headers (of which there is exactly one defined,
and it is small and fixed-size). And any extension headers
would be breaking the protocol to go over LARGE_PACKET_MAX
anyway.
The other difference is that packet_get_line would return
on error rather than dying. However, both callers of
packet_get_line are actually improved by dying.
The first caller does its own error checking, but we can
drop that; as a result, we'll actually get more specific
reporting about protocol breakage when packet_read dies
internally. The only downside is that packet_read will not
print the smart-http URL that failed, but that's not a big
deal; anybody not debugging can already see the remote's URL
already, and anybody debugging would want to run with
GIT_CURL_VERBOSE anyway to see way more information.
The second caller, which is just trying to skip past any
extra smart-http headers (of which there are none defined,
but which we allow to keep room for future expansion), did
not error check at all. As a result, it would treat an error
just like a flush packet. The resulting mess would generally
cause an error later in get_remote_heads, but now we get
error reporting much closer to the source of the problem.
Brown-paper-bag-fixes-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-23 22:31:34 +00:00
|
|
|
pktlen = packet_read(0, NULL, NULL, packet_buffer, sizeof(packet_buffer), 0);
|
2005-10-19 21:27:01 +00:00
|
|
|
alarm(0);
|
2005-07-15 16:27:05 +00:00
|
|
|
|
2006-06-07 03:58:41 +00:00
|
|
|
len = strlen(line);
|
|
|
|
if (pktlen != len)
|
|
|
|
loginfo("Extended attributes (%d bytes) exist <%.*s>",
|
|
|
|
(int) pktlen - len,
|
|
|
|
(int) pktlen - len, line + len + 1);
|
2006-10-24 01:26:05 +00:00
|
|
|
if (len && line[len-1] == '\n') {
|
2005-07-15 16:27:05 +00:00
|
|
|
line[--len] = 0;
|
2006-10-24 01:26:05 +00:00
|
|
|
pktlen--;
|
|
|
|
}
|
2005-07-15 16:27:05 +00:00
|
|
|
|
2008-11-22 23:15:01 +00:00
|
|
|
free(hostname);
|
|
|
|
free(canon_hostname);
|
|
|
|
free(ip_address);
|
|
|
|
free(tcp_port);
|
2008-11-22 23:21:52 +00:00
|
|
|
hostname = canon_hostname = ip_address = tcp_port = NULL;
|
2006-09-27 16:16:10 +00:00
|
|
|
|
2008-11-22 23:19:09 +00:00
|
|
|
if (len != pktlen)
|
2009-06-05 01:33:32 +00:00
|
|
|
parse_host_arg(line + len + 1, pktlen - len - 1);
|
2006-09-20 01:31:51 +00:00
|
|
|
|
2006-08-21 02:03:13 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(daemon_service); i++) {
|
|
|
|
struct daemon_service *s = &(daemon_service[i]);
|
|
|
|
int namelen = strlen(s->name);
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(line, "git-") &&
|
2006-08-21 02:03:13 +00:00
|
|
|
!strncmp(s->name, line + 4, namelen) &&
|
2006-09-20 01:31:51 +00:00
|
|
|
line[namelen + 4] == ' ') {
|
2006-09-27 16:16:10 +00:00
|
|
|
/*
|
|
|
|
* Note: The directory here is probably context sensitive,
|
|
|
|
* and might depend on the actual service being performed.
|
|
|
|
*/
|
2008-11-22 23:21:52 +00:00
|
|
|
return run_service(line + namelen + 5, s);
|
2006-09-20 01:31:51 +00:00
|
|
|
}
|
2006-08-21 02:03:13 +00:00
|
|
|
}
|
2005-07-14 02:45:26 +00:00
|
|
|
|
2005-09-22 09:25:28 +00:00
|
|
|
logerror("Protocol error: '%s'", line);
|
2005-07-14 02:45:26 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-01-09 14:13:28 +00:00
|
|
|
static int addrcmp(const struct sockaddr_storage *s1,
|
|
|
|
const struct sockaddr_storage *s2)
|
|
|
|
{
|
2010-03-15 22:10:06 +00:00
|
|
|
const struct sockaddr *sa1 = (const struct sockaddr*) s1;
|
|
|
|
const struct sockaddr *sa2 = (const struct sockaddr*) s2;
|
|
|
|
|
|
|
|
if (sa1->sa_family != sa2->sa_family)
|
|
|
|
return sa1->sa_family - sa2->sa_family;
|
|
|
|
if (sa1->sa_family == AF_INET)
|
2010-01-09 14:13:28 +00:00
|
|
|
return memcmp(&((struct sockaddr_in *)s1)->sin_addr,
|
|
|
|
&((struct sockaddr_in *)s2)->sin_addr,
|
|
|
|
sizeof(struct in_addr));
|
|
|
|
#ifndef NO_IPV6
|
2010-03-15 22:10:06 +00:00
|
|
|
if (sa1->sa_family == AF_INET6)
|
2010-01-09 14:13:28 +00:00
|
|
|
return memcmp(&((struct sockaddr_in6 *)s1)->sin6_addr,
|
|
|
|
&((struct sockaddr_in6 *)s2)->sin6_addr,
|
|
|
|
sizeof(struct in6_addr));
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-14 18:02:20 +00:00
|
|
|
static int max_connections = 32;
|
2005-07-16 04:51:57 +00:00
|
|
|
|
2008-08-14 18:02:20 +00:00
|
|
|
static unsigned int live_children;
|
2005-07-16 04:51:57 +00:00
|
|
|
|
2005-08-01 19:11:53 +00:00
|
|
|
static struct child {
|
2008-08-14 18:02:20 +00:00
|
|
|
struct child *next;
|
2010-11-04 01:35:16 +00:00
|
|
|
struct child_process cld;
|
2005-07-23 08:24:59 +00:00
|
|
|
struct sockaddr_storage address;
|
2008-08-14 18:02:20 +00:00
|
|
|
} *firstborn;
|
2005-07-16 04:51:57 +00:00
|
|
|
|
2010-11-04 01:35:22 +00:00
|
|
|
static void add_child(struct child_process *cld, struct sockaddr *addr, socklen_t addrlen)
|
2005-07-16 04:51:57 +00:00
|
|
|
{
|
2008-08-24 20:27:10 +00:00
|
|
|
struct child *newborn, **cradle;
|
|
|
|
|
|
|
|
newborn = xcalloc(1, sizeof(*newborn));
|
|
|
|
live_children++;
|
2010-11-04 01:35:16 +00:00
|
|
|
memcpy(&newborn->cld, cld, sizeof(*cld));
|
2008-08-24 20:27:10 +00:00
|
|
|
memcpy(&newborn->address, addr, addrlen);
|
|
|
|
for (cradle = &firstborn; *cradle; cradle = &(*cradle)->next)
|
2010-01-09 14:13:28 +00:00
|
|
|
if (!addrcmp(&(*cradle)->address, &newborn->address))
|
2008-08-24 20:27:10 +00:00
|
|
|
break;
|
|
|
|
newborn->next = *cradle;
|
|
|
|
*cradle = newborn;
|
2005-07-16 04:51:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This gets called if the number of connections grows
|
|
|
|
* past "max_connections".
|
|
|
|
*
|
2008-08-14 18:02:20 +00:00
|
|
|
* We kill the newest connection from a duplicate IP.
|
2005-07-16 04:51:57 +00:00
|
|
|
*/
|
2008-08-14 18:02:20 +00:00
|
|
|
static void kill_some_child(void)
|
2005-07-16 04:51:57 +00:00
|
|
|
{
|
2008-08-24 20:27:10 +00:00
|
|
|
const struct child *blanket, *next;
|
2005-07-16 04:51:57 +00:00
|
|
|
|
2008-08-24 20:27:10 +00:00
|
|
|
if (!(blanket = firstborn))
|
|
|
|
return;
|
2008-08-14 18:02:20 +00:00
|
|
|
|
2008-08-24 20:27:10 +00:00
|
|
|
for (; (next = blanket->next); blanket = next)
|
2010-01-09 14:13:28 +00:00
|
|
|
if (!addrcmp(&blanket->address, &next->address)) {
|
2010-11-04 01:35:16 +00:00
|
|
|
kill(blanket->cld.pid, SIGTERM);
|
2008-08-24 20:27:10 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-07-03 15:27:24 +00:00
|
|
|
}
|
|
|
|
|
2008-08-14 18:02:20 +00:00
|
|
|
static void check_dead_children(void)
|
2005-07-14 02:45:26 +00:00
|
|
|
{
|
2008-08-14 18:02:20 +00:00
|
|
|
int status;
|
|
|
|
pid_t pid;
|
2005-07-16 05:53:31 +00:00
|
|
|
|
2010-11-04 01:35:16 +00:00
|
|
|
struct child **cradle, *blanket;
|
|
|
|
for (cradle = &firstborn; (blanket = *cradle);)
|
|
|
|
if ((pid = waitpid(blanket->cld.pid, &status, WNOHANG)) > 1) {
|
|
|
|
const char *dead = "";
|
|
|
|
if (status)
|
|
|
|
dead = " (with error)";
|
|
|
|
loginfo("[%"PRIuMAX"] Disconnected%s", (uintmax_t)pid, dead);
|
|
|
|
|
|
|
|
/* remove the child */
|
|
|
|
*cradle = blanket->next;
|
|
|
|
live_children--;
|
|
|
|
free(blanket);
|
|
|
|
} else
|
|
|
|
cradle = &blanket->next;
|
2005-07-16 05:53:31 +00:00
|
|
|
}
|
|
|
|
|
2010-11-04 01:35:16 +00:00
|
|
|
static char **cld_argv;
|
2010-11-04 01:35:22 +00:00
|
|
|
static void handle(int incoming, struct sockaddr *addr, socklen_t addrlen)
|
2005-07-16 05:53:31 +00:00
|
|
|
{
|
Fix sparse warnings
Fix warnings from 'make check'.
- These files don't include 'builtin.h' causing sparse to complain that
cmd_* isn't declared:
builtin/clone.c:364, builtin/fetch-pack.c:797,
builtin/fmt-merge-msg.c:34, builtin/hash-object.c:78,
builtin/merge-index.c:69, builtin/merge-recursive.c:22
builtin/merge-tree.c:341, builtin/mktag.c:156, builtin/notes.c:426
builtin/notes.c:822, builtin/pack-redundant.c:596,
builtin/pack-refs.c:10, builtin/patch-id.c:60, builtin/patch-id.c:149,
builtin/remote.c:1512, builtin/remote-ext.c:240,
builtin/remote-fd.c:53, builtin/reset.c:236, builtin/send-pack.c:384,
builtin/unpack-file.c:25, builtin/var.c:75
- These files have symbols which should be marked static since they're
only file scope:
submodule.c:12, diff.c:631, replace_object.c:92, submodule.c:13,
submodule.c:14, trace.c:78, transport.c:195, transport-helper.c:79,
unpack-trees.c:19, url.c:3, url.c:18, url.c:104, url.c:117, url.c:123,
url.c:129, url.c:136, thread-utils.c:21, thread-utils.c:48
- These files redeclare symbols to be different types:
builtin/index-pack.c:210, parse-options.c:564, parse-options.c:571,
usage.c:49, usage.c:58, usage.c:63, usage.c:72
- These files use a literal integer 0 when they really should use a NULL
pointer:
daemon.c:663, fast-import.c:2942, imap-send.c:1072, notes-merge.c:362
While we're in the area, clean up some unused #includes in builtin files
(mostly exec_cmd.h).
Signed-off-by: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-22 07:51:05 +00:00
|
|
|
struct child_process cld = { NULL };
|
2010-11-04 01:35:19 +00:00
|
|
|
char addrbuf[300] = "REMOTE_ADDR=", portbuf[300];
|
|
|
|
char *env[] = { addrbuf, portbuf, NULL };
|
2005-07-16 05:53:31 +00:00
|
|
|
|
2008-08-14 18:02:20 +00:00
|
|
|
if (max_connections && live_children >= max_connections) {
|
|
|
|
kill_some_child();
|
2008-08-24 20:27:10 +00:00
|
|
|
sleep(1); /* give it some time to die */
|
2008-08-14 18:02:20 +00:00
|
|
|
check_dead_children();
|
|
|
|
if (live_children >= max_connections) {
|
|
|
|
close(incoming);
|
|
|
|
logerror("Too many children, dropping connection");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2005-07-16 05:53:31 +00:00
|
|
|
|
2010-11-04 01:35:19 +00:00
|
|
|
if (addr->sa_family == AF_INET) {
|
|
|
|
struct sockaddr_in *sin_addr = (void *) addr;
|
|
|
|
inet_ntop(addr->sa_family, &sin_addr->sin_addr, addrbuf + 12,
|
|
|
|
sizeof(addrbuf) - 12);
|
|
|
|
snprintf(portbuf, sizeof(portbuf), "REMOTE_PORT=%d",
|
|
|
|
ntohs(sin_addr->sin_port));
|
|
|
|
#ifndef NO_IPV6
|
2013-07-14 21:35:46 +00:00
|
|
|
} else if (addr->sa_family == AF_INET6) {
|
2010-11-04 01:35:19 +00:00
|
|
|
struct sockaddr_in6 *sin6_addr = (void *) addr;
|
|
|
|
|
|
|
|
char *buf = addrbuf + 12;
|
|
|
|
*buf++ = '['; *buf = '\0'; /* stpcpy() is cool */
|
|
|
|
inet_ntop(AF_INET6, &sin6_addr->sin6_addr, buf,
|
|
|
|
sizeof(addrbuf) - 13);
|
|
|
|
strcat(buf, "]");
|
|
|
|
|
|
|
|
snprintf(portbuf, sizeof(portbuf), "REMOTE_PORT=%d",
|
|
|
|
ntohs(sin6_addr->sin6_port));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
cld.env = (const char **)env;
|
2010-11-04 01:35:16 +00:00
|
|
|
cld.argv = (const char **)cld_argv;
|
|
|
|
cld.in = incoming;
|
|
|
|
cld.out = dup(incoming);
|
2005-07-14 02:45:26 +00:00
|
|
|
|
2010-11-04 01:35:16 +00:00
|
|
|
if (start_command(&cld))
|
|
|
|
logerror("unable to fork");
|
|
|
|
else
|
|
|
|
add_child(&cld, addr, addrlen);
|
2005-07-14 02:45:26 +00:00
|
|
|
close(incoming);
|
|
|
|
}
|
|
|
|
|
2005-07-16 03:42:28 +00:00
|
|
|
static void child_handler(int signo)
|
|
|
|
{
|
2008-08-24 20:27:10 +00:00
|
|
|
/*
|
|
|
|
* Otherwise empty handler because systemcalls will get interrupted
|
2008-08-14 18:02:20 +00:00
|
|
|
* upon signal receipt
|
|
|
|
* SysV needs the handler to be rearmed
|
|
|
|
*/
|
2008-08-12 19:36:13 +00:00
|
|
|
signal(SIGCHLD, child_handler);
|
2005-07-16 03:42:28 +00:00
|
|
|
}
|
|
|
|
|
2006-02-03 20:27:04 +00:00
|
|
|
static int set_reuse_addr(int sockfd)
|
|
|
|
{
|
|
|
|
int on = 1;
|
|
|
|
|
|
|
|
if (!reuseaddr)
|
|
|
|
return 0;
|
|
|
|
return setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
|
|
|
|
&on, sizeof(on));
|
|
|
|
}
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
struct socketlist {
|
|
|
|
int *list;
|
|
|
|
size_t nr;
|
|
|
|
size_t alloc;
|
|
|
|
};
|
|
|
|
|
2011-10-03 19:13:28 +00:00
|
|
|
static const char *ip2str(int family, struct sockaddr *sin, socklen_t len)
|
|
|
|
{
|
|
|
|
#ifdef NO_IPV6
|
|
|
|
static char ip[INET_ADDRSTRLEN];
|
|
|
|
#else
|
|
|
|
static char ip[INET6_ADDRSTRLEN];
|
|
|
|
#endif
|
|
|
|
|
|
|
|
switch (family) {
|
|
|
|
#ifndef NO_IPV6
|
|
|
|
case AF_INET6:
|
|
|
|
inet_ntop(family, &((struct sockaddr_in6*)sin)->sin6_addr, ip, len);
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case AF_INET:
|
|
|
|
inet_ntop(family, &((struct sockaddr_in*)sin)->sin_addr, ip, len);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
strcpy(ip, "<unknown>");
|
|
|
|
}
|
|
|
|
return ip;
|
|
|
|
}
|
|
|
|
|
2005-09-29 00:26:44 +00:00
|
|
|
#ifndef NO_IPV6
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
static int setup_named_sock(char *listen_addr, int listen_port, struct socketlist *socklist)
|
2005-07-14 02:45:26 +00:00
|
|
|
{
|
2010-08-30 11:30:50 +00:00
|
|
|
int socknum = 0;
|
2005-07-23 08:24:59 +00:00
|
|
|
int maxfd = -1;
|
|
|
|
char pbuf[NI_MAXSERV];
|
2005-09-29 00:26:44 +00:00
|
|
|
struct addrinfo hints, *ai0, *ai;
|
|
|
|
int gai;
|
2007-02-14 17:10:26 +00:00
|
|
|
long flags;
|
2005-07-23 08:24:59 +00:00
|
|
|
|
2006-09-26 14:47:43 +00:00
|
|
|
sprintf(pbuf, "%d", listen_port);
|
2005-07-23 08:24:59 +00:00
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_family = AF_UNSPEC;
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
hints.ai_protocol = IPPROTO_TCP;
|
|
|
|
hints.ai_flags = AI_PASSIVE;
|
|
|
|
|
2006-09-26 14:47:43 +00:00
|
|
|
gai = getaddrinfo(listen_addr, pbuf, &hints, &ai0);
|
2010-08-30 11:30:50 +00:00
|
|
|
if (gai) {
|
|
|
|
logerror("getaddrinfo() for %s failed: %s", listen_addr, gai_strerror(gai));
|
|
|
|
return 0;
|
|
|
|
}
|
2005-07-23 08:24:59 +00:00
|
|
|
|
|
|
|
for (ai = ai0; ai; ai = ai->ai_next) {
|
|
|
|
int sockfd;
|
|
|
|
|
|
|
|
sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
|
|
|
|
if (sockfd < 0)
|
|
|
|
continue;
|
|
|
|
if (sockfd >= FD_SETSIZE) {
|
2008-08-14 18:02:20 +00:00
|
|
|
logerror("Socket descriptor too large");
|
2005-07-23 08:24:59 +00:00
|
|
|
close(sockfd);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef IPV6_V6ONLY
|
|
|
|
if (ai->ai_family == AF_INET6) {
|
|
|
|
int on = 1;
|
|
|
|
setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY,
|
|
|
|
&on, sizeof(on));
|
|
|
|
/* Note: error is not fatal */
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-02-03 20:27:04 +00:00
|
|
|
if (set_reuse_addr(sockfd)) {
|
2011-10-03 19:13:28 +00:00
|
|
|
logerror("Could not set SO_REUSEADDR: %s", strerror(errno));
|
2006-02-03 20:27:04 +00:00
|
|
|
close(sockfd);
|
2006-04-18 13:11:06 +00:00
|
|
|
continue;
|
2006-02-03 20:27:04 +00:00
|
|
|
}
|
|
|
|
|
2005-07-23 08:24:59 +00:00
|
|
|
if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) {
|
2011-10-03 19:13:28 +00:00
|
|
|
logerror("Could not bind to %s: %s",
|
|
|
|
ip2str(ai->ai_family, ai->ai_addr, ai->ai_addrlen),
|
|
|
|
strerror(errno));
|
2005-07-23 08:24:59 +00:00
|
|
|
close(sockfd);
|
|
|
|
continue; /* not fatal */
|
|
|
|
}
|
|
|
|
if (listen(sockfd, 5) < 0) {
|
2011-10-03 19:13:28 +00:00
|
|
|
logerror("Could not listen to %s: %s",
|
|
|
|
ip2str(ai->ai_family, ai->ai_addr, ai->ai_addrlen),
|
|
|
|
strerror(errno));
|
2005-07-23 08:24:59 +00:00
|
|
|
close(sockfd);
|
|
|
|
continue; /* not fatal */
|
|
|
|
}
|
|
|
|
|
2007-02-14 17:10:26 +00:00
|
|
|
flags = fcntl(sockfd, F_GETFD, 0);
|
|
|
|
if (flags >= 0)
|
|
|
|
fcntl(sockfd, F_SETFD, flags | FD_CLOEXEC);
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
ALLOC_GROW(socklist->list, socklist->nr + 1, socklist->alloc);
|
|
|
|
socklist->list[socklist->nr++] = sockfd;
|
|
|
|
socknum++;
|
2005-07-23 08:24:59 +00:00
|
|
|
|
|
|
|
if (maxfd < sockfd)
|
|
|
|
maxfd = sockfd;
|
|
|
|
}
|
|
|
|
|
|
|
|
freeaddrinfo(ai0);
|
|
|
|
|
2005-09-29 00:26:44 +00:00
|
|
|
return socknum;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* NO_IPV6 */
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
static int setup_named_sock(char *listen_addr, int listen_port, struct socketlist *socklist)
|
2005-09-29 00:26:44 +00:00
|
|
|
{
|
|
|
|
struct sockaddr_in sin;
|
|
|
|
int sockfd;
|
2007-02-14 17:10:26 +00:00
|
|
|
long flags;
|
2005-09-29 00:26:44 +00:00
|
|
|
|
2006-09-26 14:47:43 +00:00
|
|
|
memset(&sin, 0, sizeof sin);
|
|
|
|
sin.sin_family = AF_INET;
|
|
|
|
sin.sin_port = htons(listen_port);
|
|
|
|
|
|
|
|
if (listen_addr) {
|
|
|
|
/* Well, host better be an IP address here. */
|
|
|
|
if (inet_pton(AF_INET, listen_addr, &sin.sin_addr.s_addr) <= 0)
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
sin.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
|
}
|
|
|
|
|
2005-09-29 00:26:44 +00:00
|
|
|
sockfd = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
|
if (sockfd < 0)
|
|
|
|
return 0;
|
|
|
|
|
2006-02-03 20:27:04 +00:00
|
|
|
if (set_reuse_addr(sockfd)) {
|
2011-10-03 19:13:28 +00:00
|
|
|
logerror("Could not set SO_REUSEADDR: %s", strerror(errno));
|
2006-02-03 20:27:04 +00:00
|
|
|
close(sockfd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-09-29 00:26:44 +00:00
|
|
|
if ( bind(sockfd, (struct sockaddr *)&sin, sizeof sin) < 0 ) {
|
2011-10-03 19:13:28 +00:00
|
|
|
logerror("Could not listen to %s: %s",
|
|
|
|
ip2str(AF_INET, (struct sockaddr *)&sin, sizeof(sin)),
|
|
|
|
strerror(errno));
|
2005-09-29 00:26:44 +00:00
|
|
|
close(sockfd);
|
|
|
|
return 0;
|
|
|
|
}
|
2005-07-14 02:45:26 +00:00
|
|
|
|
2005-11-21 17:07:23 +00:00
|
|
|
if (listen(sockfd, 5) < 0) {
|
2011-10-03 19:13:28 +00:00
|
|
|
logerror("Could not listen to %s: %s",
|
|
|
|
ip2str(AF_INET, (struct sockaddr *)&sin, sizeof(sin)),
|
|
|
|
strerror(errno));
|
2005-11-21 17:07:23 +00:00
|
|
|
close(sockfd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-02-14 17:10:26 +00:00
|
|
|
flags = fcntl(sockfd, F_GETFD, 0);
|
|
|
|
if (flags >= 0)
|
|
|
|
fcntl(sockfd, F_SETFD, flags | FD_CLOEXEC);
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
ALLOC_GROW(socklist->list, socklist->nr + 1, socklist->alloc);
|
|
|
|
socklist->list[socklist->nr++] = sockfd;
|
2005-11-21 17:07:23 +00:00
|
|
|
return 1;
|
2005-09-29 00:26:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2010-08-30 11:30:51 +00:00
|
|
|
static void socksetup(struct string_list *listen_addr, int listen_port, struct socketlist *socklist)
|
2010-08-30 11:30:50 +00:00
|
|
|
{
|
2010-08-30 11:30:51 +00:00
|
|
|
if (!listen_addr->nr)
|
|
|
|
setup_named_sock(NULL, listen_port, socklist);
|
|
|
|
else {
|
|
|
|
int i, socknum;
|
|
|
|
for (i = 0; i < listen_addr->nr; i++) {
|
|
|
|
socknum = setup_named_sock(listen_addr->items[i].string,
|
|
|
|
listen_port, socklist);
|
|
|
|
|
|
|
|
if (socknum == 0)
|
|
|
|
logerror("unable to allocate any listen sockets for host %s on port %u",
|
|
|
|
listen_addr->items[i].string, listen_port);
|
|
|
|
}
|
|
|
|
}
|
2010-08-30 11:30:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int service_loop(struct socketlist *socklist)
|
2005-09-29 00:26:44 +00:00
|
|
|
{
|
|
|
|
struct pollfd *pfd;
|
|
|
|
int i;
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
pfd = xcalloc(socklist->nr, sizeof(struct pollfd));
|
2005-09-29 00:26:44 +00:00
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
for (i = 0; i < socklist->nr; i++) {
|
|
|
|
pfd[i].fd = socklist->list[i];
|
2005-09-29 00:26:44 +00:00
|
|
|
pfd[i].events = POLLIN;
|
|
|
|
}
|
2005-09-30 18:01:57 +00:00
|
|
|
|
|
|
|
signal(SIGCHLD, child_handler);
|
2005-07-14 02:45:26 +00:00
|
|
|
|
|
|
|
for (;;) {
|
2005-07-23 08:24:59 +00:00
|
|
|
int i;
|
2005-09-29 00:26:44 +00:00
|
|
|
|
2008-08-14 18:02:20 +00:00
|
|
|
check_dead_children();
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
if (poll(pfd, socklist->nr, -1) < 0) {
|
2005-07-26 20:26:52 +00:00
|
|
|
if (errno != EINTR) {
|
2008-08-14 18:02:20 +00:00
|
|
|
logerror("Poll failed, resuming: %s",
|
2005-07-26 20:26:52 +00:00
|
|
|
strerror(errno));
|
|
|
|
sleep(1);
|
|
|
|
}
|
2005-07-23 08:24:59 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
for (i = 0; i < socklist->nr; i++) {
|
2005-09-29 00:26:44 +00:00
|
|
|
if (pfd[i].revents & POLLIN) {
|
2010-11-04 01:35:19 +00:00
|
|
|
union {
|
|
|
|
struct sockaddr sa;
|
|
|
|
struct sockaddr_in sai;
|
|
|
|
#ifndef NO_IPV6
|
|
|
|
struct sockaddr_in6 sai6;
|
|
|
|
#endif
|
|
|
|
} ss;
|
2010-11-04 01:35:22 +00:00
|
|
|
socklen_t sslen = sizeof(ss);
|
2010-11-04 01:35:19 +00:00
|
|
|
int incoming = accept(pfd[i].fd, &ss.sa, &sslen);
|
2005-07-23 08:24:59 +00:00
|
|
|
if (incoming < 0) {
|
|
|
|
switch (errno) {
|
|
|
|
case EAGAIN:
|
|
|
|
case EINTR:
|
|
|
|
case ECONNABORTED:
|
|
|
|
continue;
|
|
|
|
default:
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("accept returned");
|
2005-07-23 08:24:59 +00:00
|
|
|
}
|
|
|
|
}
|
2010-11-04 01:35:19 +00:00
|
|
|
handle(incoming, &ss.sa, sslen);
|
2005-07-14 02:45:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-04 01:35:24 +00:00
|
|
|
#ifdef NO_POSIX_GOODIES
|
|
|
|
|
|
|
|
struct credentials;
|
|
|
|
|
|
|
|
static void drop_privileges(struct credentials *cred)
|
|
|
|
{
|
|
|
|
/* nothing */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void daemonize(void)
|
|
|
|
{
|
|
|
|
die("--detach not supported on this platform");
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct credentials *prepare_credentials(const char *user_name,
|
|
|
|
const char *group_name)
|
|
|
|
{
|
|
|
|
die("--user not supported on this platform");
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
struct credentials {
|
|
|
|
struct passwd *pass;
|
|
|
|
gid_t gid;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void drop_privileges(struct credentials *cred)
|
|
|
|
{
|
|
|
|
if (cred && (initgroups(cred->pass->pw_name, cred->gid) ||
|
|
|
|
setgid (cred->gid) || setuid(cred->pass->pw_uid)))
|
|
|
|
die("cannot drop privileges");
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct credentials *prepare_credentials(const char *user_name,
|
|
|
|
const char *group_name)
|
|
|
|
{
|
|
|
|
static struct credentials c;
|
|
|
|
|
|
|
|
c.pass = getpwnam(user_name);
|
|
|
|
if (!c.pass)
|
|
|
|
die("user not found - %s", user_name);
|
|
|
|
|
|
|
|
if (!group_name)
|
|
|
|
c.gid = c.pass->pw_gid;
|
|
|
|
else {
|
|
|
|
struct group *group = getgrnam(group_name);
|
|
|
|
if (!group)
|
|
|
|
die("group not found - %s", group_name);
|
|
|
|
|
|
|
|
c.gid = group->gr_gid;
|
|
|
|
}
|
|
|
|
|
|
|
|
return &c;
|
|
|
|
}
|
|
|
|
|
2006-07-13 16:47:13 +00:00
|
|
|
static void daemonize(void)
|
|
|
|
{
|
|
|
|
switch (fork()) {
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case -1:
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("fork failed");
|
2006-07-13 16:47:13 +00:00
|
|
|
default:
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
if (setsid() == -1)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("setsid failed");
|
2006-07-13 16:47:13 +00:00
|
|
|
close(0);
|
|
|
|
close(1);
|
|
|
|
close(2);
|
|
|
|
sanitize_stdfds();
|
|
|
|
}
|
2010-11-04 01:35:24 +00:00
|
|
|
#endif
|
2006-07-13 16:47:13 +00:00
|
|
|
|
2006-07-13 10:18:08 +00:00
|
|
|
static void store_pid(const char *path)
|
|
|
|
{
|
|
|
|
FILE *f = fopen(path, "w");
|
|
|
|
if (!f)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("cannot open pid file '%s'", path);
|
2008-08-31 12:09:39 +00:00
|
|
|
if (fprintf(f, "%"PRIuMAX"\n", (uintmax_t) getpid()) < 0 || fclose(f) != 0)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("failed to write pid file '%s'", path);
|
2006-07-13 10:18:08 +00:00
|
|
|
}
|
|
|
|
|
2010-11-04 01:35:24 +00:00
|
|
|
static int serve(struct string_list *listen_addr, int listen_port,
|
|
|
|
struct credentials *cred)
|
2005-09-29 00:26:44 +00:00
|
|
|
{
|
2010-08-30 11:30:50 +00:00
|
|
|
struct socketlist socklist = { NULL, 0, 0 };
|
2005-10-21 06:21:50 +00:00
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
socksetup(listen_addr, listen_port, &socklist);
|
|
|
|
if (socklist.nr == 0)
|
2010-08-30 11:30:51 +00:00
|
|
|
die("unable to allocate any listen sockets on port %u",
|
|
|
|
listen_port);
|
2005-10-21 06:21:50 +00:00
|
|
|
|
2010-11-04 01:35:24 +00:00
|
|
|
drop_privileges(cred);
|
2006-08-22 17:37:41 +00:00
|
|
|
|
2012-01-07 11:42:46 +00:00
|
|
|
loginfo("Ready to rumble");
|
|
|
|
|
2010-08-30 11:30:50 +00:00
|
|
|
return service_loop(&socklist);
|
2005-10-21 06:21:50 +00:00
|
|
|
}
|
2005-09-29 00:26:44 +00:00
|
|
|
|
2005-07-14 02:45:26 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2006-09-26 14:47:43 +00:00
|
|
|
int listen_port = 0;
|
2010-08-30 11:30:51 +00:00
|
|
|
struct string_list listen_addr = STRING_LIST_INIT_NODUP;
|
2010-11-04 01:35:16 +00:00
|
|
|
int serve_mode = 0, inetd_mode = 0;
|
2006-08-22 17:37:41 +00:00
|
|
|
const char *pid_file = NULL, *user_name = NULL, *group_name = NULL;
|
2006-07-13 16:47:13 +00:00
|
|
|
int detach = 0;
|
2010-11-04 01:35:24 +00:00
|
|
|
struct credentials *cred = NULL;
|
2005-07-14 02:45:26 +00:00
|
|
|
int i;
|
|
|
|
|
i18n: add infrastructure for translating Git with gettext
Change the skeleton implementation of i18n in Git to one that can show
localized strings to users for our C, Shell and Perl programs using
either GNU libintl or the Solaris gettext implementation.
This new internationalization support is enabled by default. If
gettext isn't available, or if Git is compiled with
NO_GETTEXT=YesPlease, Git falls back on its current behavior of
showing interface messages in English. When using the autoconf script
we'll auto-detect if the gettext libraries are installed and act
appropriately.
This change is somewhat large because as well as adding a C, Shell and
Perl i18n interface we're adding a lot of tests for them, and for
those tests to work we need a skeleton PO file to actually test
translations. A minimal Icelandic translation is included for this
purpose. Icelandic includes multi-byte characters which makes it easy
to test various edge cases, and it's a language I happen to
understand.
The rest of the commit message goes into detail about various
sub-parts of this commit.
= Installation
Gettext .mo files will be installed and looked for in the standard
$(prefix)/share/locale path. GIT_TEXTDOMAINDIR can also be set to
override that, but that's only intended to be used to test Git itself.
= Perl
Perl code that's to be localized should use the new Git::I18n
module. It imports a __ function into the caller's package by default.
Instead of using the high level Locale::TextDomain interface I've
opted to use the low-level (equivalent to the C interface)
Locale::Messages module, which Locale::TextDomain itself uses.
Locale::TextDomain does a lot of redundant work we don't need, and
some of it would potentially introduce bugs. It tries to set the
$TEXTDOMAIN based on package of the caller, and has its own
hardcoded paths where it'll search for messages.
I found it easier just to completely avoid it rather than try to
circumvent its behavior. In any case, this is an issue wholly
internal Git::I18N. Its guts can be changed later if that's deemed
necessary.
See <AANLkTilYD_NyIZMyj9dHtVk-ylVBfvyxpCC7982LWnVd@mail.gmail.com> for
a further elaboration on this topic.
= Shell
Shell code that's to be localized should use the git-sh-i18n
library. It's basically just a wrapper for the system's gettext.sh.
If gettext.sh isn't available we'll fall back on gettext(1) if it's
available. The latter is available without the former on Solaris,
which has its own non-GNU gettext implementation. We also need to
emulate eval_gettext() there.
If neither are present we'll use a dumb printf(1) fall-through
wrapper.
= About libcharset.h and langinfo.h
We use libcharset to query the character set of the current locale if
it's available. I.e. we'll use it instead of nl_langinfo if
HAVE_LIBCHARSET_H is set.
The GNU gettext manual recommends using langinfo.h's
nl_langinfo(CODESET) to acquire the current character set, but on
systems that have libcharset.h's locale_charset() using the latter is
either saner, or the only option on those systems.
GNU and Solaris have a nl_langinfo(CODESET), FreeBSD can use either,
but MinGW and some others need to use libcharset.h's locale_charset()
instead.
=Credits
This patch is based on work by Jeff Epler <jepler@unpythonic.net> who
did the initial Makefile / C work, and a lot of comments from the Git
mailing list, including Jonathan Nieder, Jakub Narebski, Johannes
Sixt, Erik Faye-Lund, Peter Krefting, Junio C Hamano, Thomas Rast and
others.
[jc: squashed a small Makefile fix from Ramsay]
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-17 23:14:42 +00:00
|
|
|
git_setup_gettext();
|
|
|
|
|
2009-01-18 12:00:12 +00:00
|
|
|
git_extract_argv0_path(argv[0]);
|
|
|
|
|
2005-07-14 02:45:26 +00:00
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
char *arg = argv[i];
|
|
|
|
|
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(arg, "--listen=")) {
|
2010-08-30 11:30:51 +00:00
|
|
|
string_list_append(&listen_addr, xstrdup_tolower(arg + 9));
|
2008-12-26 10:12:15 +00:00
|
|
|
continue;
|
2006-09-26 14:47:43 +00:00
|
|
|
}
|
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(arg, "--port=")) {
|
2005-07-14 02:45:26 +00:00
|
|
|
char *end;
|
|
|
|
unsigned long n;
|
|
|
|
n = strtoul(arg+7, &end, 0);
|
|
|
|
if (arg[7] && !*end) {
|
2006-09-26 14:47:43 +00:00
|
|
|
listen_port = n;
|
2005-07-14 02:45:26 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2010-11-04 01:35:16 +00:00
|
|
|
if (!strcmp(arg, "--serve")) {
|
|
|
|
serve_mode = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-15 16:32:16 +00:00
|
|
|
if (!strcmp(arg, "--inetd")) {
|
|
|
|
inetd_mode = 1;
|
2005-11-16 23:38:29 +00:00
|
|
|
log_syslog = 1;
|
2005-07-15 16:32:16 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-09-22 09:25:28 +00:00
|
|
|
if (!strcmp(arg, "--verbose")) {
|
|
|
|
verbose = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-09-24 14:13:01 +00:00
|
|
|
if (!strcmp(arg, "--syslog")) {
|
|
|
|
log_syslog = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-09-27 02:10:55 +00:00
|
|
|
if (!strcmp(arg, "--export-all")) {
|
|
|
|
export_all_trees = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2012-08-14 18:37:51 +00:00
|
|
|
if (!prefixcmp(arg, "--access-hook=")) {
|
|
|
|
access_hook = arg + 14;
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--timeout=")) {
|
2005-10-19 21:27:01 +00:00
|
|
|
timeout = atoi(arg+10);
|
2005-11-16 23:38:29 +00:00
|
|
|
continue;
|
2005-10-19 21:27:01 +00:00
|
|
|
}
|
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(arg, "--init-timeout=")) {
|
2005-10-19 21:27:01 +00:00
|
|
|
init_timeout = atoi(arg+15);
|
2005-11-16 23:38:29 +00:00
|
|
|
continue;
|
2005-10-19 21:27:01 +00:00
|
|
|
}
|
2008-08-14 18:02:20 +00:00
|
|
|
if (!prefixcmp(arg, "--max-connections=")) {
|
|
|
|
max_connections = atoi(arg+18);
|
|
|
|
if (max_connections < 0)
|
|
|
|
max_connections = 0; /* unlimited */
|
|
|
|
continue;
|
|
|
|
}
|
2005-11-17 19:37:14 +00:00
|
|
|
if (!strcmp(arg, "--strict-paths")) {
|
|
|
|
strict_paths = 1;
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--base-path=")) {
|
2005-12-23 01:27:40 +00:00
|
|
|
base_path = arg+12;
|
|
|
|
continue;
|
|
|
|
}
|
2007-07-27 21:00:29 +00:00
|
|
|
if (!strcmp(arg, "--base-path-relaxed")) {
|
|
|
|
base_path_relaxed = 1;
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--interpolated-path=")) {
|
2006-09-20 01:31:51 +00:00
|
|
|
interpolated_path = arg+20;
|
|
|
|
continue;
|
|
|
|
}
|
2006-02-03 20:27:04 +00:00
|
|
|
if (!strcmp(arg, "--reuseaddr")) {
|
|
|
|
reuseaddr = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-02-05 06:27:29 +00:00
|
|
|
if (!strcmp(arg, "--user-path")) {
|
|
|
|
user_path = "";
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--user-path=")) {
|
2006-02-05 06:27:29 +00:00
|
|
|
user_path = arg + 12;
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--pid-file=")) {
|
2006-07-13 10:18:08 +00:00
|
|
|
pid_file = arg + 11;
|
|
|
|
continue;
|
|
|
|
}
|
2006-07-13 16:47:13 +00:00
|
|
|
if (!strcmp(arg, "--detach")) {
|
|
|
|
detach = 1;
|
|
|
|
log_syslog = 1;
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--user=")) {
|
2006-08-22 17:37:41 +00:00
|
|
|
user_name = arg + 7;
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--group=")) {
|
2006-08-22 17:37:41 +00:00
|
|
|
group_name = arg + 8;
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--enable=")) {
|
2006-08-21 02:03:13 +00:00
|
|
|
enable_service(arg + 9, 1);
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--disable=")) {
|
2006-08-21 02:03:13 +00:00
|
|
|
enable_service(arg + 10, 0);
|
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--allow-override=")) {
|
2006-08-21 02:03:50 +00:00
|
|
|
make_service_overridable(arg + 17, 1);
|
2006-08-21 02:03:13 +00:00
|
|
|
continue;
|
|
|
|
}
|
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(arg, "--forbid-override=")) {
|
2006-08-21 02:03:50 +00:00
|
|
|
make_service_overridable(arg + 18, 0);
|
2006-08-21 02:03:13 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-10-14 21:19:21 +00:00
|
|
|
if (!prefixcmp(arg, "--informative-errors")) {
|
|
|
|
informative_errors = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!prefixcmp(arg, "--no-informative-errors")) {
|
|
|
|
informative_errors = 0;
|
|
|
|
continue;
|
|
|
|
}
|
2005-09-27 02:10:55 +00:00
|
|
|
if (!strcmp(arg, "--")) {
|
|
|
|
ok_paths = &argv[i+1];
|
|
|
|
break;
|
|
|
|
} else if (arg[0] != '-') {
|
|
|
|
ok_paths = &argv[i];
|
|
|
|
break;
|
|
|
|
}
|
2005-07-15 16:32:16 +00:00
|
|
|
|
2005-07-14 02:45:26 +00:00
|
|
|
usage(daemon_usage);
|
|
|
|
}
|
|
|
|
|
2008-02-25 13:25:20 +00:00
|
|
|
if (log_syslog) {
|
2008-08-14 18:02:20 +00:00
|
|
|
openlog("git-daemon", LOG_PID, LOG_DAEMON);
|
2008-02-25 13:25:20 +00:00
|
|
|
set_die_routine(daemon_die);
|
2008-08-24 20:27:10 +00:00
|
|
|
} else
|
2008-09-04 03:33:29 +00:00
|
|
|
/* avoid splitting a message in the middle */
|
2010-11-04 01:35:17 +00:00
|
|
|
setvbuf(stderr, NULL, _IOFBF, 4096);
|
2008-02-25 13:25:20 +00:00
|
|
|
|
2010-11-04 01:35:23 +00:00
|
|
|
if (inetd_mode && (detach || group_name || user_name))
|
|
|
|
die("--detach, --user and --group are incompatible with --inetd");
|
2006-08-22 17:37:41 +00:00
|
|
|
|
2010-08-30 11:30:51 +00:00
|
|
|
if (inetd_mode && (listen_port || (listen_addr.nr > 0)))
|
2006-09-26 14:47:43 +00:00
|
|
|
die("--listen= and --port= are incompatible with --inetd");
|
|
|
|
else if (listen_port == 0)
|
|
|
|
listen_port = DEFAULT_GIT_PORT;
|
|
|
|
|
2006-08-22 17:37:41 +00:00
|
|
|
if (group_name && !user_name)
|
|
|
|
die("--group supplied without --user");
|
|
|
|
|
2010-11-04 01:35:24 +00:00
|
|
|
if (user_name)
|
|
|
|
cred = prepare_credentials(user_name, group_name);
|
2006-08-22 17:37:41 +00:00
|
|
|
|
2006-07-13 10:02:29 +00:00
|
|
|
if (strict_paths && (!ok_paths || !*ok_paths))
|
|
|
|
die("option --strict-paths requires a whitelist");
|
|
|
|
|
2008-09-09 08:27:07 +00:00
|
|
|
if (base_path && !is_directory(base_path))
|
|
|
|
die("base-path '%s' does not exist or is not a directory",
|
|
|
|
base_path);
|
2008-02-26 12:00:55 +00:00
|
|
|
|
2005-09-08 01:50:01 +00:00
|
|
|
if (inetd_mode) {
|
2010-11-04 01:35:16 +00:00
|
|
|
if (!freopen("/dev/null", "w", stderr))
|
|
|
|
die_errno("failed to redirect stderr to /dev/null");
|
|
|
|
}
|
|
|
|
|
2010-11-04 01:35:19 +00:00
|
|
|
if (inetd_mode || serve_mode)
|
|
|
|
return execute();
|
2005-11-14 16:41:01 +00:00
|
|
|
|
2012-01-07 11:42:46 +00:00
|
|
|
if (detach)
|
2006-07-13 16:47:13 +00:00
|
|
|
daemonize();
|
|
|
|
else
|
|
|
|
sanitize_stdfds();
|
2006-07-13 16:32:11 +00:00
|
|
|
|
2006-07-13 10:18:08 +00:00
|
|
|
if (pid_file)
|
|
|
|
store_pid(pid_file);
|
|
|
|
|
2010-11-04 01:35:16 +00:00
|
|
|
/* prepare argv for serving-processes */
|
|
|
|
cld_argv = xmalloc(sizeof (char *) * (argc + 2));
|
2011-01-04 04:04:46 +00:00
|
|
|
cld_argv[0] = argv[0]; /* git-daemon */
|
|
|
|
cld_argv[1] = "--serve";
|
|
|
|
for (i = 1; i < argc; ++i)
|
|
|
|
cld_argv[i+1] = argv[i];
|
2010-11-04 01:35:16 +00:00
|
|
|
cld_argv[argc+1] = NULL;
|
|
|
|
|
2010-11-04 01:35:24 +00:00
|
|
|
return serve(&listen_addr, listen_port, cred);
|
2005-07-14 02:45:26 +00:00
|
|
|
}
|