DEADSOFTWARE

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


2ea5016bbf538ba65ee5da1e0f7679c5610894bf
[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 <errno.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_load_list(const char *fname) {
473 FILE *f = fopen(fname, "r");
474 if (!f) {
475 u_log(LOG_WARN, "banlist: could not open %s for reading", fname);
476 return;
477 }
478
479 char ln[MAX_STRLEN] = { 0 };
480
481 while (fgets(ln, sizeof(ln), f)) {
482 for (int i = sizeof(ln) - 1; i >= 0; --i)
483 if (ln[i] == '\n' || ln[i] == '\r')
484 ln[i] = 0;
485
486 if (ln[0] == 0)
487 continue;
488
489 char ip[21] = { 0 }; // optionally includes the "/nn" prefix length at the end
490 time_t exp = 0;
491 int count = 0;
492 if (sscanf(ln, "%20s %ld %d", ip, &exp, &count) < 3) {
493 u_log(LOG_ERROR, "banlist: malformed line: `%s`", ln);
494 continue;
495 }
496
497 if (ban_record_add_ip(ip, count, exp))
498 u_log(LOG_NOTE, "banlist: banned %s until %s (ban level %d)", ip, u_strtime(exp), count);
499 }
500
501 fclose(f);
502 }
503
504 static void ban_save_list(const char *fname) {
505 FILE *f = fopen(fname, "w");
506 if (!f) {
507 u_log(LOG_ERROR, "banlist: could not open %s for writing", fname);
508 return;
509 }
510
511 for (ban_record_t *rec = banlist; rec; rec = rec->next) {
512 if (rec->ban_count)
513 fprintf(f, "%s/%u %ld %d\n", u_iptostr(rec->host), u_masktoprefix(rec->mask), rec->cur_ban, rec->ban_count);
514 }
515
516 fclose(f);
517 }
518
519 static bool ban_sanity_check(const server_t *srv) {
520 // can't have more than 24 maxplayers; can't have more than max
521 if (srv->players > srv->maxplayers || srv->maxplayers > SV_MAX_PLAYERS || srv->maxplayers == 0)
522 return false;
523 // name and map have to be non-garbage
524 if (!u_strisprint(srv->map) || !u_strisprint(srv->name))
525 return false;
526 // these protocols don't exist
527 if (srv->proto < SV_PROTO_MIN || srv->proto > SV_PROTO_MAX)
528 return false;
529 // the game doesn't allow server names longer than 64 chars
530 if (strlen(srv->name) > SV_NAME_MAX)
531 return false;
532 // game mode has to actually exist
533 if (srv->gamemode > SV_MAX_GAMEMODE)
534 return false;
535 // flags field can't be higher than the sum of all the flags
536 if (srv->flags > SV_FL_MAX)
537 return false;
538 return true;
539 }
540
541 static void ban_add(const enet_uint32 host, const char *reason) {
542 const time_t now = time(NULL);
543
544 ban_record_t *rec = ban_record_add_addr(host, NET_FULLMASK, 0, 0);
545 if (!rec) u_fatal("OOM trying to ban %s", u_iptostr(host));
546
547 rec->cur_ban = now + ban_get_time(rec->ban_count);
548 rec->ban_count++;
549
550 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);
551
552 ban_save_list(MS_BAN_FILE);
553
554 sv_remove_by_host(host, NET_FULLMASK);
555
556 if (host == cl_last_addr)
557 cl_last_addr = 0;
558 }
559
560 static inline void ban_peer(ENetPeer *peer, const char *reason) {
561 if (peer) {
562 ban_add(peer->address.host, reason);
563 enet_peer_reset(peer);
564 }
565 }
566
567 /* main */
568
569 static void deinit(void) {
570 // ban_save_list(MS_BAN_FILE);
571 if (ms_host) {
572 enet_host_destroy(ms_host);
573 ms_host = NULL;
574 }
575 enet_deinitialize();
576 }
577
578 static bool handle_msg(const enet_uint8 msgid, ENetPeer *peer) {
579 server_t *sv = NULL;
580 server_t tmpsv = { 0 };
581 char clientver[MAX_STRLEN] = { 0 };
582 const time_t now = time(NULL);
583
584 switch (msgid) {
585 case NET_MSG_ADD:
586 tmpsv.port = b_read_uint16(&buf_recv);
587 b_read_dstring_to(&buf_recv, tmpsv.name, sizeof(tmpsv.name));
588 b_read_dstring_to(&buf_recv, tmpsv.map, sizeof(tmpsv.map));
589 tmpsv.gamemode = b_read_uint8(&buf_recv);
590 tmpsv.players = b_read_uint8(&buf_recv);
591 tmpsv.maxplayers = b_read_uint8(&buf_recv);
592 tmpsv.proto = b_read_uint8(&buf_recv);
593 tmpsv.flags = b_read_uint8(&buf_recv);
594
595 if (buf_recv.overflow) {
596 ban_peer(peer, "malformed MSG_ADD");
597 return true;
598 }
599
600 sv = sv_find_or_add(peer->address.host, tmpsv.port);
601 if (!sv) {
602 u_log(LOG_ERROR, "ran out of server slots trying to add %s:%d", u_iptostr(peer->address.host), tmpsv.port);
603 return true;
604 }
605
606 if (sv->host == peer->address.host) {
607 // old server; update it
608 memcpy(sv->map, tmpsv.map, sizeof(sv->map));
609 memcpy(sv->name, tmpsv.name, sizeof(sv->name));
610 sv->players = tmpsv.players;
611 sv->maxplayers = tmpsv.maxplayers;
612 sv->flags = tmpsv.flags;
613 sv->gamemode = tmpsv.gamemode;
614 // first check if the new values are garbage
615 if (!ban_sanity_check(sv)) {
616 ban_peer(peer, "tripped sanity check");
617 return true;
618 }
619 // only then update the times
620 sv->death_time = now + ms_timeout;
621 sv->timestamp = now;
622 u_log(LOG_NOTE, "updated server #%d:", sv - servers);
623 u_printsv(sv);
624 } else {
625 // new server; first check if this host is creating too many servers in the list
626 if (max_servers_per_host) {
627 const int count = sv_count_by_host(peer->address.host, NET_FULLMASK);
628 if (count >= max_servers_per_host) {
629 ban_peer(peer, "too many servers in list");
630 return true;
631 }
632 /*
633 // FIXME: commented out as this might trip when the master restarts
634 if (count > 0) {
635 // check if this is too soon to create a new server
636 const time_t delta = now - sv_last_timestamp_for_host(peer->address.host, NET_FULLMASK);
637 if (delta < count * SV_NEW_SERVER_INTERVAL) {
638 ban_peer(peer, "creating servers too fast");
639 return true;
640 }
641 }
642 */
643 }
644 // then add that shit
645 *sv = tmpsv;
646 sv->host = peer->address.host;
647 sv->death_time = now + ms_timeout;
648 sv->timestamp = now;
649 if (!ban_sanity_check(sv)) {
650 sv->host = 0;
651 sv->port = 0;
652 ban_peer(peer, "tripped sanity check");
653 return true;
654 }
655 ++num_servers;
656 u_log(LOG_NOTE, "added new server #%d:", sv - servers);
657 u_printsv(sv);
658 }
659 return true;
660
661 case NET_MSG_RM:
662 tmpsv.port = b_read_uint16(&buf_recv);
663 if (buf_recv.overflow) {
664 ban_peer(peer, "malformed MSG_RM");
665 return true;
666 }
667 sv_remove(peer->address.host, tmpsv.port);
668 return true;
669
670 case NET_MSG_LIST:
671 buf_send.pos = 0;
672 b_write_uint8(&buf_send, NET_MSG_LIST);
673
674 clientver[0] = 0;
675 if (buf_recv.size > 2) {
676 // holy shit a fresh client
677 b_read_dstring_to(&buf_recv, clientver, sizeof(clientver));
678 b_write_uint8(&buf_send, num_servers);
679 } else {
680 // old client; feed him fake servers first
681 b_write_uint8(&buf_send, num_servers + num_fake_servers);
682 for (int i = 0; i < num_fake_servers; ++i)
683 b_write_server(&buf_send, &fake_servers[i]);
684 }
685
686 if (buf_recv.overflow) {
687 ban_peer(peer, "malformed MSG_LIST");
688 return true;
689 }
690
691 for (int i = 0; i < max_servers; ++i) {
692 if (servers[i].host)
693 b_write_server(&buf_send, servers + i);
694 }
695
696 if (clientver[0]) {
697 // TODO: check if this client is outdated (?) and send back new verstring
698 // for now just write the same shit back
699 b_write_dstring(&buf_send, clientver);
700 // write the motd and urgent message
701 b_write_dstring(&buf_send, ms_motd);
702 b_write_dstring(&buf_send, ms_urgent);
703 }
704
705 ENetPacket *p = enet_packet_create(buf_send.data, buf_send.pos, ENET_PACKET_FLAG_RELIABLE);
706 enet_peer_send(peer, NET_CH_MAIN, p);
707 enet_host_flush(ms_host);
708
709 u_log(LOG_NOTE, "sent server list to %s:%d (ver %s)", u_iptostr(peer->address.host), peer->address.port, clientver[0] ? clientver : "<old>");
710 return true;
711
712 default:
713 break;
714 }
715
716 return false;
717 }
718
719 static void print_usage(void) {
720 printf("Usage: d2df_master [OPTIONS...]\n");
721 printf("Available options:\n");
722 printf("-h show this message and exit\n");
723 printf("-p N listen on port N (default: %d)\n", DEFAULT_PORT);
724 printf("-t N seconds before server is removed from list (default: %d)\n", DEFAULT_TIMEOUT);
725 printf("-s N max number of servers in server list, 1-%d (default: %d)\n", MS_MAX_SERVERS, DEFAULT_MAX_SERVERS);
726 printf("-d N if N > 0, disallow more than N servers on the same IP (default: %d)\n", DEFAULT_MAX_PER_HOST);
727 printf("-f N crappy spam filter: ban people after they send N requests in a row too fast (default: %d)\n", DEFAULT_SPAM_CAP);
728 fflush(stdout);
729 }
730
731 static inline bool parse_int_arg(int argc, char **argv, const int i, const char *name, int vmin, int vmax, int *outval) {
732 if (strcmp(name, argv[i]))
733 return false;
734
735 if (i >= argc - 1) {
736 fprintf(stderr, "expected integer value after %s\n", name);
737 return false;
738 }
739
740 const int v = atoi(argv[i + 1]);
741 if (v < vmin || v > vmax) {
742 fprintf(stderr, "expected integer value in range %d - %d\n", vmin, vmax);
743 return false;
744 }
745
746 *outval = v;
747 return true;
748 }
749
750 static bool parse_args(int argc, char **argv) {
751 if (argc < 2)
752 return true;
753
754 if (!strcmp(argv[0], "-h")) {
755 print_usage();
756 return false;
757 }
758
759 for (int i = 1; i < argc; ++i) {
760 const bool success =
761 parse_int_arg(argc, argv, i, "-p", 1, 0xFFFF, &ms_port)
762 || parse_int_arg(argc, argv, i, "-t", 1, 0x7FFFFFFF, &ms_timeout)
763 || parse_int_arg(argc, argv, i, "-s", 1, MS_MAX_SERVERS, &max_servers)
764 || parse_int_arg(argc, argv, i, "-d", 0, MS_MAX_SERVERS, &max_servers_per_host)
765 || parse_int_arg(argc, argv, i, "-f", 0, 0xFFFF, &ms_spam_cap);
766 if (success) {
767 ++i;
768 } else {
769 fprintf(stderr, "unknown or invalid argument: %s\n", argv[i]);
770 return false;
771 }
772 }
773
774 return true;
775 }
776
777 // a stupid thing to filter sustained spam from a single IP
778 static bool spam_filter(ENetPeer *peer) {
779 const time_t now = time(NULL);
780 if (peer->address.host == cl_last_addr) {
781 // spam === sending shit faster than once a second
782 if (now - cl_last_time < 1) {
783 if (cl_spam_cnt > 1)
784 u_log(LOG_WARN, "address %s is sending packets too fast", u_iptostr(peer->address.host));
785 if (++cl_spam_cnt >= ms_spam_cap) {
786 ban_peer(peer, "spam");
787 return true;
788 }
789 } else {
790 cl_spam_cnt = 0;
791 }
792 } else {
793 cl_last_addr = peer->address.host;
794 cl_spam_cnt = 0;
795 }
796 cl_last_time = now;
797 return false;
798 }
799
800 int main(int argc, char **argv) {
801 if (enet_initialize() != 0)
802 u_fatal("could not init enet");
803
804 if (!parse_args(argc, argv))
805 return 1; // early exit
806
807 u_log(LOG_NOTE, "d2df master server starting on port %d", ms_port);
808
809 if (!u_readtextfile(MS_MOTD_FILE, ms_motd, sizeof(ms_motd)))
810 u_log(LOG_NOTE, "couldn't read motd from %s", MS_MOTD_FILE);
811 else
812 u_log(LOG_NOTE, "motd: %s", ms_motd);
813
814 if (!u_readtextfile(MS_URGENT_FILE, ms_urgent, sizeof(ms_urgent)))
815 u_log(LOG_NOTE, "couldn't read urgentmsg from %s", MS_URGENT_FILE);
816 else
817 u_log(LOG_NOTE, "urgentmsg: %s", ms_urgent);
818
819 ban_load_list(MS_BAN_FILE);
820
821 atexit(deinit);
822
823 ENetAddress addr;
824 addr.host = 0;
825 addr.port = ms_port;
826 ms_host = enet_host_create(&addr, MS_MAX_CLIENTS, NET_CH_COUNT, 0, 0);
827 if (!ms_host)
828 u_fatal("could not create enet host on port %d", ms_port);
829
830 bool running = true;
831 enet_uint8 msgid = 0;
832 ENetEvent event;
833 while (running) {
834 while (enet_host_service(ms_host, &event, 5000) > 0) {
835 if (!event.peer) {
836 continue; // can this even happen?
837 } else if (ban_check(event.peer->address.host)) {
838 enet_peer_reset(event.peer);
839 continue;
840 }
841
842 if (event.type != ENET_EVENT_TYPE_DISCONNECT)
843 if (spam_filter(event.peer))
844 continue;
845
846 switch (event.type) {
847 case ENET_EVENT_TYPE_CONNECT:
848 u_log(LOG_NOTE, "%s:%d connected", u_iptostr(event.peer->address.host), event.peer->address.port);
849 break;
850
851 case ENET_EVENT_TYPE_RECEIVE:
852 if (!event.packet || event.packet->dataLength == 0) {
853 ban_peer(event.peer, "empty packet");
854 break;
855 }
856 // set up receive buffer
857 buf_recv.pos = 0;
858 buf_recv.overflow = 0;
859 buf_recv.data = event.packet->data;
860 buf_recv.size = event.packet->dataLength;
861 // read message id and handle the message
862 msgid = b_read_uint8(&buf_recv);
863 if (!handle_msg(msgid, event.peer)) {
864 // cheeky cunt sending invalid messages
865 ban_peer(event.peer, "unknown message");
866 }
867 break;
868
869 default:
870 break;
871 }
872 }
873
874 const time_t now = time(NULL);
875 for (int i = 0; i < max_servers; ++i) {
876 if (servers[i].host) {
877 if (servers[i].death_time <= now) {
878 u_log(LOG_NOTE, "server #%d %s:%d timed out", i, u_iptostr(servers[i].host), servers[i].port);
879 servers[i].host = 0;
880 servers[i].port = 0;
881 --num_servers;
882 }
883 }
884 }
885 }
886 }
[MIRROR] a port of Doom 2D Forever to FPC/SDL
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024