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