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
  10 static const char daemon_usage[] = "git-daemon [--inetd | --port=n]";
  11
  12 static int upload(char *dir, int dirlen)
  13 {
  14         if (chdir(dir) < 0)
  15                 return -1;
  16         chdir(".git");
  17
  18         /*
  19          * Security on the cheap.
  20          *
  21          * We want a readable HEAD, usable "objects" directory, and
  22          * a "git-daemon-export-ok" flag that says that the other side
  23          * is ok with us doing this.
  24          */
  25         if (access("git-daemon-export-ok", F_OK) ||
  26             access("objects/00", X_OK) ||
  27             access("HEAD", R_OK))
  28                 return -1;
  29
  30         /*
  31          * We'll ignore SIGTERM from now on, we have a
  32          * good client.
  33          */
  34         signal(SIGTERM, SIG_IGN);
  35
  36         /* git-upload-pack only ever reads stuff, so this is safe */
  37         execlp("git-upload-pack", "git-upload-pack", ".", NULL);
  38         return -1;
  39 }
  40
  41 static int execute(void)
  42 {
  43         static char line[1000];
  44         int len;
  45
  46         len = packet_read_line(0, line, sizeof(line));
  47
  48         if (len && line[len-1] == '\n')
  49                 line[--len] = 0;
  50
  51         if (!strncmp("git-upload-pack /", line, 17))
  52                 return upload(line + 16, len - 16);
  53
  54         fprintf(stderr, "got bad connection '%s'\n", line);
  55         return -1;
  56 }
  57
  58
  59 /*
  60  * We count spawned/reaped separately, just to avoid any
  61  * races when updating them from signals. The SIGCHLD handler
  62  * will only update children_reaped, and the fork logic will
  63  * only update children_spawned.
  64  *
  65  * MAX_CHILDREN should be a power-of-two to make the modulus
  66  * operation cheap. It should also be at least twice
  67  * the maximum number of connections we will ever allow.
  68  */
  69 #define MAX_CHILDREN 128
  70
  71 static int max_connections = 25;
  72
  73 /* These are updated by the signal handler */
  74 static volatile unsigned int children_reaped = 0;
  75 static pid_t dead_child[MAX_CHILDREN];
  76
  77 /* These are updated by the main loop */
  78 static unsigned int children_spawned = 0;
  79 static unsigned int children_deleted = 0;
  80
  81 static struct child {
  82         pid_t pid;
  83         int addrlen;
  84         struct sockaddr_storage address;
  85 } live_child[MAX_CHILDREN];
  86
  87 static void add_child(int idx, pid_t pid, struct sockaddr *addr, int addrlen)
  88 {
  89         live_child[idx].pid = pid;
  90         live_child[idx].addrlen = addrlen;
  91         memcpy(&live_child[idx].address, addr, addrlen);
  92 }
  93
  94 /*
  95  * Walk from "deleted" to "spawned", and remove child "pid".
  96  *
  97  * We move everything up by one, since the new "deleted" will
  98  * be one higher.
  99  */
 100 static void remove_child(pid_t pid, unsigned deleted, unsigned spawned)
 101 {
 102         struct child n;
 103
 104         deleted %= MAX_CHILDREN;
 105         spawned %= MAX_CHILDREN;
 106         if (live_child[deleted].pid == pid) {
 107                 live_child[deleted].pid = -1;
 108                 return;
 109         }
 110         n = live_child[deleted];
 111         for (;;) {
 112                 struct child m;
 113                 deleted = (deleted + 1) % MAX_CHILDREN;
 114                 if (deleted == spawned)
 115                         die("could not find dead child %d\n", pid);
 116                 m = live_child[deleted];
 117                 live_child[deleted] = n;
 118                 if (m.pid == pid)
 119                         return;
 120                 n = m;
 121         }
 122 }
 123
 124 /*
 125  * This gets called if the number of connections grows
 126  * past "max_connections".
 127  *
 128  * We _should_ start off by searching for connections
 129  * from the same IP, and if there is some address wth
 130  * multiple connections, we should kill that first.
 131  *
 132  * As it is, we just "randomly" kill 25% of the connections,
 133  * and our pseudo-random generator sucks too. I have no
 134  * shame.
 135  *
 136  * Really, this is just a place-holder for a _real_ algorithm.
 137  */
 138 static void kill_some_children(int signo, unsigned start, unsigned stop)
 139 {
 140         start %= MAX_CHILDREN;
 141         stop %= MAX_CHILDREN;
 142         while (start != stop) {
 143                 if (!(start & 3))
 144                         kill(live_child[start].pid, signo);
 145                 start = (start + 1) % MAX_CHILDREN;
 146         }
 147 }
 148
 149 static void check_max_connections(void)
 150 {
 151         for (;;) {
 152                 int active;
 153                 unsigned spawned, reaped, deleted;
 154
 155                 spawned = children_spawned;
 156                 reaped = children_reaped;
 157                 deleted = children_deleted;
 158
 159                 while (deleted < reaped) {
 160                         pid_t pid = dead_child[deleted % MAX_CHILDREN];
 161                         remove_child(pid, deleted, spawned);
 162                         deleted++;
 163                 }
 164                 children_deleted = deleted;
 165
 166                 active = spawned - deleted;
 167                 if (active <= max_connections)
 168                         break;
 169
 170                 /* Kill some unstarted connections with SIGTERM */
 171                 kill_some_children(SIGTERM, deleted, spawned);
 172                 if (active <= max_connections << 1)
 173                         break;
 174
 175                 /* If the SIGTERM thing isn't helping use SIGKILL */
 176                 kill_some_children(SIGKILL, deleted, spawned);
 177                 sleep(1);
 178         }
 179 }
 180
 181 static void handle(int incoming, struct sockaddr *addr, int addrlen)
 182 {
 183         pid_t pid = fork();
 184
 185         if (pid) {
 186                 unsigned idx;
 187
 188                 close(incoming);
 189                 if (pid < 0)
 190                         return;
 191
 192                 idx = children_spawned % MAX_CHILDREN;
 193                 children_spawned++;
 194                 add_child(idx, pid, addr, addrlen);
 195
 196                 check_max_connections();
 197                 return;
 198         }
 199
 200         dup2(incoming, 0);
 201         dup2(incoming, 1);
 202         close(incoming);
 203         exit(execute());
 204 }
 205
 206 static void child_handler(int signo)
 207 {
 208         for (;;) {
 209                 pid_t pid = waitpid(-1, NULL, WNOHANG);
 210
 211                 if (pid > 0) {
 212                         unsigned reaped = children_reaped;
 213                         dead_child[reaped % MAX_CHILDREN] = pid;
 214                         children_reaped = reaped + 1;
 215                         continue;
 216                 }
 217                 break;
 218         }
 219 }
 220
 221 static int serve(int port)
 222 {
 223         struct addrinfo hints, *ai0, *ai;
 224         int gai;
 225         int socknum = 0, *socklist = NULL;
 226         int maxfd = -1;
 227         fd_set fds_init, fds;
 228         char pbuf[NI_MAXSERV];
 229
 230         signal(SIGCHLD, child_handler);
 231
 232         sprintf(pbuf, "%d", port);
 233         memset(&hints, 0, sizeof(hints));
 234         hints.ai_family = AF_UNSPEC;
 235         hints.ai_socktype = SOCK_STREAM;
 236         hints.ai_protocol = IPPROTO_TCP;
 237         hints.ai_flags = AI_PASSIVE;
 238
 239         gai = getaddrinfo(NULL, pbuf, &hints, &ai0);
 240         if (gai)
 241                 die("getaddrinfo() failed: %s\n", gai_strerror(gai));
 242
 243         FD_ZERO(&fds_init);
 244
 245         for (ai = ai0; ai; ai = ai->ai_next) {
 246                 int sockfd;
 247                 int *newlist;
 248
 249                 sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
 250                 if (sockfd < 0)
 251                         continue;
 252                 if (sockfd >= FD_SETSIZE) {
 253                         error("too large socket descriptor.");
 254                         close(sockfd);
 255                         continue;
 256                 }
 257
 258 #ifdef IPV6_V6ONLY
 259                 if (ai->ai_family == AF_INET6) {
 260                         int on = 1;
 261                         setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY,
 262                                    &on, sizeof(on));
 263                         /* Note: error is not fatal */
 264                 }
 265 #endif
 266
 267                 if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) {
 268                         close(sockfd);
 269                         continue;       /* not fatal */
 270                 }
 271                 if (listen(sockfd, 5) < 0) {
 272                         close(sockfd);
 273                         continue;       /* not fatal */
 274                 }
 275
 276                 newlist = realloc(socklist, sizeof(int) * (socknum + 1));
 277                 if (!newlist)
 278                         die("memory allocation failed: %s", strerror(errno));
 279
 280                 socklist = newlist;
 281                 socklist[socknum++] = sockfd;
 282
 283                 FD_SET(sockfd, &fds_init);
 284                 if (maxfd < sockfd)
 285                         maxfd = sockfd;
 286         }
 287
 288         freeaddrinfo(ai0);
 289
 290         if (socknum == 0)
 291                 die("unable to allocate any listen sockets on port %u", port);
 292
 293         for (;;) {
 294                 int i;
 295                 fds = fds_init;
 296
 297                 if (select(maxfd + 1, &fds, NULL, NULL, NULL) < 0) {
 298                         if (errno != EINTR) {
 299                                 error("select failed, resuming: %s",
 300                                       strerror(errno));
 301                                 sleep(1);
 302                         }
 303                         continue;
 304                 }
 305
 306                 for (i = 0; i < socknum; i++) {
 307                         int sockfd = socklist[i];
 308
 309                         if (FD_ISSET(sockfd, &fds)) {
 310                                 struct sockaddr_storage ss;
 311                                 int sslen = sizeof(ss);
 312                                 int incoming = accept(sockfd, (struct sockaddr *)&ss, &sslen);
 313                                 if (incoming < 0) {
 314                                         switch (errno) {
 315                                         case EAGAIN:
 316                                         case EINTR:
 317                                         case ECONNABORTED:
 318                                                 continue;
 319                                         default:
 320                                                 die("accept returned %s", strerror(errno));
 321                                         }
 322                                 }
 323                                 handle(incoming, (struct sockaddr *)&ss, sslen);
 324                         }
 325                 }
 326         }
 327 }
 328
 329 int main(int argc, char **argv)
 330 {
 331         int port = DEFAULT_GIT_PORT;
 332         int inetd_mode = 0;
 333         int i;
 334
 335         for (i = 1; i < argc; i++) {
 336                 char *arg = argv[i];
 337
 338                 if (!strncmp(arg, "--port=", 7)) {
 339                         char *end;
 340                         unsigned long n;
 341                         n = strtoul(arg+7, &end, 0);
 342                         if (arg[7] && !*end) {
 343                                 port = n;
 344                                 continue;
 345                         }
 346                 }
 347
 348                 if (!strcmp(arg, "--inetd")) {
 349                         inetd_mode = 1;
 350                         continue;
 351                 }
 352
 353                 usage(daemon_usage);
 354         }
 355
 356         if (inetd_mode) {
 357                 fclose(stderr); //FIXME: workaround
 358                 return execute();
 359         }
 360
 361         return serve(port);
 362 }