GIT 1.4.2
[git] / daemon.c
1 #include <signal.h>
2 #include <sys/wait.h>
3 #include <sys/socket.h>
4 #include <sys/time.h>
5 #include <sys/poll.h>
6 #include <netdb.h>
7 #include <netinet/in.h>
8 #include <arpa/inet.h>
9 #include <syslog.h>
10 #include "pkt-line.h"
11 #include "cache.h"
12 #include "exec_cmd.h"
13
14 static int log_syslog;
15 static int verbose;
16 static int reuseaddr;
17
18 static const char daemon_usage[] =
19 "git-daemon [--verbose] [--syslog] [--inetd | --port=n] [--export-all]\n"
20 "           [--timeout=n] [--init-timeout=n] [--strict-paths]\n"
21 "           [--base-path=path] [--user-path | --user-path=path]\n"
22 "           [--reuseaddr] [--detach] [--pid-file=file] [directory...]";
23
24 /* List of acceptable pathname prefixes */
25 static char **ok_paths = NULL;
26 static int strict_paths = 0;
27
28 /* If this is set, git-daemon-export-ok is not required */
29 static int export_all_trees = 0;
30
31 /* Take all paths relative to this one if non-NULL */
32 static char *base_path = NULL;
33
34 /* If defined, ~user notation is allowed and the string is inserted
35  * after ~user/.  E.g. a request to git://host/~alice/frotz would
36  * go to /home/alice/pub_git/frotz with --user-path=pub_git.
37  */
38 static const char *user_path = NULL;
39
40 /* Timeout, and initial timeout */
41 static unsigned int timeout = 0;
42 static unsigned int init_timeout = 0;
43
44 static void logreport(int priority, const char *err, va_list params)
45 {
46         /* We should do a single write so that it is atomic and output
47          * of several processes do not get intermingled. */
48         char buf[1024];
49         int buflen;
50         int maxlen, msglen;
51
52         /* sizeof(buf) should be big enough for "[pid] \n" */
53         buflen = snprintf(buf, sizeof(buf), "[%ld] ", (long) getpid());
54
55         maxlen = sizeof(buf) - buflen - 1; /* -1 for our own LF */
56         msglen = vsnprintf(buf + buflen, maxlen, err, params);
57
58         if (log_syslog) {
59                 syslog(priority, "%s", buf);
60                 return;
61         }
62
63         /* maxlen counted our own LF but also counts space given to
64          * vsnprintf for the terminating NUL.  We want to make sure that
65          * we have space for our own LF and NUL after the "meat" of the
66          * message, so truncate it at maxlen - 1.
67          */
68         if (msglen > maxlen - 1)
69                 msglen = maxlen - 1;
70         else if (msglen < 0)
71                 msglen = 0; /* Protect against weird return values. */
72         buflen += msglen;
73
74         buf[buflen++] = '\n';
75         buf[buflen] = '\0';
76
77         write(2, buf, buflen);
78 }
79
80 static void logerror(const char *err, ...)
81 {
82         va_list params;
83         va_start(params, err);
84         logreport(LOG_ERR, err, params);
85         va_end(params);
86 }
87
88 static void loginfo(const char *err, ...)
89 {
90         va_list params;
91         if (!verbose)
92                 return;
93         va_start(params, err);
94         logreport(LOG_INFO, err, params);
95         va_end(params);
96 }
97
98 static void NORETURN daemon_die(const char *err, va_list params)
99 {
100         logreport(LOG_ERR, err, params);
101         exit(1);
102 }
103
104 static int avoid_alias(char *p)
105 {
106         int sl, ndot;
107
108         /* 
109          * This resurrects the belts and suspenders paranoia check by HPA
110          * done in <435560F7.4080006@zytor.com> thread, now enter_repo()
111          * does not do getcwd() based path canonicalizations.
112          *
113          * sl becomes true immediately after seeing '/' and continues to
114          * be true as long as dots continue after that without intervening
115          * non-dot character.
116          */
117         if (!p || (*p != '/' && *p != '~'))
118                 return -1;
119         sl = 1; ndot = 0;
120         p++;
121
122         while (1) {
123                 char ch = *p++;
124                 if (sl) {
125                         if (ch == '.')
126                                 ndot++;
127                         else if (ch == '/') {
128                                 if (ndot < 3)
129                                         /* reject //, /./ and /../ */
130                                         return -1;
131                                 ndot = 0;
132                         }
133                         else if (ch == 0) {
134                                 if (0 < ndot && ndot < 3)
135                                         /* reject /.$ and /..$ */
136                                         return -1;
137                                 return 0;
138                         }
139                         else
140                                 sl = ndot = 0;
141                 }
142                 else if (ch == 0)
143                         return 0;
144                 else if (ch == '/') {
145                         sl = 1;
146                         ndot = 0;
147                 }
148         }
149 }
150
151 static char *path_ok(char *dir)
152 {
153         static char rpath[PATH_MAX];
154         char *path;
155
156         if (avoid_alias(dir)) {
157                 logerror("'%s': aliased", dir);
158                 return NULL;
159         }
160
161         if (*dir == '~') {
162                 if (!user_path) {
163                         logerror("'%s': User-path not allowed", dir);
164                         return NULL;
165                 }
166                 if (*user_path) {
167                         /* Got either "~alice" or "~alice/foo";
168                          * rewrite them to "~alice/%s" or
169                          * "~alice/%s/foo".
170                          */
171                         int namlen, restlen = strlen(dir);
172                         char *slash = strchr(dir, '/');
173                         if (!slash)
174                                 slash = dir + restlen;
175                         namlen = slash - dir;
176                         restlen -= namlen;
177                         loginfo("userpath <%s>, request <%s>, namlen %d, restlen %d, slash <%s>", user_path, dir, namlen, restlen, slash);
178                         snprintf(rpath, PATH_MAX, "%.*s/%s%.*s",
179                                  namlen, dir, user_path, restlen, slash);
180                         dir = rpath;
181                 }
182         }
183         else if (base_path) {
184                 if (*dir != '/') {
185                         /* Allow only absolute */
186                         logerror("'%s': Non-absolute path denied (base-path active)", dir);
187                         return NULL;
188                 }
189                 else {
190                         snprintf(rpath, PATH_MAX, "%s%s", base_path, dir);
191                         dir = rpath;
192                 }
193         }
194
195         path = enter_repo(dir, strict_paths);
196
197         if (!path) {
198                 logerror("'%s': unable to chdir or not a git archive", dir);
199                 return NULL;
200         }
201
202         if ( ok_paths && *ok_paths ) {
203                 char **pp;
204                 int pathlen = strlen(path);
205
206                 /* The validation is done on the paths after enter_repo
207                  * appends optional {.git,.git/.git} and friends, but 
208                  * it does not use getcwd().  So if your /pub is
209                  * a symlink to /mnt/pub, you can whitelist /pub and
210                  * do not have to say /mnt/pub.
211                  * Do not say /pub/.
212                  */
213                 for ( pp = ok_paths ; *pp ; pp++ ) {
214                         int len = strlen(*pp);
215                         if (len <= pathlen &&
216                             !memcmp(*pp, path, len) &&
217                             (path[len] == '\0' ||
218                              (!strict_paths && path[len] == '/')))
219                                 return path;
220                 }
221         }
222         else {
223                 /* be backwards compatible */
224                 if (!strict_paths)
225                         return path;
226         }
227
228         logerror("'%s': not in whitelist", path);
229         return NULL;            /* Fallthrough. Deny by default */
230 }
231
232 static int upload(char *dir)
233 {
234         /* Timeout as string */
235         char timeout_buf[64];
236         const char *path;
237
238         loginfo("Request for '%s'", dir);
239
240         if (!(path = path_ok(dir)))
241                 return -1;
242
243         /*
244          * Security on the cheap.
245          *
246          * We want a readable HEAD, usable "objects" directory, and
247          * a "git-daemon-export-ok" flag that says that the other side
248          * is ok with us doing this.
249          *
250          * path_ok() uses enter_repo() and does whitelist checking.
251          * We only need to make sure the repository is exported.
252          */
253
254         if (!export_all_trees && access("git-daemon-export-ok", F_OK)) {
255                 logerror("'%s': repository not exported.", path);
256                 errno = EACCES;
257                 return -1;
258         }
259
260         /*
261          * We'll ignore SIGTERM from now on, we have a
262          * good client.
263          */
264         signal(SIGTERM, SIG_IGN);
265
266         snprintf(timeout_buf, sizeof timeout_buf, "--timeout=%u", timeout);
267
268         /* git-upload-pack only ever reads stuff, so this is safe */
269         execl_git_cmd("upload-pack", "--strict", timeout_buf, ".", NULL);
270         return -1;
271 }
272
273 static int execute(struct sockaddr *addr)
274 {
275         static char line[1000];
276         int pktlen, len;
277
278         if (addr) {
279                 char addrbuf[256] = "";
280                 int port = -1;
281
282                 if (addr->sa_family == AF_INET) {
283                         struct sockaddr_in *sin_addr = (void *) addr;
284                         inet_ntop(addr->sa_family, &sin_addr->sin_addr, addrbuf, sizeof(addrbuf));
285                         port = sin_addr->sin_port;
286 #ifndef NO_IPV6
287                 } else if (addr && addr->sa_family == AF_INET6) {
288                         struct sockaddr_in6 *sin6_addr = (void *) addr;
289
290                         char *buf = addrbuf;
291                         *buf++ = '['; *buf = '\0'; /* stpcpy() is cool */
292                         inet_ntop(AF_INET6, &sin6_addr->sin6_addr, buf, sizeof(addrbuf) - 1);
293                         strcat(buf, "]");
294
295                         port = sin6_addr->sin6_port;
296 #endif
297                 }
298                 loginfo("Connection from %s:%d", addrbuf, port);
299         }
300
301         alarm(init_timeout ? init_timeout : timeout);
302         pktlen = packet_read_line(0, line, sizeof(line));
303         alarm(0);
304
305         len = strlen(line);
306         if (pktlen != len)
307                 loginfo("Extended attributes (%d bytes) exist <%.*s>",
308                         (int) pktlen - len,
309                         (int) pktlen - len, line + len + 1);
310         if (len && line[len-1] == '\n')
311                 line[--len] = 0;
312
313         if (!strncmp("git-upload-pack ", line, 16))
314                 return upload(line+16);
315
316         logerror("Protocol error: '%s'", line);
317         return -1;
318 }
319
320
321 /*
322  * We count spawned/reaped separately, just to avoid any
323  * races when updating them from signals. The SIGCHLD handler
324  * will only update children_reaped, and the fork logic will
325  * only update children_spawned.
326  *
327  * MAX_CHILDREN should be a power-of-two to make the modulus
328  * operation cheap. It should also be at least twice
329  * the maximum number of connections we will ever allow.
330  */
331 #define MAX_CHILDREN 128
332
333 static int max_connections = 25;
334
335 /* These are updated by the signal handler */
336 static volatile unsigned int children_reaped = 0;
337 static pid_t dead_child[MAX_CHILDREN];
338
339 /* These are updated by the main loop */
340 static unsigned int children_spawned = 0;
341 static unsigned int children_deleted = 0;
342
343 static struct child {
344         pid_t pid;
345         int addrlen;
346         struct sockaddr_storage address;
347 } live_child[MAX_CHILDREN];
348
349 static void add_child(int idx, pid_t pid, struct sockaddr *addr, int addrlen)
350 {
351         live_child[idx].pid = pid;
352         live_child[idx].addrlen = addrlen;
353         memcpy(&live_child[idx].address, addr, addrlen);
354 }
355
356 /*
357  * Walk from "deleted" to "spawned", and remove child "pid".
358  *
359  * We move everything up by one, since the new "deleted" will
360  * be one higher.
361  */
362 static void remove_child(pid_t pid, unsigned deleted, unsigned spawned)
363 {
364         struct child n;
365
366         deleted %= MAX_CHILDREN;
367         spawned %= MAX_CHILDREN;
368         if (live_child[deleted].pid == pid) {
369                 live_child[deleted].pid = -1;
370                 return;
371         }
372         n = live_child[deleted];
373         for (;;) {
374                 struct child m;
375                 deleted = (deleted + 1) % MAX_CHILDREN;
376                 if (deleted == spawned)
377                         die("could not find dead child %d\n", pid);
378                 m = live_child[deleted];
379                 live_child[deleted] = n;
380                 if (m.pid == pid)
381                         return;
382                 n = m;
383         }
384 }
385
386 /*
387  * This gets called if the number of connections grows
388  * past "max_connections".
389  *
390  * We _should_ start off by searching for connections
391  * from the same IP, and if there is some address wth
392  * multiple connections, we should kill that first.
393  *
394  * As it is, we just "randomly" kill 25% of the connections,
395  * and our pseudo-random generator sucks too. I have no
396  * shame.
397  *
398  * Really, this is just a place-holder for a _real_ algorithm.
399  */
400 static void kill_some_children(int signo, unsigned start, unsigned stop)
401 {
402         start %= MAX_CHILDREN;
403         stop %= MAX_CHILDREN;
404         while (start != stop) {
405                 if (!(start & 3))
406                         kill(live_child[start].pid, signo);
407                 start = (start + 1) % MAX_CHILDREN;
408         }
409 }
410
411 static void check_max_connections(void)
412 {
413         for (;;) {
414                 int active;
415                 unsigned spawned, reaped, deleted;
416
417                 spawned = children_spawned;
418                 reaped = children_reaped;
419                 deleted = children_deleted;
420
421                 while (deleted < reaped) {
422                         pid_t pid = dead_child[deleted % MAX_CHILDREN];
423                         remove_child(pid, deleted, spawned);
424                         deleted++;
425                 }
426                 children_deleted = deleted;
427
428                 active = spawned - deleted;
429                 if (active <= max_connections)
430                         break;
431
432                 /* Kill some unstarted connections with SIGTERM */
433                 kill_some_children(SIGTERM, deleted, spawned);
434                 if (active <= max_connections << 1)
435                         break;
436
437                 /* If the SIGTERM thing isn't helping use SIGKILL */
438                 kill_some_children(SIGKILL, deleted, spawned);
439                 sleep(1);
440         }
441 }
442
443 static void handle(int incoming, struct sockaddr *addr, int addrlen)
444 {
445         pid_t pid = fork();
446
447         if (pid) {
448                 unsigned idx;
449
450                 close(incoming);
451                 if (pid < 0)
452                         return;
453
454                 idx = children_spawned % MAX_CHILDREN;
455                 children_spawned++;
456                 add_child(idx, pid, addr, addrlen);
457
458                 check_max_connections();
459                 return;
460         }
461
462         dup2(incoming, 0);
463         dup2(incoming, 1);
464         close(incoming);
465
466         exit(execute(addr));
467 }
468
469 static void child_handler(int signo)
470 {
471         for (;;) {
472                 int status;
473                 pid_t pid = waitpid(-1, &status, WNOHANG);
474
475                 if (pid > 0) {
476                         unsigned reaped = children_reaped;
477                         dead_child[reaped % MAX_CHILDREN] = pid;
478                         children_reaped = reaped + 1;
479                         /* XXX: Custom logging, since we don't wanna getpid() */
480                         if (verbose) {
481                                 const char *dead = "";
482                                 if (!WIFEXITED(status) || WEXITSTATUS(status) > 0)
483                                         dead = " (with error)";
484                                 if (log_syslog)
485                                         syslog(LOG_INFO, "[%d] Disconnected%s", pid, dead);
486                                 else
487                                         fprintf(stderr, "[%d] Disconnected%s\n", pid, dead);
488                         }
489                         continue;
490                 }
491                 break;
492         }
493 }
494
495 static int set_reuse_addr(int sockfd)
496 {
497         int on = 1;
498
499         if (!reuseaddr)
500                 return 0;
501         return setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
502                           &on, sizeof(on));
503 }
504
505 #ifndef NO_IPV6
506
507 static int socksetup(int port, int **socklist_p)
508 {
509         int socknum = 0, *socklist = NULL;
510         int maxfd = -1;
511         char pbuf[NI_MAXSERV];
512
513         struct addrinfo hints, *ai0, *ai;
514         int gai;
515
516         sprintf(pbuf, "%d", port);
517         memset(&hints, 0, sizeof(hints));
518         hints.ai_family = AF_UNSPEC;
519         hints.ai_socktype = SOCK_STREAM;
520         hints.ai_protocol = IPPROTO_TCP;
521         hints.ai_flags = AI_PASSIVE;
522
523         gai = getaddrinfo(NULL, pbuf, &hints, &ai0);
524         if (gai)
525                 die("getaddrinfo() failed: %s\n", gai_strerror(gai));
526
527         for (ai = ai0; ai; ai = ai->ai_next) {
528                 int sockfd;
529                 int *newlist;
530
531                 sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
532                 if (sockfd < 0)
533                         continue;
534                 if (sockfd >= FD_SETSIZE) {
535                         error("too large socket descriptor.");
536                         close(sockfd);
537                         continue;
538                 }
539
540 #ifdef IPV6_V6ONLY
541                 if (ai->ai_family == AF_INET6) {
542                         int on = 1;
543                         setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY,
544                                    &on, sizeof(on));
545                         /* Note: error is not fatal */
546                 }
547 #endif
548
549                 if (set_reuse_addr(sockfd)) {
550                         close(sockfd);
551                         continue;
552                 }
553
554                 if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) {
555                         close(sockfd);
556                         continue;       /* not fatal */
557                 }
558                 if (listen(sockfd, 5) < 0) {
559                         close(sockfd);
560                         continue;       /* not fatal */
561                 }
562
563                 newlist = realloc(socklist, sizeof(int) * (socknum + 1));
564                 if (!newlist)
565                         die("memory allocation failed: %s", strerror(errno));
566
567                 socklist = newlist;
568                 socklist[socknum++] = sockfd;
569
570                 if (maxfd < sockfd)
571                         maxfd = sockfd;
572         }
573
574         freeaddrinfo(ai0);
575
576         *socklist_p = socklist;
577         return socknum;
578 }
579
580 #else /* NO_IPV6 */
581
582 static int socksetup(int port, int **socklist_p)
583 {
584         struct sockaddr_in sin;
585         int sockfd;
586
587         sockfd = socket(AF_INET, SOCK_STREAM, 0);
588         if (sockfd < 0)
589                 return 0;
590
591         memset(&sin, 0, sizeof sin);
592         sin.sin_family = AF_INET;
593         sin.sin_addr.s_addr = htonl(INADDR_ANY);
594         sin.sin_port = htons(port);
595
596         if (set_reuse_addr(sockfd)) {
597                 close(sockfd);
598                 return 0;
599         }
600
601         if ( bind(sockfd, (struct sockaddr *)&sin, sizeof sin) < 0 ) {
602                 close(sockfd);
603                 return 0;
604         }
605
606         if (listen(sockfd, 5) < 0) {
607                 close(sockfd);
608                 return 0;
609         }
610
611         *socklist_p = xmalloc(sizeof(int));
612         **socklist_p = sockfd;
613         return 1;
614 }
615
616 #endif
617
618 static int service_loop(int socknum, int *socklist)
619 {
620         struct pollfd *pfd;
621         int i;
622
623         pfd = xcalloc(socknum, sizeof(struct pollfd));
624
625         for (i = 0; i < socknum; i++) {
626                 pfd[i].fd = socklist[i];
627                 pfd[i].events = POLLIN;
628         }
629
630         signal(SIGCHLD, child_handler);
631
632         for (;;) {
633                 int i;
634
635                 if (poll(pfd, socknum, -1) < 0) {
636                         if (errno != EINTR) {
637                                 error("poll failed, resuming: %s",
638                                       strerror(errno));
639                                 sleep(1);
640                         }
641                         continue;
642                 }
643
644                 for (i = 0; i < socknum; i++) {
645                         if (pfd[i].revents & POLLIN) {
646                                 struct sockaddr_storage ss;
647                                 unsigned int sslen = sizeof(ss);
648                                 int incoming = accept(pfd[i].fd, (struct sockaddr *)&ss, &sslen);
649                                 if (incoming < 0) {
650                                         switch (errno) {
651                                         case EAGAIN:
652                                         case EINTR:
653                                         case ECONNABORTED:
654                                                 continue;
655                                         default:
656                                                 die("accept returned %s", strerror(errno));
657                                         }
658                                 }
659                                 handle(incoming, (struct sockaddr *)&ss, sslen);
660                         }
661                 }
662         }
663 }
664
665 /* if any standard file descriptor is missing open it to /dev/null */
666 static void sanitize_stdfds(void)
667 {
668         int fd = open("/dev/null", O_RDWR, 0);
669         while (fd != -1 && fd < 2)
670                 fd = dup(fd);
671         if (fd == -1)
672                 die("open /dev/null or dup failed: %s", strerror(errno));
673         if (fd > 2)
674                 close(fd);
675 }
676
677 static void daemonize(void)
678 {
679         switch (fork()) {
680                 case 0:
681                         break;
682                 case -1:
683                         die("fork failed: %s", strerror(errno));
684                 default:
685                         exit(0);
686         }
687         if (setsid() == -1)
688                 die("setsid failed: %s", strerror(errno));
689         close(0);
690         close(1);
691         close(2);
692         sanitize_stdfds();
693 }
694
695 static void store_pid(const char *path)
696 {
697         FILE *f = fopen(path, "w");
698         if (!f)
699                 die("cannot open pid file %s: %s", path, strerror(errno));
700         fprintf(f, "%d\n", getpid());
701         fclose(f);
702 }
703
704 static int serve(int port)
705 {
706         int socknum, *socklist;
707
708         socknum = socksetup(port, &socklist);
709         if (socknum == 0)
710                 die("unable to allocate any listen sockets on port %u", port);
711
712         return service_loop(socknum, socklist);
713 }
714
715 int main(int argc, char **argv)
716 {
717         int port = DEFAULT_GIT_PORT;
718         int inetd_mode = 0;
719         const char *pid_file = NULL;
720         int detach = 0;
721         int i;
722
723         /* Without this we cannot rely on waitpid() to tell
724          * what happened to our children.
725          */
726         signal(SIGCHLD, SIG_DFL);
727
728         for (i = 1; i < argc; i++) {
729                 char *arg = argv[i];
730
731                 if (!strncmp(arg, "--port=", 7)) {
732                         char *end;
733                         unsigned long n;
734                         n = strtoul(arg+7, &end, 0);
735                         if (arg[7] && !*end) {
736                                 port = n;
737                                 continue;
738                         }
739                 }
740                 if (!strcmp(arg, "--inetd")) {
741                         inetd_mode = 1;
742                         log_syslog = 1;
743                         continue;
744                 }
745                 if (!strcmp(arg, "--verbose")) {
746                         verbose = 1;
747                         continue;
748                 }
749                 if (!strcmp(arg, "--syslog")) {
750                         log_syslog = 1;
751                         continue;
752                 }
753                 if (!strcmp(arg, "--export-all")) {
754                         export_all_trees = 1;
755                         continue;
756                 }
757                 if (!strncmp(arg, "--timeout=", 10)) {
758                         timeout = atoi(arg+10);
759                         continue;
760                 }
761                 if (!strncmp(arg, "--init-timeout=", 15)) {
762                         init_timeout = atoi(arg+15);
763                         continue;
764                 }
765                 if (!strcmp(arg, "--strict-paths")) {
766                         strict_paths = 1;
767                         continue;
768                 }
769                 if (!strncmp(arg, "--base-path=", 12)) {
770                         base_path = arg+12;
771                         continue;
772                 }
773                 if (!strcmp(arg, "--reuseaddr")) {
774                         reuseaddr = 1;
775                         continue;
776                 }
777                 if (!strcmp(arg, "--user-path")) {
778                         user_path = "";
779                         continue;
780                 }
781                 if (!strncmp(arg, "--user-path=", 12)) {
782                         user_path = arg + 12;
783                         continue;
784                 }
785                 if (!strncmp(arg, "--pid-file=", 11)) {
786                         pid_file = arg + 11;
787                         continue;
788                 }
789                 if (!strcmp(arg, "--detach")) {
790                         detach = 1;
791                         log_syslog = 1;
792                         continue;
793                 }
794                 if (!strcmp(arg, "--")) {
795                         ok_paths = &argv[i+1];
796                         break;
797                 } else if (arg[0] != '-') {
798                         ok_paths = &argv[i];
799                         break;
800                 }
801
802                 usage(daemon_usage);
803         }
804
805         if (log_syslog) {
806                 openlog("git-daemon", 0, LOG_DAEMON);
807                 set_die_routine(daemon_die);
808         }
809
810         if (strict_paths && (!ok_paths || !*ok_paths))
811                 die("option --strict-paths requires a whitelist");
812
813         if (inetd_mode) {
814                 struct sockaddr_storage ss;
815                 struct sockaddr *peer = (struct sockaddr *)&ss;
816                 socklen_t slen = sizeof(ss);
817
818                 freopen("/dev/null", "w", stderr);
819
820                 if (getpeername(0, peer, &slen))
821                         peer = NULL;
822
823                 return execute(peer);
824         }
825
826         if (detach)
827                 daemonize();
828         else
829                 sanitize_stdfds();
830
831         if (pid_file)
832                 store_pid(pid_file);
833
834         return serve(port);
835 }