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 = 187;
  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
 164   NetAuthTimeout:   Integer = 36 * 15;
 165   NetPacketTimeout: Integer = 36 * 30;
 166
 167   NetState:      Integer = NET_STATE_NONE;
 168
 169   NetMyID:       Integer = -1;
 170   NetPlrUID1:    Integer = -1;
 171   NetPlrUID2:    Integer = -1;
 172
 173   NetInterpLevel: Integer = 1;
 174   NetUpdateRate:  Cardinal = 0;  // as soon as possible
 175   NetRelupdRate:  Cardinal = 18; // around two times a second
 176   NetMasterRate:  Cardinal = 60000;
 177
 178   NetForcePlayerUpdate: Boolean = False;
 179   NetPredictSelf:       Boolean = True;
 180   NetForwardPorts:      Boolean = False;
 181
 182   NetGotEverything: Boolean = False;
 183   NetGotKeys:       Boolean = False;
 184
 185   NetDeafLevel: Integer = 0;
 186
 187 {$IFDEF USE_MINIUPNPC}
 188   NetPortForwarded: Word = 0;
 189   NetPongForwarded: Boolean = False;
 190   NetIGDControl: AnsiString;
 191   NetIGDService: TURLStr;
 192 {$ENDIF}
 193
 194   NetPortThread: TThreadID = NilThreadId;
 195
 196   NetDumpFile: TStream;
 197
 198   g_Res_received_map_start: Integer = 0; // set if we received "map change" event
 199
 200
 201 function  g_Net_Init(): Boolean;
 202 procedure g_Net_Cleanup();
 203 procedure g_Net_Free();
 204 procedure g_Net_Flush();
 205
 206 function  g_Net_Host(IPAddr: LongWord; Port: enet_uint16; MaxClients: Cardinal = 16): Boolean;
 207 procedure g_Net_Host_Die();
 208 procedure g_Net_Host_Send(ID: Integer; Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
 209 function  g_Net_Host_Update(): enet_size_t;
 210
 211 function  g_Net_Connect(IP: string; Port: enet_uint16): Boolean;
 212 procedure g_Net_Disconnect(Forced: Boolean = False);
 213 procedure g_Net_Client_Send(Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
 214 function  g_Net_Client_Update(): enet_size_t;
 215 function  g_Net_Client_UpdateWhileLoading(): enet_size_t;
 216
 217 function  g_Net_Client_ByName(Name: string): pTNetClient;
 218 function  g_Net_Client_ByPlayer(PID: Word): pTNetClient;
 219 function  g_Net_ClientName_ByID(ID: Integer): string;
 220
 221 procedure g_Net_SendData(Data: AByte; peer: pENetPeer; Reliable: Boolean; Chan: Byte = NET_CHAN_DOWNLOAD);
 222 //function  g_Net_Wait_Event(msgId: Word): TMemoryStream;
 223 //function g_Net_Wait_FileInfo (var tf: TNetFileTransfer; asMap: Boolean; out resList: TStringList): Integer;
 224
 225 function  IpToStr(IP: LongWord): string;
 226 function  StrToIp(IPstr: string; var IP: LongWord): Boolean;
 227
 228 function  g_Net_IsHostBanned(IP: LongWord; Perm: Boolean = False): Boolean;
 229 procedure g_Net_BanHost(IP: LongWord; Perm: Boolean = True); overload;
 230 procedure g_Net_BanHost(IP: string; Perm: Boolean = True); overload;
 231 function  g_Net_UnbanHost(IP: string): Boolean; overload;
 232 function  g_Net_UnbanHost(IP: LongWord): Boolean; overload;
 233 procedure g_Net_UnbanNonPermHosts();
 234 procedure g_Net_SaveBanList();
 235
 236 procedure g_Net_Penalize(C: pTNetClient; Reason: string);
 237
 238 procedure g_Net_DumpStart();
 239 procedure g_Net_DumpSendBuffer();
 240 procedure g_Net_DumpRecvBuffer(Buf: penet_uint8; Len: LongWord);
 241 procedure g_Net_DumpEnd();
 242
 243 function g_Net_ForwardPorts(ForwardPongPort: Boolean = True): Boolean;
 244 procedure g_Net_UnforwardPorts();
 245
 246 function g_Net_UserRequestExit: Boolean;
 247
 248 function g_Net_Wait_MapInfo (var tf: TNetFileTransfer; var resList: TNetMapResourceInfoArray): Integer;
 249 function g_Net_RequestResFileInfo (resIndex: LongInt; out tf: TNetFileTransfer): Integer;
 250 function g_Net_AbortResTransfer (var tf: TNetFileTransfer): Boolean;
 251 function g_Net_ReceiveResourceFile (resIndex: LongInt; var tf: TNetFileTransfer; strm: TStream): Integer;
 252
 253 function g_Net_IsNetworkAvailable (): Boolean;
 254 procedure g_Net_InitLowLevel ();
 255 procedure g_Net_DeinitLowLevel ();
 256
 257 procedure NetServerCVars(P: SSArray);
 258
 259
 260 implementation
 261
 262 // *enet_host_service()*
 263 // fuck! https://www.mail-archive.com/enet-discuss@cubik.org/msg00852.html
 264 // tl;dr: on shitdows, we can get -1 sometimes, and it is *NOT* a failure.
 265 //        thank you, enet. let's ignore failures altogether then.
 266
 267 uses
 268   SysUtils,
 269   e_input, e_res,
 270   g_nethandler, g_netmsg, g_netmaster, g_player, g_window, g_console,
 271   g_main, g_game, g_language, g_weapons, ctypes, g_system, g_map;
 272
 273 const
 274   FILE_CHUNK_SIZE = 8192;
 275
 276 var
 277   enet_init_success: Boolean = false;
 278   g_Net_DownloadTimeout: Single;
 279   trans_omsg: TMsg;
 280
 281
 282 function g_Net_IsNetworkAvailable (): Boolean;
 283 begin
 284   result := enet_init_success;
 285 end;
 286
 287 procedure g_Net_InitLowLevel ();
 288   var v: ENetVersion;
 289 begin
 290   v := enet_linked_version();
 291   e_LogWritefln('ENet Version: %s.%s.%s', [ENET_VERSION_GET_MAJOR(v), ENET_VERSION_GET_MINOR(v), ENET_VERSION_GET_PATCH(v)]);
 292   if enet_init_success then raise Exception.Create('wuta?!');
 293   enet_init_success := (enet_initialize() = 0);
 294 end;
 295
 296 procedure g_Net_DeinitLowLevel ();
 297 begin
 298   if enet_init_success then
 299   begin
 300     enet_deinitialize();
 301     enet_init_success := false;
 302   end;
 303 end;
 304
 305
 306 //**************************************************************************
 307 //
 308 // SERVICE FUNCTIONS
 309 //
 310 //**************************************************************************
 311
 312 procedure clearNetClientTransfers (var nc: TNetClient);
 313 begin
 314   nc.Transfer.stream.Free;
 315   nc.Transfer.diskName := ''; // just in case
 316   if (nc.Transfer.diskBuffer <> nil) then FreeMem(nc.Transfer.diskBuffer);
 317   nc.Transfer.stream := nil;
 318   nc.Transfer.diskBuffer := nil;
 319 end;
 320
 321
 322 procedure clearNetClient (var nc: TNetClient);
 323 begin
 324   clearNetClientTransfers(nc);
 325 end;
 326
 327
 328 procedure clearNetClients (clearArray: Boolean);
 329 var
 330   f: Integer;
 331 begin
 332   for f := Low(NetClients) to High(NetClients) do clearNetClient(NetClients[f]);
 333   if (clearArray) then SetLength(NetClients, 0);
 334 end;
 335
 336
 337 function g_Net_UserRequestExit (): Boolean;
 338 begin
 339   Result := {e_KeyPressed(IK_SPACE) or}
 340             e_KeyPressed(IK_ESCAPE) or
 341             e_KeyPressed(VK_ESCAPE) or
 342             e_KeyPressed(JOY0_JUMP) or
 343             e_KeyPressed(JOY1_JUMP) or
 344             e_KeyPressed(JOY2_JUMP) or
 345             e_KeyPressed(JOY3_JUMP)
 346 end;
 347
 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_CheckPings();
1628 var
1629   ClAddr: ENetAddress;
1630   Buf: ENetBuffer;
1631   Len: Integer;
1632   ClTime: Int64;
1633   Ping: array [0..9] of Byte;
1634   NPl: Byte;
1635 begin
1636   if (NetPongSock = ENET_SOCKET_NULL) or (NetHost = nil) then Exit;
1637
1638   Buf.data := Addr(Ping[0]);
1639   Buf.dataLength := 2+8;
1640
1641   Ping[0] := 0;
1642
1643   Len := enet_socket_receive(NetPongSock, @ClAddr, @Buf, 1);
1644   if Len < 0 then Exit;
1645
1646   if (Ping[0] = Ord('D')) and (Ping[1] = Ord('F')) then
1647   begin
1648     ClTime := Int64(Addr(Ping[2])^);
1649
1650     NetOut.Clear();
1651     NetOut.Write(Byte(Ord('D')));
1652     NetOut.Write(Byte(Ord('F')));
1653     NetOut.Write(NetHost.address.port);
1654     NetOut.Write(ClTime);
1655     TMasterHost.writeInfo(NetOut);
1656     NPl := 0;
1657     if gPlayer1 <> nil then Inc(NPl);
1658     if gPlayer2 <> nil then Inc(NPl);
1659     NetOut.Write(NPl);
1660     NetOut.Write(gNumBots);
1661
1662     Buf.data := NetOut.Data;
1663     Buf.dataLength := NetOut.CurSize;
1664     enet_socket_send(NetPongSock, @ClAddr, @Buf, 1);
1665
1666     NetOut.Clear();
1667   end;
1668 end;
1669
1670 procedure g_Net_Host_CheckTimeouts();
1671 var
1672   ID: Integer;
1673 begin
1674   // auth timeout
1675   for ID := Low(NetClients) to High(NetClients) do
1676   begin
1677     with NetClients[ID] do
1678     begin
1679       if (Peer = nil) or (State = NET_STATE_NONE) then continue;
1680       if (State = NET_STATE_AUTH) and (AuthTime > 0) and (AuthTime <= gTime) then
1681       begin
1682         g_Net_Penalize(@NetClients[ID], 'auth taking too long');
1683         AuthTime := gTime + 18; // do it twice a second to give them a chance
1684       end
1685       else if (State = NET_STATE_GAME) and (MsgTime > 0) and (MsgTime <= gTime) then
1686       begin
1687         g_Net_Penalize(@NetClients[ID], 'message timeout');
1688         AuthTime := gTime + 18; // do it twice a second to give them a chance
1689       end;
1690     end;
1691   end;
1692
1693
1694 end;
1695
1696
1697 function g_Net_Host_Update(): enet_size_t;
1698 var
1699   IP: string;
1700   Port: Word;
1701   ID: Integer;
1702   TC: pTNetClient;
1703   TP: TPlayer;
1704 begin
1705   IP := '';
1706   Result := 0;
1707
1708   if NetUseMaster then g_Net_Slist_Pulse();
1709   g_Net_Host_CheckPings();
1710   g_Net_Host_CheckTimeouts();
1711
1712   while (enet_host_service(NetHost, @NetEvent, 0) > 0) do
1713   begin
1714     case (NetEvent.kind) of
1715       ENET_EVENT_TYPE_CONNECT:
1716       begin
1717         IP := IpToStr(NetEvent.Peer^.address.host);
1718         Port := NetEvent.Peer^.address.port;
1719         g_Console_Add(_lc[I_NET_MSG] +
1720           Format(_lc[I_NET_MSG_HOST_CONN], [IP, Port]));
1721         e_WriteLog('NET: Connection request from ' + IP + '.', TMsgType.Notify);
1722
1723         if (NetEvent.data <> NET_PROTOCOL_VER) then
1724         begin
1725           g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
1726             _lc[I_NET_DISC_PROTOCOL]);
1727           e_WriteLog('NET: Connection request from ' + IP + ' rejected: version mismatch',
1728             TMsgType.Notify);
1729           NetEvent.peer^.data := GetMemory(SizeOf(Byte));
1730           Byte(NetEvent.peer^.data^) := 255;
1731           enet_peer_disconnect(NetEvent.peer, NET_DISC_PROTOCOL);
1732           enet_host_flush(NetHost);
1733           Exit;
1734         end;
1735
1736         if g_Net_IsHostBanned(NetEvent.Peer^.address.host) then
1737         begin
1738           g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
1739             _lc[I_NET_DISC_BAN]);
1740           e_WriteLog('NET: Connection request from ' + IP + ' rejected: banned',
1741             TMsgType.Notify);
1742           NetEvent.peer^.data := GetMemory(SizeOf(Byte));
1743           Byte(NetEvent.peer^.data^) := 255;
1744           enet_peer_disconnect(NetEvent.Peer, NET_DISC_BAN);
1745           enet_host_flush(NetHost);
1746           Exit;
1747         end;
1748
1749         ID := g_Net_FindSlot();
1750
1751         if ID < 0 then
1752         begin
1753           g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
1754             _lc[I_NET_DISC_FULL]);
1755           e_WriteLog('NET: Connection request from ' + IP + ' rejected: server full',
1756             TMsgType.Notify);
1757           NetEvent.Peer^.data := GetMemory(SizeOf(Byte));
1758           Byte(NetEvent.peer^.data^) := 255;
1759           enet_peer_disconnect(NetEvent.peer, NET_DISC_FULL);
1760           enet_host_flush(NetHost);
1761           Exit;
1762         end;
1763
1764         NetClients[ID].Peer := NetEvent.peer;
1765         NetClients[ID].Peer^.data := GetMemory(SizeOf(Byte));
1766         Byte(NetClients[ID].Peer^.data^) := ID;
1767         NetClients[ID].State := NET_STATE_AUTH;
1768         NetClients[ID].Player := 0;
1769         NetClients[ID].Crimes := 0;
1770         NetClients[ID].RCONAuth := False;
1771         NetClients[ID].NetOut[NET_UNRELIABLE].Alloc(NET_BUFSIZE*2);
1772         NetClients[ID].NetOut[NET_RELIABLE].Alloc(NET_BUFSIZE*2);
1773         if (NetAuthTimeout > 0) then
1774           NetClients[ID].AuthTime := gTime + NetAuthTimeout
1775         else
1776           NetClients[ID].AuthTime := 0;
1777         if (NetPacketTimeout > 0) then
1778           NetClients[ID].MsgTime := gTime + NetPacketTimeout
1779         else
1780           NetClients[ID].MsgTime := 0;
1781         clearNetClientTransfers(NetClients[ID]); // just in case
1782
1783         enet_peer_timeout(NetEvent.peer, ENET_PEER_TIMEOUT_LIMIT * 2, ENET_PEER_TIMEOUT_MINIMUM * 2, ENET_PEER_TIMEOUT_MAXIMUM * 2);
1784
1785         Inc(NetClientCount);
1786         g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_HOST_ADD], [ID]));
1787       end;
1788
1789       ENET_EVENT_TYPE_RECEIVE:
1790       begin
1791         //e_LogWritefln('RECEIVE: chan=%u', [NetEvent.channelID]);
1792         if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then
1793         begin
1794           ProcessDownloadExPacket();
1795         end
1796         else
1797         begin
1798           ID := Byte(NetEvent.peer^.data^);
1799           if ID > High(NetClients) then Exit;
1800           TC := @NetClients[ID];
1801
1802           if (NetPacketTimeout > 0) then
1803             TC^.MsgTime := gTime + NetPacketTimeout;
1804
1805           if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
1806           g_Net_Host_HandlePacket(TC, NetEvent.packet, g_Net_HostMsgHandler);
1807         end;
1808       end;
1809
1810       ENET_EVENT_TYPE_DISCONNECT:
1811       begin
1812         ID := Byte(NetEvent.peer^.data^);
1813         if ID > High(NetClients) then Exit;
1814         clearNetClient(NetClients[ID]);
1815         TC := @NetClients[ID];
1816         if TC = nil then Exit;
1817
1818         if not (TC^.Used) then Exit;
1819
1820         TP := g_Player_Get(TC^.Player);
1821
1822         if TP <> nil then
1823         begin
1824           TP.Lives := 0;
1825           TP.Kill(K_SIMPLEKILL, 0, HIT_DISCON);
1826           g_Console_Add(Format(_lc[I_PLAYER_LEAVE], [TP.Name]), True);
1827           e_WriteLog('NET: Client ' + TP.Name + ' [' + IntToStr(ID) + '] disconnected.', TMsgType.Notify);
1828           g_Player_Remove(TP.UID);
1829         end;
1830
1831         TC^.Used := False;
1832         TC^.State := NET_STATE_NONE;
1833         TC^.Peer := nil;
1834         TC^.Player := 0;
1835         TC^.Crimes := 0;
1836         TC^.AuthTime := 0;
1837         TC^.MsgTime := 0;
1838         TC^.RequestedFullUpdate := False;
1839         TC^.WaitForFirstSpawn := False;
1840         TC^.NetOut[NET_UNRELIABLE].Free();
1841         TC^.NetOut[NET_RELIABLE].Free();
1842
1843         FreeMemory(NetEvent.peer^.data);
1844         NetEvent.peer^.data := nil;
1845         g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_HOST_DISC], [ID]));
1846         Dec(NetClientCount);
1847
1848         if NetUseMaster then g_Net_Slist_ServerPlayerLeaves();
1849       end;
1850     end;
1851   end;
1852 end;
1853
1854
1855 //**************************************************************************
1856 //
1857 // CLIENT FUNCTIONS
1858 //
1859 //**************************************************************************
1860
1861 procedure g_Net_Disconnect(Forced: Boolean = False);
1862 begin
1863   if NetMode <> NET_CLIENT then Exit;
1864   if (NetHost = nil) or (NetPeer = nil) then Exit;
1865
1866   if not Forced then
1867   begin
1868     enet_peer_disconnect(NetPeer, NET_DISC_NONE);
1869
1870     while (enet_host_service(NetHost, @NetEvent, 1500) > 0) do
1871     begin
1872       if (NetEvent.kind = ENET_EVENT_TYPE_DISCONNECT) then
1873       begin
1874         NetPeer := nil;
1875         break;
1876       end;
1877
1878       if (NetEvent.kind = ENET_EVENT_TYPE_RECEIVE) then
1879         enet_packet_destroy(NetEvent.packet);
1880     end;
1881
1882     if NetPeer <> nil then
1883     begin
1884       enet_peer_reset(NetPeer);
1885       NetPeer := nil;
1886     end;
1887   end
1888   else
1889   begin
1890     e_WriteLog('NET: Kicked from server: ' + IntToStr(NetEvent.data), TMsgType.Notify);
1891     if (NetEvent.data <= NET_DISC_MAX) then
1892       g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_KICK] +
1893         _lc[TStrings_Locale(Cardinal(I_NET_DISC_NONE) + NetEvent.data)], True);
1894   end;
1895
1896   if NetHost <> nil then
1897   begin
1898     enet_host_destroy(NetHost);
1899     NetHost := nil;
1900   end;
1901   g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_CLIENT_DISC]);
1902
1903   g_Net_Cleanup;
1904   e_WriteLog('NET: Disconnected', TMsgType.Notify);
1905 end;
1906
1907 procedure g_Net_Client_Send(Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
1908 var
1909   T: Integer;
1910 begin
1911   if (Reliable) then
1912     T := NET_RELIABLE
1913   else
1914     T := NET_UNRELIABLE;
1915
1916   // write size first
1917   NetBuf[T].Write(Integer(NetOut.CurSize));
1918   NetBuf[T].Write(NetOut);
1919
1920   if NetDump then g_Net_DumpSendBuffer();
1921   NetOut.Clear();
1922   g_Net_Flush(); // FIXME: for now, send immediately
1923 end;
1924
1925 function g_Net_Client_Update(): enet_size_t;
1926 begin
1927   Result := 0;
1928   while (NetHost <> nil) and (enet_host_service(NetHost, @NetEvent, 0) > 0) do
1929   begin
1930     case NetEvent.kind of
1931       ENET_EVENT_TYPE_RECEIVE:
1932       begin
1933         if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then continue; // ignore all download packets, they're processed by separate code
1934         if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
1935         g_Net_Client_HandlePacket(NetEvent.packet, g_Net_ClientMsgHandler);
1936       end;
1937
1938       ENET_EVENT_TYPE_DISCONNECT:
1939       begin
1940         g_Net_Disconnect(True);
1941         Result := 1;
1942         Exit;
1943       end;
1944     end;
1945   end
1946 end;
1947
1948 function g_Net_Client_UpdateWhileLoading(): enet_size_t;
1949 begin
1950   Result := 0;
1951   while (enet_host_service(NetHost, @NetEvent, 0) > 0) do
1952   begin
1953     case NetEvent.kind of
1954       ENET_EVENT_TYPE_RECEIVE:
1955       begin
1956         if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then continue; // ignore all download packets, they're processed by separate code
1957         if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
1958         g_Net_Client_HandlePacket(NetEvent.packet, g_Net_ClientLightMsgHandler);
1959       end;
1960
1961       ENET_EVENT_TYPE_DISCONNECT:
1962       begin
1963         g_Net_Disconnect(True);
1964         Result := 1;
1965         Exit;
1966       end;
1967     end;
1968   end;
1969   g_Net_Flush();
1970 end;
1971
1972 function g_Net_Connect(IP: string; Port: enet_uint16): Boolean;
1973 var
1974   OuterLoop: Boolean;
1975   TimeoutTime, T: Int64;
1976 begin
1977   if NetMode <> NET_NONE then
1978   begin
1979     g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_ERR_INGAME], True);
1980     Result := False;
1981     Exit;
1982   end;
1983
1984   Result := True;
1985
1986   g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_CLIENT_CONN],
1987     [IP, Port]));
1988   if not NetInitDone then
1989   begin
1990     if (not g_Net_Init()) then
1991     begin
1992       g_Console_Add(_lc[I_NET_MSG_FERROR] + _lc[I_NET_ERR_ENET], True);
1993       Result := False;
1994       Exit;
1995     end
1996     else
1997       NetInitDone := True;
1998   end;
1999
2000   NetHost := enet_host_create(nil, 1, NET_CHANS, 0, 0);
2001
2002   if (NetHost = nil) then
2003   begin
2004     g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CLIENT], True);
2005     g_Net_Cleanup;
2006     Result := False;
2007     Exit;
2008   end;
2009
2010   enet_address_set_host(@NetAddr, PChar(Addr(IP[1])));
2011   NetAddr.port := Port;
2012
2013   NetPeer := enet_host_connect(NetHost, @NetAddr, NET_CHANS, NET_PROTOCOL_VER);
2014
2015   if (NetPeer = nil) then
2016   begin
2017     g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CLIENT], True);
2018     enet_host_destroy(NetHost);
2019     g_Net_Cleanup;
2020     Result := False;
2021     Exit;
2022   end;
2023
2024   // предупредить что ждем слишком долго через N секунд
2025   TimeoutTime := sys_GetTicks() + NET_CONNECT_TIMEOUT;
2026
2027   OuterLoop := True;
2028   while OuterLoop do
2029   begin
2030     while (enet_host_service(NetHost, @NetEvent, 0) > 0) do
2031     begin
2032       if (NetEvent.kind = ENET_EVENT_TYPE_CONNECT) then
2033       begin
2034         g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_CLIENT_DONE]);
2035         NetMode := NET_CLIENT;
2036         NetOut.Clear();
2037         enet_peer_timeout(NetPeer, ENET_PEER_TIMEOUT_LIMIT * 2, ENET_PEER_TIMEOUT_MINIMUM * 2, ENET_PEER_TIMEOUT_MAXIMUM * 2);
2038         NetClientIP := IP;
2039         NetClientPort := Port;
2040         if NetDump then
2041           g_Net_DumpStart();
2042         Exit;
2043       end;
2044     end;
2045
2046     T := sys_GetTicks();
2047     if T > TimeoutTime then
2048     begin
2049       TimeoutTime := T + NET_CONNECT_TIMEOUT * 100; // одного предупреждения хватит
2050       g_Console_Add(_lc[I_NET_MSG_TIMEOUT_WARN], True);
2051       g_Console_Add(Format(_lc[I_NET_MSG_PORTS], [Integer(Port), Integer(NET_PING_PORT)]), True);
2052     end;
2053
2054     ProcessLoading(true);
2055
2056     if e_KeyPressed(IK_SPACE) or e_KeyPressed(IK_ESCAPE) or e_KeyPressed(VK_ESCAPE) or
2057        e_KeyPressed(JOY0_JUMP) or e_KeyPressed(JOY1_JUMP) or e_KeyPressed(JOY2_JUMP) or e_KeyPressed(JOY3_JUMP) then
2058       OuterLoop := False;
2059   end;
2060
2061   g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_TIMEOUT], True);
2062   g_Console_Add(Format(_lc[I_NET_MSG_PORTS], [Integer(Port), Integer(NET_PING_PORT)]), True);
2063   if NetPeer <> nil then enet_peer_reset(NetPeer);
2064   if NetHost <> nil then
2065   begin
2066     enet_host_destroy(NetHost);
2067     NetHost := nil;
2068   end;
2069   g_Net_Cleanup();
2070   Result := False;
2071 end;
2072
2073 function IpToStr(IP: LongWord): string;
2074 var
2075   Ptr: Pointer;
2076 begin
2077   Ptr := Addr(IP);
2078   Result :=          IntToStr(PByte(Ptr + 0)^) + '.';
2079   Result := Result + IntToStr(PByte(Ptr + 1)^) + '.';
2080   Result := Result + IntToStr(PByte(Ptr + 2)^) + '.';
2081   Result := Result + IntToStr(PByte(Ptr + 3)^);
2082 end;
2083
2084 function StrToIp(IPstr: string; var IP: LongWord): Boolean;
2085 var
2086   EAddr: ENetAddress;
2087 begin
2088   Result := enet_address_set_host(@EAddr, PChar(@IPstr[1])) = 0;
2089   IP := EAddr.host;
2090 end;
2091
2092 function g_Net_Client_ByName(Name: string): pTNetClient;
2093 var
2094   a: Integer;
2095   pl: TPlayer;
2096 begin
2097   Result := nil;
2098   for a := Low(NetClients) to High(NetClients) do
2099     if (NetClients[a].Used) and (NetClients[a].State = NET_STATE_GAME) then
2100     begin
2101       pl := g_Player_Get(NetClients[a].Player);
2102       if pl = nil then continue;
2103       if Copy(LowerCase(pl.Name), 1, Length(Name)) <> LowerCase(Name) then continue;
2104       if NetClients[a].Peer <> nil then
2105       begin
2106         Result := @NetClients[a];
2107         Exit;
2108       end;
2109     end;
2110 end;
2111
2112 function g_Net_Client_ByPlayer(PID: Word): pTNetClient;
2113 var
2114   a: Integer;
2115 begin
2116   Result := nil;
2117   for a := Low(NetClients) to High(NetClients) do
2118     if (NetClients[a].Used) and (NetClients[a].State = NET_STATE_GAME) then
2119       if NetClients[a].Player = PID then
2120       begin
2121         Result := @NetClients[a];
2122         Exit;
2123       end;
2124 end;
2125
2126 function g_Net_ClientName_ByID(ID: Integer): string;
2127 var
2128   a: Integer;
2129   pl: TPlayer;
2130 begin
2131   Result := '';
2132   if ID = NET_EVERYONE then
2133     Exit;
2134   for a := Low(NetClients) to High(NetClients) do
2135     if (NetClients[a].ID = ID) and (NetClients[a].Used) and (NetClients[a].State = NET_STATE_GAME) then
2136     begin
2137       pl := g_Player_Get(NetClients[a].Player);
2138       if pl = nil then Exit;
2139       Result := pl.Name;
2140     end;
2141 end;
2142
2143 procedure g_Net_SendData(Data: AByte; peer: pENetPeer; Reliable: Boolean; Chan: Byte = NET_CHAN_DOWNLOAD);
2144 var
2145   P: pENetPacket;
2146   F: enet_uint32;
2147   dataLength: Cardinal;
2148 begin
2149   dataLength := Length(Data);
2150
2151   if (Reliable) then
2152     F := LongWord(ENET_PACKET_FLAG_RELIABLE)
2153   else
2154     F := 0;
2155
2156   if (peer <> nil) then
2157   begin
2158     P := enet_packet_create(@Data[0], dataLength, F);
2159     if not Assigned(P) then Exit;
2160     enet_peer_send(peer, Chan, P);
2161   end
2162   else
2163   begin
2164     P := enet_packet_create(@Data[0], dataLength, F);
2165     if not Assigned(P) then Exit;
2166     enet_host_broadcast(NetHost, Chan, P);
2167   end;
2168
2169   enet_host_flush(NetHost);
2170 end;
2171
2172 function g_Net_IsHostBanned(IP: LongWord; Perm: Boolean = False): Boolean;
2173 var
2174   I: Integer;
2175 begin
2176   Result := False;
2177   if NetBannedHosts = nil then
2178     Exit;
2179   for I := 0 to High(NetBannedHosts) do
2180     if (NetBannedHosts[I].IP = IP) and ((not Perm) or (NetBannedHosts[I].Perm)) then
2181     begin
2182       Result := True;
2183       break;
2184     end;
2185 end;
2186
2187 procedure g_Net_BanHost(IP: LongWord; Perm: Boolean = True); overload;
2188 var
2189   I, P: Integer;
2190 begin
2191   if IP = 0 then
2192     Exit;
2193   if g_Net_IsHostBanned(IP, Perm) then
2194     Exit;
2195
2196   P := -1;
2197   for I := Low(NetBannedHosts) to High(NetBannedHosts) do
2198     if NetBannedHosts[I].IP = 0 then
2199     begin
2200       P := I;
2201       break;
2202     end;
2203
2204   if P < 0 then
2205   begin
2206     SetLength(NetBannedHosts, Length(NetBannedHosts) + 1);
2207     P := High(NetBannedHosts);
2208   end;
2209
2210   NetBannedHosts[P].IP := IP;
2211   NetBannedHosts[P].Perm := Perm;
2212 end;
2213
2214 procedure g_Net_BanHost(IP: string; Perm: Boolean = True); overload;
2215 var
2216   a: LongWord;
2217   b: Boolean;
2218 begin
2219   b := StrToIp(IP, a);
2220   if b then
2221     g_Net_BanHost(a, Perm);
2222 end;
2223
2224 procedure g_Net_UnbanNonPermHosts();
2225 var
2226   I: Integer;
2227 begin
2228   if NetBannedHosts = nil then
2229     Exit;
2230   for I := Low(NetBannedHosts) to High(NetBannedHosts) do
2231     if (NetBannedHosts[I].IP > 0) and not NetBannedHosts[I].Perm then
2232     begin
2233       NetBannedHosts[I].IP := 0;
2234       NetBannedHosts[I].Perm := True;
2235     end;
2236 end;
2237
2238 function g_Net_UnbanHost(IP: string): Boolean; overload;
2239 var
2240   a: LongWord;
2241 begin
2242   Result := StrToIp(IP, a);
2243   if Result then
2244     Result := g_Net_UnbanHost(a);
2245 end;
2246
2247 function g_Net_UnbanHost(IP: LongWord): Boolean; overload;
2248 var
2249   I: Integer;
2250 begin
2251   Result := False;
2252   if IP = 0 then
2253     Exit;
2254   if NetBannedHosts = nil then
2255     Exit;
2256   for I := 0 to High(NetBannedHosts) do
2257     if NetBannedHosts[I].IP = IP then
2258     begin
2259       NetBannedHosts[I].IP := 0;
2260       NetBannedHosts[I].Perm := True;
2261       Result := True;
2262       // no break here to clear all bans of this host, perm and non-perm
2263     end;
2264 end;
2265
2266 procedure g_Net_SaveBanList();
2267 var
2268   F: TextFile;
2269   I: Integer;
2270   path: AnsiString;
2271 begin
2272   path := e_GetWriteableDir(DataDirs);
2273   if path <> '' then
2274   begin
2275     path := e_CatPath(path, BANLIST_FILENAME);
2276     Assign(F, path);
2277     Rewrite(F);
2278     if NetBannedHosts <> nil then
2279       for I := 0 to High(NetBannedHosts) do
2280         if NetBannedHosts[I].Perm and (NetBannedHosts[I].IP > 0) then
2281           Writeln(F, IpToStr(NetBannedHosts[I].IP));
2282     CloseFile(F)
2283   end
2284 end;
2285
2286 procedure g_Net_Penalize(C: pTNetClient; Reason: string);
2287 var
2288   s: string;
2289 begin
2290   e_LogWritefln('NET: client #%u (cid #%u) triggered a penalty (%d/%d): %s',
2291     [C^.ID, C^.Player, C^.Crimes, NetAutoBanLimit, Reason]);
2292
2293   if (NetAutoBanLimit <= 0) then Exit;
2294
2295   Inc(C^.Crimes);
2296
2297   if (NetAutoBanWarn) then
2298     MH_SEND_Chat('You have been warned by the server: ' + Reason, NET_CHAT_SYSTEM, C^.ID);
2299
2300   if (C^.Crimes >= NetAutoBanLimit) then
2301   begin
2302     s := '#' + IntToStr(C^.ID); // can't be arsed
2303     g_Net_BanHost(C^.Peer^.address.host, NetAutoBanPerm);
2304     enet_peer_disconnect(C^.Peer, NET_DISC_BAN);
2305     g_Console_Add(Format(_lc[I_PLAYER_BAN], [s]));
2306     MH_SEND_GameEvent(NET_EV_PLAYER_BAN, 0, s);
2307     g_Net_Slist_ServerPlayerLeaves();
2308   end;
2309 end;
2310
2311 procedure g_Net_DumpStart();
2312 begin
2313   if NetMode = NET_SERVER then
2314     NetDumpFile := e_CreateResource(LogDirs, NETDUMP_FILENAME + '_server')
2315   else
2316     NetDumpFile := e_CreateResource(LogDirs, NETDUMP_FILENAME + '_client');
2317 end;
2318
2319 procedure g_Net_DumpSendBuffer();
2320 begin
2321   writeInt(NetDumpFile, gTime);
2322   writeInt(NetDumpFile, LongWord(NetOut.CurSize));
2323   writeInt(NetDumpFile, Byte(1));
2324   NetDumpFile.WriteBuffer(NetOut.Data^, NetOut.CurSize);
2325 end;
2326
2327 procedure g_Net_DumpRecvBuffer(Buf: penet_uint8; Len: LongWord);
2328 begin
2329   if (Buf = nil) or (Len = 0) then Exit;
2330   writeInt(NetDumpFile, gTime);
2331   writeInt(NetDumpFile, Len);
2332   writeInt(NetDumpFile, Byte(0));
2333   NetDumpFile.WriteBuffer(Buf^, Len);
2334 end;
2335
2336 procedure g_Net_DumpEnd();
2337 begin
2338   NetDumpFile.Free();
2339   NetDumpFile := nil;
2340 end;
2341
2342 function g_Net_ForwardPorts(ForwardPongPort: Boolean = True): Boolean;
2343 {$IFDEF USE_MINIUPNPC}
2344 var
2345   DevList: PUPNPDev;
2346   Urls: TUPNPUrls;
2347   Data: TIGDDatas;
2348   LanAddr: array [0..255] of Char;
2349   StrPort: AnsiString;
2350   Err, I: Integer;
2351 begin
2352   Result := False;
2353
2354   if NetHost = nil then
2355     exit;
2356
2357   if NetPortForwarded = NetHost.address.port then
2358   begin
2359     Result := True;
2360     exit;
2361   end;
2362
2363   NetPongForwarded := False;
2364   NetPortForwarded := 0;
2365
2366   DevList := upnpDiscover(1000, nil, nil, 0, 0, 2, Addr(Err));
2367   if DevList = nil then
2368   begin
2369     conwritefln('port forwarding failed: upnpDiscover() failed: %d', [Err]);
2370     exit;
2371   end;
2372
2373   I := UPNP_GetValidIGD(DevList, @Urls, @Data, Addr(LanAddr[0]), 256);
2374
2375   if I = 0 then
2376   begin
2377     conwriteln('port forwarding failed: could not find an IGD device on this LAN');
2378     FreeUPNPDevList(DevList);
2379     FreeUPNPUrls(@Urls);
2380     exit;
2381   end;
2382
2383   StrPort := IntToStr(NetHost.address.port);
2384   I := UPNP_AddPortMapping(
2385     Urls.controlURL, Addr(data.first.servicetype[1]),
2386     PChar(StrPort), PChar(StrPort), Addr(LanAddr[0]), PChar('D2DF'),
2387     PChar('UDP'), nil, PChar('0')
2388   );
2389
2390   if I <> 0 then
2391   begin
2392     conwritefln('forwarding port %d failed: error %d', [NetHost.address.port, I]);
2393     FreeUPNPDevList(DevList);
2394     FreeUPNPUrls(@Urls);
2395     exit;
2396   end;
2397
2398   if ForwardPongPort then
2399   begin
2400     StrPort := IntToStr(NET_PING_PORT);
2401     I := UPNP_AddPortMapping(
2402       Urls.controlURL, Addr(data.first.servicetype[1]),
2403       PChar(StrPort), PChar(StrPort), Addr(LanAddr[0]), PChar('D2DF'),
2404       PChar('UDP'), nil, PChar('0')
2405     );
2406
2407     if I <> 0 then
2408     begin
2409       conwritefln('forwarding port %d failed: error %d', [NET_PING_PORT, I]);
2410       NetPongForwarded := False;
2411     end
2412     else
2413     begin
2414       conwritefln('forwarded port %d successfully', [NET_PING_PORT]);
2415       NetPongForwarded := True;
2416     end;
2417   end;
2418
2419   conwritefln('forwarded port %d successfully', [NetHost.address.port]);
2420   NetIGDControl := AnsiString(Urls.controlURL);
2421   NetIGDService := data.first.servicetype;
2422   NetPortForwarded := NetHost.address.port;
2423
2424   FreeUPNPDevList(DevList);
2425   FreeUPNPUrls(@Urls);
2426   Result := True;
2427 end;
2428 {$ELSE}
2429 begin
2430   Result := False;
2431 end;
2432 {$ENDIF}
2433
2434 procedure g_Net_UnforwardPorts();
2435 {$IFDEF USE_MINIUPNPC}
2436 var
2437   I: Integer;
2438   StrPort: AnsiString;
2439 begin
2440   if NetPortForwarded = 0 then Exit;
2441
2442   conwriteln('unforwarding ports...');
2443
2444   StrPort := IntToStr(NetPortForwarded);
2445   I := UPNP_DeletePortMapping(
2446     PChar(NetIGDControl), Addr(NetIGDService[1]),
2447     PChar(StrPort), PChar('UDP'), nil
2448   );
2449   conwritefln('  port %d: %d', [NetPortForwarded, I]);
2450
2451   if NetPongForwarded then
2452   begin
2453     NetPongForwarded := False;
2454     StrPort := IntToStr(NET_PING_PORT);
2455     I := UPNP_DeletePortMapping(
2456       PChar(NetIGDControl), Addr(NetIGDService[1]),
2457       PChar(StrPort), PChar('UDP'), nil
2458     );
2459     conwritefln('  port %d: %d', [NET_PING_PORT, I]);
2460   end;
2461
2462   NetPortForwarded := 0;
2463 end;
2464 {$ELSE}
2465 begin
2466 end;
2467 {$ENDIF}
2468
2469 procedure NetServerCVars(P: SSArray);
2470 var
2471   cmd, s: string;
2472   a, b: Integer;
2473 begin
2474   cmd := LowerCase(P[0]);
2475   case cmd of
2476     'sv_name':
2477       begin
2478         if (Length(P) > 1) and (Length(P[1]) > 0) then
2479         begin
2480           NetServerName := P[1];
2481           if Length(NetServerName) > 64 then
2482             SetLength(NetServerName, 64);
2483           g_Net_Slist_ServerRenamed();
2484         end;
2485         g_Console_Add(cmd + ' "' + NetServerName + '"');
2486       end;
2487     'sv_passwd':
2488       begin
2489         if (Length(P) > 1) and (Length(P[1]) > 0) then
2490         begin
2491           NetPassword := P[1];
2492           if Length(NetPassword) > 24 then
2493             SetLength(NetPassword, 24);
2494           g_Net_Slist_ServerRenamed();
2495         end;
2496         g_Console_Add(cmd + ' "' + AnsiLowerCase(NetPassword) + '"');
2497       end;
2498     'sv_maxplrs':
2499       begin
2500         if (Length(P) > 1) then
2501         begin
2502           NetMaxClients := nclamp(StrToIntDef(P[1], NetMaxClients), 1, NET_MAXCLIENTS);
2503           if g_Game_IsServer and g_Game_IsNet then
2504           begin
2505             b := 0;
2506             for a := 0 to High(NetClients) do
2507             begin
2508               if NetClients[a].Used then
2509               begin
2510                 Inc(b);
2511                 if b > NetMaxClients then
2512                 begin
2513                   s := g_Player_Get(NetClients[a].Player).Name;
2514                   enet_peer_disconnect(NetClients[a].Peer, NET_DISC_FULL);
2515                   g_Console_Add(Format(_lc[I_PLAYER_KICK], [s]));
2516                   MH_SEND_GameEvent(NET_EV_PLAYER_KICK, 0, s);
2517                 end;
2518               end;
2519             end;
2520             g_Net_Slist_ServerRenamed();
2521           end;
2522         end;
2523         g_Console_Add(cmd + ' ' + IntToStr(NetMaxClients));
2524       end;
2525     'sv_public':
2526       begin
2527         if (Length(P) > 1) then
2528         begin
2529           NetUseMaster := StrToIntDef(P[1], Byte(NetUseMaster)) <> 0;
2530           if NetUseMaster then g_Net_Slist_Public() else g_Net_Slist_Private();
2531         end;
2532         g_Console_Add(cmd + ' ' + IntToStr(Byte(NetUseMaster)));
2533       end;
2534     'sv_port':
2535       begin
2536         if (Length(P) > 1) then
2537         begin
2538           if not g_Game_IsNet then
2539             NetPort := nclamp(StrToIntDef(P[1], NetPort), 0, $FFFF)
2540           else
2541             g_Console_Add(_lc[I_MSG_NOT_NETGAME]);
2542         end;
2543         g_Console_Add(cmd + ' ' + IntToStr(Ord(NetUseMaster)));
2544       end;
2545   end;
2546 end;
2547
2548 initialization
2549   conRegVar('cl_downloadtimeout', @g_Net_DownloadTimeout, 0.0, 1000000.0, '', 'timeout in seconds, 0 to disable it');
2550   conRegVar('cl_predictself', @NetPredictSelf, '', 'predict local player');
2551   conRegVar('cl_forceplayerupdate', @NetForcePlayerUpdate, '', 'update net players on NET_MSG_PLRPOS');
2552   conRegVar('cl_interp', @NetInterpLevel, '', 'net player interpolation steps');
2553   conRegVar('cl_last_ip', @NetClientIP, '', 'address of the last you have connected to');
2554   conRegVar('cl_last_port', @NetClientPort, '', 'port of the last server you have connected to');
2555   conRegVar('cl_deafen', @NetDeafLevel, '', 'filter server messages (0-3)');
2556
2557   conRegVar('sv_forwardports', @NetForwardPorts, '', 'forward server port using miniupnpc (requires server restart)');
2558   conRegVar('sv_rcon', @NetAllowRCON, '', 'enable remote console');
2559   conRegVar('sv_rcon_password', @NetRCONPassword, '', 'remote console password');
2560   conRegVar('sv_update_interval', @NetUpdateRate, '', 'unreliable update interval');
2561   conRegVar('sv_reliable_interval', @NetRelupdRate, '', 'reliable update interval');
2562   conRegVar('sv_master_interval', @NetMasterRate, '', 'master server update interval');
2563
2564   conRegVar('sv_autoban_threshold', @NetAutoBanLimit, '', 'max crimes before autoban (0 = no autoban)');
2565   conRegVar('sv_autoban_permanent', @NetAutoBanPerm, '', 'whether autobans are permanent');
2566   conRegVar('sv_autoban_warn', @NetAutoBanWarn, '', 'send warnings to the client when he triggers penalties');
2567
2568   conRegVar('sv_auth_timeout', @NetAuthTimeout, '', 'number of frames in which connecting clients must complete auth (0 = unlimited)');
2569   conRegVar('sv_packet_timeout', @NetPacketTimeout, '', 'number of frames the client must idle to be kicked (0 = unlimited)');
2570
2571   conRegVar('net_master_list', @NetMasterList, '', 'list of master servers');
2572
2573   SetLength(NetClients, 0);
2574   g_Net_DownloadTimeout := 60;
2575   NetIn.Alloc(NET_BUFSIZE);
2576   NetOut.Alloc(NET_BUFSIZE);
2577   NetBuf[NET_UNRELIABLE].Alloc(NET_BUFSIZE*2);
2578   NetBuf[NET_RELIABLE].Alloc(NET_BUFSIZE*2);
2579   trans_omsg.Alloc(NET_BUFSIZE);
2580 finalization
2581   NetIn.Free();
2582   NetOut.Free();
2583   NetBuf[NET_UNRELIABLE].Free();
2584   NetBuf[NET_RELIABLE].Free();
2585 end.