DEADSOFTWARE

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


a743fa1cfad95dbe8791937cb819c12f72a23ff0
[d2df-sdl.git] / src / game / g_net.pas
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 {$INCLUDE ../shared/a_modes.inc}
16 unit g_net;
17
18 interface
19
20 uses
21 e_log, e_msg, utils, ENet, Classes, md5, MAPDEF{$IFDEF USE_MINIUPNPC}, miniupnpc;{$ELSE};{$ENDIF}
22
23 const
24 NET_PROTOCOL_VER = 188;
25
26 NET_MAXCLIENTS = 24;
27 NET_CHANS = 12;
28
29 NET_CHAN_SERVICE = 0;
30 NET_CHAN_IMPORTANT = 1;
31 NET_CHAN_GAME = 2;
32 NET_CHAN_PLAYER = 3;
33 NET_CHAN_PLAYERPOS = 4;
34 NET_CHAN_MONSTER = 5;
35 NET_CHAN_MONSTERPOS = 6;
36 NET_CHAN_LARGEDATA = 7;
37 NET_CHAN_CHAT = 8;
38 NET_CHAN_DOWNLOAD = 9;
39 NET_CHAN_SHOTS = 10;
40 NET_CHAN_DOWNLOAD_EX = 11;
41
42 NET_NONE = 0;
43 NET_SERVER = 1;
44 NET_CLIENT = 2;
45
46 NET_BUFSIZE = $FFFF;
47 NET_PING_PORT = $DF2D;
48
49 NET_EVERYONE = -1;
50
51 NET_UNRELIABLE = 0;
52 NET_RELIABLE = 1;
53
54 NET_DISC_NONE: enet_uint32 = 0;
55 NET_DISC_PROTOCOL: enet_uint32 = 1;
56 NET_DISC_VERSION: enet_uint32 = 2;
57 NET_DISC_FULL: enet_uint32 = 3;
58 NET_DISC_KICK: enet_uint32 = 4;
59 NET_DISC_DOWN: enet_uint32 = 5;
60 NET_DISC_PASSWORD: enet_uint32 = 6;
61 NET_DISC_TEMPBAN: enet_uint32 = 7;
62 NET_DISC_BAN: enet_uint32 = 8;
63 NET_DISC_MAX: enet_uint32 = 8;
64 NET_DISC_FILE_TIMEOUT: enet_uint32 = 13;
65
66 NET_STATE_NONE = 0;
67 NET_STATE_AUTH = 1;
68 NET_STATE_GAME = 2;
69
70 NET_CONNECT_TIMEOUT = 1000 * 10;
71
72 BANLIST_FILENAME = 'banlist.txt';
73 NETDUMP_FILENAME = 'netdump';
74
75 type
76 TNetMapResourceInfo = record
77 wadName: AnsiString; // wad file name, without a path
78 size: Integer; // wad file size (-1: size and hash are not known)
79 hash: TMD5Digest; // wad hash
80 end;
81
82 TNetMapResourceInfoArray = array of TNetMapResourceInfo;
83
84 TNetFileTransfer = record
85 diskName: string;
86 hash: TMD5Digest;
87 stream: TStream;
88 size: Integer; // file size in bytes
89 chunkSize: Integer;
90 lastSentChunk: Integer;
91 lastAckChunk: Integer;
92 lastAckTime: Int64; // msecs; if not "in progress", we're waiting for the first ack
93 inProgress: Boolean;
94 diskBuffer: PChar; // of `chunkSize` bytes
95 resumed: Boolean;
96 end;
97
98 TNetClient = record
99 ID: Byte;
100 Used: Boolean;
101 State: Byte;
102 Peer: pENetPeer;
103 Player: Word;
104 RequestedFullUpdate: Boolean;
105 WaitForFirstSpawn: Boolean; // set to `true` in server, used to spawn a player on first full state request
106 RCONAuth: Boolean;
107 Voted: Boolean;
108 Crimes: Integer;
109 AuthTime: LongWord;
110 MsgTime: LongWord;
111 Transfer: TNetFileTransfer; // only one transfer may be active
112 NetOut: array [0..1] of TMsg;
113 end;
114 TBanRecord = record
115 IP: LongWord;
116 Perm: Boolean;
117 end;
118 pTNetClient = ^TNetClient;
119
120 AByte = array of Byte;
121
122 var
123 NetInitDone: Boolean = False;
124 NetMode: Byte = NET_NONE;
125 NetDump: Boolean = False;
126
127 NetServerName: string = 'Unnamed Server';
128 NetPassword: string = '';
129 NetPort: Word = 25666;
130
131 NetAllowRCON: Boolean = False;
132 NetRCONPassword: string = '';
133
134 NetTimeToUpdate: Cardinal = 0;
135 NetTimeToReliable: Cardinal = 0;
136 NetTimeToMaster: Cardinal = 0;
137
138 NetHost: pENetHost = nil;
139 NetPeer: pENetPeer = nil;
140 NetEvent: ENetEvent;
141 NetAddr: ENetAddress;
142
143 NetPongAddr: ENetAddress;
144 NetPongSock: ENetSocket = ENET_SOCKET_NULL;
145
146 NetUseMaster: Boolean = True;
147 NetMasterList: string = 'mpms.doom2d.org:25665, deadsoftware.ru:25665';
148
149 NetClientIP: string = '127.0.0.1';
150 NetClientPort: Word = 25666;
151
152 NetIn, NetOut: TMsg;
153 NetBuf: array [0..1] of TMsg;
154
155 NetClients: array of TNetClient;
156 NetClientCount: Byte = 0;
157 NetMaxClients: Byte = 255;
158 NetBannedHosts: array of TBanRecord;
159
160 NetAutoBanLimit: Integer = 5;
161 NetAutoBanPerm: Boolean = True;
162 NetAutoBanWarn: Boolean = False;
163 NetAutoBanForTimeout: Boolean = False;
164
165 NetAuthTimeout: Integer = 30 * 1000;
166 NetPacketTimeout: Integer = 60 * 1000;
167
168 NetState: Integer = NET_STATE_NONE;
169
170 NetMyID: Integer = -1;
171 NetPlrUID1: Integer = -1;
172 NetPlrUID2: Integer = -1;
173
174 NetInterpLevel: Integer = 1;
175 NetUpdateRate: Cardinal = 0; // as soon as possible
176 NetRelupdRate: Cardinal = 18; // around two times a second
177 NetMasterRate: Cardinal = 60000;
178
179 NetForcePlayerUpdate: Boolean = False;
180 NetPredictSelf: Boolean = True;
181 NetForwardPorts: Boolean = False;
182
183 NetGotEverything: Boolean = False;
184 NetGotKeys: Boolean = False;
185
186 NetDeafLevel: Integer = 0;
187
188 {$IFDEF USE_MINIUPNPC}
189 NetPortForwarded: Word = 0;
190 NetPongForwarded: Boolean = False;
191 NetIGDControl: AnsiString;
192 NetIGDService: TURLStr;
193 {$ENDIF}
194
195 NetPortThread: TThreadID = NilThreadId;
196
197 NetDumpFile: TStream;
198
199 g_Res_received_map_start: Integer = 0; // set if we received "map change" event
200
201
202 function g_Net_Init(): Boolean;
203 procedure g_Net_Cleanup();
204 procedure g_Net_Free();
205 procedure g_Net_Flush();
206
207 function g_Net_Host(IPAddr: LongWord; Port: enet_uint16; MaxClients: Cardinal = 16): Boolean;
208 procedure g_Net_Host_Die();
209 procedure g_Net_Host_Send(ID: Integer; Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
210 procedure g_Net_Host_Update();
211
212 function g_Net_Connect(IP: string; Port: enet_uint16): Boolean;
213 procedure g_Net_Disconnect(Forced: Boolean = False);
214 procedure g_Net_Client_Send(Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
215 procedure g_Net_Client_Update();
216 procedure g_Net_Client_UpdateWhileLoading();
217
218 function g_Net_Client_ByName(Name: string): pTNetClient;
219 function g_Net_Client_ByPlayer(PID: Word): pTNetClient;
220 function g_Net_ClientName_ByID(ID: Integer): string;
221
222 procedure g_Net_SendData(Data: AByte; peer: pENetPeer; Reliable: Boolean; Chan: Byte = NET_CHAN_DOWNLOAD);
223 //function g_Net_Wait_Event(msgId: Word): TMemoryStream;
224 //function g_Net_Wait_FileInfo (var tf: TNetFileTransfer; asMap: Boolean; out resList: TStringList): Integer;
225
226 function IpToStr(IP: LongWord): string;
227 function StrToIp(IPstr: string; var IP: LongWord): Boolean;
228
229 function g_Net_IsHostBanned(IP: LongWord; Perm: Boolean = False): Boolean;
230 procedure g_Net_BanHost(IP: LongWord; Perm: Boolean = True); overload;
231 procedure g_Net_BanHost(IP: string; Perm: Boolean = True); overload;
232 function g_Net_UnbanHost(IP: string): Boolean; overload;
233 function g_Net_UnbanHost(IP: LongWord): Boolean; overload;
234 procedure g_Net_UnbanNonPermHosts();
235 procedure g_Net_SaveBanList();
236
237 procedure g_Net_Penalize(C: pTNetClient; Reason: string);
238
239 procedure g_Net_DumpStart();
240 procedure g_Net_DumpSendBuffer();
241 procedure g_Net_DumpRecvBuffer(Buf: penet_uint8; Len: LongWord);
242 procedure g_Net_DumpEnd();
243
244 function g_Net_ForwardPorts(ForwardPongPort: Boolean = True): Boolean;
245 procedure g_Net_UnforwardPorts();
246
247 function g_Net_UserRequestExit: Boolean;
248
249 function g_Net_Wait_MapInfo (var tf: TNetFileTransfer; var resList: TNetMapResourceInfoArray): Integer;
250 function g_Net_RequestResFileInfo (resIndex: LongInt; out tf: TNetFileTransfer): Integer;
251 function g_Net_AbortResTransfer (var tf: TNetFileTransfer): Boolean;
252 function g_Net_ReceiveResourceFile (resIndex: LongInt; var tf: TNetFileTransfer; strm: TStream): Integer;
253
254 function g_Net_IsNetworkAvailable (): Boolean;
255 procedure g_Net_InitLowLevel ();
256 procedure g_Net_DeinitLowLevel ();
257
258 procedure NetServerCVars(P: SSArray);
259
260
261 implementation
262
263 // *enet_host_service()*
264 // fuck! https://www.mail-archive.com/enet-discuss@cubik.org/msg00852.html
265 // tl;dr: on shitdows, we can get -1 sometimes, and it is *NOT* a failure.
266 // thank you, enet. let's ignore failures altogether then.
267
268 uses
269 SysUtils,
270 e_input, e_res,
271 g_nethandler, g_netmsg, g_netmaster, g_player, g_window, g_console,
272 g_main, g_game, g_language, g_weapons, ctypes, g_system, g_map;
273
274 const
275 FILE_CHUNK_SIZE = 8192;
276
277 var
278 enet_init_success: Boolean = false;
279 g_Net_DownloadTimeout: Single;
280 trans_omsg: TMsg;
281
282
283 function g_Net_IsNetworkAvailable (): Boolean;
284 begin
285 result := enet_init_success;
286 end;
287
288 procedure g_Net_InitLowLevel ();
289 var v: ENetVersion;
290 begin
291 v := enet_linked_version();
292 e_LogWritefln('ENet Version: %s.%s.%s', [ENET_VERSION_GET_MAJOR(v), ENET_VERSION_GET_MINOR(v), ENET_VERSION_GET_PATCH(v)]);
293 if enet_init_success then raise Exception.Create('wuta?!');
294 enet_init_success := (enet_initialize() = 0);
295 end;
296
297 procedure g_Net_DeinitLowLevel ();
298 begin
299 if enet_init_success then
300 begin
301 enet_deinitialize();
302 enet_init_success := false;
303 end;
304 end;
305
306
307 //**************************************************************************
308 //
309 // SERVICE FUNCTIONS
310 //
311 //**************************************************************************
312
313 procedure clearNetClientTransfers (var nc: TNetClient);
314 begin
315 nc.Transfer.stream.Free;
316 nc.Transfer.diskName := ''; // just in case
317 if (nc.Transfer.diskBuffer <> nil) then FreeMem(nc.Transfer.diskBuffer);
318 nc.Transfer.stream := nil;
319 nc.Transfer.diskBuffer := nil;
320 end;
321
322
323 procedure clearNetClient (var nc: TNetClient);
324 begin
325 clearNetClientTransfers(nc);
326 end;
327
328
329 procedure clearNetClients (clearArray: Boolean);
330 var
331 f: Integer;
332 begin
333 for f := Low(NetClients) to High(NetClients) do clearNetClient(NetClients[f]);
334 if (clearArray) then SetLength(NetClients, 0);
335 end;
336
337
338 function g_Net_UserRequestExit (): Boolean;
339 begin
340 Result := {e_KeyPressed(IK_SPACE) or}
341 e_KeyPressed(IK_ESCAPE) or
342 e_KeyPressed(VK_ESCAPE) or
343 e_KeyPressed(JOY0_JUMP) or
344 e_KeyPressed(JOY1_JUMP) or
345 e_KeyPressed(JOY2_JUMP) or
346 e_KeyPressed(JOY3_JUMP)
347 end;
348
349 //**************************************************************************
350 //
351 // file transfer declaraions and host packet processor
352 //
353 //**************************************************************************
354
355 const
356 // server packet type
357 NTF_SERVER_DONE = 10; // done with this file
358 NTF_SERVER_FILE_INFO = 11; // sent after client request
359 NTF_SERVER_CHUNK = 12; // next chunk; chunk number follows
360 NTF_SERVER_ABORT = 13; // server abort
361 NTF_SERVER_MAP_INFO = 14;
362
363 // client packet type
364 NTF_CLIENT_MAP_REQUEST = 100; // map file request; also, returns list of additional wads to download
365 NTF_CLIENT_FILE_REQUEST = 101; // resource file request (by index)
366 NTF_CLIENT_ABORT = 102; // do not send requested file, or abort current transfer
367 NTF_CLIENT_START = 103; // start transfer; client may resume download by sending non-zero starting chunk
368 NTF_CLIENT_ACK = 104; // chunk ack; chunk number follows
369
370
371 // disconnect client due to some file transfer error
372 procedure killClientByFT (var nc: TNetClient);
373 begin
374 e_LogWritefln('disconnected client #%d due to file transfer error', [nc.ID], TMsgType.Warning);
375 enet_peer_disconnect(nc.Peer, NET_DISC_FILE_TIMEOUT);
376 clearNetClientTransfers(nc);
377 g_Net_Slist_ServerPlayerLeaves();
378 end;
379
380
381 // send file transfer message from server to client
382 function ftransSendServerMsg (var nc: TNetClient; var m: TMsg): Boolean;
383 var
384 pkt: PENetPacket;
385 begin
386 result := false;
387 if (m.CurSize < 1) then exit;
388 pkt := enet_packet_create(m.Data, m.CurSize, ENET_PACKET_FLAG_RELIABLE);
389 if not Assigned(pkt) then begin killClientByFT(nc); exit; end;
390 if (enet_peer_send(nc.Peer, NET_CHAN_DOWNLOAD_EX, pkt) <> 0) then begin killClientByFT(nc); exit; end;
391 result := true;
392 end;
393
394
395 // send file transfer message from client to server
396 function ftransSendClientMsg (var m: TMsg): Boolean;
397 var
398 pkt: PENetPacket;
399 begin
400 result := false;
401 if (m.CurSize < 1) then exit;
402 pkt := enet_packet_create(m.Data, m.CurSize, ENET_PACKET_FLAG_RELIABLE);
403 if not Assigned(pkt) then exit;
404 if (enet_peer_send(NetPeer, NET_CHAN_DOWNLOAD_EX, pkt) <> 0) then exit;
405 result := true;
406 end;
407
408
409 // file chunk sender
410 procedure ProcessChunkSend (var nc: TNetClient);
411 var
412 tf: ^TNetFileTransfer;
413 ct: Int64;
414 chunks: Integer;
415 rd: Integer;
416 begin
417 tf := @nc.Transfer;
418 if (tf.stream = nil) then exit;
419 ct := GetTimerMS();
420 // arbitrary timeout number
421 if (ct-tf.lastAckTime >= 5000) then
422 begin
423 killClientByFT(nc);
424 exit;
425 end;
426 // check if we need to send something
427 if (not tf.inProgress) then exit; // waiting for the initial ack
428 // ok, we're sending chunks
429 if (tf.lastAckChunk <> tf.lastSentChunk) then exit;
430 Inc(tf.lastSentChunk);
431 // do it one chunk at a time; client ack will advance our chunk counter
432 chunks := (tf.size+tf.chunkSize-1) div tf.chunkSize;
433
434 if (tf.lastSentChunk > chunks) then
435 begin
436 killClientByFT(nc);
437 exit;
438 end;
439
440 trans_omsg.Clear();
441 if (tf.lastSentChunk = chunks) then
442 begin
443 // we're done with this file
444 e_LogWritefln('download: client #%d, DONE sending chunks #%d/#%d', [nc.ID, tf.lastSentChunk, chunks]);
445 trans_omsg.Write(Byte(NTF_SERVER_DONE));
446 clearNetClientTransfers(nc);
447 end
448 else
449 begin
450 // packet type
451 trans_omsg.Write(Byte(NTF_SERVER_CHUNK));
452 trans_omsg.Write(LongInt(tf.lastSentChunk));
453 // read chunk
454 rd := tf.size-(tf.lastSentChunk*tf.chunkSize);
455 if (rd > tf.chunkSize) then rd := tf.chunkSize;
456 trans_omsg.Write(LongInt(rd));
457 //e_LogWritefln('download: client #%d, sending chunk #%d/#%d (%d bytes)', [nc.ID, tf.lastSentChunk, chunks, rd]);
458 //FIXME: check for errors here
459 try
460 tf.stream.Seek(tf.lastSentChunk*tf.chunkSize, soFromBeginning);
461 tf.stream.ReadBuffer(tf.diskBuffer^, rd);
462 trans_omsg.WriteData(tf.diskBuffer, rd);
463 except // sorry
464 killClientByFT(nc);
465 exit;
466 end;
467 end;
468 // send packet
469 ftransSendServerMsg(nc, trans_omsg);
470 end;
471
472
473 // server file transfer packet processor
474 // received packet is in `NetEvent`
475 procedure ProcessDownloadExPacket ();
476 var
477 f: Integer;
478 nc: ^TNetClient;
479 nid: Integer = -1;
480 msg: TMsg;
481 cmd: Byte;
482 tf: ^TNetFileTransfer;
483 fname: string;
484 chunk: Integer;
485 ridx: Integer;
486 dfn: AnsiString;
487 md5: TMD5Digest;
488 //st: TStream;
489 size: LongInt;
490 fi: TDiskFileInfo;
491 begin
492 // find client index by peer
493 for f := Low(NetClients) to High(NetClients) do
494 begin
495 if (not NetClients[f].Used) then continue;
496 if (NetClients[f].Peer = NetEvent.peer) then
497 begin
498 nid := f;
499 break;
500 end;
501 end;
502 //e_LogWritefln('RECEIVE: dlpacket; client=%d (datalen=%u)', [nid, NetEvent.packet^.dataLength]);
503
504 if (nid < 0) then exit; // wtf?!
505 nc := @NetClients[nid];
506
507 if (NetEvent.packet^.dataLength = 0) then
508 begin
509 killClientByFT(nc^);
510 exit;
511 end;
512
513 // don't time out clients during a file transfer
514 if (NetAuthTimeout > 0) then
515 nc^.AuthTime := gTime + NetAuthTimeout;
516 if (NetPacketTimeout > 0) then
517 nc^.MsgTime := gTime + NetPacketTimeout;
518
519 tf := @NetClients[nid].Transfer;
520 tf.lastAckTime := GetTimerMS();
521
522 cmd := Byte(NetEvent.packet^.data^);
523 //e_LogWritefln('RECEIVE: nid=%d; cmd=%u', [nid, cmd]);
524 case cmd of
525 NTF_CLIENT_FILE_REQUEST: // file request
526 begin
527 if (tf.stream <> nil) then
528 begin
529 killClientByFT(nc^);
530 exit;
531 end;
532 if (NetEvent.packet^.dataLength < 2) then
533 begin
534 killClientByFT(nc^);
535 exit;
536 end;
537 // new transfer request; build packet
538 if not msg.Init(NetEvent.packet^.data+1, NetEvent.packet^.dataLength-1, True) then
539 begin
540 killClientByFT(nc^);
541 exit;
542 end;
543 // get resource index
544 ridx := msg.ReadLongInt();
545 if (ridx < -1) or (ridx >= length(gExternalResources)) then
546 begin
547 e_LogWritefln('Invalid resource index %d', [ridx], TMsgType.Warning);
548 killClientByFT(nc^);
549 exit;
550 end;
551 if (ridx < 0) then fname := gGameSettings.WAD else fname := gExternalResources[ridx].diskName;
552 if (length(fname) = 0) then
553 begin
554 e_WriteLog('Invalid filename: '+fname, TMsgType.Warning);
555 killClientByFT(nc^);
556 exit;
557 end;
558 tf.diskName := findDiskWad(fname);
559 if (length(tf.diskName) = 0) then
560 begin
561 e_LogWritefln('NETWORK: file "%s" not found!', [fname], TMsgType.Fatal);
562 killClientByFT(nc^);
563 exit;
564 end;
565 // calculate hash
566 //tf.hash := MD5File(tf.diskName);
567 if (ridx < 0) then tf.hash := gWADHash else tf.hash := gExternalResources[ridx].hash;
568 // create file stream
569 tf.diskName := findDiskWad(fname);
570 try
571 tf.stream := openDiskFileRO(tf.diskName);
572 except
573 tf.stream := nil;
574 end;
575 if (tf.stream = nil) then
576 begin
577 e_WriteLog(Format('NETWORK: file "%s" not found!', [fname]), TMsgType.Fatal);
578 killClientByFT(nc^);
579 exit;
580 end;
581 e_LogWritefln('client #%d requested resource #%d (file is `%s` : `%s`)', [nc.ID, ridx, fname, tf.diskName]);
582 tf.size := tf.stream.size;
583 tf.chunkSize := FILE_CHUNK_SIZE; // arbitrary
584 tf.lastSentChunk := -1;
585 tf.lastAckChunk := -1;
586 tf.lastAckTime := GetTimerMS();
587 tf.inProgress := False; // waiting for the first ACK or for the cancel
588 GetMem(tf.diskBuffer, tf.chunkSize);
589 // sent file info message
590 trans_omsg.Clear();
591 trans_omsg.Write(Byte(NTF_SERVER_FILE_INFO));
592 trans_omsg.Write(tf.hash);
593 trans_omsg.Write(tf.size);
594 trans_omsg.Write(tf.chunkSize);
595 trans_omsg.Write(ExtractFileName(fname));
596 if not ftransSendServerMsg(nc^, trans_omsg) then exit;
597 end;
598 NTF_CLIENT_ABORT: // do not send requested file, or abort current transfer
599 begin
600 e_LogWritefln('client #%d aborted file transfer', [nc.ID]);
601 clearNetClientTransfers(nc^);
602 end;
603 NTF_CLIENT_START: // start transfer; client may resume download by sending non-zero starting chunk
604 begin
605 if not Assigned(tf.stream) then
606 begin
607 killClientByFT(nc^);
608 exit;
609 end;
610 if (tf.lastSentChunk <> -1) or (tf.lastAckChunk <> -1) or (tf.inProgress) then
611 begin
612 // double ack, get lost
613 killClientByFT(nc^);
614 exit;
615 end;
616 if (NetEvent.packet^.dataLength < 2) then
617 begin
618 killClientByFT(nc^);
619 exit;
620 end;
621 // build packet
622 if not msg.Init(NetEvent.packet^.data+1, NetEvent.packet^.dataLength-1, True) then
623 begin
624 killClientByFT(nc^);
625 exit;
626 end;
627 chunk := msg.ReadLongInt();
628 if (chunk < 0) or (chunk > (tf.size+tf.chunkSize-1) div tf.chunkSize) then
629 begin
630 killClientByFT(nc^);
631 exit;
632 end;
633 e_LogWritefln('client #%d started file transfer from chunk %d', [nc.ID, chunk]);
634 // start sending chunks
635 tf.inProgress := True;
636 tf.lastSentChunk := chunk-1;
637 tf.lastAckChunk := chunk-1;
638 ProcessChunkSend(nc^);
639 end;
640 NTF_CLIENT_ACK: // chunk ack; chunk number follows
641 begin
642 if not Assigned(tf.stream) then
643 begin
644 killClientByFT(nc^);
645 exit;
646 end;
647 if (tf.lastSentChunk < 0) or (not tf.inProgress) then
648 begin
649 // double ack, get lost
650 killClientByFT(nc^);
651 exit;
652 end;
653 if (NetEvent.packet^.dataLength < 2) then
654 begin
655 killClientByFT(nc^);
656 exit;
657 end;
658 // build packet
659 if not msg.Init(NetEvent.packet^.data+1, NetEvent.packet^.dataLength-1, True) then
660 begin
661 killClientByFT(nc^);
662 exit;
663 end;
664 chunk := msg.ReadLongInt();
665 if (chunk < 0) or (chunk > (tf.size+tf.chunkSize-1) div tf.chunkSize) then
666 begin
667 killClientByFT(nc^);
668 exit;
669 end;
670 // do it this way, so client may seek, or request retransfers for some reason
671 tf.lastAckChunk := chunk;
672 tf.lastSentChunk := chunk;
673 //e_LogWritefln('client #%d acked file transfer chunk %d', [nc.ID, chunk]);
674 ProcessChunkSend(nc^);
675 end;
676 NTF_CLIENT_MAP_REQUEST:
677 begin
678 e_LogWritefln('client #%d requested map info', [nc.ID]);
679 trans_omsg.Clear();
680 dfn := findDiskWad(gGameSettings.WAD);
681 if (dfn = '') then dfn := '!wad_not_found!.wad'; //FIXME
682 //md5 := MD5File(dfn);
683 md5 := gWADHash;
684 if (not GetDiskFileInfo(dfn, fi)) then
685 begin
686 e_LogWritefln('client #%d requested map info, but i cannot get file info', [nc.ID]);
687 killClientByFT(nc^);
688 exit;
689 end;
690 size := fi.size;
691 {
692 st := openDiskFileRO(dfn);
693 if not assigned(st) then exit; //wtf?!
694 size := st.size;
695 st.Free;
696 }
697 // packet type
698 trans_omsg.Write(Byte(NTF_SERVER_MAP_INFO));
699 // map wad name
700 trans_omsg.Write(ExtractFileName(gGameSettings.WAD));
701 // map wad md5
702 trans_omsg.Write(md5);
703 // map wad size
704 trans_omsg.Write(size);
705 // number of external resources for map
706 trans_omsg.Write(LongInt(length(gExternalResources)));
707 // external resource names
708 for f := 0 to High(gExternalResources) do
709 begin
710 // old style packet
711 //trans_omsg.Write(ExtractFileName(gExternalResources[f])); // GameDir+'/wads/'+ResList.Strings[i]
712 // new style packet
713 trans_omsg.Write('!');
714 trans_omsg.Write(LongInt(gExternalResources[f].size));
715 trans_omsg.Write(gExternalResources[f].hash);
716 trans_omsg.Write(ExtractFileName(gExternalResources[f].diskName));
717 end;
718 // send packet
719 if not ftransSendServerMsg(nc^, trans_omsg) then exit;
720 end;
721 else
722 begin
723 killClientByFT(nc^);
724 exit;
725 end;
726 end;
727 end;
728
729
730 //**************************************************************************
731 //
732 // file transfer crap (both client and server)
733 //
734 //**************************************************************************
735
736 function getNewTimeoutEnd (): Int64;
737 begin
738 result := GetTimerMS();
739 if (g_Net_DownloadTimeout <= 0) then
740 begin
741 result := result+1000*60*3; // 3 minutes
742 end
743 else
744 begin
745 result := result+trunc(g_Net_DownloadTimeout*1000);
746 end;
747 end;
748
749
750 // send map request to server, and wait for "map info" server reply
751 //
752 // returns `false` on error or user abort
753 // fills:
754 // diskName: map wad file name (without a path)
755 // hash: map wad hash
756 // size: map wad size
757 // chunkSize: set too
758 // resList: list of resource wads
759 // returns:
760 // <0 on error
761 // 0 on success
762 // 1 on user abort
763 // 2 on server abort
764 // for maps, first `tf.diskName` name will be map wad name, and `tf.hash`/`tf.size` will contain map info
765 function g_Net_Wait_MapInfo (var tf: TNetFileTransfer; var resList: TNetMapResourceInfoArray): Integer;
766 var
767 ev: ENetEvent;
768 rMsgId: Byte;
769 Ptr: Pointer;
770 msg: TMsg;
771 freePacket: Boolean = false;
772 ct, ett: Int64;
773 status: cint;
774 s: AnsiString;
775 rc, f: LongInt;
776 ri: ^TNetMapResourceInfo;
777 begin
778 SetLength(resList, 0);
779
780 // send request
781 trans_omsg.Clear();
782 trans_omsg.Write(Byte(NTF_CLIENT_MAP_REQUEST));
783 if not ftransSendClientMsg(trans_omsg) then begin result := -1; exit; end;
784
785 FillChar(ev, SizeOf(ev), 0);
786 Result := -1;
787 try
788 ett := getNewTimeoutEnd();
789 repeat
790 status := enet_host_service(NetHost, @ev, 300);
791 {
792 if (status < 0) then
793 begin
794 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' network error', True);
795 Result := -1;
796 exit;
797 end;
798 }
799 if (status <= 0) then
800 begin
801 // check for timeout
802 ct := GetTimerMS();
803 if (ct >= ett) then
804 begin
805 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' timeout reached', True);
806 Result := -1;
807 exit;
808 end;
809 end
810 else
811 begin
812 // some event
813 case ev.kind of
814 ENET_EVENT_TYPE_RECEIVE:
815 begin
816 freePacket := true;
817 if (ev.channelID <> NET_CHAN_DOWNLOAD_EX) then
818 begin
819 //e_LogWritefln('g_Net_Wait_MapInfo: skip message from non-transfer channel', []);
820 freePacket := false;
821 g_Net_Client_HandlePacket(ev.packet, g_Net_ClientLightMsgHandler);
822 if (g_Res_received_map_start < 0) then begin result := -666; exit; end;
823 end
824 else
825 begin
826 ett := getNewTimeoutEnd();
827 if (ev.packet.dataLength < 1) then
828 begin
829 e_LogWritefln('g_Net_Wait_MapInfo: invalid server packet (no data)', []);
830 Result := -1;
831 exit;
832 end;
833 Ptr := ev.packet^.data;
834 rMsgId := Byte(Ptr^);
835 e_LogWritefln('g_Net_Wait_MapInfo: got message %u from server (dataLength=%u)', [rMsgId, ev.packet^.dataLength]);
836 if (rMsgId = NTF_SERVER_FILE_INFO) then
837 begin
838 e_LogWritefln('g_Net_Wait_MapInfo: waiting for map info reply, but got file info reply', []);
839 Result := -1;
840 exit;
841 end
842 else if (rMsgId = NTF_SERVER_ABORT) then
843 begin
844 e_LogWritefln('g_Net_Wait_MapInfo: server aborted transfer', []);
845 Result := 2;
846 exit;
847 end
848 else if (rMsgId = NTF_SERVER_MAP_INFO) then
849 begin
850 e_LogWritefln('g_Net_Wait_MapInfo: creating map info packet...', []);
851 if not msg.Init(ev.packet^.data+1, ev.packet^.dataLength-1, True) then exit;
852 e_LogWritefln('g_Net_Wait_MapInfo: parsing map info packet (rd=%d; max=%d)...', [msg.ReadCount, msg.MaxSize]);
853 SetLength(resList, 0); // just in case
854 // map wad name
855 tf.diskName := msg.ReadString();
856 e_LogWritefln('g_Net_Wait_MapInfo: map wad is `%s`', [tf.diskName]);
857 // map wad md5
858 tf.hash := msg.ReadMD5();
859 // map wad size
860 tf.size := msg.ReadLongInt();
861 e_LogWritefln('g_Net_Wait_MapInfo: map wad size is %d', [tf.size]);
862 // number of external resources for map
863 rc := msg.ReadLongInt();
864 if (rc < 0) or (rc > 1024) then
865 begin
866 e_LogWritefln('g_Net_Wait_Event: invalid number of map external resources (%d)', [rc]);
867 Result := -1;
868 exit;
869 end;
870 e_LogWritefln('g_Net_Wait_MapInfo: map external resource count is %d', [rc]);
871 SetLength(resList, rc);
872 // external resource names
873 for f := 0 to rc-1 do
874 begin
875 ri := @resList[f];
876 s := msg.ReadString();
877 if (length(s) = 0) then begin result := -1; exit; end;
878 if (s = '!') then
879 begin
880 // extended packet
881 ri.size := msg.ReadLongInt();
882 ri.hash := msg.ReadMD5();
883 ri.wadName := ExtractFileName(msg.ReadString());
884 if (length(ri.wadName) = 0) or (ri.size < 0) then begin result := -1; exit; end;
885 end
886 else
887 begin
888 // old-style packet, only name
889 ri.wadName := ExtractFileName(s);
890 if (length(ri.wadName) = 0) then begin result := -1; exit; end;
891 ri.size := -1; // unknown
892 end;
893 end;
894 e_LogWritefln('g_Net_Wait_MapInfo: got map info', []);
895 Result := 0; // success
896 exit;
897 end
898 else
899 begin
900 e_LogWritefln('g_Net_Wait_Event: invalid server packet type', []);
901 Result := -1;
902 exit;
903 end;
904 end;
905 end;
906 ENET_EVENT_TYPE_DISCONNECT:
907 begin
908 if (ev.data <= NET_DISC_MAX) then
909 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' ' + _lc[TStrings_Locale(Cardinal(I_NET_DISC_NONE) + ev.data)], True);
910 Result := -1;
911 exit;
912 end;
913 else
914 begin
915 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' unknown ENet event ' + IntToStr(Ord(ev.kind)), True);
916 result := -1;
917 exit;
918 end;
919 end;
920 if (freePacket) then begin freePacket := false; enet_packet_destroy(ev.packet); end;
921 end;
922 ProcessLoading();
923 if g_Net_UserRequestExit() then
924 begin
925 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' user abort', True);
926 Result := 1;
927 exit;
928 end;
929 until false;
930 finally
931 if (freePacket) then enet_packet_destroy(ev.packet);
932 end;
933 end;
934
935
936 // send file request to server, and wait for server reply
937 //
938 // returns `false` on error or user abort
939 // fills:
940 // diskName (actually, base name)
941 // hash
942 // size
943 // chunkSize
944 // returns:
945 // <0 on error
946 // 0 on success
947 // 1 on user abort
948 // 2 on server abort
949 // for maps, first `tf.diskName` name will be map wad name, and `tf.hash`/`tf.size` will contain map info
950 function g_Net_RequestResFileInfo (resIndex: LongInt; out tf: TNetFileTransfer): Integer;
951 var
952 ev: ENetEvent;
953 rMsgId: Byte;
954 Ptr: Pointer;
955 msg: TMsg;
956 freePacket: Boolean = false;
957 ct, ett: Int64;
958 status: cint;
959 begin
960 // send request
961 trans_omsg.Clear();
962 trans_omsg.Write(Byte(NTF_CLIENT_FILE_REQUEST));
963 trans_omsg.Write(resIndex);
964 if not ftransSendClientMsg(trans_omsg) then begin result := -1; exit; end;
965
966 FillChar(ev, SizeOf(ev), 0);
967 Result := -1;
968 try
969 ett := getNewTimeoutEnd();
970 repeat
971 status := enet_host_service(NetHost, @ev, 300);
972 {
973 if (status < 0) then
974 begin
975 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' network error', True);
976 Result := -1;
977 exit;
978 end;
979 }
980 if (status <= 0) then
981 begin
982 // check for timeout
983 ct := GetTimerMS();
984 if (ct >= ett) then
985 begin
986 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' timeout reached', True);
987 Result := -1;
988 exit;
989 end;
990 end
991 else
992 begin
993 // some event
994 case ev.kind of
995 ENET_EVENT_TYPE_RECEIVE:
996 begin
997 freePacket := true;
998 if (ev.channelID <> NET_CHAN_DOWNLOAD_EX) then
999 begin
1000 //e_LogWriteln('g_Net_Wait_Event: skip message from non-transfer channel');
1001 freePacket := false;
1002 g_Net_Client_HandlePacket(ev.packet, g_Net_ClientLightMsgHandler);
1003 if (g_Res_received_map_start < 0) then begin result := -666; exit; end;
1004 end
1005 else
1006 begin
1007 ett := getNewTimeoutEnd();
1008 if (ev.packet.dataLength < 1) then
1009 begin
1010 e_LogWriteln('g_Net_Wait_Event: invalid server packet (no data)');
1011 Result := -1;
1012 exit;
1013 end;
1014 Ptr := ev.packet^.data;
1015 rMsgId := Byte(Ptr^);
1016 e_LogWritefln('received transfer packet with id %d (%u bytes)', [rMsgId, ev.packet^.dataLength]);
1017 if (rMsgId = NTF_SERVER_FILE_INFO) then
1018 begin
1019 if not msg.Init(ev.packet^.data+1, ev.packet^.dataLength-1, True) then exit;
1020 tf.hash := msg.ReadMD5();
1021 tf.size := msg.ReadLongInt();
1022 tf.chunkSize := msg.ReadLongInt();
1023 tf.diskName := ExtractFileName(msg.readString());
1024 if (tf.size < 0) or (tf.chunkSize <> FILE_CHUNK_SIZE) or (length(tf.diskName) = 0) then
1025 begin
1026 e_LogWritefln('g_Net_RequestResFileInfo: invalid file info packet', []);
1027 Result := -1;
1028 exit;
1029 end;
1030 e_LogWritefln('got file info for resource #%d: size=%d; name=%s', [resIndex, tf.size, tf.diskName]);
1031 Result := 0; // success
1032 exit;
1033 end
1034 else if (rMsgId = NTF_SERVER_ABORT) then
1035 begin
1036 e_LogWriteln('g_Net_RequestResFileInfo: server aborted transfer');
1037 Result := 2;
1038 exit;
1039 end
1040 else if (rMsgId = NTF_SERVER_MAP_INFO) then
1041 begin
1042 e_LogWriteln('g_Net_RequestResFileInfo: waiting for map info reply, but got file info reply');
1043 Result := -1;
1044 exit;
1045 end
1046 else
1047 begin
1048 e_LogWriteln('g_Net_RequestResFileInfo: invalid server packet type');
1049 Result := -1;
1050 exit;
1051 end;
1052 end;
1053 end;
1054 ENET_EVENT_TYPE_DISCONNECT:
1055 begin
1056 if (ev.data <= NET_DISC_MAX) then
1057 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' ' + _lc[TStrings_Locale(Cardinal(I_NET_DISC_NONE) + ev.data)], True);
1058 Result := -1;
1059 exit;
1060 end;
1061 else
1062 begin
1063 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' unknown ENet event ' + IntToStr(Ord(ev.kind)), True);
1064 result := -1;
1065 exit;
1066 end;
1067 end;
1068 if (freePacket) then begin freePacket := false; enet_packet_destroy(ev.packet); end;
1069 end;
1070 ProcessLoading();
1071 if g_Net_UserRequestExit() then
1072 begin
1073 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' user abort', True);
1074 Result := 1;
1075 exit;
1076 end;
1077 until false;
1078 finally
1079 if (freePacket) then enet_packet_destroy(ev.packet);
1080 end;
1081 end;
1082
1083
1084 // call this to cancel file transfer requested by `g_Net_RequestResFileInfo()`
1085 function g_Net_AbortResTransfer (var tf: TNetFileTransfer): Boolean;
1086 begin
1087 result := false;
1088 e_LogWritefln('aborting file transfer...', []);
1089 // send request
1090 trans_omsg.Clear();
1091 trans_omsg.Write(Byte(NTF_CLIENT_ABORT));
1092 result := ftransSendClientMsg(trans_omsg);
1093 if result then enet_host_flush(NetHost);
1094 end;
1095
1096
1097 // call this to start file transfer requested by `g_Net_RequestResFileInfo()`
1098 //
1099 // returns `false` on error or user abort
1100 // fills:
1101 // hash
1102 // size
1103 // chunkSize
1104 // returns:
1105 // <0 on error
1106 // 0 on success
1107 // 1 on user abort
1108 // 2 on server abort
1109 // for maps, first `tf.diskName` name will be map wad name, and `tf.hash`/`tf.size` will contain map info
1110 function g_Net_ReceiveResourceFile (resIndex: LongInt; var tf: TNetFileTransfer; strm: TStream): Integer;
1111 var
1112 ev: ENetEvent;
1113 rMsgId: Byte;
1114 Ptr: Pointer;
1115 msg: TMsg;
1116 freePacket: Boolean = false;
1117 ct, ett: Int64;
1118 status: cint;
1119 nextChunk: Integer = 0;
1120 chunkTotal: Integer;
1121 chunk: Integer;
1122 csize: Integer;
1123 buf: PChar = nil;
1124 resumed: Boolean;
1125 //stx: Int64;
1126 begin
1127 tf.resumed := false;
1128 e_LogWritefln('file `%s`, size=%d (%d)', [tf.diskName, Integer(strm.size), tf.size], TMsgType.Notify);
1129 // check if we should resume downloading
1130 resumed := (strm.size > tf.chunkSize) and (strm.size < tf.size);
1131 // send request
1132 trans_omsg.Clear();
1133 trans_omsg.Write(Byte(NTF_CLIENT_START));
1134 if resumed then chunk := strm.size div tf.chunkSize else chunk := 0;
1135 trans_omsg.Write(LongInt(chunk));
1136 if not ftransSendClientMsg(trans_omsg) then begin result := -1; exit; end;
1137
1138 strm.Seek(chunk*tf.chunkSize, soFromBeginning);
1139 chunkTotal := (tf.size+tf.chunkSize-1) div tf.chunkSize;
1140 e_LogWritefln('receiving file `%s` (%d chunks)', [tf.diskName, chunkTotal], TMsgType.Notify);
1141 g_Game_SetLoadingText('downloading "'+ExtractFileName(tf.diskName)+'"', chunkTotal, False);
1142 tf.resumed := resumed;
1143
1144 if (chunk > 0) then g_Game_StepLoading(chunk);
1145 nextChunk := chunk;
1146
1147 // wait for reply data
1148 FillChar(ev, SizeOf(ev), 0);
1149 Result := -1;
1150 GetMem(buf, tf.chunkSize);
1151 try
1152 ett := getNewTimeoutEnd();
1153 repeat
1154 //stx := -GetTimerMS();
1155 status := enet_host_service(NetHost, @ev, 300);
1156 {
1157 if (status < 0) then
1158 begin
1159 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' network error', True);
1160 Result := -1;
1161 exit;
1162 end;
1163 }
1164 if (status <= 0) then
1165 begin
1166 // check for timeout
1167 ct := GetTimerMS();
1168 if (ct >= ett) then
1169 begin
1170 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' timeout reached', True);
1171 Result := -1;
1172 exit;
1173 end;
1174 end
1175 else
1176 begin
1177 // some event
1178 case ev.kind of
1179 ENET_EVENT_TYPE_RECEIVE:
1180 begin
1181 freePacket := true;
1182 if (ev.channelID <> NET_CHAN_DOWNLOAD_EX) then
1183 begin
1184 //e_LogWritefln('g_Net_Wait_Event: skip message from non-transfer channel', []);
1185 freePacket := false;
1186 g_Net_Client_HandlePacket(ev.packet, g_Net_ClientLightMsgHandler);
1187 if (g_Res_received_map_start < 0) then begin result := -666; exit; end;
1188 end
1189 else
1190 begin
1191 //stx := stx+GetTimerMS();
1192 //e_LogWritefln('g_Net_ReceiveResourceFile: stx=%d', [Integer(stx)]);
1193 //stx := -GetTimerMS();
1194 ett := getNewTimeoutEnd();
1195 if (ev.packet.dataLength < 1) then
1196 begin
1197 e_LogWritefln('g_Net_ReceiveResourceFile: invalid server packet (no data)', []);
1198 Result := -1;
1199 exit;
1200 end;
1201 Ptr := ev.packet^.data;
1202 rMsgId := Byte(Ptr^);
1203 if (rMsgId = NTF_SERVER_DONE) then
1204 begin
1205 e_LogWritefln('file transfer complete.', []);
1206 result := 0;
1207 exit;
1208 end
1209 else if (rMsgId = NTF_SERVER_CHUNK) then
1210 begin
1211 if not msg.Init(ev.packet^.data+1, ev.packet^.dataLength-1, True) then exit;
1212 chunk := msg.ReadLongInt();
1213 csize := msg.ReadLongInt();
1214 if (chunk <> nextChunk) then
1215 begin
1216 e_LogWritefln('received chunk %d, but expected chunk %d', [chunk, nextChunk]);
1217 Result := -1;
1218 exit;
1219 end;
1220 if (csize < 0) or (csize > tf.chunkSize) then
1221 begin
1222 e_LogWritefln('received chunk with size %d, but expected chunk size is %d', [csize, tf.chunkSize]);
1223 Result := -1;
1224 exit;
1225 end;
1226 //e_LogWritefln('got chunk #%d of #%d (csize=%d)', [chunk, (tf.size+tf.chunkSize-1) div tf.chunkSize, csize]);
1227 msg.ReadData(buf, csize);
1228 strm.WriteBuffer(buf^, csize);
1229 nextChunk := chunk+1;
1230 g_Game_StepLoading();
1231 // send ack
1232 trans_omsg.Clear();
1233 trans_omsg.Write(Byte(NTF_CLIENT_ACK));
1234 trans_omsg.Write(LongInt(chunk));
1235 if not ftransSendClientMsg(trans_omsg) then begin result := -1; exit; end;
1236 end
1237 else if (rMsgId = NTF_SERVER_ABORT) then
1238 begin
1239 e_LogWritefln('g_Net_ReceiveResourceFile: server aborted transfer', []);
1240 Result := 2;
1241 exit;
1242 end
1243 else
1244 begin
1245 e_LogWritefln('g_Net_ReceiveResourceFile: invalid server packet type', []);
1246 Result := -1;
1247 exit;
1248 end;
1249 //stx := stx+GetTimerMS();
1250 //e_LogWritefln('g_Net_ReceiveResourceFile: process stx=%d', [Integer(stx)]);
1251 end;
1252 end;
1253 ENET_EVENT_TYPE_DISCONNECT:
1254 begin
1255 if (ev.data <= NET_DISC_MAX) then
1256 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' ' + _lc[TStrings_Locale(Cardinal(I_NET_DISC_NONE) + ev.data)], True);
1257 Result := -1;
1258 exit;
1259 end;
1260 else
1261 begin
1262 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' unknown ENet event ' + IntToStr(Ord(ev.kind)), True);
1263 result := -1;
1264 exit;
1265 end;
1266 end;
1267 if (freePacket) then begin freePacket := false; enet_packet_destroy(ev.packet); end;
1268 end;
1269 ProcessLoading();
1270 if g_Net_UserRequestExit() then
1271 begin
1272 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' user abort', True);
1273 Result := 1;
1274 exit;
1275 end;
1276 until false;
1277 finally
1278 FreeMem(buf);
1279 if (freePacket) then enet_packet_destroy(ev.packet);
1280 end;
1281 end;
1282
1283
1284 //**************************************************************************
1285 //
1286 // common functions
1287 //
1288 //**************************************************************************
1289
1290 function g_Net_FindSlot(): Integer;
1291 var
1292 I: Integer;
1293 F: Boolean;
1294 N, C: Integer;
1295 begin
1296 N := -1;
1297 F := False;
1298 C := 0;
1299 for I := Low(NetClients) to High(NetClients) do
1300 begin
1301 if NetClients[I].Used then
1302 Inc(C)
1303 else
1304 if not F then
1305 begin
1306 F := True;
1307 N := I;
1308 end;
1309 end;
1310 if C >= NetMaxClients then
1311 begin
1312 Result := -1;
1313 Exit;
1314 end;
1315
1316 if not F then
1317 begin
1318 if (Length(NetClients) >= NetMaxClients) then
1319 N := -1
1320 else
1321 begin
1322 SetLength(NetClients, Length(NetClients) + 1);
1323 N := High(NetClients);
1324 end;
1325 end;
1326
1327 if N >= 0 then
1328 begin
1329 NetClients[N].Used := True;
1330 NetClients[N].ID := N;
1331 NetClients[N].RequestedFullUpdate := False;
1332 NetClients[N].WaitForFirstSpawn := False;
1333 NetClients[N].RCONAuth := False;
1334 NetClients[N].Voted := False;
1335 NetClients[N].Player := 0;
1336 clearNetClientTransfers(NetClients[N]); // just in case
1337 end;
1338
1339 Result := N;
1340 end;
1341
1342
1343 function g_Net_Init(): Boolean;
1344 var
1345 F: TextFile;
1346 IPstr: string;
1347 IP: LongWord;
1348 path: AnsiString;
1349 begin
1350 NetIn.Clear();
1351 NetOut.Clear();
1352 NetBuf[NET_UNRELIABLE].Clear();
1353 NetBuf[NET_RELIABLE].Clear();
1354 //SetLength(NetClients, 0);
1355 clearNetClients(true); // clear array
1356 NetPeer := nil;
1357 NetHost := nil;
1358 NetMyID := -1;
1359 NetPlrUID1 := -1;
1360 NetPlrUID2 := -1;
1361 NetAddr.port := 25666;
1362 SetLength(NetBannedHosts, 0);
1363 path := BANLIST_FILENAME;
1364 if e_FindResource(DataDirs, path) = true then
1365 begin
1366 Assign(F, path);
1367 Reset(F);
1368 while not EOF(F) do
1369 begin
1370 Readln(F, IPstr);
1371 if StrToIp(IPstr, IP) then
1372 g_Net_BanHost(IP);
1373 end;
1374 CloseFile(F);
1375 g_Net_SaveBanList();
1376 end;
1377
1378 //Result := (enet_initialize() = 0);
1379 Result := enet_init_success;
1380 end;
1381
1382 procedure g_Net_Flush();
1383 var
1384 T: Integer;
1385 P: pENetPacket;
1386 F, Chan: enet_uint32;
1387 I: Integer;
1388 begin
1389 F := 0;
1390 Chan := NET_CHAN_GAME;
1391
1392 if NetMode = NET_SERVER then
1393 for T := NET_UNRELIABLE to NET_RELIABLE do
1394 begin
1395 if NetBuf[T].CurSize > 0 then
1396 begin
1397 P := enet_packet_create(NetBuf[T].Data, NetBuf[T].CurSize, F);
1398 if not Assigned(P) then continue;
1399 enet_host_broadcast(NetHost, Chan, P);
1400 NetBuf[T].Clear();
1401 end;
1402
1403 for I := Low(NetClients) to High(NetClients) do
1404 begin
1405 if not NetClients[I].Used then continue;
1406 if NetClients[I].NetOut[T].CurSize <= 0 then continue;
1407 P := enet_packet_create(NetClients[I].NetOut[T].Data, NetClients[I].NetOut[T].CurSize, F);
1408 if not Assigned(P) then continue;
1409 enet_peer_send(NetClients[I].Peer, Chan, P);
1410 NetClients[I].NetOut[T].Clear();
1411 end;
1412
1413 // next and last iteration is always RELIABLE
1414 F := LongWord(ENET_PACKET_FLAG_RELIABLE);
1415 Chan := NET_CHAN_IMPORTANT;
1416 end
1417 else if NetMode = NET_CLIENT then
1418 for T := NET_UNRELIABLE to NET_RELIABLE do
1419 begin
1420 if NetBuf[T].CurSize > 0 then
1421 begin
1422 P := enet_packet_create(NetBuf[T].Data, NetBuf[T].CurSize, F);
1423 if not Assigned(P) then continue;
1424 enet_peer_send(NetPeer, Chan, P);
1425 NetBuf[T].Clear();
1426 end;
1427 // next and last iteration is always RELIABLE
1428 F := LongWord(ENET_PACKET_FLAG_RELIABLE);
1429 Chan := NET_CHAN_IMPORTANT;
1430 end;
1431 end;
1432
1433 procedure g_Net_Cleanup();
1434 begin
1435 NetIn.Clear();
1436 NetOut.Clear();
1437 NetBuf[NET_UNRELIABLE].Clear();
1438 NetBuf[NET_RELIABLE].Clear();
1439
1440 //SetLength(NetClients, 0);
1441 clearNetClients(true); // clear array
1442 NetClientCount := 0;
1443
1444 NetPeer := nil;
1445 NetHost := nil;
1446 g_Net_Slist_ServerClosed();
1447 NetMyID := -1;
1448 NetPlrUID1 := -1;
1449 NetPlrUID2 := -1;
1450 NetState := NET_STATE_NONE;
1451
1452 NetPongSock := ENET_SOCKET_NULL;
1453
1454 NetTimeToMaster := 0;
1455 NetTimeToUpdate := 0;
1456 NetTimeToReliable := 0;
1457
1458 NetMode := NET_NONE;
1459
1460 if NetPortThread <> NilThreadId then
1461 WaitForThreadTerminate(NetPortThread, 66666);
1462
1463 NetPortThread := NilThreadId;
1464 g_Net_UnforwardPorts();
1465
1466 if NetDump then
1467 g_Net_DumpEnd();
1468 end;
1469
1470 procedure g_Net_Free();
1471 begin
1472 g_Net_Cleanup();
1473
1474 //enet_deinitialize();
1475 NetInitDone := False;
1476 end;
1477
1478
1479 //**************************************************************************
1480 //
1481 // SERVER FUNCTIONS
1482 //
1483 //**************************************************************************
1484
1485 function ForwardThread(Param: Pointer): PtrInt;
1486 begin
1487 Result := 0;
1488 if not g_Net_ForwardPorts() then Result := -1;
1489 end;
1490
1491 function g_Net_Host(IPAddr: LongWord; Port: enet_uint16; MaxClients: Cardinal = 16): Boolean;
1492 begin
1493 if NetMode <> NET_NONE then
1494 begin
1495 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_INGAME]);
1496 Result := False;
1497 Exit;
1498 end;
1499
1500 Result := True;
1501
1502 g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_HOST], [Port]));
1503 if not NetInitDone then
1504 begin
1505 if (not g_Net_Init()) then
1506 begin
1507 g_Console_Add(_lc[I_NET_MSG_FERROR] + _lc[I_NET_ERR_ENET]);
1508 Result := False;
1509 Exit;
1510 end
1511 else
1512 NetInitDone := True;
1513 end;
1514
1515 NetAddr.host := IPAddr;
1516 NetAddr.port := Port;
1517
1518 NetHost := enet_host_create(@NetAddr, NET_MAXCLIENTS, NET_CHANS, 0, 0);
1519
1520 if (NetHost = nil) then
1521 begin
1522 g_Console_Add(_lc[I_NET_MSG_ERROR] + Format(_lc[I_NET_ERR_HOST], [Port]));
1523 Result := False;
1524 g_Net_Cleanup;
1525 Exit;
1526 end;
1527
1528 if NetForwardPorts then NetPortThread := BeginThread(ForwardThread);
1529
1530 NetPongSock := enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM);
1531 if NetPongSock <> ENET_SOCKET_NULL then
1532 begin
1533 NetPongAddr.host := IPAddr;
1534 NetPongAddr.port := NET_PING_PORT;
1535 if enet_socket_bind(NetPongSock, @NetPongAddr) < 0 then
1536 begin
1537 enet_socket_destroy(NetPongSock);
1538 NetPongSock := ENET_SOCKET_NULL;
1539 end
1540 else
1541 enet_socket_set_option(NetPongSock, ENET_SOCKOPT_NONBLOCK, 1);
1542 end;
1543
1544 NetMode := NET_SERVER;
1545 NetOut.Clear();
1546 NetBuf[NET_UNRELIABLE].Clear();
1547 NetBuf[NET_RELIABLE].Clear();
1548
1549 if NetDump then
1550 g_Net_DumpStart();
1551 end;
1552
1553 procedure g_Net_Host_Die();
1554 var
1555 I: Integer;
1556 begin
1557 if NetMode <> NET_SERVER then Exit;
1558
1559 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_DISCALL]);
1560 for I := 0 to High(NetClients) do
1561 if NetClients[I].Used then
1562 enet_peer_disconnect(NetClients[I].Peer, NET_DISC_DOWN);
1563
1564 while enet_host_service(NetHost, @NetEvent, 1000) > 0 do
1565 if NetEvent.kind = ENET_EVENT_TYPE_RECEIVE then
1566 enet_packet_destroy(NetEvent.packet);
1567
1568 for I := 0 to High(NetClients) do
1569 if NetClients[I].Used then
1570 begin
1571 FreeMemory(NetClients[I].Peer^.data);
1572 NetClients[I].Peer^.data := nil;
1573 enet_peer_reset(NetClients[I].Peer);
1574 NetClients[I].Peer := nil;
1575 NetClients[I].Used := False;
1576 NetClients[I].Player := 0;
1577 NetClients[I].Crimes := 0;
1578 NetClients[I].AuthTime := 0;
1579 NetClients[I].MsgTime := 0;
1580 NetClients[I].NetOut[NET_UNRELIABLE].Free();
1581 NetClients[I].NetOut[NET_RELIABLE].Free();
1582 end;
1583
1584 clearNetClients(false); // don't clear array
1585 g_Net_Slist_ServerClosed();
1586 if NetPongSock <> ENET_SOCKET_NULL then
1587 enet_socket_destroy(NetPongSock);
1588
1589 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_DIE]);
1590 enet_host_destroy(NetHost);
1591
1592 NetMode := NET_NONE;
1593
1594 g_Net_Cleanup;
1595 e_WriteLog('NET: Server stopped', TMsgType.Notify);
1596 end;
1597
1598
1599 procedure g_Net_Host_Send(ID: Integer; Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
1600 var
1601 T: Integer;
1602 begin
1603 if (Reliable) then
1604 T := NET_RELIABLE
1605 else
1606 T := NET_UNRELIABLE;
1607
1608 if (ID >= 0) then
1609 begin
1610 if ID > High(NetClients) then Exit;
1611 if NetClients[ID].Peer = nil then Exit;
1612 // write size first
1613 NetClients[ID].NetOut[T].Write(Integer(NetOut.CurSize));
1614 NetClients[ID].NetOut[T].Write(NetOut);
1615 end
1616 else
1617 begin
1618 // write size first
1619 NetBuf[T].Write(Integer(NetOut.CurSize));
1620 NetBuf[T].Write(NetOut);
1621 end;
1622
1623 if NetDump then g_Net_DumpSendBuffer();
1624 NetOut.Clear();
1625 end;
1626
1627 procedure g_Net_Host_Disconnect_Client(ID: Integer; Force: Boolean = False);
1628 var
1629 TP: TPlayer;
1630 TC: pTNetClient;
1631 begin
1632 TC := @NetClients[ID];
1633 if (TC = nil) then Exit;
1634 clearNetClient(NetClients[ID]);
1635 if not (TC^.Used) then Exit;
1636
1637 TP := g_Player_Get(TC^.Player);
1638
1639 if TP <> nil then
1640 begin
1641 TP.Lives := 0;
1642 TP.Kill(K_SIMPLEKILL, 0, HIT_DISCON);
1643 g_Console_Add(Format(_lc[I_PLAYER_LEAVE], [TP.Name]), True);
1644 e_WriteLog('NET: Client ' + TP.Name + ' [' + IntToStr(TC^.ID) + '] disconnected.', TMsgType.Notify);
1645 g_Player_Remove(TP.UID);
1646 end;
1647
1648 if (TC^.Peer^.data <> nil) then
1649 begin
1650 FreeMemory(TC^.Peer^.data);
1651 TC^.Peer^.data := nil;
1652 end;
1653
1654 if (Force) then
1655 enet_peer_reset(TC^.Peer);
1656
1657 TC^.Used := False;
1658 TC^.State := NET_STATE_NONE;
1659 TC^.Peer := nil;
1660 TC^.Player := 0;
1661 TC^.Crimes := 0;
1662 TC^.AuthTime := 0;
1663 TC^.MsgTime := 0;
1664 TC^.RequestedFullUpdate := False;
1665 TC^.WaitForFirstSpawn := False;
1666 TC^.NetOut[NET_UNRELIABLE].Free();
1667 TC^.NetOut[NET_RELIABLE].Free();
1668
1669 g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_HOST_DISC], [ID]));
1670 Dec(NetClientCount);
1671
1672 if NetUseMaster then g_Net_Slist_ServerPlayerLeaves();
1673 end;
1674
1675 procedure g_Net_Host_CheckPings();
1676 var
1677 ClAddr: ENetAddress;
1678 Buf: ENetBuffer;
1679 Len: Integer;
1680 ClTime: Int64;
1681 Ping: array [0..9] of Byte;
1682 NPl: Byte;
1683 begin
1684 if (NetPongSock = ENET_SOCKET_NULL) or (NetHost = nil) then Exit;
1685
1686 Buf.data := Addr(Ping[0]);
1687 Buf.dataLength := 2+8;
1688
1689 Ping[0] := 0;
1690
1691 Len := enet_socket_receive(NetPongSock, @ClAddr, @Buf, 1);
1692 if Len < 0 then Exit;
1693
1694 if (Ping[0] = Ord('D')) and (Ping[1] = Ord('F')) then
1695 begin
1696 ClTime := Int64(Addr(Ping[2])^);
1697
1698 NetOut.Clear();
1699 NetOut.Write(Byte(Ord('D')));
1700 NetOut.Write(Byte(Ord('F')));
1701 NetOut.Write(NetHost.address.port);
1702 NetOut.Write(ClTime);
1703 TMasterHost.writeInfo(NetOut);
1704 NPl := 0;
1705 if gPlayer1 <> nil then Inc(NPl);
1706 if gPlayer2 <> nil then Inc(NPl);
1707 NetOut.Write(NPl);
1708 NetOut.Write(gNumBots);
1709
1710 Buf.data := NetOut.Data;
1711 Buf.dataLength := NetOut.CurSize;
1712 enet_socket_send(NetPongSock, @ClAddr, @Buf, 1);
1713
1714 NetOut.Clear();
1715 end;
1716 end;
1717
1718 procedure g_Net_Host_CheckTimeouts();
1719 var
1720 ID: Integer;
1721 begin
1722 for ID := Low(NetClients) to High(NetClients) do
1723 begin
1724 with NetClients[ID] do
1725 begin
1726 if (Peer = nil) or (State = NET_STATE_NONE) then continue;
1727 if (State = NET_STATE_AUTH) and (AuthTime > 0) and (AuthTime <= gTime) then
1728 begin
1729 g_Net_Penalize(@NetClients[ID], 'auth taking too long');
1730 AuthTime := gTime + 1000; // do it every second to give them a chance
1731 end
1732 else if (State = NET_STATE_GAME) and (MsgTime > 0) and (MsgTime <= gTime) then
1733 begin
1734 // client hasn't sent packets in a while; either ban em or kick em
1735 if (NetAutoBanForTimeout) then
1736 begin
1737 g_Net_Penalize(@NetClients[ID], 'message timeout');
1738 MsgTime := gTime + (NetPacketTimeout div 2) + 500; // wait less for the next check
1739 end
1740 else
1741 begin
1742 e_LogWritefln('NET: client #%u (cid #%u) timed out', [ID, Player]);
1743 g_Net_Host_Disconnect_Client(ID, True);
1744 end;
1745 end;
1746 end;
1747 end;
1748 end;
1749
1750
1751 procedure g_Net_Host_Update();
1752 var
1753 IP: string;
1754 Port: Word;
1755 ID: Integer;
1756 TC: pTNetClient;
1757 begin
1758 IP := '';
1759
1760 if NetUseMaster then g_Net_Slist_Pulse();
1761 g_Net_Host_CheckPings();
1762 g_Net_Host_CheckTimeouts();
1763
1764 while (enet_host_service(NetHost, @NetEvent, 0) > 0) do
1765 begin
1766 case (NetEvent.kind) of
1767 ENET_EVENT_TYPE_CONNECT:
1768 begin
1769 IP := IpToStr(NetEvent.Peer^.address.host);
1770 Port := NetEvent.Peer^.address.port;
1771 g_Console_Add(_lc[I_NET_MSG] +
1772 Format(_lc[I_NET_MSG_HOST_CONN], [IP, Port]));
1773 e_WriteLog('NET: Connection request from ' + IP + '.', TMsgType.Notify);
1774
1775 if (NetEvent.data <> NET_PROTOCOL_VER) then
1776 begin
1777 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
1778 _lc[I_NET_DISC_PROTOCOL]);
1779 e_WriteLog('NET: Connection request from ' + IP + ' rejected: version mismatch',
1780 TMsgType.Notify);
1781 NetEvent.peer^.data := GetMemory(SizeOf(Byte));
1782 Byte(NetEvent.peer^.data^) := 255;
1783 enet_peer_disconnect(NetEvent.peer, NET_DISC_PROTOCOL);
1784 enet_host_flush(NetHost);
1785 Exit;
1786 end;
1787
1788 if g_Net_IsHostBanned(NetEvent.Peer^.address.host) then
1789 begin
1790 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
1791 _lc[I_NET_DISC_BAN]);
1792 e_WriteLog('NET: Connection request from ' + IP + ' rejected: banned',
1793 TMsgType.Notify);
1794 NetEvent.peer^.data := GetMemory(SizeOf(Byte));
1795 Byte(NetEvent.peer^.data^) := 255;
1796 enet_peer_disconnect(NetEvent.Peer, NET_DISC_BAN);
1797 enet_host_flush(NetHost);
1798 Exit;
1799 end;
1800
1801 ID := g_Net_FindSlot();
1802
1803 if ID < 0 then
1804 begin
1805 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
1806 _lc[I_NET_DISC_FULL]);
1807 e_WriteLog('NET: Connection request from ' + IP + ' rejected: server full',
1808 TMsgType.Notify);
1809 NetEvent.Peer^.data := GetMemory(SizeOf(Byte));
1810 Byte(NetEvent.peer^.data^) := 255;
1811 enet_peer_disconnect(NetEvent.peer, NET_DISC_FULL);
1812 enet_host_flush(NetHost);
1813 Exit;
1814 end;
1815
1816 NetClients[ID].Peer := NetEvent.peer;
1817 NetClients[ID].Peer^.data := GetMemory(SizeOf(Byte));
1818 Byte(NetClients[ID].Peer^.data^) := ID;
1819 NetClients[ID].State := NET_STATE_AUTH;
1820 NetClients[ID].Player := 0;
1821 NetClients[ID].Crimes := 0;
1822 NetClients[ID].RCONAuth := False;
1823 NetClients[ID].NetOut[NET_UNRELIABLE].Alloc(NET_BUFSIZE*2);
1824 NetClients[ID].NetOut[NET_RELIABLE].Alloc(NET_BUFSIZE*2);
1825 if (NetAuthTimeout > 0) then
1826 NetClients[ID].AuthTime := gTime + NetAuthTimeout
1827 else
1828 NetClients[ID].AuthTime := 0;
1829 if (NetPacketTimeout > 0) then
1830 NetClients[ID].MsgTime := gTime + NetPacketTimeout
1831 else
1832 NetClients[ID].MsgTime := 0;
1833 clearNetClientTransfers(NetClients[ID]); // just in case
1834
1835 enet_peer_timeout(NetEvent.peer, ENET_PEER_TIMEOUT_LIMIT * 2, ENET_PEER_TIMEOUT_MINIMUM * 2, ENET_PEER_TIMEOUT_MAXIMUM * 2);
1836
1837 Inc(NetClientCount);
1838 g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_HOST_ADD], [ID]));
1839 end;
1840
1841 ENET_EVENT_TYPE_RECEIVE:
1842 begin
1843 //e_LogWritefln('RECEIVE: chan=%u', [NetEvent.channelID]);
1844 if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then
1845 begin
1846 ProcessDownloadExPacket();
1847 end
1848 else
1849 begin
1850 ID := Byte(NetEvent.peer^.data^);
1851 if ID > High(NetClients) then Exit;
1852 TC := @NetClients[ID];
1853
1854 if (NetPacketTimeout > 0) then
1855 TC^.MsgTime := gTime + NetPacketTimeout;
1856
1857 if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
1858 g_Net_Host_HandlePacket(TC, NetEvent.packet, g_Net_HostMsgHandler);
1859 end;
1860 end;
1861
1862 ENET_EVENT_TYPE_DISCONNECT:
1863 begin
1864 ID := Byte(NetEvent.peer^.data^);
1865 if ID > High(NetClients) then Exit;
1866 g_Net_Host_Disconnect_Client(ID);
1867 end;
1868 end;
1869 end;
1870 end;
1871
1872
1873 //**************************************************************************
1874 //
1875 // CLIENT FUNCTIONS
1876 //
1877 //**************************************************************************
1878
1879 procedure g_Net_Disconnect(Forced: Boolean = False);
1880 begin
1881 if NetMode <> NET_CLIENT then Exit;
1882 if (NetHost = nil) or (NetPeer = nil) then Exit;
1883
1884 if not Forced then
1885 begin
1886 enet_peer_disconnect(NetPeer, NET_DISC_NONE);
1887
1888 while (enet_host_service(NetHost, @NetEvent, 1500) > 0) do
1889 begin
1890 if (NetEvent.kind = ENET_EVENT_TYPE_DISCONNECT) then
1891 begin
1892 NetPeer := nil;
1893 break;
1894 end;
1895
1896 if (NetEvent.kind = ENET_EVENT_TYPE_RECEIVE) then
1897 enet_packet_destroy(NetEvent.packet);
1898 end;
1899
1900 if NetPeer <> nil then
1901 begin
1902 enet_peer_reset(NetPeer);
1903 NetPeer := nil;
1904 end;
1905 end
1906 else
1907 begin
1908 e_WriteLog('NET: Kicked from server: ' + IntToStr(NetEvent.data), TMsgType.Notify);
1909 if (NetEvent.data <= NET_DISC_MAX) then
1910 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_KICK] +
1911 _lc[TStrings_Locale(Cardinal(I_NET_DISC_NONE) + NetEvent.data)], True);
1912 end;
1913
1914 if NetHost <> nil then
1915 begin
1916 enet_host_destroy(NetHost);
1917 NetHost := nil;
1918 end;
1919 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_CLIENT_DISC]);
1920
1921 g_Net_Cleanup;
1922 e_WriteLog('NET: Disconnected', TMsgType.Notify);
1923 end;
1924
1925 procedure g_Net_Client_Send(Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
1926 var
1927 T: Integer;
1928 begin
1929 if (Reliable) then
1930 T := NET_RELIABLE
1931 else
1932 T := NET_UNRELIABLE;
1933
1934 // write size first
1935 NetBuf[T].Write(Integer(NetOut.CurSize));
1936 NetBuf[T].Write(NetOut);
1937
1938 if NetDump then g_Net_DumpSendBuffer();
1939 NetOut.Clear();
1940 g_Net_Flush(); // FIXME: for now, send immediately
1941 end;
1942
1943 procedure g_Net_Client_Update();
1944 begin
1945 while (NetHost <> nil) and (enet_host_service(NetHost, @NetEvent, 0) > 0) do
1946 begin
1947 case NetEvent.kind of
1948 ENET_EVENT_TYPE_RECEIVE:
1949 begin
1950 if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then continue; // ignore all download packets, they're processed by separate code
1951 if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
1952 g_Net_Client_HandlePacket(NetEvent.packet, g_Net_ClientMsgHandler);
1953 end;
1954
1955 ENET_EVENT_TYPE_DISCONNECT:
1956 begin
1957 g_Net_Disconnect(True);
1958 Exit;
1959 end;
1960 end;
1961 end
1962 end;
1963
1964 procedure g_Net_Client_UpdateWhileLoading();
1965 begin
1966 while (enet_host_service(NetHost, @NetEvent, 0) > 0) do
1967 begin
1968 case NetEvent.kind of
1969 ENET_EVENT_TYPE_RECEIVE:
1970 begin
1971 if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then continue; // ignore all download packets, they're processed by separate code
1972 if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
1973 g_Net_Client_HandlePacket(NetEvent.packet, g_Net_ClientLightMsgHandler);
1974 end;
1975
1976 ENET_EVENT_TYPE_DISCONNECT:
1977 begin
1978 g_Net_Disconnect(True);
1979 Exit;
1980 end;
1981 end;
1982 end;
1983 g_Net_Flush();
1984 end;
1985
1986 function g_Net_Connect(IP: string; Port: enet_uint16): Boolean;
1987 var
1988 OuterLoop: Boolean;
1989 TimeoutTime, T: Int64;
1990 begin
1991 if NetMode <> NET_NONE then
1992 begin
1993 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_ERR_INGAME], True);
1994 Result := False;
1995 Exit;
1996 end;
1997
1998 Result := True;
1999
2000 g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_CLIENT_CONN],
2001 [IP, Port]));
2002 if not NetInitDone then
2003 begin
2004 if (not g_Net_Init()) then
2005 begin
2006 g_Console_Add(_lc[I_NET_MSG_FERROR] + _lc[I_NET_ERR_ENET], True);
2007 Result := False;
2008 Exit;
2009 end
2010 else
2011 NetInitDone := True;
2012 end;
2013
2014 NetHost := enet_host_create(nil, 1, NET_CHANS, 0, 0);
2015
2016 if (NetHost = nil) then
2017 begin
2018 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CLIENT], True);
2019 g_Net_Cleanup;
2020 Result := False;
2021 Exit;
2022 end;
2023
2024 enet_address_set_host(@NetAddr, PChar(Addr(IP[1])));
2025 NetAddr.port := Port;
2026
2027 NetPeer := enet_host_connect(NetHost, @NetAddr, NET_CHANS, NET_PROTOCOL_VER);
2028
2029 if (NetPeer = nil) then
2030 begin
2031 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CLIENT], True);
2032 enet_host_destroy(NetHost);
2033 g_Net_Cleanup;
2034 Result := False;
2035 Exit;
2036 end;
2037
2038 // предупредить что ждем слишком долго через N секунд
2039 TimeoutTime := sys_GetTicks() + NET_CONNECT_TIMEOUT;
2040
2041 OuterLoop := True;
2042 while OuterLoop do
2043 begin
2044 while (enet_host_service(NetHost, @NetEvent, 0) > 0) do
2045 begin
2046 if (NetEvent.kind = ENET_EVENT_TYPE_CONNECT) then
2047 begin
2048 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_CLIENT_DONE]);
2049 NetMode := NET_CLIENT;
2050 NetOut.Clear();
2051 enet_peer_timeout(NetPeer, ENET_PEER_TIMEOUT_LIMIT * 2, ENET_PEER_TIMEOUT_MINIMUM * 2, ENET_PEER_TIMEOUT_MAXIMUM * 2);
2052 NetClientIP := IP;
2053 NetClientPort := Port;
2054 if NetDump then
2055 g_Net_DumpStart();
2056 Exit;
2057 end;
2058 end;
2059
2060 T := sys_GetTicks();
2061 if T > TimeoutTime then
2062 begin
2063 TimeoutTime := T + NET_CONNECT_TIMEOUT * 100; // одного предупреждения хватит
2064 g_Console_Add(_lc[I_NET_MSG_TIMEOUT_WARN], True);
2065 g_Console_Add(Format(_lc[I_NET_MSG_PORTS], [Integer(Port), Integer(NET_PING_PORT)]), True);
2066 end;
2067
2068 ProcessLoading(true);
2069
2070 if e_KeyPressed(IK_SPACE) or e_KeyPressed(IK_ESCAPE) or e_KeyPressed(VK_ESCAPE) or
2071 e_KeyPressed(JOY0_JUMP) or e_KeyPressed(JOY1_JUMP) or e_KeyPressed(JOY2_JUMP) or e_KeyPressed(JOY3_JUMP) then
2072 OuterLoop := False;
2073 end;
2074
2075 g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_TIMEOUT], True);
2076 g_Console_Add(Format(_lc[I_NET_MSG_PORTS], [Integer(Port), Integer(NET_PING_PORT)]), True);
2077 if NetPeer <> nil then enet_peer_reset(NetPeer);
2078 if NetHost <> nil then
2079 begin
2080 enet_host_destroy(NetHost);
2081 NetHost := nil;
2082 end;
2083 g_Net_Cleanup();
2084 Result := False;
2085 end;
2086
2087 function IpToStr(IP: LongWord): string;
2088 var
2089 Ptr: Pointer;
2090 begin
2091 Ptr := Addr(IP);
2092 Result := IntToStr(PByte(Ptr + 0)^) + '.';
2093 Result := Result + IntToStr(PByte(Ptr + 1)^) + '.';
2094 Result := Result + IntToStr(PByte(Ptr + 2)^) + '.';
2095 Result := Result + IntToStr(PByte(Ptr + 3)^);
2096 end;
2097
2098 function StrToIp(IPstr: string; var IP: LongWord): Boolean;
2099 var
2100 EAddr: ENetAddress;
2101 begin
2102 Result := enet_address_set_host(@EAddr, PChar(@IPstr[1])) = 0;
2103 IP := EAddr.host;
2104 end;
2105
2106 function g_Net_Client_ByName(Name: string): pTNetClient;
2107 var
2108 a: Integer;
2109 pl: TPlayer;
2110 begin
2111 Result := nil;
2112 for a := Low(NetClients) to High(NetClients) do
2113 if (NetClients[a].Used) and (NetClients[a].State = NET_STATE_GAME) then
2114 begin
2115 pl := g_Player_Get(NetClients[a].Player);
2116 if pl = nil then continue;
2117 if Copy(LowerCase(pl.Name), 1, Length(Name)) <> LowerCase(Name) then continue;
2118 if NetClients[a].Peer <> nil then
2119 begin
2120 Result := @NetClients[a];
2121 Exit;
2122 end;
2123 end;
2124 end;
2125
2126 function g_Net_Client_ByPlayer(PID: Word): pTNetClient;
2127 var
2128 a: Integer;
2129 begin
2130 Result := nil;
2131 for a := Low(NetClients) to High(NetClients) do
2132 if (NetClients[a].Used) and (NetClients[a].State = NET_STATE_GAME) then
2133 if NetClients[a].Player = PID then
2134 begin
2135 Result := @NetClients[a];
2136 Exit;
2137 end;
2138 end;
2139
2140 function g_Net_ClientName_ByID(ID: Integer): string;
2141 var
2142 a: Integer;
2143 pl: TPlayer;
2144 begin
2145 Result := '';
2146 if ID = NET_EVERYONE then
2147 Exit;
2148 for a := Low(NetClients) to High(NetClients) do
2149 if (NetClients[a].ID = ID) and (NetClients[a].Used) and (NetClients[a].State = NET_STATE_GAME) then
2150 begin
2151 pl := g_Player_Get(NetClients[a].Player);
2152 if pl = nil then Exit;
2153 Result := pl.Name;
2154 end;
2155 end;
2156
2157 procedure g_Net_SendData(Data: AByte; peer: pENetPeer; Reliable: Boolean; Chan: Byte = NET_CHAN_DOWNLOAD);
2158 var
2159 P: pENetPacket;
2160 F: enet_uint32;
2161 dataLength: Cardinal;
2162 begin
2163 dataLength := Length(Data);
2164
2165 if (Reliable) then
2166 F := LongWord(ENET_PACKET_FLAG_RELIABLE)
2167 else
2168 F := 0;
2169
2170 if (peer <> nil) then
2171 begin
2172 P := enet_packet_create(@Data[0], dataLength, F);
2173 if not Assigned(P) then Exit;
2174 enet_peer_send(peer, Chan, P);
2175 end
2176 else
2177 begin
2178 P := enet_packet_create(@Data[0], dataLength, F);
2179 if not Assigned(P) then Exit;
2180 enet_host_broadcast(NetHost, Chan, P);
2181 end;
2182
2183 enet_host_flush(NetHost);
2184 end;
2185
2186 function g_Net_IsHostBanned(IP: LongWord; Perm: Boolean = False): Boolean;
2187 var
2188 I: Integer;
2189 begin
2190 Result := False;
2191 if NetBannedHosts = nil then
2192 Exit;
2193 for I := 0 to High(NetBannedHosts) do
2194 if (NetBannedHosts[I].IP = IP) and ((not Perm) or (NetBannedHosts[I].Perm)) then
2195 begin
2196 Result := True;
2197 break;
2198 end;
2199 end;
2200
2201 procedure g_Net_BanHost(IP: LongWord; Perm: Boolean = True); overload;
2202 var
2203 I, P: Integer;
2204 begin
2205 if IP = 0 then
2206 Exit;
2207 if g_Net_IsHostBanned(IP, Perm) then
2208 Exit;
2209
2210 P := -1;
2211 for I := Low(NetBannedHosts) to High(NetBannedHosts) do
2212 if NetBannedHosts[I].IP = 0 then
2213 begin
2214 P := I;
2215 break;
2216 end;
2217
2218 if P < 0 then
2219 begin
2220 SetLength(NetBannedHosts, Length(NetBannedHosts) + 1);
2221 P := High(NetBannedHosts);
2222 end;
2223
2224 NetBannedHosts[P].IP := IP;
2225 NetBannedHosts[P].Perm := Perm;
2226 end;
2227
2228 procedure g_Net_BanHost(IP: string; Perm: Boolean = True); overload;
2229 var
2230 a: LongWord;
2231 b: Boolean;
2232 begin
2233 b := StrToIp(IP, a);
2234 if b then
2235 g_Net_BanHost(a, Perm);
2236 end;
2237
2238 procedure g_Net_UnbanNonPermHosts();
2239 var
2240 I: Integer;
2241 begin
2242 if NetBannedHosts = nil then
2243 Exit;
2244 for I := Low(NetBannedHosts) to High(NetBannedHosts) do
2245 if (NetBannedHosts[I].IP > 0) and not NetBannedHosts[I].Perm then
2246 begin
2247 NetBannedHosts[I].IP := 0;
2248 NetBannedHosts[I].Perm := True;
2249 end;
2250 end;
2251
2252 function g_Net_UnbanHost(IP: string): Boolean; overload;
2253 var
2254 a: LongWord;
2255 begin
2256 Result := StrToIp(IP, a);
2257 if Result then
2258 Result := g_Net_UnbanHost(a);
2259 end;
2260
2261 function g_Net_UnbanHost(IP: LongWord): Boolean; overload;
2262 var
2263 I: Integer;
2264 begin
2265 Result := False;
2266 if IP = 0 then
2267 Exit;
2268 if NetBannedHosts = nil then
2269 Exit;
2270 for I := 0 to High(NetBannedHosts) do
2271 if NetBannedHosts[I].IP = IP then
2272 begin
2273 NetBannedHosts[I].IP := 0;
2274 NetBannedHosts[I].Perm := True;
2275 Result := True;
2276 // no break here to clear all bans of this host, perm and non-perm
2277 end;
2278 end;
2279
2280 procedure g_Net_SaveBanList();
2281 var
2282 F: TextFile;
2283 I: Integer;
2284 path: AnsiString;
2285 begin
2286 path := e_GetWriteableDir(DataDirs);
2287 if path <> '' then
2288 begin
2289 path := e_CatPath(path, BANLIST_FILENAME);
2290 Assign(F, path);
2291 Rewrite(F);
2292 if NetBannedHosts <> nil then
2293 for I := 0 to High(NetBannedHosts) do
2294 if NetBannedHosts[I].Perm and (NetBannedHosts[I].IP > 0) then
2295 Writeln(F, IpToStr(NetBannedHosts[I].IP));
2296 CloseFile(F)
2297 end
2298 end;
2299
2300 procedure g_Net_Penalize(C: pTNetClient; Reason: string);
2301 var
2302 s: string;
2303 begin
2304 e_LogWritefln('NET: client #%u (cid #%u) triggered a penalty (%d/%d): %s',
2305 [C^.ID, C^.Player, C^.Crimes + 1, NetAutoBanLimit, Reason]);
2306
2307 if (NetAutoBanLimit <= 0) then Exit;
2308
2309 if (C^.Crimes >= NetAutoBanLimit) then
2310 begin
2311 // we have tried asking nicely before, now it is time to die
2312 e_LogWritefln('NET: client #%u (cid #%u) force kicked',
2313 [C^.ID, C^.Player]);
2314 g_Net_Host_Disconnect_Client(C^.ID, True);
2315 Exit;
2316 end;
2317
2318 Inc(C^.Crimes);
2319
2320 if (NetAutoBanWarn) then
2321 MH_SEND_Chat('You have been warned by the server: ' + Reason, NET_CHAT_SYSTEM, C^.ID);
2322
2323 if (C^.Crimes >= NetAutoBanLimit) then
2324 begin
2325 s := '#' + IntToStr(C^.ID); // can't be arsed
2326 g_Net_BanHost(C^.Peer^.address.host, NetAutoBanPerm);
2327 enet_peer_disconnect(C^.Peer, NET_DISC_BAN);
2328 g_Console_Add(Format(_lc[I_PLAYER_BAN], [s]));
2329 MH_SEND_GameEvent(NET_EV_PLAYER_BAN, 0, s);
2330 g_Net_Slist_ServerPlayerLeaves();
2331 end;
2332 end;
2333
2334 procedure g_Net_DumpStart();
2335 begin
2336 if NetMode = NET_SERVER then
2337 NetDumpFile := e_CreateResource(LogDirs, NETDUMP_FILENAME + '_server')
2338 else
2339 NetDumpFile := e_CreateResource(LogDirs, NETDUMP_FILENAME + '_client');
2340 end;
2341
2342 procedure g_Net_DumpSendBuffer();
2343 begin
2344 writeInt(NetDumpFile, gTime);
2345 writeInt(NetDumpFile, LongWord(NetOut.CurSize));
2346 writeInt(NetDumpFile, Byte(1));
2347 NetDumpFile.WriteBuffer(NetOut.Data^, NetOut.CurSize);
2348 end;
2349
2350 procedure g_Net_DumpRecvBuffer(Buf: penet_uint8; Len: LongWord);
2351 begin
2352 if (Buf = nil) or (Len = 0) then Exit;
2353 writeInt(NetDumpFile, gTime);
2354 writeInt(NetDumpFile, Len);
2355 writeInt(NetDumpFile, Byte(0));
2356 NetDumpFile.WriteBuffer(Buf^, Len);
2357 end;
2358
2359 procedure g_Net_DumpEnd();
2360 begin
2361 NetDumpFile.Free();
2362 NetDumpFile := nil;
2363 end;
2364
2365 function g_Net_ForwardPorts(ForwardPongPort: Boolean = True): Boolean;
2366 {$IFDEF USE_MINIUPNPC}
2367 var
2368 DevList: PUPNPDev;
2369 Urls: TUPNPUrls;
2370 Data: TIGDDatas;
2371 LanAddr: array [0..255] of Char;
2372 StrPort: AnsiString;
2373 Err, I: Integer;
2374 begin
2375 Result := False;
2376
2377 if NetHost = nil then
2378 exit;
2379
2380 if NetPortForwarded = NetHost.address.port then
2381 begin
2382 Result := True;
2383 exit;
2384 end;
2385
2386 NetPongForwarded := False;
2387 NetPortForwarded := 0;
2388
2389 DevList := upnpDiscover(1000, nil, nil, 0, 0, 2, Addr(Err));
2390 if DevList = nil then
2391 begin
2392 conwritefln('port forwarding failed: upnpDiscover() failed: %d', [Err]);
2393 exit;
2394 end;
2395
2396 I := UPNP_GetValidIGD(DevList, @Urls, @Data, Addr(LanAddr[0]), 256);
2397
2398 if I = 0 then
2399 begin
2400 conwriteln('port forwarding failed: could not find an IGD device on this LAN');
2401 FreeUPNPDevList(DevList);
2402 FreeUPNPUrls(@Urls);
2403 exit;
2404 end;
2405
2406 StrPort := IntToStr(NetHost.address.port);
2407 I := UPNP_AddPortMapping(
2408 Urls.controlURL, Addr(data.first.servicetype[1]),
2409 PChar(StrPort), PChar(StrPort), Addr(LanAddr[0]), PChar('D2DF'),
2410 PChar('UDP'), nil, PChar('0')
2411 );
2412
2413 if I <> 0 then
2414 begin
2415 conwritefln('forwarding port %d failed: error %d', [NetHost.address.port, I]);
2416 FreeUPNPDevList(DevList);
2417 FreeUPNPUrls(@Urls);
2418 exit;
2419 end;
2420
2421 if ForwardPongPort then
2422 begin
2423 StrPort := IntToStr(NET_PING_PORT);
2424 I := UPNP_AddPortMapping(
2425 Urls.controlURL, Addr(data.first.servicetype[1]),
2426 PChar(StrPort), PChar(StrPort), Addr(LanAddr[0]), PChar('D2DF'),
2427 PChar('UDP'), nil, PChar('0')
2428 );
2429
2430 if I <> 0 then
2431 begin
2432 conwritefln('forwarding port %d failed: error %d', [NET_PING_PORT, I]);
2433 NetPongForwarded := False;
2434 end
2435 else
2436 begin
2437 conwritefln('forwarded port %d successfully', [NET_PING_PORT]);
2438 NetPongForwarded := True;
2439 end;
2440 end;
2441
2442 conwritefln('forwarded port %d successfully', [NetHost.address.port]);
2443 NetIGDControl := AnsiString(Urls.controlURL);
2444 NetIGDService := data.first.servicetype;
2445 NetPortForwarded := NetHost.address.port;
2446
2447 FreeUPNPDevList(DevList);
2448 FreeUPNPUrls(@Urls);
2449 Result := True;
2450 end;
2451 {$ELSE}
2452 begin
2453 Result := False;
2454 end;
2455 {$ENDIF}
2456
2457 procedure g_Net_UnforwardPorts();
2458 {$IFDEF USE_MINIUPNPC}
2459 var
2460 I: Integer;
2461 StrPort: AnsiString;
2462 begin
2463 if NetPortForwarded = 0 then Exit;
2464
2465 conwriteln('unforwarding ports...');
2466
2467 StrPort := IntToStr(NetPortForwarded);
2468 I := UPNP_DeletePortMapping(
2469 PChar(NetIGDControl), Addr(NetIGDService[1]),
2470 PChar(StrPort), PChar('UDP'), nil
2471 );
2472 conwritefln(' port %d: %d', [NetPortForwarded, I]);
2473
2474 if NetPongForwarded then
2475 begin
2476 NetPongForwarded := False;
2477 StrPort := IntToStr(NET_PING_PORT);
2478 I := UPNP_DeletePortMapping(
2479 PChar(NetIGDControl), Addr(NetIGDService[1]),
2480 PChar(StrPort), PChar('UDP'), nil
2481 );
2482 conwritefln(' port %d: %d', [NET_PING_PORT, I]);
2483 end;
2484
2485 NetPortForwarded := 0;
2486 end;
2487 {$ELSE}
2488 begin
2489 end;
2490 {$ENDIF}
2491
2492 procedure NetServerCVars(P: SSArray);
2493 var
2494 cmd, s: string;
2495 a, b: Integer;
2496 begin
2497 cmd := LowerCase(P[0]);
2498 case cmd of
2499 'sv_name':
2500 begin
2501 if (Length(P) > 1) and (Length(P[1]) > 0) then
2502 begin
2503 NetServerName := P[1];
2504 if Length(NetServerName) > 64 then
2505 SetLength(NetServerName, 64);
2506 g_Net_Slist_ServerRenamed();
2507 end;
2508 g_Console_Add(cmd + ' "' + NetServerName + '"');
2509 end;
2510 'sv_passwd':
2511 begin
2512 if (Length(P) > 1) and (Length(P[1]) > 0) then
2513 begin
2514 NetPassword := P[1];
2515 if Length(NetPassword) > 24 then
2516 SetLength(NetPassword, 24);
2517 g_Net_Slist_ServerRenamed();
2518 end;
2519 g_Console_Add(cmd + ' "' + AnsiLowerCase(NetPassword) + '"');
2520 end;
2521 'sv_maxplrs':
2522 begin
2523 if (Length(P) > 1) then
2524 begin
2525 NetMaxClients := nclamp(StrToIntDef(P[1], NetMaxClients), 1, NET_MAXCLIENTS);
2526 if g_Game_IsServer and g_Game_IsNet then
2527 begin
2528 b := 0;
2529 for a := 0 to High(NetClients) do
2530 begin
2531 if NetClients[a].Used then
2532 begin
2533 Inc(b);
2534 if b > NetMaxClients then
2535 begin
2536 s := g_Player_Get(NetClients[a].Player).Name;
2537 enet_peer_disconnect(NetClients[a].Peer, NET_DISC_FULL);
2538 g_Console_Add(Format(_lc[I_PLAYER_KICK], [s]));
2539 MH_SEND_GameEvent(NET_EV_PLAYER_KICK, 0, s);
2540 end;
2541 end;
2542 end;
2543 g_Net_Slist_ServerRenamed();
2544 end;
2545 end;
2546 g_Console_Add(cmd + ' ' + IntToStr(NetMaxClients));
2547 end;
2548 'sv_public':
2549 begin
2550 if (Length(P) > 1) then
2551 begin
2552 NetUseMaster := StrToIntDef(P[1], Byte(NetUseMaster)) <> 0;
2553 if NetUseMaster then g_Net_Slist_Public() else g_Net_Slist_Private();
2554 end;
2555 g_Console_Add(cmd + ' ' + IntToStr(Byte(NetUseMaster)));
2556 end;
2557 'sv_port':
2558 begin
2559 if (Length(P) > 1) then
2560 begin
2561 if not g_Game_IsNet then
2562 NetPort := nclamp(StrToIntDef(P[1], NetPort), 0, $FFFF)
2563 else
2564 g_Console_Add(_lc[I_MSG_NOT_NETGAME]);
2565 end;
2566 g_Console_Add(cmd + ' ' + IntToStr(Ord(NetUseMaster)));
2567 end;
2568 end;
2569 end;
2570
2571 initialization
2572 conRegVar('cl_downloadtimeout', @g_Net_DownloadTimeout, 0.0, 1000000.0, '', 'timeout in seconds, 0 to disable it');
2573 conRegVar('cl_predictself', @NetPredictSelf, '', 'predict local player');
2574 conRegVar('cl_forceplayerupdate', @NetForcePlayerUpdate, '', 'update net players on NET_MSG_PLRPOS');
2575 conRegVar('cl_interp', @NetInterpLevel, '', 'net player interpolation steps');
2576 conRegVar('cl_last_ip', @NetClientIP, '', 'address of the last you have connected to');
2577 conRegVar('cl_last_port', @NetClientPort, '', 'port of the last server you have connected to');
2578 conRegVar('cl_deafen', @NetDeafLevel, '', 'filter server messages (0-3)');
2579
2580 conRegVar('sv_forwardports', @NetForwardPorts, '', 'forward server port using miniupnpc (requires server restart)');
2581 conRegVar('sv_rcon', @NetAllowRCON, '', 'enable remote console');
2582 conRegVar('sv_rcon_password', @NetRCONPassword, '', 'remote console password');
2583 conRegVar('sv_update_interval', @NetUpdateRate, '', 'unreliable update interval');
2584 conRegVar('sv_reliable_interval', @NetRelupdRate, '', 'reliable update interval');
2585 conRegVar('sv_master_interval', @NetMasterRate, '', 'master server update interval');
2586
2587 conRegVar('sv_autoban_threshold', @NetAutoBanLimit, '', 'max crimes before autoban (0 = no autoban)');
2588 conRegVar('sv_autoban_permanent', @NetAutoBanPerm, '', 'whether autobans are permanent');
2589 conRegVar('sv_autoban_warn', @NetAutoBanWarn, '', 'send warnings to the client when he triggers penalties');
2590 conRegVar('sv_autoban_packet_timeout', @NetAutoBanForTimeout, '', 'autoban for packet timeouts');
2591
2592 conRegVar('sv_auth_timeout', @NetAuthTimeout, '', 'number of msec in which connecting clients must complete auth (0 = unlimited)');
2593 conRegVar('sv_packet_timeout', @NetPacketTimeout, '', 'number of msec the client must idle to be kicked (0 = unlimited)');
2594
2595 conRegVar('net_master_list', @NetMasterList, '', 'list of master servers');
2596
2597 SetLength(NetClients, 0);
2598 g_Net_DownloadTimeout := 60;
2599 NetIn.Alloc(NET_BUFSIZE);
2600 NetOut.Alloc(NET_BUFSIZE);
2601 NetBuf[NET_UNRELIABLE].Alloc(NET_BUFSIZE*2);
2602 NetBuf[NET_RELIABLE].Alloc(NET_BUFSIZE*2);
2603 trans_omsg.Alloc(NET_BUFSIZE);
2604 finalization
2605 NetIn.Free();
2606 NetOut.Free();
2607 NetBuf[NET_UNRELIABLE].Free();
2608 NetBuf[NET_RELIABLE].Free();
2609 end.
[MIRROR] a port of Doom 2D Forever to FPC/SDL
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024