DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / d2df-sdl.git / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
master: fix possible segfault
[d2df-sdl.git] / 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 enet_peer_reset(sv->peer);
353 }
354 sv->host = 0;
355 sv->port = 0;
356 sv->peer = NULL;
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 static inline void sv_clear_peer(ENetPeer *peer) {
411 server_t *sv = peer->data;
412 if (sv) {
413 sv->peer = NULL;
414 peer->data = NULL;
415 }
416 }
417
418 /* ban list functions */
419
420 static inline time_t ban_get_time(const int cnt) {
421 static const time_t times[] = {
422 1 * 5 * 60,
423 1 * 30 * 60,
424 1 * 60 * 60,
425 24 * 60 * 60,
426 72 * 60 * 60,
427 720 * 60 * 60,
428 8760 * 60 * 60,
429 };
430
431 static const size_t numtimes = sizeof(times) / sizeof(*times);
432
433 if (cnt >= numtimes || cnt < 0)
434 return times[numtimes - 1];
435
436 return times[cnt];
437 }
438
439 static ban_record_t *ban_check(const enet_uint32 host) {
440 const time_t now = time(NULL);
441
442 for (ban_record_t *b = banlist; b; b = b->next) {
443 if ((b->host & b->mask) == (host & b->mask)) {
444 if (b->cur_ban > now)
445 return b;
446 }
447 }
448
449 return NULL;
450 }
451
452 static inline ban_record_t *ban_record_check(const enet_uint32 host) {
453 for (ban_record_t *b = banlist; b; b = b->next) {
454 if ((b->host & b->mask) == (host & b->mask))
455 return b;
456 }
457 return NULL;
458 }
459
460 static ban_record_t *ban_record_add_addr(const enet_uint32 host, const enet_uint32 mask, const int cnt, const time_t cur) {
461 ban_record_t *rec = ban_record_check(host);
462 if (rec) return rec;
463
464 rec = calloc(1, sizeof(*rec));
465 if (!rec) return NULL;
466
467 rec->host = host & mask;
468 rec->mask = mask;
469 if (rec->mask == 0) rec->mask = NET_FULLMASK;
470 rec->ban_count = cnt;
471 rec->cur_ban = cur;
472
473 if (banlist) banlist->prev = rec;
474 rec->next = banlist;
475 banlist = rec;
476
477 return rec;
478 }
479
480 static ban_record_t *ban_record_add_ip(const char *ip, const int cnt, const time_t cur) {
481 enet_uint32 prefix = 32;
482
483 // find and get the prefix length, if any
484 char ip_copy[24] = { 0 };
485 strncpy(ip_copy, ip, sizeof(ip_copy) - 1);
486 char *slash = strrchr(ip_copy, '/');
487 if (slash) {
488 *slash++ = '\0'; // strip the prefix length off
489 if (*slash) prefix = atoi(slash);
490 }
491
492 ENetAddress addr = { 0 };
493 if (enet_address_set_host_ip(&addr, ip_copy) != 0) {
494 u_log(LOG_ERROR, "banlist: `%s` is not a valid IP address", ip_copy);
495 return NULL;
496 }
497
498 // transform prefix length into mask
499 const enet_uint32 mask = u_prefixtomask(prefix);
500
501 return ban_record_add_addr(addr.host, mask, cnt, cur);
502 }
503
504 static void ban_free_list(void) {
505 ban_record_t *rec = banlist;
506 while (rec) {
507 ban_record_t *next = rec->next;
508 free(rec);
509 rec = next;
510 }
511 banlist = NULL;
512 }
513
514 static void ban_load_list(const char *fname) {
515 FILE *f = fopen(fname, "r");
516 if (!f) {
517 u_log(LOG_WARN, "banlist: could not open %s for reading", fname);
518 return;
519 }
520
521 char ln[MAX_STRLEN] = { 0 };
522
523 while (fgets(ln, sizeof(ln), f)) {
524 for (int i = sizeof(ln) - 1; i >= 0; --i)
525 if (ln[i] == '\n' || ln[i] == '\r')
526 ln[i] = 0;
527
528 if (ln[0] == 0)
529 continue;
530
531 char ip[21] = { 0 }; // optionally includes the "/nn" prefix length at the end
532 time_t exp = 0;
533 int count = 0;
534 if (sscanf(ln, "%20s %ld %d", ip, &exp, &count) < 3) {
535 u_log(LOG_ERROR, "banlist: malformed line: `%s`", ln);
536 continue;
537 }
538
539 if (ban_record_add_ip(ip, count, exp))
540 u_log(LOG_NOTE, "banlist: banned %s until %s (ban level %d)", ip, u_strtime(exp), count);
541 }
542
543 fclose(f);
544 }
545
546 static void ban_save_list(const char *fname) {
547 FILE *f = fopen(fname, "w");
548 if (!f) {
549 u_log(LOG_ERROR, "banlist: could not open %s for writing", fname);
550 return;
551 }
552
553 for (ban_record_t *rec = banlist; rec; rec = rec->next) {
554 if (rec->ban_count)
555 fprintf(f, "%s/%u %ld %d\n", u_iptostr(rec->host), u_masktoprefix(rec->mask), rec->cur_ban, rec->ban_count);
556 }
557
558 fclose(f);
559 }
560
561 static bool ban_sanity_check(const server_t *srv) {
562 // can't have more than 24 maxplayers; can't have more than max
563 if (srv->players > srv->maxplayers || srv->maxplayers > SV_MAX_PLAYERS || srv->maxplayers == 0)
564 return false;
565 // name and map have to be non-garbage
566 if (!u_strisprint(srv->map) || !u_strisprint(srv->name))
567 return false;
568 // these protocols don't exist
569 if (srv->proto < SV_PROTO_MIN || srv->proto > SV_PROTO_MAX)
570 return false;
571 // the game doesn't allow server names longer than 64 chars
572 if (strlen(srv->name) > SV_NAME_MAX)
573 return false;
574 // game mode has to actually exist
575 if (srv->gamemode > SV_MAX_GAMEMODE)
576 return false;
577 // flags field can't be higher than the sum of all the flags
578 if (srv->flags > SV_FL_MAX)
579 return false;
580 return true;
581 }
582
583 static void ban_add(const enet_uint32 host, const char *reason) {
584 const time_t now = time(NULL);
585
586 ban_record_t *rec = ban_record_add_addr(host, NET_FULLMASK, 0, 0);
587 if (!rec) u_fatal("OOM trying to ban %s", u_iptostr(host));
588
589 rec->cur_ban = now + ban_get_time(rec->ban_count);
590 rec->ban_count++;
591
592 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);
593
594 ban_save_list(MS_BAN_FILE);
595
596 sv_remove_by_host(host, NET_FULLMASK);
597
598 if (host == cl_last_addr)
599 cl_last_addr = 0;
600 }
601
602 static inline void ban_peer(ENetPeer *peer, const char *reason) {
603 if (peer) {
604 ban_add(peer->address.host, reason);
605 sv_clear_peer(peer);
606 enet_peer_reset(peer);
607 }
608 }
609
610 /* main */
611
612 static void deinit(void) {
613 // ban_save_list(MS_BAN_FILE);
614 ban_free_list();
615 if (ms_host) {
616 enet_host_destroy(ms_host);
617 ms_host = NULL;
618 }
619 enet_deinitialize();
620 }
621
622 #ifdef SIGUSR1
623 static void sigusr_handler(int signum) {
624 if (signum == SIGUSR1) {
625 u_log(LOG_WARN, "received SIGUSR1, reloading banlist");
626 ban_free_list();
627 ban_load_list(MS_BAN_FILE);
628 }
629 }
630 #endif
631
632 static bool handle_msg(const enet_uint8 msgid, ENetPeer *peer) {
633 server_t *sv = NULL;
634 server_t tmpsv = { 0 };
635 char clientver[MAX_STRLEN] = { 0 };
636 const time_t now = time(NULL);
637
638 switch (msgid) {
639 case NET_MSG_ADD:
640 tmpsv.port = b_read_uint16(&buf_recv);
641 b_read_dstring_to(&buf_recv, tmpsv.name, sizeof(tmpsv.name));
642 b_read_dstring_to(&buf_recv, tmpsv.map, sizeof(tmpsv.map));
643 tmpsv.gamemode = b_read_uint8(&buf_recv);
644 tmpsv.players = b_read_uint8(&buf_recv);
645 tmpsv.maxplayers = b_read_uint8(&buf_recv);
646 tmpsv.proto = b_read_uint8(&buf_recv);
647 tmpsv.flags = b_read_uint8(&buf_recv);
648
649 if (buf_recv.overflow) {
650 ban_peer(peer, "malformed MSG_ADD");
651 return true;
652 }
653
654 sv = sv_find_or_add(peer->address.host, tmpsv.port);
655 if (!sv) {
656 u_log(LOG_ERROR, "ran out of server slots trying to add %s:%d", u_iptostr(peer->address.host), tmpsv.port);
657 return true;
658 }
659
660 if (sv->host == peer->address.host) {
661 // old server; update it
662 memcpy(sv->map, tmpsv.map, sizeof(sv->map));
663 memcpy(sv->name, tmpsv.name, sizeof(sv->name));
664 sv->players = tmpsv.players;
665 sv->maxplayers = tmpsv.maxplayers;
666 sv->flags = tmpsv.flags;
667 sv->gamemode = tmpsv.gamemode;
668 // first check if the new values are garbage
669 if (!ban_sanity_check(sv)) {
670 ban_peer(peer, "tripped sanity check");
671 return true;
672 }
673 // only then update the times
674 sv->death_time = now + ms_sv_timeout;
675 sv->timestamp = now;
676 // check if we're updating from a new peer
677 if (sv->peer != peer) {
678 // if there was an old one, kill it
679 if (sv->peer) {
680 sv->peer->data = NULL;
681 enet_peer_reset(sv->peer);
682 }
683 sv->peer = peer;
684 peer->data = sv;
685 }
686 u_log(LOG_NOTE, "updated server #%d:", sv - servers);
687 u_printsv(sv);
688 } else {
689 // new server; first check if this host is creating too many servers in the list
690 if (max_servers_per_host) {
691 const int count = sv_count_by_host(peer->address.host, NET_FULLMASK);
692 if (count >= max_servers_per_host) {
693 ban_peer(peer, "too many servers in list");
694 return true;
695 }
696 /*
697 // FIXME: commented out as this might trip when the master restarts
698 if (count > 0) {
699 // check if this is too soon to create a new server
700 const time_t delta = now - sv_last_timestamp_for_host(peer->address.host, NET_FULLMASK);
701 if (delta < count * SV_NEW_SERVER_INTERVAL) {
702 ban_peer(peer, "creating servers too fast");
703 return true;
704 }
705 }
706 */
707 }
708 // then add that shit
709 *sv = tmpsv;
710 sv->host = peer->address.host;
711 sv->death_time = now + ms_sv_timeout;
712 sv->timestamp = now;
713 if (!ban_sanity_check(sv)) {
714 sv->host = 0;
715 sv->port = 0;
716 ban_peer(peer, "tripped sanity check");
717 return true;
718 }
719 sv->peer = peer;
720 peer->data = sv;
721 ++num_servers;
722 u_log(LOG_NOTE, "added new server #%d:", sv - servers);
723 u_printsv(sv);
724 }
725 return true;
726
727 case NET_MSG_RM:
728 tmpsv.port = b_read_uint16(&buf_recv);
729 if (buf_recv.overflow) {
730 ban_peer(peer, "malformed MSG_RM");
731 return true;
732 }
733 sv_remove_by_addr(peer->address.host, tmpsv.port);
734 // this peer can be disconnected pretty much immediately since he has no servers left, tell him to fuck off
735 sv_clear_peer(peer);
736 enet_peer_disconnect_later(peer, 0);
737 return true;
738
739 case NET_MSG_LIST:
740 buf_send.pos = 0;
741 buf_send.overflow = 0;
742 b_write_uint8(&buf_send, NET_MSG_LIST);
743
744 clientver[0] = 0;
745 if (buf_recv.size > 2) {
746 // holy shit a fresh client
747 b_read_dstring_to(&buf_recv, clientver, sizeof(clientver));
748 b_write_uint8(&buf_send, num_servers);
749 } else {
750 // old client; feed him fake servers first
751 b_write_uint8(&buf_send, num_servers + num_fake_servers);
752 for (int i = 0; i < num_fake_servers; ++i)
753 b_write_server(&buf_send, &fake_servers[i]);
754 }
755
756 if (buf_recv.overflow) {
757 ban_peer(peer, "malformed MSG_LIST");
758 return true;
759 }
760
761 if (clientver[0] && !u_strisver(clientver)) {
762 ban_peer(peer, "malformed MSG_LIST clientver");
763 return true;
764 }
765
766 for (int i = 0; i < max_servers; ++i) {
767 if (servers[i].host)
768 b_write_server(&buf_send, servers + i);
769 }
770
771 if (clientver[0]) {
772 // TODO: check if this client is outdated (?) and send back new verstring
773 // for now just write the same shit back
774 b_write_dstring(&buf_send, clientver);
775 // write the motd and urgent message
776 b_write_dstring(&buf_send, ms_motd);
777 b_write_dstring(&buf_send, ms_urgent);
778 }
779
780 ENetPacket *p = enet_packet_create(buf_send.data, buf_send.pos, ENET_PACKET_FLAG_RELIABLE);
781 enet_peer_send(peer, NET_CH_MAIN, p);
782 // enet_host_flush(ms_host);
783
784 // this peer can be disconnected pretty much immediately after receiving the server list, tell him to fuck off
785 sv_clear_peer(peer);
786 enet_peer_disconnect_later(peer, 0);
787
788 u_log(LOG_NOTE, "sent server list to %s:%d (ver %s)", u_iptostr(peer->address.host), peer->address.port, clientver[0] ? clientver : "<old>");
789 return true;
790
791 default:
792 break;
793 }
794
795 return false;
796 }
797
798 static void print_usage(void) {
799 printf("Usage: d2df_master [OPTIONS...]\n");
800 printf("Available options:\n");
801 printf("-h show this message and exit\n");
802 printf("-p N listen on port N (default: %d)\n", DEFAULT_PORT);
803 printf("-t N seconds before server is removed from list (default: %d)\n", DEFAULT_SERVER_TIMEOUT);
804 printf("-c N how long a client is allowed to hold the connection active (default: %d)\n", DEFAULT_CLIENT_TIMEOUT);
805 printf("-s N max number of servers in server list, 1-%d (default: %d)\n", MS_MAX_SERVERS, DEFAULT_MAX_SERVERS);
806 printf("-d N if N > 0, disallow more than N servers on the same IP (default: %d)\n", DEFAULT_MAX_PER_HOST);
807 printf("-f N crappy spam filter: ban clients after they send N requests in a row too fast (default: %d)\n", DEFAULT_SPAM_CAP);
808 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);
809 fflush(stdout);
810 }
811
812 static inline bool parse_int_arg(int argc, char **argv, const int i, const char *name, int vmin, int vmax, int *outval) {
813 if (strcmp(name, argv[i]))
814 return false;
815
816 if (i >= argc - 1) {
817 fprintf(stderr, "expected integer value after %s\n", name);
818 return false;
819 }
820
821 const int v = atoi(argv[i + 1]);
822 if (v < vmin || v > vmax) {
823 fprintf(stderr, "expected integer value in range %d - %d\n", vmin, vmax);
824 return false;
825 }
826
827 *outval = v;
828 return true;
829 }
830
831 static bool parse_args(int argc, char **argv) {
832 if (argc < 2)
833 return true;
834
835 if (!strcmp(argv[1], "-h")) {
836 print_usage();
837 return false;
838 }
839
840 for (int i = 1; i < argc; ++i) {
841 const bool success =
842 parse_int_arg(argc, argv, i, "-p", 1, 0xFFFF, &ms_port)
843 || parse_int_arg(argc, argv, i, "-t", 1, 0x7FFFFFFF, &ms_sv_timeout)
844 || parse_int_arg(argc, argv, i, "-c", 1, 0x7FFFFFFF, &ms_cl_timeout)
845 || parse_int_arg(argc, argv, i, "-s", 1, MS_MAX_SERVERS, &max_servers)
846 || parse_int_arg(argc, argv, i, "-d", 0, MS_MAX_SERVERS, &max_servers_per_host)
847 || parse_int_arg(argc, argv, i, "-f", 0, 0xFFFF, &ms_spam_cap)
848 || parse_int_arg(argc, argv, i, "-w", 1, 0x7FFFFFFF, &ms_spam_timeout);
849 if (success) {
850 ++i;
851 } else {
852 fprintf(stderr, "unknown or invalid argument: %s\n", argv[i]);
853 return false;
854 }
855 }
856
857 return true;
858 }
859
860 // a stupid thing to filter sustained spam from a single IP
861 static bool spam_filter(ENetPeer *peer, const time_t now) {
862 if (peer->address.host == cl_last_addr) {
863 // spam === sending shit faster than once a second
864 if (now - cl_last_time < ms_spam_timeout) {
865 if (cl_spam_cnt > 1)
866 u_log(LOG_WARN, "address %s is sending packets too fast", u_iptostr(peer->address.host));
867 if (++cl_spam_cnt >= ms_spam_cap) {
868 ban_peer(peer, "spam");
869 cl_last_addr = 0;
870 return true;
871 }
872 } else {
873 cl_spam_cnt = 0;
874 }
875 } else {
876 cl_last_addr = peer->address.host;
877 cl_spam_cnt = 0;
878 }
879 cl_last_time = now;
880 return false;
881 }
882
883 // filter incoming UDP packets before the protocol kicks in
884 static int packet_filter(ENetHost *host, ENetEvent *event) {
885 return !!ban_check(host->receivedAddress.host);
886 }
887
888 int main(int argc, char **argv) {
889 if (enet_initialize() != 0)
890 u_fatal("could not init enet");
891
892 if (!parse_args(argc, argv))
893 return 1; // early exit
894
895 u_log(LOG_NOTE, "d2df master server starting on port %d", ms_port);
896
897 if (!u_readtextfile(MS_MOTD_FILE, ms_motd, sizeof(ms_motd)))
898 u_log(LOG_NOTE, "couldn't read motd from %s", MS_MOTD_FILE);
899 else
900 u_log(LOG_NOTE, "motd: %s", ms_motd);
901
902 if (!u_readtextfile(MS_URGENT_FILE, ms_urgent, sizeof(ms_urgent)))
903 u_log(LOG_NOTE, "couldn't read urgentmsg from %s", MS_URGENT_FILE);
904 else
905 u_log(LOG_NOTE, "urgentmsg: %s", ms_urgent);
906
907 ban_load_list(MS_BAN_FILE);
908
909 atexit(deinit);
910
911 #ifdef SIGUSR1
912 signal(SIGUSR1, sigusr_handler);
913 #endif
914
915 ENetAddress addr;
916 addr.host = 0;
917 addr.port = ms_port;
918 ms_host = enet_host_create(&addr, MS_MAX_CLIENTS, NET_CH_COUNT + 1, 0, 0);
919 if (!ms_host)
920 u_fatal("could not create enet host on port %d", ms_port);
921
922 ms_host->intercept = packet_filter;
923
924 bool running = true;
925 enet_uint8 msgid = 0;
926 ENetEvent event;
927 while (running) {
928 while (enet_host_service(ms_host, &event, 10) > 0) {
929 const time_t now = time(NULL);
930 const bool filtered = !event.peer || (ms_spam_cap && spam_filter(event.peer, now));
931
932 if (!filtered) {
933 switch (event.type) {
934 case ENET_EVENT_TYPE_CONNECT:
935 u_log(LOG_NOTE, "%s:%d connected", u_iptostr(event.peer->address.host), event.peer->address.port);
936 if (event.peer->channelCount != NET_CH_COUNT)
937 ban_peer(event.peer, "what is this");
938 else
939 enet_peer_timeout(event.peer, 0, 0, ms_cl_timeout * 1000);
940 break;
941
942 case ENET_EVENT_TYPE_RECEIVE:
943 if (!event.packet || event.packet->dataLength == 0) {
944 ban_peer(event.peer, "empty packet");
945 break;
946 }
947 // set up receive buffer
948 buf_recv.pos = 0;
949 buf_recv.overflow = 0;
950 buf_recv.data = event.packet->data;
951 buf_recv.size = event.packet->dataLength;
952 // read message id and handle the message
953 msgid = b_read_uint8(&buf_recv);
954 if (!handle_msg(msgid, event.peer)) {
955 // cheeky cunt sending invalid messages
956 ban_peer(event.peer, "unknown message");
957 }
958 break;
959
960 case ENET_EVENT_TYPE_DISCONNECT:
961
962 // u_log(LOG_NOTE, "%s:%d disconnected", u_iptostr(event.peer->address.host), event.peer->address.port);
963 break;
964
965 default:
966 break;
967 }
968 } else if (event.peer) {
969 // u_log(LOG_WARN, "filtered event %d from %s", event.type, u_iptostr(event.peer->address.host));
970 sv_clear_peer(event.peer);
971 enet_peer_reset(event.peer);
972 }
973
974 if (event.packet) {
975 buf_recv.data = NULL;
976 enet_packet_destroy(event.packet);
977 }
978 }
979
980 const time_t now = time(NULL);
981
982 // time out servers
983 for (int i = 0; i < max_servers; ++i) {
984 if (servers[i].host && servers[i].death_time <= now) {
985 u_log(LOG_NOTE, "server #%d %s:%d timed out", i, u_iptostr(servers[i].host), servers[i].port);
986 sv_remove(servers + i);
987 }
988 }
989 }
990 }
[MIRROR] a port of Doom 2D Forever to FPC/SDL
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024