[thirdparty/git.git] / daemon.c

#include "cache.h"
#include "pkt-line.h"
#include <signal.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <syslog.h>

static int log_syslog;
static int verbose;

static const char daemon_usage[] = "git-daemon [--verbose] [--syslog] [--inetd | --port=n]";


static void logreport(int priority, const char *err, va_list params)
{
	/* We should do a single write so that it is atomic and output
	 * of several processes do not get intermingled. */
	char buf[1024];
	int buflen;
	int maxlen, msglen;

	/* sizeof(buf) should be big enough for "[pid] \n" */
	buflen = snprintf(buf, sizeof(buf), "[%ld] ", (long) getpid());

	maxlen = sizeof(buf) - buflen - 1; /* -1 for our own LF */
	msglen = vsnprintf(buf + buflen, maxlen, err, params);

	if (log_syslog) {
		syslog(priority, "%s", buf);
		return;
	}

	/* maxlen counted our own LF but also counts space given to
	 * vsnprintf for the terminating NUL.  We want to make sure that
	 * we have space for our own LF and NUL after the "meat" of the
	 * message, so truncate it at maxlen - 1.
	 */
	if (msglen > maxlen - 1)
		msglen = maxlen - 1;
	else if (msglen < 0)
		msglen = 0; /* Protect against weird return values. */
	buflen += msglen;

	buf[buflen++] = '\n';
	buf[buflen] = '\0';

	write(2, buf, buflen);
}

void logerror(const char *err, ...)
{
	va_list params;
	va_start(params, err);
	logreport(LOG_ERR, err, params);
	va_end(params);
}

void loginfo(const char *err, ...)
{
	va_list params;
	if (!verbose)
		return;
	va_start(params, err);
	logreport(LOG_INFO, err, params);
	va_end(params);
}


static int upload(char *dir, int dirlen)
{
	loginfo("Request for '%s'", dir);
	if (chdir(dir) < 0) {
		logerror("Cannot chdir('%s'): %s", dir, strerror(errno));
		return -1;
	}
	chdir(".git");

	/*
	 * Security on the cheap.
	 *
	 * We want a readable HEAD, usable "objects" directory, and 
	 * a "git-daemon-export-ok" flag that says that the other side
	 * is ok with us doing this.
	 */
	if (access("git-daemon-export-ok", F_OK) ||
	    access("objects/00", X_OK) ||
	    access("HEAD", R_OK)) {
		logerror("Not a valid gitd-enabled repository: '%s'", dir);
		return -1;
	}

	/*
	 * We'll ignore SIGTERM from now on, we have a
	 * good client.
	 */
	signal(SIGTERM, SIG_IGN);

	/* git-upload-pack only ever reads stuff, so this is safe */
	execlp("git-upload-pack", "git-upload-pack", ".", NULL);
	return -1;
}

static int execute(void)
{
	static char line[1000];
	int len;

	len = packet_read_line(0, line, sizeof(line));

	if (len && line[len-1] == '\n')
		line[--len] = 0;

	if (!strncmp("git-upload-pack /", line, 17))
		return upload(line + 16, len - 16);

	logerror("Protocol error: '%s'", line);
	return -1;
}


/*
 * We count spawned/reaped separately, just to avoid any
 * races when updating them from signals. The SIGCHLD handler
 * will only update children_reaped, and the fork logic will
 * only update children_spawned.
 *
 * MAX_CHILDREN should be a power-of-two to make the modulus
 * operation cheap. It should also be at least twice
 * the maximum number of connections we will ever allow.
 */
#define MAX_CHILDREN 128

static int max_connections = 25;

/* These are updated by the signal handler */
static volatile unsigned int children_reaped = 0;
static pid_t dead_child[MAX_CHILDREN];

/* These are updated by the main loop */
static unsigned int children_spawned = 0;
static unsigned int children_deleted = 0;

static struct child {
	pid_t pid;
	int addrlen;
	struct sockaddr_storage address;
} live_child[MAX_CHILDREN];

static void add_child(int idx, pid_t pid, struct sockaddr *addr, int addrlen)
{
	live_child[idx].pid = pid;
	live_child[idx].addrlen = addrlen;
	memcpy(&live_child[idx].address, addr, addrlen);
}

/*
 * Walk from "deleted" to "spawned", and remove child "pid".
 *
 * We move everything up by one, since the new "deleted" will
 * be one higher.
 */
static void remove_child(pid_t pid, unsigned deleted, unsigned spawned)
{
	struct child n;

	deleted %= MAX_CHILDREN;
	spawned %= MAX_CHILDREN;
	if (live_child[deleted].pid == pid) {
		live_child[deleted].pid = -1;
		return;
	}
	n = live_child[deleted];
	for (;;) {
		struct child m;
		deleted = (deleted + 1) % MAX_CHILDREN;
		if (deleted == spawned)
			die("could not find dead child %d\n", pid);
		m = live_child[deleted];
		live_child[deleted] = n;
		if (m.pid == pid)
			return;
		n = m;
	}
}

/*
 * This gets called if the number of connections grows
 * past "max_connections".
 *
 * We _should_ start off by searching for connections
 * from the same IP, and if there is some address wth
 * multiple connections, we should kill that first.
 *
 * As it is, we just "randomly" kill 25% of the connections,
 * and our pseudo-random generator sucks too. I have no
 * shame.
 *
 * Really, this is just a place-holder for a _real_ algorithm.
 */
static void kill_some_children(int signo, unsigned start, unsigned stop)
{
	start %= MAX_CHILDREN;
	stop %= MAX_CHILDREN;
	while (start != stop) {
		if (!(start & 3))
			kill(live_child[start].pid, signo);
		start = (start + 1) % MAX_CHILDREN;
	}
}

static void check_max_connections(void)
{
	for (;;) {
		int active;
		unsigned spawned, reaped, deleted;

		spawned = children_spawned;
		reaped = children_reaped;
		deleted = children_deleted;

		while (deleted < reaped) {
			pid_t pid = dead_child[deleted % MAX_CHILDREN];
			remove_child(pid, deleted, spawned);
			deleted++;
		}
		children_deleted = deleted;

		active = spawned - deleted;
		if (active <= max_connections)
			break;

		/* Kill some unstarted connections with SIGTERM */
		kill_some_children(SIGTERM, deleted, spawned);
		if (active <= max_connections << 1)
			break;

		/* If the SIGTERM thing isn't helping use SIGKILL */
		kill_some_children(SIGKILL, deleted, spawned);
		sleep(1);
	}
}

static void handle(int incoming, struct sockaddr *addr, int addrlen)
{
	pid_t pid = fork();
	char addrbuf[256] = "";
	int port = -1;

	if (pid) {
		unsigned idx;

		close(incoming);
		if (pid < 0)
			return;

		idx = children_spawned % MAX_CHILDREN;
		children_spawned++;
		add_child(idx, pid, addr, addrlen);

		check_max_connections();
		return;
	}

	dup2(incoming, 0);
	dup2(incoming, 1);
	close(incoming);

	if (addr->sa_family == AF_INET) {
		struct sockaddr_in *sin_addr = (void *) addr;
		inet_ntop(AF_INET, &sin_addr->sin_addr, addrbuf, sizeof(addrbuf));
		port = sin_addr->sin_port;

	} else if (addr->sa_family == AF_INET6) {
		struct sockaddr_in6 *sin6_addr = (void *) addr;

		char *buf = addrbuf;
		*buf++ = '['; *buf = '\0'; /* stpcpy() is cool */
		inet_ntop(AF_INET6, &sin6_addr->sin6_addr, buf, sizeof(addrbuf) - 1);
		strcat(buf, "]");

		port = sin6_addr->sin6_port;
	}
	loginfo("Connection from %s:%d", addrbuf, port);

	exit(execute());
}

static void child_handler(int signo)
{
	for (;;) {
		int status;
		pid_t pid = waitpid(-1, &status, WNOHANG);

		if (pid > 0) {
			unsigned reaped = children_reaped;
			dead_child[reaped % MAX_CHILDREN] = pid;
			children_reaped = reaped + 1;
			/* XXX: Custom logging, since we don't wanna getpid() */
			if (verbose) {
				char *dead = "";
				if (!WIFEXITED(status) || WEXITSTATUS(status) > 0)
					dead = " (with error)";
				if (log_syslog)
					syslog(LOG_INFO, "[%d] Disconnected%s", pid, dead);
				else
					fprintf(stderr, "[%d] Disconnected%s\n", pid, dead);
			}
			continue;
		}
		break;
	}
}

static int serve(int port)
{
	struct addrinfo hints, *ai0, *ai;
	int gai;
	int socknum = 0, *socklist = NULL;
	int maxfd = -1;
	fd_set fds_init, fds;
	char pbuf[NI_MAXSERV];

	signal(SIGCHLD, child_handler);

	sprintf(pbuf, "%d", port);
	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;

	gai = getaddrinfo(NULL, pbuf, &hints, &ai0);
	if (gai)
		die("getaddrinfo() failed: %s\n", gai_strerror(gai));

	FD_ZERO(&fds_init);

	for (ai = ai0; ai; ai = ai->ai_next) {
		int sockfd;
		int *newlist;

		sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
		if (sockfd < 0)
			continue;
		if (sockfd >= FD_SETSIZE) {
			error("too large socket descriptor.");
			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

		if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) {
			close(sockfd);
			continue;	/* not fatal */
		}
		if (listen(sockfd, 5) < 0) {
			close(sockfd);
			continue;	/* not fatal */
		}

		newlist = realloc(socklist, sizeof(int) * (socknum + 1));
		if (!newlist)
			die("memory allocation failed: %s", strerror(errno));

		socklist = newlist;
		socklist[socknum++] = sockfd;

		FD_SET(sockfd, &fds_init);
		if (maxfd < sockfd)
			maxfd = sockfd;
	}

	freeaddrinfo(ai0);

	if (socknum == 0)
		die("unable to allocate any listen sockets on port %u", port);

	for (;;) {
		int i;
		fds = fds_init;
		
		if (select(maxfd + 1, &fds, NULL, NULL, NULL) < 0) {
			if (errno != EINTR) {
				error("select failed, resuming: %s",
				      strerror(errno));
				sleep(1);
			}
			continue;
		}

		for (i = 0; i < socknum; i++) {
			int sockfd = socklist[i];

			if (FD_ISSET(sockfd, &fds)) {
				struct sockaddr_storage ss;
				int sslen = sizeof(ss);
				int incoming = accept(sockfd, (struct sockaddr *)&ss, &sslen);
				if (incoming < 0) {
					switch (errno) {
					case EAGAIN:
					case EINTR:
					case ECONNABORTED:
						continue;
					default:
						die("accept returned %s", strerror(errno));
					}
				}
				handle(incoming, (struct sockaddr *)&ss, sslen);
			}
		}
	}
}

int main(int argc, char **argv)
{
	int port = DEFAULT_GIT_PORT;
	int inetd_mode = 0;
	int i;

	for (i = 1; i < argc; i++) {
		char *arg = argv[i];

		if (!strncmp(arg, "--port=", 7)) {
			char *end;
			unsigned long n;
			n = strtoul(arg+7, &end, 0);
			if (arg[7] && !*end) {
				port = n;
				continue;
			}
		}

		if (!strcmp(arg, "--inetd")) {
			inetd_mode = 1;
			continue;
		}
		if (!strcmp(arg, "--verbose")) {
			verbose = 1;
			continue;
		}
		if (!strcmp(arg, "--syslog")) {
			log_syslog = 1;
			openlog("git-daemon", 0, LOG_DAEMON);
			continue;
		}

		usage(daemon_usage);
	}

	if (inetd_mode) {
		fclose(stderr); //FIXME: workaround
		return execute();
	}

	return serve(port);
}
Commit	Line	Data
a87e8be2 LT	1	#include "cache.h"
a87e8be2 LT	2	#include "pkt-line.h"
eaa94919 LT	3	#include <signal.h>
eaa94919 LT	4	#include <sys/wait.h>
a87e8be2	5	#include <sys/socket.h>
3cd6ecda	6	#include <sys/time.h>
df076bdb	7	#include <netdb.h>
a87e8be2	8	#include <netinet/in.h>
f8ff0c06	9	#include <arpa/inet.h>
9048fe1c	10	#include <syslog.h>
f8ff0c06	11
9048fe1c	12	static int log_syslog;
f8ff0c06 PB	13	static int verbose;
f8ff0c06 PB	14
9048fe1c	15	static const char daemon_usage[] = "git-daemon [--verbose] [--syslog] [--inetd \| --port=n]";
f8ff0c06 PB	16
f8ff0c06 PB	17
9048fe1c	18	static void logreport(int priority, const char *err, va_list params)
f8ff0c06 PB	19	{
	20	/* We should do a single write so that it is atomic and output
	21	* of several processes do not get intermingled. */
	22	char buf[1024];
	23	int buflen;
	24	int maxlen, msglen;
	25
	26	/* sizeof(buf) should be big enough for "[pid] \n" */
1bedd4ca	27	buflen = snprintf(buf, sizeof(buf), "[%ld] ", (long) getpid());
f8ff0c06 PB	28
	29	maxlen = sizeof(buf) - buflen - 1; /* -1 for our own LF */
	30	msglen = vsnprintf(buf + buflen, maxlen, err, params);
	31
9048fe1c PB	32	if (log_syslog) {
	33	syslog(priority, "%s", buf);
	34	return;
	35	}
	36
f8ff0c06 PB	37	/* maxlen counted our own LF but also counts space given to
	38	* vsnprintf for the terminating NUL. We want to make sure that
	39	* we have space for our own LF and NUL after the "meat" of the
	40	* message, so truncate it at maxlen - 1.
	41	*/
	42	if (msglen > maxlen - 1)
	43	msglen = maxlen - 1;
	44	else if (msglen < 0)
	45	msglen = 0; /* Protect against weird return values. */
	46	buflen += msglen;
	47
	48	buf[buflen++] = '\n';
	49	buf[buflen] = '\0';
	50
	51	write(2, buf, buflen);
	52	}
	53
	54	void logerror(const char *err, ...)
	55	{
	56	va_list params;
	57	va_start(params, err);
9048fe1c	58	logreport(LOG_ERR, err, params);
f8ff0c06 PB	59	va_end(params);
	60	}
	61
da38641d	62	void loginfo(const char *err, ...)
f8ff0c06 PB	63	{
	64	va_list params;
	65	if (!verbose)
	66	return;
	67	va_start(params, err);
9048fe1c	68	logreport(LOG_INFO, err, params);
f8ff0c06 PB	69	va_end(params);
f8ff0c06 PB	70	}
a87e8be2	71
a87e8be2 LT	72
	73	static int upload(char *dir, int dirlen)
	74	{
da38641d	75	loginfo("Request for '%s'", dir);
f8ff0c06 PB	76	if (chdir(dir) < 0) {
f8ff0c06 PB	77	logerror("Cannot chdir('%s'): %s", dir, strerror(errno));
a87e8be2	78	return -1;
f8ff0c06	79	}
a87e8be2 LT	80	chdir(".git");
	81
	82	/*
	83	* Security on the cheap.
	84	*
	85	* We want a readable HEAD, usable "objects" directory, and
	86	* a "git-daemon-export-ok" flag that says that the other side
	87	* is ok with us doing this.
	88	*/
	89	if (access("git-daemon-export-ok", F_OK) \|\|
	90	access("objects/00", X_OK) \|\|
f8ff0c06 PB	91	access("HEAD", R_OK)) {
f8ff0c06 PB	92	logerror("Not a valid gitd-enabled repository: '%s'", dir);
a87e8be2	93	return -1;
f8ff0c06	94	}
a87e8be2	95
02d57da4 LT	96	/*
	97	* We'll ignore SIGTERM from now on, we have a
	98	* good client.
	99	*/
	100	signal(SIGTERM, SIG_IGN);
	101
a87e8be2 LT	102	/* git-upload-pack only ever reads stuff, so this is safe */
	103	execlp("git-upload-pack", "git-upload-pack", ".", NULL);
	104	return -1;
	105	}
	106
7d80694a	107	static int execute(void)
a87e8be2	108	{
7d80694a LT	109	static char line[1000];
	110	int len;
	111
	112	len = packet_read_line(0, line, sizeof(line));
	113
	114	if (len && line[len-1] == '\n')
	115	line[--len] = 0;
	116
a87e8be2 LT	117	if (!strncmp("git-upload-pack /", line, 17))
	118	return upload(line + 16, len - 16);
	119
f8ff0c06	120	logerror("Protocol error: '%s'", line);
a87e8be2 LT	121	return -1;
	122	}
	123
66e631de LT	124
	125	/*
	126	* We count spawned/reaped separately, just to avoid any
	127	* races when updating them from signals. The SIGCHLD handler
	128	* will only update children_reaped, and the fork logic will
	129	* only update children_spawned.
	130	*
	131	* MAX_CHILDREN should be a power-of-two to make the modulus
	132	* operation cheap. It should also be at least twice
	133	* the maximum number of connections we will ever allow.
	134	*/
	135	#define MAX_CHILDREN 128
	136
	137	static int max_connections = 25;
	138
	139	/* These are updated by the signal handler */
	140	static volatile unsigned int children_reaped = 0;
4d8fa916	141	static pid_t dead_child[MAX_CHILDREN];
66e631de LT	142
	143	/* These are updated by the main loop */
	144	static unsigned int children_spawned = 0;
	145	static unsigned int children_deleted = 0;
	146
4d8fa916	147	static struct child {
66e631de	148	pid_t pid;
7fa09084	149	int addrlen;
df076bdb	150	struct sockaddr_storage address;
66e631de LT	151	} live_child[MAX_CHILDREN];
66e631de LT	152
7fa09084	153	static void add_child(int idx, pid_t pid, struct sockaddr *addr, int addrlen)
66e631de LT	154	{
	155	live_child[idx].pid = pid;
	156	live_child[idx].addrlen = addrlen;
df076bdb	157	memcpy(&live_child[idx].address, addr, addrlen);
66e631de LT	158	}
	159
	160	/*
	161	* Walk from "deleted" to "spawned", and remove child "pid".
	162	*
	163	* We move everything up by one, since the new "deleted" will
	164	* be one higher.
	165	*/
	166	static void remove_child(pid_t pid, unsigned deleted, unsigned spawned)
	167	{
	168	struct child n;
	169
	170	deleted %= MAX_CHILDREN;
	171	spawned %= MAX_CHILDREN;
	172	if (live_child[deleted].pid == pid) {
	173	live_child[deleted].pid = -1;
	174	return;
	175	}
	176	n = live_child[deleted];
	177	for (;;) {
	178	struct child m;
	179	deleted = (deleted + 1) % MAX_CHILDREN;
	180	if (deleted == spawned)
	181	die("could not find dead child %d\n", pid);
	182	m = live_child[deleted];
	183	live_child[deleted] = n;
	184	if (m.pid == pid)
	185	return;
	186	n = m;
	187	}
	188	}
	189
	190	/*
	191	* This gets called if the number of connections grows
	192	* past "max_connections".
	193	*
	194	* We _should_ start off by searching for connections
	195	* from the same IP, and if there is some address wth
	196	* multiple connections, we should kill that first.
	197	*
	198	* As it is, we just "randomly" kill 25% of the connections,
	199	* and our pseudo-random generator sucks too. I have no
	200	* shame.
	201	*
	202	* Really, this is just a place-holder for a _real_ algorithm.
	203	*/
02d57da4	204	static void kill_some_children(int signo, unsigned start, unsigned stop)
66e631de LT	205	{
	206	start %= MAX_CHILDREN;
	207	stop %= MAX_CHILDREN;
	208	while (start != stop) {
	209	if (!(start & 3))
02d57da4	210	kill(live_child[start].pid, signo);
66e631de LT	211	start = (start + 1) % MAX_CHILDREN;
	212	}
	213	}
	214
02d57da4	215	static void check_max_connections(void)
a87e8be2	216	{
02d57da4	217	for (;;) {
eaa94919	218	int active;
66e631de	219	unsigned spawned, reaped, deleted;
eaa94919	220
66e631de	221	spawned = children_spawned;
66e631de LT	222	reaped = children_reaped;
	223	deleted = children_deleted;
	224
	225	while (deleted < reaped) {
	226	pid_t pid = dead_child[deleted % MAX_CHILDREN];
	227	remove_child(pid, deleted, spawned);
	228	deleted++;
	229	}
	230	children_deleted = deleted;
	231
	232	active = spawned - deleted;
02d57da4 LT	233	if (active <= max_connections)
02d57da4 LT	234	break;
66e631de	235
02d57da4 LT	236	/* Kill some unstarted connections with SIGTERM */
	237	kill_some_children(SIGTERM, deleted, spawned);
	238	if (active <= max_connections << 1)
	239	break;
	240
	241	/* If the SIGTERM thing isn't helping use SIGKILL */
	242	kill_some_children(SIGKILL, deleted, spawned);
	243	sleep(1);
	244	}
	245	}
	246
7fa09084	247	static void handle(int incoming, struct sockaddr *addr, int addrlen)
02d57da4 LT	248	{
02d57da4 LT	249	pid_t pid = fork();
f8ff0c06 PB	250	char addrbuf[256] = "";
f8ff0c06 PB	251	int port = -1;
02d57da4 LT	252
	253	if (pid) {
	254	unsigned idx;
	255
	256	close(incoming);
	257	if (pid < 0)
	258	return;
	259
	260	idx = children_spawned % MAX_CHILDREN;
	261	children_spawned++;
	262	add_child(idx, pid, addr, addrlen);
66e631de	263
02d57da4	264	check_max_connections();
a87e8be2 LT	265	return;
	266	}
	267
	268	dup2(incoming, 0);
	269	dup2(incoming, 1);
	270	close(incoming);
f8ff0c06 PB	271
	272	if (addr->sa_family == AF_INET) {
	273	struct sockaddr_in sin_addr = (void ) addr;
	274	inet_ntop(AF_INET, &sin_addr->sin_addr, addrbuf, sizeof(addrbuf));
	275	port = sin_addr->sin_port;
	276
	277	} else if (addr->sa_family == AF_INET6) {
	278	struct sockaddr_in6 sin6_addr = (void ) addr;
	279
	280	char *buf = addrbuf;
	281	buf++ = '['; buf = '\0'; /* stpcpy() is cool */
	282	inet_ntop(AF_INET6, &sin6_addr->sin6_addr, buf, sizeof(addrbuf) - 1);
	283	strcat(buf, "]");
	284
	285	port = sin6_addr->sin6_port;
	286	}
da38641d	287	loginfo("Connection from %s:%d", addrbuf, port);
f8ff0c06	288
7d80694a	289	exit(execute());
a87e8be2 LT	290	}
a87e8be2 LT	291
eaa94919 LT	292	static void child_handler(int signo)
	293	{
	294	for (;;) {
9048fe1c PB	295	int status;
9048fe1c PB	296	pid_t pid = waitpid(-1, &status, WNOHANG);
66e631de LT	297
	298	if (pid > 0) {
	299	unsigned reaped = children_reaped;
	300	dead_child[reaped % MAX_CHILDREN] = pid;
	301	children_reaped = reaped + 1;
f8ff0c06	302	/* XXX: Custom logging, since we don't wanna getpid() */
9048fe1c PB	303	if (verbose) {
	304	char *dead = "";
	305	if (!WIFEXITED(status) \|\| WEXITSTATUS(status) > 0)
	306	dead = " (with error)";
	307	if (log_syslog)
	308	syslog(LOG_INFO, "[%d] Disconnected%s", pid, dead);
	309	else
	310	fprintf(stderr, "[%d] Disconnected%s\n", pid, dead);
	311	}
eaa94919 LT	312	continue;
	313	}
	314	break;
	315	}
	316	}
	317
a87e8be2 LT	318	static int serve(int port)
a87e8be2 LT	319	{
df076bdb YH	320	struct addrinfo hints, ai0, ai;
	321	int gai;
	322	int socknum = 0, *socklist = NULL;
	323	int maxfd = -1;
	324	fd_set fds_init, fds;
	325	char pbuf[NI_MAXSERV];
a87e8be2	326
eaa94919	327	signal(SIGCHLD, child_handler);
df076bdb YH	328
	329	sprintf(pbuf, "%d", port);
	330	memset(&hints, 0, sizeof(hints));
	331	hints.ai_family = AF_UNSPEC;
	332	hints.ai_socktype = SOCK_STREAM;
	333	hints.ai_protocol = IPPROTO_TCP;
	334	hints.ai_flags = AI_PASSIVE;
	335
	336	gai = getaddrinfo(NULL, pbuf, &hints, &ai0);
	337	if (gai)
	338	die("getaddrinfo() failed: %s\n", gai_strerror(gai));
	339
	340	FD_ZERO(&fds_init);
	341
	342	for (ai = ai0; ai; ai = ai->ai_next) {
	343	int sockfd;
	344	int *newlist;
	345
	346	sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
	347	if (sockfd < 0)
	348	continue;
	349	if (sockfd >= FD_SETSIZE) {
	350	error("too large socket descriptor.");
	351	close(sockfd);
	352	continue;
	353	}
	354
	355	#ifdef IPV6_V6ONLY
	356	if (ai->ai_family == AF_INET6) {
	357	int on = 1;
	358	setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY,
	359	&on, sizeof(on));
	360	/* Note: error is not fatal */
	361	}
	362	#endif
	363
	364	if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) {
	365	close(sockfd);
	366	continue; /* not fatal */
	367	}
	368	if (listen(sockfd, 5) < 0) {
	369	close(sockfd);
	370	continue; /* not fatal */
	371	}
	372
	373	newlist = realloc(socklist, sizeof(int) * (socknum + 1));
	374	if (!newlist)
	375	die("memory allocation failed: %s", strerror(errno));
	376
	377	socklist = newlist;
	378	socklist[socknum++] = sockfd;
	379
	380	FD_SET(sockfd, &fds_init);
	381	if (maxfd < sockfd)
	382	maxfd = sockfd;
	383	}
	384
	385	freeaddrinfo(ai0);
	386
	387	if (socknum == 0)
	388	die("unable to allocate any listen sockets on port %u", port);
a87e8be2 LT	389
a87e8be2 LT	390	for (;;) {
df076bdb YH	391	int i;
	392	fds = fds_init;
	393
	394	if (select(maxfd + 1, &fds, NULL, NULL, NULL) < 0) {
1eef0b33 JH	395	if (errno != EINTR) {
	396	error("select failed, resuming: %s",
	397	strerror(errno));
	398	sleep(1);
	399	}
df076bdb YH	400	continue;
	401	}
	402
	403	for (i = 0; i < socknum; i++) {
	404	int sockfd = socklist[i];
	405
	406	if (FD_ISSET(sockfd, &fds)) {
	407	struct sockaddr_storage ss;
7fa09084	408	int sslen = sizeof(ss);
df076bdb YH	409	int incoming = accept(sockfd, (struct sockaddr *)&ss, &sslen);
	410	if (incoming < 0) {
	411	switch (errno) {
	412	case EAGAIN:
	413	case EINTR:
	414	case ECONNABORTED:
	415	continue;
	416	default:
	417	die("accept returned %s", strerror(errno));
	418	}
	419	}
	420	handle(incoming, (struct sockaddr *)&ss, sslen);
a87e8be2 LT	421	}
a87e8be2 LT	422	}
a87e8be2 LT	423	}
	424	}
	425
	426	int main(int argc, char **argv)
	427	{
	428	int port = DEFAULT_GIT_PORT;
e64e1b79	429	int inetd_mode = 0;
a87e8be2 LT	430	int i;
	431
	432	for (i = 1; i < argc; i++) {
	433	char *arg = argv[i];
	434
	435	if (!strncmp(arg, "--port=", 7)) {
	436	char *end;
	437	unsigned long n;
	438	n = strtoul(arg+7, &end, 0);
	439	if (arg[7] && !*end) {
	440	port = n;
	441	continue;
	442	}
	443	}
e64e1b79 LT	444
	445	if (!strcmp(arg, "--inetd")) {
	446	inetd_mode = 1;
	447	continue;
	448	}
f8ff0c06 PB	449	if (!strcmp(arg, "--verbose")) {
	450	verbose = 1;
	451	continue;
	452	}
9048fe1c PB	453	if (!strcmp(arg, "--syslog")) {
	454	log_syslog = 1;
	455	openlog("git-daemon", 0, LOG_DAEMON);
	456	continue;
	457	}
e64e1b79	458
a87e8be2 LT	459	usage(daemon_usage);
	460	}
	461
7c3693f1 LD	462	if (inetd_mode) {
7c3693f1 LD	463	fclose(stderr); //FIXME: workaround
e64e1b79	464	return execute();
7c3693f1	465	}
e64e1b79	466
a87e8be2 LT	467	return serve(port);
a87e8be2 LT	468	}