DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / d2df-sdl.git / blob


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