DEADSOFTWARE

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