src/mastersrv/master.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <stdint.h>
   4 #include <stdbool.h>
   5 #include <stdarg.h>
   6 #include <ctype.h>
   7 #include <string.h>
   8 #include <time.h>
   9 #include <signal.h>
  10
  11 #define ENET_DEBUG 1
  12 #include <enet/enet.h>
  13 #include <enet/types.h>
  14
  15 #define MS_VERSION "0.3"
  16 #define MS_MAX_SERVERS 128
  17 #define MS_MAX_CLIENTS (MS_MAX_SERVERS + 1)
  18 #define MS_URGENT_FILE "urgent.txt"
  19 #define MS_MOTD_FILE "motd.txt"
  20 #define MS_BAN_FILE "master_bans.txt"
  21
  22 #define DEFAULT_SPAM_CAP 10
  23 #define DEFAULT_MAX_SERVERS MS_MAX_SERVERS
  24 #define DEFAULT_MAX_PER_HOST 4
  25 #define DEFAULT_SERVER_TIMEOUT 100
  26 #define DEFAULT_CLIENT_TIMEOUT 3
  27 #define DEFAULT_SPAM_TIMEOUT 1
  28 #define DEFAULT_PORT 25665
  29
  30 #define NET_BUFSIZE 65536
  31 #define NET_FULLMASK 0xFFFFFFFF
  32
  33 #define SV_PROTO_MIN 140
  34 #define SV_PROTO_MAX 210
  35 #define SV_NAME_MAX 64
  36 #define SV_MAP_MAX 64
  37 #define SV_MAX_PLAYERS 24
  38 #define SV_MAX_GAMEMODE 5
  39 #define SV_NEW_SERVER_INTERVAL 3
  40
  41 #define MAX_STRLEN 0xFF
  42
  43 enum log_severity_e {
  44   LOG_NOTE,
  45   LOG_WARN,
  46   LOG_ERROR
  47 };
  48
  49 enum net_ch_e {
  50   NET_CH_MAIN,
  51   NET_CH_UPD,
  52   NET_CH_COUNT
  53 };
  54
  55 enum net_msg_e {
  56   NET_MSG_ADD = 200,
  57   NET_MSG_RM = 201,
  58   NET_MSG_LIST = 202
  59 };
  60
  61 enum sv_flags_e {
  62   SV_FL_PASSWORD = 1 << 0,
  63   SV_FL_VERIFIED = 1 << 1,
  64   SV_FL_MAX = SV_FL_PASSWORD | SV_FL_VERIFIED,
  65 };
  66
  67 typedef struct enet_buf_s {
  68   enet_uint8 *data;
  69   size_t size;
  70   size_t pos;
  71   int overflow;
  72 } enet_buf_t;
  73
  74 typedef struct ban_record_s {
  75   enet_uint32 host;
  76   enet_uint32 mask;
  77   int ban_count;
  78   time_t cur_ban;
  79   struct ban_record_s *next;
  80   struct ban_record_s *prev;
  81 } ban_record_t;
  82
  83 typedef struct server_s {
  84   enet_uint32 host; // BE; 0 means this slot is unused
  85   enet_uint16 port; // LE, which is what the game and enet both expect
  86   enet_uint8  flags;
  87   enet_uint8  proto;
  88   enet_uint8  gamemode;
  89   enet_uint8  players;
  90   enet_uint8  maxplayers;
  91   char        name[MAX_STRLEN + 2];
  92   char        map[MAX_STRLEN + 2];
  93   time_t      death_time;
  94   time_t      timestamp;
  95   ENetPeer   *peer; // who sent this server in
  96 } server_t;
  97
  98 // real servers
  99 static server_t servers[MS_MAX_SERVERS];
 100 static int max_servers = DEFAULT_MAX_SERVERS;
 101 static int max_servers_per_host = DEFAULT_MAX_PER_HOST;
 102 static int num_servers = 0;
 103
 104 // fake servers to show on old versions of the game
 105 static const server_t fake_servers[] = {
 106   {
 107     .name  = "! \xc2\xc0\xd8\xc0 \xca\xce\xcf\xc8\xdf \xc8\xc3\xd0\xdb "
 108              "\xd3\xd1\xd2\xc0\xd0\xc5\xcb\xc0! "
 109              "\xd1\xca\xc0\xd7\xc0\xc9\xd2\xc5 \xcd\xce\xc2\xd3\xde C "
 110              "doom2d.org !",
 111     .map   = "! Your game is outdated. "
 112              "Get latest version at doom2d.org !",
 113     .proto = 255,
 114   },
 115   {
 116     .name  = "! \xcf\xd0\xce\xc1\xd0\xce\xd1\xdcTE \xcf\xce\xd0\xd2\xdb "
 117              "25666 \xc8 57133 HA CEPBEPE \xcf\xc5\xd0\xc5\xc4 \xc8\xc3\xd0\xce\xc9 !",
 118     .map   = "! Forward ports 25666 and 57133 before hosting !",
 119     .proto = 255,
 120   },
 121 };
 122 static const int num_fake_servers = sizeof(fake_servers) / sizeof(*fake_servers);
 123
 124 // ban list
 125 static ban_record_t *banlist;
 126
 127 // settings
 128 static int ms_port = DEFAULT_PORT;
 129 static int ms_sv_timeout = DEFAULT_SERVER_TIMEOUT;
 130 static int ms_cl_timeout = DEFAULT_CLIENT_TIMEOUT;
 131 static int ms_spam_timeout = DEFAULT_SPAM_TIMEOUT;
 132 static int ms_spam_cap = DEFAULT_SPAM_CAP;
 133 static char ms_motd[MAX_STRLEN + 1] = "";
 134 static char ms_urgent[MAX_STRLEN + 1] = "";
 135 static ENetHost *ms_host;
 136
 137 // network buffers
 138 static enet_uint8 buf_send_data[NET_BUFSIZE];
 139 static enet_buf_t buf_send = { .data = buf_send_data, .size = sizeof(buf_send_data) };
 140 static enet_buf_t buf_recv; // rx data supplied by enet packets
 141
 142 // stupid client spam filter
 143 static enet_uint32 cl_last_addr;
 144 static time_t cl_last_time;
 145 static int cl_spam_cnt;
 146
 147 /* common utility functions */
 148
 149 static char *u_vabuf(void) {
 150   static char vabuf[4][MAX_STRLEN];
 151   static int idx = 0;
 152   char *ret = vabuf[idx++];
 153   if (idx >= 4) idx = 0;
 154   return ret;
 155 }
 156
 157 static const char *u_strtime(const time_t t) {
 158   char *buf = u_vabuf();
 159   struct tm *ptm = localtime(&t);
 160   strftime(buf, MAX_STRLEN - 1, "%d/%m/%y %H:%M:%S", ptm);
 161   return buf;
 162 }
 163
 164 static inline const char *u_logprefix(const enum log_severity_e s) {
 165   switch (s) {
 166     case LOG_WARN: return "WARNING: ";
 167     case LOG_ERROR: return "ERROR: ";
 168     default: return "";
 169   }
 170 }
 171
 172 static void u_log(const enum log_severity_e severity, const char *fmt, ...) {
 173   printf("[%s] %s", u_strtime(time(NULL)), u_logprefix(severity));
 174   va_list args;
 175   va_start(args, fmt);
 176   vprintf(fmt, args);
 177   va_end(args);
 178   printf("\n");
 179 }
 180
 181 static void __attribute__((noreturn)) u_fatal(const char *fmt, ...) {
 182   fprintf(stderr, "[%s] FATAL ERROR:\n", u_strtime(time(NULL)));
 183   va_list args;
 184   va_start(args, fmt);
 185   vfprintf(stderr, fmt, args);
 186   va_end(args);
 187   fprintf(stderr, "\n");
 188   fflush(stderr);
 189   exit(1);
 190 }
 191
 192 static bool u_strisprint(const char *str) {
 193   if (!str || !*str)
 194     return false;
 195   for (const char *p = str; *p; ++p) {
 196     // only stuff before space, DEL, NBSP and SHY are considered garbage since we're on 1251
 197     if (*p < 0x20 || *p == 0x7F || *p == 0xA0 || *p == 0xAD)
 198       return false;
 199   }
 200   return true;
 201 }
 202
 203 static bool u_strisver(const char *str) {
 204   if (!str || !*str)
 205     return false;
 206   for (const char *p = str; *p; ++p) {
 207     // version strings consist of 0-9 . and space
 208     if (!isdigit(*p) && *p != '.' && *p != ' ')
 209       return false;
 210   }
 211   return true;
 212 }
 213
 214 static const char *u_iptostr(const enet_uint32 host) {
 215   ENetAddress addr = { .host = host, .port = 0 };
 216   char *buf = u_vabuf();
 217   enet_address_get_host_ip(&addr, buf, MAX_STRLEN - 1);
 218   return buf;
 219 }
 220
 221 static bool u_readtextfile(const char *fname, char *buf, size_t max) {
 222   FILE *f = fopen(fname, "r");
 223   char *const end = buf + max - 1;
 224   char *p = buf;
 225   if (f) {
 226     char ln[max];
 227     char *const lend = ln + max - 1;
 228     while (p < end && fgets(ln, max, f)) {
 229       for (char *n = ln; n < lend && *n && *n != '\r' && *n != '\n'; ++n) {
 230         *(p++) = *n;
 231         if (p == end) break;
 232       }
 233     }
 234     *p = '\0';
 235     fclose(f);
 236     return true;
 237   }
 238   return false;
 239 }
 240
 241 static inline enet_uint32 u_prefixtomask(const enet_uint32 prefix) {
 242   return ENET_HOST_TO_NET_32((0xFFFFFFFF << (32 - prefix)) & 0xFFFFFFFF);
 243 }
 244
 245 static inline enet_uint32 u_masktoprefix(const enet_uint32 mask) {
 246   return (32 - __builtin_ctz(mask));
 247 }
 248
 249 static inline void u_printsv(const server_t *sv) {
 250   printf("* addr: %s:%d\n", u_iptostr(sv->host), sv->port);
 251   printf("* name: %s\n", sv->name);
 252   printf("* map:  %s (mode %d)\n", sv->map, sv->gamemode);
 253   printf("* plrs: %d/%d\n", sv->players, sv->maxplayers);
 254   printf("* flag: %04x\n", sv->flags);
 255 }
 256
 257 /* buffer utility functions */
 258
 259 static inline int b_enough_left(enet_buf_t *buf, size_t size) {
 260   if (buf->pos + size > buf->size) {
 261     buf->overflow = 1;
 262     return 0;
 263   }
 264   return 1;
 265 }
 266
 267 static enet_uint8 b_read_uint8(enet_buf_t *buf) {
 268   if (b_enough_left(buf, 1))
 269     return buf->data[buf->pos++];
 270   return 0;
 271 }
 272
 273 static enet_uint16 b_read_uint16(enet_buf_t *buf) {
 274   enet_uint16 ret = 0;
 275
 276   if (b_enough_left(buf, sizeof(ret))) {
 277     ret = *(enet_uint16*)(buf->data + buf->pos);
 278     buf->pos += sizeof(ret);
 279   }
 280
 281   return ret;
 282 }
 283
 284 static char *b_read_dstring(enet_buf_t *buf) {
 285   char *ret = NULL;
 286
 287   if (b_enough_left(buf, 1)) {
 288     const size_t len = b_read_uint8(buf);
 289     if (b_enough_left(buf, len)) {
 290       ret = malloc(len + 1);
 291       memmove(ret, (char*)(buf->data + buf->pos), len);
 292       buf->pos += len;
 293       ret[len] = '\0';
 294     }
 295   }
 296
 297   return ret;
 298 }
 299
 300 static char *b_read_dstring_to(enet_buf_t *buf, char *out, size_t out_size) {
 301   if (b_enough_left(buf, 1)) {
 302     const size_t len = b_read_uint8(buf);
 303     if (b_enough_left(buf, len)) {
 304       if (len < out_size) {
 305         memmove(out, (char*)(buf->data + buf->pos), len);
 306         out[len] = '\0';
 307       } else if (out_size) {
 308         out[0] = '\0';
 309       }
 310       buf->pos += len;
 311       return out;
 312     }
 313   }
 314   return NULL;
 315 }
 316
 317 static void b_write_uint8(enet_buf_t *buf, enet_uint8 val) {
 318   buf->data[buf->pos++] = val;
 319 }
 320
 321 static void b_write_uint16(enet_buf_t *buf, enet_uint16 val) {
 322   *(enet_uint16*)(buf->data + buf->pos) = val;
 323   buf->pos += sizeof(val);
 324 }
 325
 326 static void b_write_dstring(enet_buf_t *buf, const char* val) {
 327   enet_uint8 len = strlen(val);
 328   b_write_uint8(buf, len);
 329   memmove((char*)(buf->data + buf->pos), val, len);
 330   buf->pos += len;
 331 }
 332
 333 void b_write_server(enet_buf_t *buf, const server_t *s) {
 334   b_write_dstring(buf, u_iptostr(s->host));
 335   b_write_uint16 (buf, s->port);
 336   b_write_dstring(buf, s->name);
 337   b_write_dstring(buf, s->map);
 338   b_write_uint8  (buf, s->gamemode);
 339   b_write_uint8  (buf, s->players);
 340   b_write_uint8  (buf, s->maxplayers);
 341   b_write_uint8  (buf, s->proto);
 342   b_write_uint8  (buf, (s->flags & SV_FL_PASSWORD));
 343 }
 344
 345 /* server functions */
 346
 347 static inline void sv_remove(server_t *sv) {
 348   if (sv->host) {
 349     // drop the associated peer, if any
 350     if (sv->peer && sv->peer->state == ENET_PEER_STATE_CONNECTED && sv->peer->data == sv) {
 351       sv->peer->data = NULL;
 352       sv->peer = NULL;
 353       enet_peer_reset(sv->peer);
 354     }
 355     sv->host = 0;
 356     sv->port = 0;
 357     --num_servers;
 358   }
 359 }
 360
 361 static void sv_remove_by_addr(const enet_uint32 host, const enet_uint16 port) {
 362   for (int i = 0; i < max_servers; ++i) {
 363     if (servers[i].host == host && servers[i].port == port)
 364       sv_remove(servers + i);
 365   }
 366 }
 367
 368 static void sv_remove_by_host(enet_uint32 host, enet_uint32 mask) {
 369   host &= mask;
 370   for (int i = 0; i < max_servers; ++i) {
 371     if (servers[i].host && (servers[i].host & mask) == host)
 372       sv_remove(servers + i);
 373   }
 374 }
 375
 376 static int sv_count_by_host(enet_uint32 host, enet_uint32 mask) {
 377   host &= mask;
 378   int count = 0;
 379   for (int i = 0; i < max_servers; ++i) {
 380     if (servers[i].host && (servers[i].host & mask) == host)
 381       ++count;
 382   }
 383   return count;
 384 }
 385
 386 static time_t sv_last_timestamp_for_host(enet_uint32 host, enet_uint32 mask) {
 387   host &= mask;
 388   time_t last = 0;
 389   for (int i = 0; i < max_servers; ++i) {
 390     if (servers[i].host && (servers[i].host & mask) == host) {
 391       if (servers[i].timestamp > last)
 392         last = servers[i].timestamp;
 393     }
 394   }
 395   return last;
 396 }
 397
 398 static inline server_t *sv_find_or_add(const enet_uint32 host, const enet_uint32 port) {
 399   server_t *empty = NULL;
 400   for (int i = 0; i < max_servers; ++i) {
 401     server_t *s = servers + i;
 402     if (s->host == host && s->port == port)
 403       return s; // this server already exists
 404     if (!s->host && !empty)
 405       empty = s; // remember the first empty slot in case it's needed later
 406   }
 407   return empty;
 408 }
 409
 410 /* ban list functions */
 411
 412 static inline time_t ban_get_time(const int cnt) {
 413   static const time_t times[] = {
 414        1 *  5 * 60,
 415        1 * 30 * 60,
 416        1 * 60 * 60,
 417       24 * 60 * 60,
 418       72 * 60 * 60,
 419      720 * 60 * 60,
 420     8760 * 60 * 60,
 421   };
 422
 423   static const size_t numtimes = sizeof(times) / sizeof(*times);
 424
 425   if (cnt >= numtimes || cnt < 0)
 426     return times[numtimes - 1];
 427
 428   return times[cnt];
 429 }
 430
 431 static ban_record_t *ban_check(const enet_uint32 host) {
 432   const time_t now = time(NULL);
 433
 434   for (ban_record_t *b = banlist; b; b = b->next) {
 435     if ((b->host & b->mask) == (host & b->mask)) {
 436       if (b->cur_ban > now)
 437         return b;
 438     }
 439   }
 440
 441   return NULL;
 442 }
 443
 444 static inline ban_record_t *ban_record_check(const enet_uint32 host) {
 445   for (ban_record_t *b = banlist; b; b = b->next) {
 446     if ((b->host & b->mask) == (host & b->mask))
 447       return b;
 448   }
 449   return NULL;
 450 }
 451
 452 static ban_record_t *ban_record_add_addr(const enet_uint32 host, const enet_uint32 mask, const int cnt, const time_t cur) {
 453   ban_record_t *rec = ban_record_check(host);
 454   if (rec) return rec;
 455
 456   rec = calloc(1, sizeof(*rec));
 457   if (!rec) return NULL;
 458
 459   rec->host = host & mask;
 460   rec->mask = mask;
 461   if (rec->mask == 0) rec->mask = NET_FULLMASK;
 462   rec->ban_count = cnt;
 463   rec->cur_ban = cur;
 464
 465   if (banlist) banlist->prev = rec;
 466   rec->next = banlist;
 467   banlist = rec;
 468
 469   return rec;
 470 }
 471
 472 static ban_record_t *ban_record_add_ip(const char *ip, const int cnt, const time_t cur) {
 473   enet_uint32 prefix = 32;
 474
 475   // find and get the prefix length, if any
 476   char ip_copy[24] = { 0 };
 477   strncpy(ip_copy, ip, sizeof(ip_copy) - 1);
 478   char *slash = strrchr(ip_copy, '/');
 479   if (slash) {
 480     *slash++ = '\0'; // strip the prefix length off
 481     if (*slash) prefix = atoi(slash);
 482   }
 483
 484   ENetAddress addr = { 0 };
 485   if (enet_address_set_host_ip(&addr, ip_copy) != 0) {
 486     u_log(LOG_ERROR, "banlist: `%s` is not a valid IP address", ip_copy);
 487     return NULL;
 488   }
 489
 490   // transform prefix length into mask
 491   const enet_uint32 mask = u_prefixtomask(prefix);
 492
 493   return ban_record_add_addr(addr.host, mask, cnt, cur);
 494 }
 495
 496 static void ban_free_list(void) {
 497   ban_record_t *rec = banlist;
 498   while (rec) {
 499     ban_record_t *next = rec->next;
 500     free(rec);
 501     rec = next;
 502   }
 503   banlist = NULL;
 504 }
 505
 506 static void ban_load_list(const char *fname) {
 507   FILE *f = fopen(fname, "r");
 508   if (!f) {
 509     u_log(LOG_WARN, "banlist: could not open %s for reading", fname);
 510     return;
 511   }
 512
 513   char ln[MAX_STRLEN] = { 0 };
 514
 515   while (fgets(ln, sizeof(ln), f)) {
 516     for (int i = sizeof(ln) - 1; i >= 0; --i)
 517       if (ln[i] == '\n' || ln[i] == '\r')
 518         ln[i] = 0;
 519
 520     if (ln[0] == 0)
 521       continue;
 522
 523     char ip[21] = { 0 }; // optionally includes the "/nn" prefix length at the end
 524     time_t exp = 0;
 525     int count = 0;
 526     if (sscanf(ln, "%20s %ld %d", ip, &exp, &count) < 3) {
 527       u_log(LOG_ERROR, "banlist: malformed line: `%s`", ln);
 528       continue;
 529     }
 530
 531     if (ban_record_add_ip(ip, count, exp))
 532       u_log(LOG_NOTE, "banlist: banned %s until %s (ban level %d)", ip, u_strtime(exp), count);
 533   }
 534
 535   fclose(f);
 536 }
 537
 538 static void ban_save_list(const char *fname) {
 539   FILE *f = fopen(fname, "w");
 540   if (!f) {
 541     u_log(LOG_ERROR, "banlist: could not open %s for writing", fname);
 542     return;
 543   }
 544
 545   for (ban_record_t *rec = banlist; rec; rec = rec->next) {
 546     if (rec->ban_count)
 547       fprintf(f, "%s/%u %ld %d\n", u_iptostr(rec->host), u_masktoprefix(rec->mask), rec->cur_ban, rec->ban_count);
 548   }
 549
 550   fclose(f);
 551 }
 552
 553 static bool ban_sanity_check(const server_t *srv) {
 554   // can't have more than 24 maxplayers; can't have more than max
 555   if (srv->players > srv->maxplayers || srv->maxplayers > SV_MAX_PLAYERS || srv->maxplayers == 0)
 556     return false;
 557   // name and map have to be non-garbage
 558   if (!u_strisprint(srv->map) || !u_strisprint(srv->name))
 559     return false;
 560   // these protocols don't exist
 561   if (srv->proto < SV_PROTO_MIN || srv->proto > SV_PROTO_MAX)
 562     return false;
 563   // the game doesn't allow server names longer than 64 chars
 564   if (strlen(srv->name) > SV_NAME_MAX)
 565     return false;
 566   // game mode has to actually exist
 567   if (srv->gamemode > SV_MAX_GAMEMODE)
 568     return false;
 569   // flags field can't be higher than the sum of all the flags
 570   if (srv->flags > SV_FL_MAX)
 571     return false;
 572   return true;
 573 }
 574
 575 static void ban_add(const enet_uint32 host, const char *reason) {
 576   const time_t now = time(NULL);
 577
 578   ban_record_t *rec = ban_record_add_addr(host, NET_FULLMASK, 0, 0);
 579   if (!rec) u_fatal("OOM trying to ban %s", u_iptostr(host));
 580
 581   rec->cur_ban = now + ban_get_time(rec->ban_count);
 582   rec->ban_count++;
 583
 584   u_log(LOG_NOTE, "banned %s until %s, reason: %s, ban level: %d", u_iptostr(rec->host), u_strtime(rec->cur_ban), reason, rec->ban_count);
 585
 586   ban_save_list(MS_BAN_FILE);
 587
 588   sv_remove_by_host(host, NET_FULLMASK);
 589
 590   if (host == cl_last_addr)
 591     cl_last_addr = 0;
 592 }
 593
 594 static inline void ban_peer(ENetPeer *peer, const char *reason) {
 595   if (peer) {
 596     ban_add(peer->address.host, reason);
 597     peer->data = NULL;
 598     enet_peer_reset(peer);
 599   }
 600 }
 601
 602 /* main */
 603
 604 static void deinit(void) {
 605   // ban_save_list(MS_BAN_FILE);
 606   ban_free_list();
 607   if (ms_host) {
 608     enet_host_destroy(ms_host);
 609     ms_host = NULL;
 610   }
 611   enet_deinitialize();
 612 }
 613
 614 #ifdef SIGUSR1
 615 static void sigusr_handler(int signum) {
 616   if (signum == SIGUSR1) {
 617     u_log(LOG_WARN, "received SIGUSR1, reloading banlist");
 618     ban_free_list();
 619     ban_load_list(MS_BAN_FILE);
 620   }
 621 }
 622 #endif
 623
 624 static bool handle_msg(const enet_uint8 msgid, ENetPeer *peer) {
 625   server_t *sv = NULL;
 626   server_t tmpsv = { 0 };
 627   char clientver[MAX_STRLEN] = { 0 };
 628   const time_t now = time(NULL);
 629
 630   switch (msgid) {
 631     case NET_MSG_ADD:
 632       tmpsv.port = b_read_uint16(&buf_recv);
 633       b_read_dstring_to(&buf_recv, tmpsv.name, sizeof(tmpsv.name));
 634       b_read_dstring_to(&buf_recv, tmpsv.map, sizeof(tmpsv.map));
 635       tmpsv.gamemode = b_read_uint8(&buf_recv);
 636       tmpsv.players = b_read_uint8(&buf_recv);
 637       tmpsv.maxplayers = b_read_uint8(&buf_recv);
 638       tmpsv.proto = b_read_uint8(&buf_recv);
 639       tmpsv.flags = b_read_uint8(&buf_recv);
 640
 641       if (buf_recv.overflow) {
 642         ban_peer(peer, "malformed MSG_ADD");
 643         return true;
 644       }
 645
 646       sv = sv_find_or_add(peer->address.host, tmpsv.port);
 647       if (!sv) {
 648         u_log(LOG_ERROR, "ran out of server slots trying to add %s:%d", u_iptostr(peer->address.host), tmpsv.port);
 649         return true;
 650       }
 651
 652       if (sv->host == peer->address.host) {
 653         // old server; update it
 654         memcpy(sv->map, tmpsv.map, sizeof(sv->map));
 655         memcpy(sv->name, tmpsv.name, sizeof(sv->name));
 656         sv->players = tmpsv.players;
 657         sv->maxplayers = tmpsv.maxplayers;
 658         sv->flags = tmpsv.flags;
 659         sv->gamemode = tmpsv.gamemode;
 660         // first check if the new values are garbage
 661         if (!ban_sanity_check(sv)) {
 662           ban_peer(peer, "tripped sanity check");
 663           return true;
 664         }
 665         // only then update the times
 666         sv->death_time = now + ms_sv_timeout;
 667         sv->timestamp = now;
 668         // check if we're updating from a new peer
 669         if (sv->peer != peer) {
 670           // if there was an old one, kill it
 671           if (sv->peer)
 672             enet_peer_reset(peer);
 673           sv->peer = peer;
 674         }
 675         u_log(LOG_NOTE, "updated server #%d:", sv - servers);
 676         u_printsv(sv);
 677       } else {
 678         // new server; first check if this host is creating too many servers in the list
 679         if (max_servers_per_host) {
 680           const int count = sv_count_by_host(peer->address.host, NET_FULLMASK);
 681           if (count >= max_servers_per_host) {
 682             ban_peer(peer, "too many servers in list");
 683             return true;
 684           }
 685           /*
 686           // FIXME: commented out as this might trip when the master restarts
 687           if (count > 0) {
 688             // check if this is too soon to create a new server
 689             const time_t delta = now - sv_last_timestamp_for_host(peer->address.host, NET_FULLMASK);
 690             if (delta < count * SV_NEW_SERVER_INTERVAL) {
 691               ban_peer(peer, "creating servers too fast");
 692               return true;
 693             }
 694           }
 695           */
 696         }
 697         // then add that shit
 698         *sv = tmpsv;
 699         sv->host = peer->address.host;
 700         sv->death_time = now + ms_sv_timeout;
 701         sv->timestamp = now;
 702         if (!ban_sanity_check(sv)) {
 703           sv->host = 0;
 704           sv->port = 0;
 705           ban_peer(peer, "tripped sanity check");
 706           return true;
 707         }
 708         sv->peer = peer;
 709         peer->data = sv;
 710         ++num_servers;
 711         u_log(LOG_NOTE, "added new server #%d:", sv - servers);
 712         u_printsv(sv);
 713       }
 714       return true;
 715
 716     case NET_MSG_RM:
 717       tmpsv.port = b_read_uint16(&buf_recv);
 718       if (buf_recv.overflow) {
 719         ban_peer(peer, "malformed MSG_RM");
 720         return true;
 721       }
 722       sv_remove_by_addr(peer->address.host, tmpsv.port);
 723       // this peer can be disconnected pretty much immediately since he has no servers left, tell him to fuck off
 724       peer->data = NULL;
 725       enet_peer_disconnect_later(peer, 0);
 726       return true;
 727
 728     case NET_MSG_LIST:
 729       buf_send.pos = 0;
 730       buf_send.overflow = 0;
 731       b_write_uint8(&buf_send, NET_MSG_LIST);
 732
 733       clientver[0] = 0;
 734       if (buf_recv.size > 2) {
 735         // holy shit a fresh client
 736         b_read_dstring_to(&buf_recv, clientver, sizeof(clientver));
 737         b_write_uint8(&buf_send, num_servers);
 738       } else {
 739         // old client; feed him fake servers first
 740         b_write_uint8(&buf_send, num_servers + num_fake_servers);
 741         for (int i = 0; i < num_fake_servers; ++i)
 742           b_write_server(&buf_send, &fake_servers[i]);
 743       }
 744
 745       if (buf_recv.overflow) {
 746         ban_peer(peer, "malformed MSG_LIST");
 747         return true;
 748       }
 749
 750       if (clientver[0] && !u_strisver(clientver)) {
 751         ban_peer(peer, "malformed MSG_LIST clientver");
 752         return true;
 753       }
 754
 755       for (int i = 0; i < max_servers; ++i) {
 756         if (servers[i].host)
 757           b_write_server(&buf_send, servers + i);
 758       }
 759
 760       if (clientver[0]) {
 761         // TODO: check if this client is outdated (?) and send back new verstring
 762         // for now just write the same shit back
 763         b_write_dstring(&buf_send, clientver);
 764         // write the motd and urgent message
 765         b_write_dstring(&buf_send, ms_motd);
 766         b_write_dstring(&buf_send, ms_urgent);
 767       }
 768
 769       ENetPacket *p = enet_packet_create(buf_send.data, buf_send.pos, ENET_PACKET_FLAG_RELIABLE);
 770       enet_peer_send(peer, NET_CH_MAIN, p);
 771       // enet_host_flush(ms_host);
 772
 773       // this peer can be disconnected pretty much immediately after receiving the server list, tell him to fuck off
 774       enet_peer_disconnect_later(peer, 0);
 775
 776       u_log(LOG_NOTE, "sent server list to %s:%d (ver %s)", u_iptostr(peer->address.host), peer->address.port, clientver[0] ? clientver : "<old>");
 777       return true;
 778
 779     default:
 780       break;
 781   }
 782
 783   return false;
 784 }
 785
 786 static void print_usage(void) {
 787   printf("Usage: d2df_master [OPTIONS...]\n");
 788   printf("Available options:\n");
 789   printf("-h     show this message and exit\n");
 790   printf("-p N   listen on port N (default: %d)\n", DEFAULT_PORT);
 791   printf("-t N   seconds before server is removed from list (default: %d)\n", DEFAULT_SERVER_TIMEOUT);
 792   printf("-c N   how long a client is allowed to hold the connection active (default: %d)\n", DEFAULT_CLIENT_TIMEOUT);
 793   printf("-s N   max number of servers in server list, 1-%d (default: %d)\n", MS_MAX_SERVERS, DEFAULT_MAX_SERVERS);
 794   printf("-d N   if N > 0, disallow more than N servers on the same IP (default: %d)\n", DEFAULT_MAX_PER_HOST);
 795   printf("-f N   crappy spam filter: ban clients after they send N requests in a row too fast (default: %d)\n", DEFAULT_SPAM_CAP);
 796   printf("-w N   how often does a client have to send packets for the filter to kick in, i.e. once every N sec (default: %d)\n", DEFAULT_SPAM_TIMEOUT);
 797   fflush(stdout);
 798 }
 799
 800 static inline bool parse_int_arg(int argc, char **argv, const int i, const char *name, int vmin, int vmax, int *outval) {
 801   if (strcmp(name, argv[i]))
 802     return false;
 803
 804   if (i >= argc - 1) {
 805     fprintf(stderr, "expected integer value after %s\n", name);
 806     return false;
 807   }
 808
 809   const int v = atoi(argv[i + 1]);
 810   if (v < vmin || v > vmax) {
 811     fprintf(stderr, "expected integer value in range %d - %d\n", vmin, vmax);
 812     return false;
 813   }
 814
 815   *outval = v;
 816   return true;
 817 }
 818
 819 static bool parse_args(int argc, char **argv) {
 820   if (argc < 2)
 821     return true;
 822
 823   if (!strcmp(argv[1], "-h")) {
 824     print_usage();
 825     return false;
 826   }
 827
 828   for (int i = 1; i < argc; ++i) {
 829     const bool success =
 830          parse_int_arg(argc, argv, i, "-p", 1, 0xFFFF, &ms_port)
 831       || parse_int_arg(argc, argv, i, "-t", 1, 0x7FFFFFFF, &ms_sv_timeout)
 832       || parse_int_arg(argc, argv, i, "-c", 1, 0x7FFFFFFF, &ms_cl_timeout)
 833       || parse_int_arg(argc, argv, i, "-s", 1, MS_MAX_SERVERS, &max_servers)
 834       || parse_int_arg(argc, argv, i, "-d", 0, MS_MAX_SERVERS, &max_servers_per_host)
 835       || parse_int_arg(argc, argv, i, "-f", 0, 0xFFFF, &ms_spam_cap)
 836       || parse_int_arg(argc, argv, i, "-w", 1, 0x7FFFFFFF, &ms_spam_timeout);
 837     if (success) {
 838       ++i;
 839     } else {
 840       fprintf(stderr, "unknown or invalid argument: %s\n", argv[i]);
 841       return false;
 842     }
 843   }
 844
 845   return true;
 846 }
 847
 848 // a stupid thing to filter sustained spam from a single IP
 849 static bool spam_filter(ENetPeer *peer, const time_t now) {
 850   if (peer->address.host == cl_last_addr) {
 851     // spam === sending shit faster than once a second
 852     if (now - cl_last_time < ms_spam_timeout) {
 853       if (cl_spam_cnt > 1)
 854         u_log(LOG_WARN, "address %s is sending packets too fast", u_iptostr(peer->address.host));
 855       if (++cl_spam_cnt >= ms_spam_cap) {
 856         ban_peer(peer, "spam");
 857         cl_last_addr = 0;
 858         return true;
 859       }
 860     } else {
 861       cl_spam_cnt = 0;
 862     }
 863   } else {
 864     cl_last_addr = peer->address.host;
 865     cl_spam_cnt = 0;
 866   }
 867   cl_last_time = now;
 868   return false;
 869 }
 870
 871 // filter incoming UDP packets before the protocol kicks in
 872 static int packet_filter(ENetHost *host, ENetEvent *event) {
 873   return !!ban_check(host->receivedAddress.host);
 874 }
 875
 876 int main(int argc, char **argv) {
 877   if (enet_initialize() != 0)
 878     u_fatal("could not init enet");
 879
 880   if (!parse_args(argc, argv))
 881     return 1; // early exit
 882
 883   u_log(LOG_NOTE, "d2df master server starting on port %d", ms_port);
 884
 885   if (!u_readtextfile(MS_MOTD_FILE, ms_motd, sizeof(ms_motd)))
 886     u_log(LOG_NOTE, "couldn't read motd from %s", MS_MOTD_FILE);
 887   else
 888     u_log(LOG_NOTE, "motd: %s", ms_motd);
 889
 890   if (!u_readtextfile(MS_URGENT_FILE, ms_urgent, sizeof(ms_urgent)))
 891     u_log(LOG_NOTE, "couldn't read urgentmsg from %s", MS_URGENT_FILE);
 892   else
 893     u_log(LOG_NOTE, "urgentmsg: %s", ms_urgent);
 894
 895   ban_load_list(MS_BAN_FILE);
 896
 897   atexit(deinit);
 898
 899 #ifdef SIGUSR1
 900   signal(SIGUSR1, sigusr_handler);
 901 #endif
 902
 903   ENetAddress addr;
 904   addr.host = 0;
 905   addr.port = ms_port;
 906   ms_host = enet_host_create(&addr, MS_MAX_CLIENTS, NET_CH_COUNT + 1, 0, 0);
 907   if (!ms_host)
 908     u_fatal("could not create enet host on port %d", ms_port);
 909
 910   ms_host->intercept = packet_filter;
 911
 912   bool running = true;
 913   enet_uint8 msgid = 0;
 914   ENetEvent event;
 915   while (running) {
 916     while (enet_host_service(ms_host, &event, 10) > 0) {
 917       const time_t now = time(NULL);
 918       const bool filtered = !event.peer || (ms_spam_cap && spam_filter(event.peer, now));
 919
 920       if (!filtered) {
 921         switch (event.type) {
 922           case ENET_EVENT_TYPE_CONNECT:
 923             u_log(LOG_NOTE, "%s:%d connected", u_iptostr(event.peer->address.host), event.peer->address.port);
 924             if (event.peer->channelCount != NET_CH_COUNT)
 925               ban_peer(event.peer, "what is this");
 926             else
 927               enet_peer_timeout(event.peer, 0, 0, ms_cl_timeout * 1000);
 928             break;
 929
 930           case ENET_EVENT_TYPE_RECEIVE:
 931             if (!event.packet || event.packet->dataLength == 0) {
 932               ban_peer(event.peer, "empty packet");
 933               break;
 934             }
 935             // set up receive buffer
 936             buf_recv.pos = 0;
 937             buf_recv.overflow = 0;
 938             buf_recv.data = event.packet->data;
 939             buf_recv.size = event.packet->dataLength;
 940             // read message id and handle the message
 941             msgid = b_read_uint8(&buf_recv);
 942             if (!handle_msg(msgid, event.peer)) {
 943               // cheeky cunt sending invalid messages
 944               ban_peer(event.peer, "unknown message");
 945             }
 946             break;
 947
 948           case ENET_EVENT_TYPE_DISCONNECT:
 949             event.peer->data = NULL;
 950             // u_log(LOG_NOTE, "%s:%d disconnected", u_iptostr(event.peer->address.host), event.peer->address.port);
 951             break;
 952
 953           default:
 954             break;
 955         }
 956       } else if (event.peer) {
 957         // u_log(LOG_WARN, "filtered event %d from %s", event.type, u_iptostr(event.peer->address.host));
 958         event.peer->data = NULL;
 959         enet_peer_reset(event.peer);
 960       }
 961
 962       if (event.packet) {
 963         buf_recv.data = NULL;
 964         enet_packet_destroy(event.packet);
 965       }
 966     }
 967
 968     const time_t now = time(NULL);
 969
 970     // time out servers
 971     for (int i = 0; i < max_servers; ++i) {
 972       if (servers[i].host && servers[i].death_time <= now) {
 973         u_log(LOG_NOTE, "server #%d %s:%d timed out", i, u_iptostr(servers[i].host), servers[i].port);
 974         sv_remove(servers + i);
 975       }
 976     }
 977   }
 978 }