1 files changed, 56 insertions, 460 deletions

diff --git a/opentracker.c b/opentracker.c
index 5b197d1..60bdceb 100644
--- a/opentracker.c
+++ b/opentracker.c
@@ -23,10 +23,10 @@
 
 /* Libowfat */
 #include "io.h"
-#include "iob.h"
 
 /* Opentracker */
 #include "ot_accesslist.h"
+#include "ot_config.h"
 #include "ot_hex.h"
 #include "ot_http.h"
 #include "ot_ip.h"
@@ -35,20 +35,17 @@
 #include "ot_random.h"
 #include "ot_scan.h"
 #include "ot_socket.h"
+#include "ot_timeout.h"
 #include "ot_stats.h"
 #include "ot_udp.h"
 #include "trackerlogic.h"
 
 /* Globals */
 time_t              g_now_seconds;
-char               *g_redirecturl;
 uint32_t            g_tracker_id;
 volatile int        g_opentracker_running = 1;
 int                 g_self_pipe[2];
 
-static char        *g_serverdir;
-static char        *g_serveruser;
-static unsigned int g_udp_workers;
 
 static void         panic(const char *routine) __attribute__((noreturn));
 static void         panic(const char *routine) {
@@ -100,42 +97,6 @@ static void install_signal_handlers(void) {
   pthread_sigmask(SIG_UNBLOCK, &signal_mask, NULL);
 }
 
-static void usage(char *name) {
-  fprintf(stderr,
-          "Usage: %s [-i ip] [-p port] [-P port] [-r redirect] [-d dir] [-u user] [-A ip[/bits]] [-f config] [-s livesyncport]"
-#ifdef WANT_ACCESSLIST_BLACK
-          " [-b blacklistfile]"
-#elif defined(WANT_ACCESSLIST_WHITE)
-          " [-w whitelistfile]"
-#endif
-          "\n",
-          name);
-}
-
-#define HELPLINE(opt, desc) fprintf(stderr, "\t%-10s%s\n", opt, desc)
-static void help(char *name) {
-  usage(name);
-
-  HELPLINE("-f config", "include and execute the config file");
-  HELPLINE("-i ip", "specify ip to bind to with next -[pP] (default: any, overrides preceeding ones)");
-  HELPLINE("-p port", "do bind to tcp port (default: 6969, you may specify more than one)");
-  HELPLINE("-P port", "do bind to udp port (default: 6969, you may specify more than one)");
-  HELPLINE("-r redirecturl", "specify url where / should be redirected to (default none)");
-  HELPLINE("-d dir", "specify directory to try to chroot to (default: \".\")");
-  HELPLINE("-u user", "specify user under whose privileges opentracker should run (default: \"nobody\")");
-  HELPLINE("-A ip[/bits]", "bless an ip address or net as admin address (e.g. to allow syncs from this address)");
-#ifdef WANT_ACCESSLIST_BLACK
-  HELPLINE("-b file", "specify blacklist file.");
-#elif defined(WANT_ACCESSLIST_WHITE)
-  HELPLINE("-w file", "specify whitelist file.");
-#endif
-
-  fprintf(stderr, "\nExample:   ./opentracker -i 127.0.0.1 -p 6969 -P 6969 -f ./opentracker.conf -i 10.1.1.23 -p 2710 -p 80\n");
-  fprintf(stderr, "           Here -i 127.0.0.1 selects the ip address for the next -p 6969 and -P 6969.\n");
-  fprintf(stderr, "           If no port is bound from config file or command line, the last address given\n");
-  fprintf(stderr, "           (or ::1 if none is set) will be used on port 6969.\n");
-}
-#undef HELPLINE
 
 static ssize_t header_complete(char *request, ssize_t byte_count) {
   ssize_t i = 0, state = 0;
@@ -159,9 +120,8 @@ static ssize_t header_complete(char *request, ssize_t byte_count) {
 static void handle_dead(const int64_t sock) {
   struct http_data *cookie = io_getcookie(sock);
   if (cookie) {
-    size_t i;
-    for (i = 0; i < cookie->batches; ++i)
-      iob_reset(cookie->batch + i);
+    if (cookie->batch)
+      batch_reset(cookie->batch);
     free(cookie->batch);
     buf_reset(&cookie->request);
     if (cookie->flag & (STRUCT_HTTP_FLAG_WAITINGFORTASK | STRUCT_HTTP_FLAG_CHUNKED_IN_TRANSFER))
@@ -217,33 +177,23 @@ static void handle_read(const int64_t sock, struct ot_workstruct *ws) {
 
 static void handle_write(const int64_t sock) {
   struct http_data *cookie = io_getcookie(sock);
-  size_t            i;
   int               chunked = 0;
 
-  /* Look for the first io_batch still containing bytes to write */
   if (cookie) {
     if (cookie->flag & STRUCT_HTTP_FLAG_CHUNKED_IN_TRANSFER)
       chunked = 1;
 
-    for (i = 0; i < cookie->batches; ++i) {
-      if (cookie->batch[i].bytesleft) {
-        int64_t res = iob_send(sock, cookie->batch + i);
-
-        if (res == -3) {
-          handle_dead(sock);
-          return;
-        }
-
-        if (!cookie->batch[i].bytesleft)
-          continue;
-
-        if (res == -1 || res > 0 || i < cookie->batches - 1)
-          return;
+    if (cookie->batch) {
+      if (batch_send(sock, cookie->batch) == BATCH_FAILED) {
+        handle_dead(sock);
+        return;
       }
+      if (batch_pending(cookie->batch))
+        return;
     }
   }
 
-  /* In a chunked transfer after all batches accumulated have been sent, wait for the next one */
+  /* In a chunked transfer, wait for the next piece once everything queued has gone out */
   if (chunked)
     io_dontwantwrite(sock);
   else
@@ -255,7 +205,6 @@ static void handle_accept(const int64_t serversocket) {
   int64_t           sock;
   ot_ip6            ip;
   uint16_t          port;
-  tai6464           t;
 
   while ((sock = socket_accept(serversocket, ip, &port)) != -1) {
 
@@ -274,11 +223,7 @@ static void handle_accept(const int64_t serversocket) {
 
     stats_issue_event(EVENT_ACCEPT, FLAG_TCP, (uintptr_t)ip);
 
-    /* That breaks taia encapsulation. But there is no way to take system
-       time this often in FreeBSD and libowfat does not allow to set unix time */
-    taia_uint(&t, 0); /* Clear t */
-    tai_unix(&(t.sec), (g_now_seconds + OT_CLIENT_TIMEOUT));
-    io_timeout(sock, t);
+    timeout_in(sock, OT_CLIENT_TIMEOUT);
   }
   io_eagain(serversocket);
 }
@@ -338,320 +283,75 @@ static void *server_mainloop(void *args) {
   return 0;
 }
 
-static int64_t ot_try_bind(ot_ip6 ip, uint16_t port, PROTO_FLAG proto) {
-  int64_t sock;
+
+static void listen_bind_one(ot_listen *entry) {
+  socket_sharing sharing = entry->shared ? SOCKET_SHARED : SOCKET_EXCLUSIVE;
 
 #ifdef _DEBUG
   {
-    char *protos[] = {"TCP", "UDP", "UDP mcast"};
+    const char *protos[] = {"TCP", "UDP", "UDP mcast"};
     char  _debug[512];
-    int   off  = snprintf(_debug, sizeof(_debug), "Binding socket type %s to address [", protos[proto]);
-    off       += ip_format(_debug + off, ip);
-    snprintf(_debug + off, sizeof(_debug) - off, "]:%d...", port);
+    int   off  = snprintf(_debug, sizeof(_debug), "Binding socket type %s to address [", protos[entry->proto]);
+    off       += ip_format(_debug + off, entry->ip);
+    snprintf(_debug + off, sizeof(_debug) - off, "]:%d...", entry->port);
     fputs(_debug, stderr);
   }
 #endif
 
-  if (proto == FLAG_TCP) {
-    if ((sock = socket_tcp_listen(ip, port)) == -1)
+#ifdef WANT_SYNC_LIVE
+  if (entry->proto == FLAG_MCA) {
+    livesync_bind_mcast(entry->ip, entry->port);
+#ifdef _DEBUG
+    fputs(" success.\n", stderr);
+#endif
+    return;
+  }
+#endif
+
+  if (entry->proto == FLAG_TCP) {
+    if ((entry->sock = socket_tcp_listen(entry->ip, entry->port, sharing)) == -1)
       panic("socket_tcp_listen");
   } else {
-    if ((sock = socket_udp_bind(ip, port)) == -1)
+    if ((entry->sock = socket_udp_bind(entry->ip, entry->port, sharing)) == -1)
       panic("socket_udp_bind");
   }
 
-  if (!io_fd(sock))
+  if (!io_fd(entry->sock))
     panic("io_fd");
 
-  io_setcookie(sock, (void *)proto);
-
-  if ((proto == FLAG_UDP) && g_udp_workers) {
-    io_block(sock);
-    udp_init(sock, g_udp_workers);
-  } else
-    io_wantread(sock);
+  io_setcookie(entry->sock, (void *)entry->proto);
+  io_wantread(entry->sock);
 
 #ifdef _DEBUG
   fputs(" success.\n", stderr);
 #endif
-
-  return sock;
 }
 
-char *set_config_option(char **option, char *value) {
-#ifdef _DEBUG
-  fprintf(stderr, "Setting config option: %s\n", value);
-#endif
-  while (isspace(*value))
-    ++value;
-  free(*option);
-  return *option = strdup(value);
-}
-
-static int scan_ip6_port(const char *src, ot_ip6 ip, uint16_t *port) {
-  const char *s = src;
-  uint64_t    value;
-  int         off, bracket = 0;
-  while (isspace(*s))
-    ++s;
-  if (*s == '[')
-    ++s, ++bracket; /* for v6 style notation */
-  if (!(off = ip_scan(s, ip)))
-    return 0;
-  s += off;
-  if (bracket && *s == ']')
-    ++s;
-  if (*s == 0 || isspace(*s))
-    return s - src;
-  if (!ip_is_v4mapped(ip)) {
-    if (*s != ':' && *s != '.')
-      return 0;
-    if (!bracket && *(s) == ':')
-      return 0;
-    s++;
-  } else {
-    if (*(s++) != ':')
-      return 0;
-  }
-  if (!(off = scan_udec(s, &value, 65535)))
-    return 0;
-  *port = (uint16_t)value;
-  return off + s - src;
-}
+/* Bound in the order the entries were given.
+   Note: On macOS SO_REUSEPORT delivers everything to the socket that bound last. */
+static void listen_bind_all(void) {
+  size_t     count, i;
+  ot_listen *entries = config_listen_entries(&count);
 
-static int scan_ip6_net(const char *src, ot_net *net) {
-  const char *s = src;
-  uint64_t    value;
-  int         off;
-  while (isspace(*s))
-    ++s;
-  if (!(off = ip_scan(s, net->address)))
-    return 0;
-  s += off;
-  if (*s != '/')
-    net->bits = 128;
-  else {
-    s++;
-    if (!(off = scan_udec(s, &value, 128)))
-      return 0;
-    net->bits = (int)value;
-    if (ip_is_v4mapped(net->address))
-      net->bits += 96;
-    if (net->bits > 128)
-      return 0;
-    s += off;
-  }
-  return off + s - src;
+  for (i = 0; i < count; ++i)
+    listen_bind_one(entries + i);
 }
 
-typedef enum {
-    CONFIG_UNKNOWN,
-    CONFIG_TRACKER_ROOTDIR,
-    CONFIG_TRACKER_USER,
-    CONFIG_LISTEN_TCP_UDP,
-    CONFIG_LISTEN_TCP,
-    CONFIG_LISTEN_UDP,
-    CONFIG_LISTEN_UDP_WORKERS,
-    CONFIG_LISTEN_REUSEPORT,
-    CONFIG_ACCESS_WHITELIST,
-    CONFIG_ACCESS_BLACKLIST,
-    CONFIG_ACCESS_FIFO_ADD,
-    CONFIG_ACCESS_FIFO_DELETE,
-    CONFIG_ACCESS_STATS,
-    CONFIG_ACCESS_STATS_PATH,
-    CONFIG_ACCESS_PROXY,
-    CONFIG_TRACKER_REDIRECT_URL,
-    CONFIG_LIVESYNC_CLUSTER_NODE_IP,
-    CONFIG_LIVESYNC_CLUSTER_LISTEN,
-} config_kind;
+static void listen_start_udp_workers(void) {
+  size_t     count, i;
+  ot_listen *entries = config_listen_entries(&count);
 
-typedef struct {
-    const char *name;
-    size_t len;
-    config_kind kind;
-} config_key;
+  udp_init();
 
-#define CONFIG_KEY(s, k) { s, sizeof(s) - 1, k }
+  for (i = 0; i < count; ++i) {
+    ot_listen *entry = entries + i;
 
-static const config_key config_keys[] = {
-    CONFIG_KEY("tracker.rootdir",          CONFIG_TRACKER_ROOTDIR),
-    CONFIG_KEY("tracker.user",             CONFIG_TRACKER_USER),
-    CONFIG_KEY("listen.tcp_udp",           CONFIG_LISTEN_TCP_UDP),
-    CONFIG_KEY("listen.tcp",               CONFIG_LISTEN_TCP),
-    CONFIG_KEY("listen.udp",               CONFIG_LISTEN_UDP),
-    CONFIG_KEY("listen.udp.workers",       CONFIG_LISTEN_UDP_WORKERS),
-    CONFIG_KEY("listen.reuseport",         CONFIG_LISTEN_REUSEPORT),
-#ifdef WANT_ACCESSLIST_WHITE
-    CONFIG_KEY("access.whitelist",         CONFIG_ACCESS_WHITELIST),
-#elif defined(WANT_ACCESSLIST_BLACK)
-    CONFIG_KEY("access.blacklist",         CONFIG_ACCESS_BLACKLIST),
-#endif
-#ifdef WANT_DYNAMIC_ACCESSLIST
-    CONFIG_KEY("access.fifo_add",          CONFIG_ACCESS_FIFO_ADD),
-    CONFIG_KEY("access.fifo_delete",       CONFIG_ACCESS_FIFO_DELETE),
-#endif
-#ifdef WANT_RESTRICT_STATS
-    CONFIG_KEY("access.stats",             CONFIG_ACCESS_STATS),
-#endif
-    CONFIG_KEY("access.stats_path",        CONFIG_ACCESS_STATS_PATH),
-#ifdef WANT_IP_FROM_PROXY
-    CONFIG_KEY("access.proxy",             CONFIG_ACCESS_PROXY),
-#endif
-    CONFIG_KEY("tracker.redirect_url",     CONFIG_TRACKER_REDIRECT_URL),
-#ifdef WANT_SYNC_LIVE
-    CONFIG_KEY("livesync.cluster.node_ip", CONFIG_LIVESYNC_CLUSTER_NODE_IP),
-    CONFIG_KEY("livesync.cluster.listen",  CONFIG_LIVESYNC_CLUSTER_LISTEN),
-#endif
-};
-static const size_t config_entry_count = sizeof(config_keys) / sizeof(config_keys[0]);
-
-static config_kind parse_config_key(char **p) {
-    size_t i;
-    for (i = 0; i < config_entry_count; ++i) {
-        const config_key *key = &config_keys[i];
-        if (strncmp(*p, key->name, key->len) == 0 && isspace((unsigned char)(*p)[key->len])) {
-            *p += key->len + 1;
-            /* Skip white spaces */
-            while (isspace((unsigned char)**p))
-              ++(*p);
-            return key->kind;
-        }
-    }
-    return CONFIG_UNKNOWN;
-}
-
-int parse_configfile(char *config_filename) {
-  FILE  *config_file_handle;
-  char   inbuf[512];
-  ot_ip6 tmpip;
-#if defined(WANT_RESTRICT_STATS) || defined(WANT_IP_FROM_PROXY) || defined(WANT_SYNC_LIVE)
-  ot_net tmpnet;
-#endif
-  int bound = 0;
-
-  config_file_handle = fopen(config_filename, "r");
-
-  if (config_file_handle == NULL) {
-    fprintf(stderr, "Warning: Can't open config file: %s.", config_filename);
-    return 0;
-  }
-
-  while (fgets(inbuf, sizeof(inbuf), config_file_handle)) {
-    char    *p = inbuf, *end;
-    uint64_t value;
-    uint16_t tmpport = 6969;
-
-    /* Skip white spaces */
-    while (isspace((unsigned char)*p))
-      ++p;
-
-    /* Ignore comments and empty lines */
-    if ((*p == '#') || (*p == '\n') || (*p == 0))
+    if (entry->proto != FLAG_UDP || entry->workers <= 0)
       continue;
 
-    /* consume trailing new lines and spaces */
-    end = p + strlen(p);
-    while (end > p && isspace((unsigned char)end[-1]))
-      *--end = 0;
-
-    /* Scan for commands */
-    switch (parse_config_key(&p)) {
-      case CONFIG_TRACKER_ROOTDIR:
-        set_config_option(&g_serverdir, p);
-        break;
-      case CONFIG_TRACKER_USER:
-        set_config_option(&g_serveruser, p);
-        break;
-      case CONFIG_LISTEN_TCP_UDP:
-        if (!scan_ip6_port(p, tmpip, &tmpport))
-          goto parse_error;
-        ot_try_bind(tmpip, tmpport, FLAG_TCP);
-        ++bound;
-        ot_try_bind(tmpip, tmpport, FLAG_UDP);
-        ++bound;
-        break;
-      case CONFIG_LISTEN_TCP:
-        if (!scan_ip6_port(p, tmpip, &tmpport))
-          goto parse_error;
-        ot_try_bind(tmpip, tmpport, FLAG_TCP);
-        ++bound;
-        break;
-      case CONFIG_LISTEN_UDP:
-        if (!scan_ip6_port(p, tmpip, &tmpport))
-          goto parse_error;
-        ot_try_bind(tmpip, tmpport, FLAG_UDP);
-        ++bound;
-        break;
-      case CONFIG_LISTEN_UDP_WORKERS:
-        if (scan_udec(p, &value, UINT_MAX))
-          g_udp_workers = (unsigned int)value;
-        break;
-      case CONFIG_LISTEN_REUSEPORT:
-        /* Like listen.udp.workers this is read when a socket is bound, so it
-           has to come before the listen lines it should apply to. */
-        if (!scan_udec(p, &value, 1))
-          goto parse_error;
-        g_socket_reuseport = (int)value;
-        break;
-#ifdef WANT_ACCESSLIST_WHITE
-      case CONFIG_ACCESS_WHITELIST:
-        set_config_option(&g_accesslist_filename, p);
-        break;
-#elif defined(WANT_ACCESSLIST_BLACK)
-      case CONFIG_ACCESS_BLACKLIST:
-        set_config_option(&g_accesslist_filename, p);
-        break;
-#endif
-#ifdef WANT_DYNAMIC_ACCESSLIST
-      case CONFIG_ACCESS_FIFO_ADD:
-        set_config_option(&g_accesslist_pipe_add, p);
-        break;
-      case CONFIG_ACCESS_FIFO_DELETE:
-        set_config_option(&g_accesslist_pipe_delete, p);
-        break;
-#endif
-#ifdef WANT_RESTRICT_STATS
-      case CONFIG_ACCESS_STATS:
-        if (!scan_ip6_net(p, &tmpnet))
-          goto parse_error;
-        accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_STAT);
-        break;
-#endif
-      case CONFIG_ACCESS_STATS_PATH:
-        set_config_option(&g_stats_path, p);
-        break;
-#ifdef WANT_IP_FROM_PROXY
-      case CONFIG_ACCESS_PROXY:
-        if (!scan_ip6_net(p, &tmpnet))
-          goto parse_error;
-        accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_PROXY);
-        break;
-#endif
-      case CONFIG_TRACKER_REDIRECT_URL:
-        set_config_option(&g_redirecturl, p);
-        break;
-#ifdef WANT_SYNC_LIVE
-      case CONFIG_LIVESYNC_CLUSTER_NODE_IP:
-        if (!scan_ip6_net(p, &tmpnet))
-          goto parse_error;
-        accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_LIVESYNC);
-        break;
-      case CONFIG_LIVESYNC_CLUSTER_LISTEN:
-        tmpport = LIVESYNC_PORT;
-        if (!scan_ip6_port(p, tmpip, &tmpport))
-          goto parse_error;
-        livesync_bind_mcast(tmpip, tmpport);
-      break;
-#endif
-      default:
-        fprintf(stderr, "Unhandled line in config file: %s\n", inbuf);
-        break;
-      parse_error:
-        fprintf(stderr, "Parse error in config file: %s\n", inbuf);
-    }
+    io_block(entry->sock);
+    udp_workers_install(entry->sock, (unsigned int)entry->workers);
   }
-  fclose(config_file_handle);
-  return bound;
 }
 
 void load_state(const char *const state_filename) {
@@ -745,115 +445,12 @@ static void *time_caching_worker(void *args) {
 }
 
 int main(int argc, char **argv) {
-  ot_ip6    serverip;
-  ot_net    tmpnet;
-  int       bound = 0, scanon = 1;
-  uint64_t  value;
-  char     *statefile = 0;
   pthread_t thread_id; /* time cacher */
 
-  memset(serverip, 0, sizeof(ot_ip6));
-#ifdef WANT_V4_ONLY
-  serverip[10] = serverip[11] = -1;
-#endif
-
   random_init();
+  config_parse(argc, argv);
 
-  while (scanon) {
-    switch (getopt(argc, argv,
-                   ":i:p:A:P:d:u:r:s:f:l:v"
-#ifdef WANT_ACCESSLIST_BLACK
-                   "b:"
-#elif defined(WANT_ACCESSLIST_WHITE)
-                   "w:"
-#endif
-                   "h")) {
-    case -1:
-      scanon = 0;
-      break;
-    case 'i':
-      if (!ip_scan(optarg, serverip)) {
-        usage(argv[0]);
-        exit(1);
-      }
-      break;
-#ifdef WANT_ACCESSLIST_BLACK
-    case 'b':
-      set_config_option(&g_accesslist_filename, optarg);
-      break;
-#elif defined(WANT_ACCESSLIST_WHITE)
-    case 'w':
-      set_config_option(&g_accesslist_filename, optarg);
-      break;
-#endif
-    case 'p':
-      if (!scan_udec(optarg, &value, 65535)) {
-        usage(argv[0]);
-        exit(1);
-      }
-      ot_try_bind(serverip, (uint16_t)value, FLAG_TCP);
-      bound++;
-      break;
-    case 'P':
-      if (!scan_udec(optarg, &value, 65535)) {
-        usage(argv[0]);
-        exit(1);
-      }
-      ot_try_bind(serverip, (uint16_t)value, FLAG_UDP);
-      bound++;
-      break;
-#ifdef WANT_SYNC_LIVE
-    case 's':
-      if (!scan_udec(optarg, &value, 65535)) {
-        usage(argv[0]);
-        exit(1);
-      }
-      livesync_bind_mcast(serverip, (uint16_t)value);
-      break;
-#endif
-    case 'd':
-      set_config_option(&g_serverdir, optarg);
-      break;
-    case 'u':
-      set_config_option(&g_serveruser, optarg);
-      break;
-    case 'r':
-      set_config_option(&g_redirecturl, optarg);
-      break;
-    case 'l':
-      statefile = optarg;
-      break;
-    case 'A':
-      if (!scan_ip6_net(optarg, &tmpnet)) {
-        usage(argv[0]);
-        exit(1);
-      }
-      accesslist_bless_net(&tmpnet, 0xffff); /* Allow everything for now */
-      break;
-    case 'f':
-      bound += parse_configfile(optarg);
-      break;
-    case 'h':
-      help(argv[0]);
-      exit(0);
-    case 'v': {
-      char buffer[8192];
-      stats_return_tracker_version(buffer);
-      fputs(buffer, stderr);
-      exit(0);
-    }
-    default:
-    case '?':
-      usage(argv[0]);
-      exit(1);
-    }
-  }
-
-  /* Bind to our default tcp/udp ports */
-  if (!bound) {
-    ot_try_bind(serverip, 6969, FLAG_TCP);
-    ot_try_bind(serverip, 6969, FLAG_UDP);
-  }
+  listen_bind_all();
 
   defaul_signal_handlers();
 
@@ -888,13 +485,12 @@ int main(int argc, char **argv) {
   fprintf(stderr, "... done.\n");
 #endif
 
-  if (statefile)
-    load_state(statefile);
+  if (g_statefile)
+    load_state(g_statefile);
 
   install_signal_handlers();
 
-  if (!g_udp_workers)
-    udp_init(-1, 0);
+  listen_start_udp_workers();
 
   server_mainloop(0);