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