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