DEADSOFTWARE

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


ca1c129895cb851f83c68d026288706b462bf011
[d2df-sdl.git] / src / mastersrv / master.c
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <string.h>
4 #include <enet/enet.h>
5 #include <enet/types.h>
6 #include <time.h>
7
8 #define MS_VERSION "0.2"
9 #define MS_MAXSRVS 128
10 #define MS_TIMEOUT 100
11
12 #define NET_CHANS 2
13 #define NET_CH_MAIN 0
14 #define NET_CH_UPD 1
15 #define NET_MAXCLIENTS 64
16
17 #define NET_BUFSIZE 65536
18
19 #define NET_MSG_ADD 200
20 #define NET_MSG_RM 201
21 #define NET_MSG_LIST 202
22
23 #define LC_MS_INIT "D2DF master server starting on port %d...\n"
24 #define LC_MS_ADD "\nAdded server in slot #%d:\n%s:%d\n%s\n%s (%d)\n%d/%d plrs\nproto: %d pw?: %d\n"
25 #define LC_MS_UPD "\nUpdated server #%d (%s:%d):\n%s\n%s (%d)\n%d/%d plrs\nproto: %d pw?: %d\n"
26 #define LC_MS_RM "\nRemoved server #%d (%s:%d) by request.\n"
27 #define LC_MS_TIME "\nServer #%d (%s:%d) timed out.\n"
28 #define LC_MS_LIST "\nSent server list to %x:%u (ver. %s).\n"
29 #define LC_MS_DIE "\nD2DF master server shutting down...\n"
30 #define LC_MS_CONN "\nIncoming connection from %x:%u...\n"
31 #define LC_MS_MOTD "\nMOTD: %s\n"
32 #define LC_MS_URGENT "\nURGENT: %s\n"
33
34 #define MS_URGENT_FILE "urgent.txt"
35 #define MS_MOTD_FILE "motd.txt"
36
37 struct ms_server_s {
38 enet_uint8 used;
39 char s_ip[17];
40 char s_name[256];
41 char s_map[256];
42 enet_uint8 s_pw;
43 enet_uint8 s_plrs;
44 enet_uint8 s_maxplrs;
45 enet_uint8 s_mode;
46 enet_uint8 s_protocol;
47 enet_uint16 s_port;
48 time_t deathtime;
49 };
50
51 typedef struct ms_server_s ms_server;
52
53 const char ms_game_ver[] = "0.63";
54 char ms_motd[255] = "";
55 char ms_urgent[255] = "";
56
57 int ms_port = 25660;
58 int ms_timeout = 100;
59
60 size_t b_read = 0;
61 size_t b_write = 0;
62
63 enet_uint8 b_send[NET_BUFSIZE];
64
65 ENetHost *ms_host = NULL;
66 ENetPeer *ms_peers[NET_MAXCLIENTS];
67 ms_server ms_srv[MS_MAXSRVS];
68 enet_uint8 ms_count = 0;
69
70 // fake servers to show on old versions of the game
71 static const ms_server ms_fake_srv[] = {
72 {
73 .used = 1,
74 .s_ip = "0.0.0.0",
75 .s_name = "! \xc2\xc0\xd8\xc0 \xca\xce\xcf\xc8\xdf \xc8\xc3\xd0\xdb "
76 "\xd3\xd1\xd2\xc0\xd0\xc5\xcb\xc0! "
77 "\xd1\xca\xc0\xd7\xc0\xc9\xd2\xc5 \xcd\xce\xc2\xd3\xde C "
78 "doom2d.org !",
79 .s_map = "! Your game is outdated. "
80 "Get latest version at doom2d.org !",
81 .s_protocol = 255,
82 },
83 {
84 .used = 1,
85 .s_ip = "0.0.0.0",
86 .s_name = "! \xcf\xd0\xce\xc1\xd0\xce\xd1\xdcTE \xcf\xce\xd0\xd2\xdb "
87 "25666 \xc8 57133 HA CEPBEPE \xcf\xc5\xd0\xc5\xc4 \xc8\xc3\xd0\xce\xc9 !",
88 .s_map = "! Forward ports 25666 and 57133 before hosting !",
89 .s_protocol = 255,
90 },
91 };
92
93 #define MS_FAKESRVS (sizeof(ms_fake_srv) / sizeof(ms_fake_srv[0]))
94
95 void i_usage () {
96 printf("Usage: d2df_master -p port_number [-t timeout_seconds]\n");
97 fflush(stdout);
98 }
99
100
101 void i_version () {
102 printf("Doom 2D Forever master server v%s\n", MS_VERSION);
103 fflush(stdout);
104 }
105
106
107 void d_error (const char *msg, int fatal) {
108 if (fatal) {
109 fprintf(stderr, "FATAL ERROR: %s\n", msg);
110 exit(EXIT_FAILURE);
111 } else {
112 fprintf(stderr, "ERROR: %s\n", msg);
113 }
114 }
115
116
117 void d_getargs (int argc, char *argv[]) {
118 if (argc < 2) {
119 i_usage();
120 exit(0);
121 return;
122 }
123
124 for (int i = 1; i < argc; ++i) {
125 if (!strcmp(argv[i], "-v")) {
126 i_version();
127 exit(0);
128 return;
129 } else if (!strcmp(argv[i], "-p")) {
130 if (i + 1 >= argc) {
131 d_error("Specify a port value!", 1);
132 return;
133 } else {
134 ms_port = atoi(argv[++i]);
135 }
136 } else if (!strcmp(argv[i], "-t") & (i + 1 < argc)) {
137 ms_timeout = atoi(argv[++i]);
138 }
139 }
140 }
141
142
143 int d_readtextfile (const char *fname, char *buf, size_t max) {
144 FILE *f = fopen(fname, "r");
145 char *const end = buf + max - 1;
146 char *p = buf;
147 if (f) {
148 char ln[max];
149 char *const lend = ln + max - 1;
150 while(p < end && fgets(ln, sizeof(ln), f)) {
151 for (char *n = ln; n < lend && *n && *n != '\r' && *n != '\n'; ++n) {
152 *(p++) = *n;
153 if (p == end) break;
154 }
155 }
156 *p = '\0';
157 fclose(f);
158 return 0;
159 }
160 return 1;
161 }
162
163
164 enet_uint8 b_read_uint8 (enet_uint8 buf[], size_t *pos) {
165 return buf[(*pos)++];
166 }
167
168
169 enet_uint16 b_read_uint16 (enet_uint8 buf[], size_t *pos) {
170 enet_uint16 ret = 0;
171
172 ret = *(enet_uint16*)(buf + *pos);
173 *pos += sizeof(enet_uint16);
174
175 return ret;
176 }
177
178
179 char* b_read_dstring (enet_uint8 buf[], size_t *pos) {
180 char *ret = NULL;
181
182 size_t len = b_read_uint8(buf, pos);
183
184 ret = malloc(len + 1);
185
186 memmove(ret, (char*)(buf + *pos), len);
187 ret[len] = '\0';
188 *pos += len;
189
190 return ret;
191 }
192
193
194 void b_write_uint8 (enet_uint8 buf[], size_t *pos, enet_uint8 val) {
195 buf[(*pos)++] = val;
196 }
197
198
199 void b_write_uint16 (enet_uint8 buf[], size_t *pos, enet_uint16 val) {
200 *(enet_uint16*)(buf + *pos) = val;
201 *pos += sizeof(enet_uint16);
202 }
203
204
205 void b_write_dstring (enet_uint8 buf[], size_t *pos, const char* val) {
206 enet_uint8 len = strlen(val);
207 b_write_uint8(buf, pos, len);
208
209 memmove((char*)(buf + *pos), val, len);
210 *pos += len;
211 }
212
213
214 void b_write_server (enet_uint8 buf[], size_t *pos, ms_server s) {
215 b_write_dstring(b_send, pos, s.s_ip);
216 b_write_uint16 (b_send, pos, s.s_port);
217 b_write_dstring(b_send, pos, s.s_name);
218 b_write_dstring(b_send, pos, s.s_map);
219 b_write_uint8 (b_send, pos, s.s_mode);
220 b_write_uint8 (b_send, pos, s.s_plrs);
221 b_write_uint8 (b_send, pos, s.s_maxplrs);
222 b_write_uint8 (b_send, pos, s.s_protocol);
223 b_write_uint8 (b_send, pos, s.s_pw);
224 }
225
226
227 int main (int argc, char *argv[]) {
228 d_getargs(argc, argv);
229
230 if (enet_initialize()) {
231 d_error("Could not init ENet!", 1);
232 return EXIT_FAILURE;
233 }
234
235 printf(LC_MS_INIT, ms_port);
236
237 d_readtextfile(MS_MOTD_FILE, ms_motd, sizeof(ms_motd));
238 d_readtextfile(MS_URGENT_FILE, ms_urgent, sizeof(ms_urgent));
239
240 if (ms_motd[0]) printf(LC_MS_MOTD, ms_motd);
241 if (ms_urgent[0]) printf(LC_MS_URGENT, ms_urgent);
242
243 for (int i = 0; i < NET_MAXCLIENTS; ++i) ms_peers[i] = NULL;
244
245 for (int i = 0; i < MS_MAXSRVS; ++i) {
246 ms_srv[i].used = 0;
247 ms_srv[i].s_ip[0] = '\0';
248 ms_srv[i].s_name[0] = '\0';
249 ms_srv[i].s_map[0] = '\0';
250 ms_srv[i].deathtime = 0;
251 }
252
253 ENetAddress addr;
254 addr.host = ENET_HOST_ANY;
255 addr.port = ms_port;
256
257 ms_host = enet_host_create(&addr, NET_MAXCLIENTS, NET_CHANS, 0, 0);
258 if (!ms_host) {
259 d_error("Could not create host on specified port!", 1);
260 return EXIT_FAILURE;
261 }
262
263 atexit(enet_deinitialize);
264
265 ENetEvent event;
266 int shutdown = 0;
267 enet_uint8 msg = 255;
268
269 char ip[17];
270 enet_uint16 port = 0;
271
272 char *name = NULL;
273 char *map = NULL;
274 char *clientver = NULL;
275 enet_uint8 gm = 0;
276 enet_uint16 pl = 0;
277 enet_uint16 mpl = 0;
278
279 enet_uint8 proto = 0;
280 enet_uint8 pw = 0;
281 while (!shutdown) {
282 while (enet_host_service(ms_host, &event, 5000) > 0) {
283 switch (event.type) {
284 case ENET_EVENT_TYPE_CONNECT:
285 printf(LC_MS_CONN, event.peer->address.host, event.peer->address.port);
286 break;
287 case ENET_EVENT_TYPE_RECEIVE:
288 if (!event.peer) continue;
289 b_read = 0;
290 msg = b_read_uint8(event.packet->data, &b_read);
291
292 switch (msg) {
293 case NET_MSG_ADD:
294 if (!event.peer) continue;
295
296 enet_address_get_host_ip(&(event.peer->address), ip, 17);
297 port = b_read_uint16(event.packet->data, &b_read);
298
299 name = b_read_dstring(event.packet->data, &b_read);
300 map = b_read_dstring(event.packet->data, &b_read);
301 gm = b_read_uint8(event.packet->data, &b_read);
302
303 pl = b_read_uint8(event.packet->data, &b_read);
304 mpl = b_read_uint8(event.packet->data, &b_read);
305
306 proto = b_read_uint8(event.packet->data, &b_read);
307 pw = b_read_uint8(event.packet->data, &b_read);
308
309 for (int i = 0; i < MS_MAXSRVS; ++i) {
310 if (ms_srv[i].used) {
311 if ((strncmp(ip, ms_srv[i].s_ip, 16) == 0) && (ms_srv[i].s_port == port)) {
312 strncpy(ms_srv[i].s_map, map, sizeof(ms_srv[i].s_map));
313 strncpy(ms_srv[i].s_name, name, sizeof(ms_srv[i].s_name));
314 ms_srv[i].s_plrs = pl;
315 ms_srv[i].s_maxplrs = mpl;
316 ms_srv[i].s_pw = pw;
317 ms_srv[i].s_mode = gm;
318
319 ms_srv[i].deathtime = time(NULL) + ms_timeout;
320
321 printf(LC_MS_UPD, i, ip, port, name, map, gm, pl, mpl, proto, pw);
322 break;
323 }
324 } else {
325 strncpy(ms_srv[i].s_ip, ip, sizeof(ms_srv[i].s_ip));
326 strncpy(ms_srv[i].s_map, map, sizeof(ms_srv[i].s_map));
327 strncpy(ms_srv[i].s_name, name, sizeof(ms_srv[i].s_name));
328 ms_srv[i].s_port = port;
329 ms_srv[i].s_plrs = pl;
330 ms_srv[i].s_maxplrs = mpl;
331 ms_srv[i].s_pw = pw;
332 ms_srv[i].s_mode = gm;
333 ms_srv[i].s_protocol = proto;
334 ms_srv[i].deathtime = time(NULL) + ms_timeout;
335
336 ms_srv[i].used = 1;
337
338 printf(LC_MS_ADD, i, ip, port, name, map, gm, pl, mpl, proto, pw);
339
340 ++ms_count;
341 break;
342 }
343 }
344 free(name);
345 free(map);
346 break;
347 case NET_MSG_RM:
348 enet_address_get_host_ip(&(event.peer->address), ip, 17);
349 port = b_read_uint16(event.packet->data, &b_read);
350 for (int i = 0; i < MS_MAXSRVS; ++i) {
351 if (ms_srv[i].used) {
352 if ((strncmp(ip, ms_srv[i].s_ip, 16) == 0) && (ms_srv[i].s_port == port)) {
353 ms_srv[i].used = 0;
354 printf(LC_MS_RM, i, ip, port);
355 --ms_count;
356 }
357 }
358 }
359 break;
360 case NET_MSG_LIST:
361 if (!event.peer) continue;
362
363 b_write = 0;
364 b_write_uint8(b_send, &b_write, NET_MSG_LIST);
365
366 if (event.packet->dataLength > 2) {
367 // holy shit a fresh client
368 clientver = b_read_dstring(event.packet->data, &b_read);
369 b_write_uint8(b_send, &b_write, ms_count);
370 } else {
371 // old client, feed them bullshit first
372 b_write_uint8(b_send, &b_write, ms_count + 2);
373 for (int i = 0; i < MS_FAKESRVS; ++i)
374 b_write_server(b_send, &b_write, ms_fake_srv[i]);
375 }
376
377 for (int i = 0; i < MS_MAXSRVS; ++i) {
378 if (ms_srv[i].used) b_write_server(b_send, &b_write, ms_srv[i]);
379 }
380
381 if (clientver) {
382 // TODO: check if this client is outdated (?) and send back new verstring
383 // for now just write the same shit back
384 b_write_dstring(b_send, &b_write, clientver);
385 // write the motd and urgent message
386 b_write_dstring(b_send, &b_write, ms_motd);
387 b_write_dstring(b_send, &b_write, ms_urgent);
388 }
389
390 ENetPacket *p = enet_packet_create(b_send, b_write, ENET_PACKET_FLAG_RELIABLE);
391 enet_peer_send(event.peer, NET_CH_MAIN, p);
392 enet_host_flush(ms_host);
393
394 printf(LC_MS_LIST, event.peer->address.host, event.peer->address.port, clientver ? clientver : "<old>");
395 free(clientver);
396 clientver = NULL;
397 break;
398 }
399
400 enet_packet_destroy(event.packet);
401 break;
402
403 default:
404 break;
405 }
406 }
407
408 time_t now = time(NULL);
409 for (int i = 0; i < MS_MAXSRVS; ++i) {
410 if (ms_srv[i].used) {
411 if (ms_srv[i].deathtime <= now) {
412 ms_srv[i].used = 0;
413 printf(LC_MS_TIME, i, ms_srv[i].s_ip, ms_srv[i].s_port);
414 --ms_count;
415 }
416 }
417 }
418 }
419
420 printf(LC_MS_DIE);
421
422 return EXIT_SUCCESS;
423 }
[MIRROR] a port of Doom 2D Forever to FPC/SDL
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024