diff --git a/src/game/g_net.pas b/src/game/g_net.pas
index 95b2319e6acd1eb2f92a7f599de2ce1af7011800..292f919b9e9c5beb4981f9f073313e52ed679595 100644 (file)
--- a/src/game/g_net.pas
+++ b/src/game/g_net.pas
e_log, e_msg, utils, ENet, Classes, md5, MAPDEF{$IFDEF USE_MINIUPNPC}, miniupnpc;{$ELSE};{$ENDIF}
const
- NET_PROTOCOL_VER = 184;
-
+ NET_PROTOCOL_VER = 188;
NET_MAXCLIENTS = 24;
- NET_CHANS = 12;
-
- NET_CHAN_SERVICE = 0;
- NET_CHAN_IMPORTANT = 1;
- NET_CHAN_GAME = 2;
- NET_CHAN_PLAYER = 3;
- NET_CHAN_PLAYERPOS = 4;
- NET_CHAN_MONSTER = 5;
- NET_CHAN_MONSTERPOS = 6;
- NET_CHAN_LARGEDATA = 7;
- NET_CHAN_CHAT = 8;
- NET_CHAN_DOWNLOAD = 9;
- NET_CHAN_SHOTS = 10;
- NET_CHAN_DOWNLOAD_EX = 11;
+
+ // NOTE: We use different channels for unreliable and reliable packets because ENet seems to
+ // discard preceeding RELIABLE packets if a later UNRELIABLE (but not UNSEQUENCED) packet sent
+ // on the same channel has arrived earlier, which is useful for occasional full-state updates.
+ // However, we use a separate download channel to avoid being delayed by other reliable packets.
+ NET_CHAN_UNRELIABLE = 2;
+ NET_CHAN_RELIABLE = 1;
+ NET_CHAN_DOWNLOAD = 11;
+ NET_CHANNELS = 12; // TODO: Reduce to 3 and re-enumerate channels. Requires protocol increment.
NET_NONE = 0;
NET_SERVER = 1;
BANLIST_FILENAME = 'banlist.txt';
NETDUMP_FILENAME = 'netdump';
- {$IF DEFINED(FREEBSD) OR DEFINED(DARWIN)}
- NilThreadId = nil;
- {$ELSE}
- NilThreadId = 0;
- {$ENDIF}
-
type
TNetMapResourceInfo = record
wadName: AnsiString; // wad file name, without a path
Player: Word;
RequestedFullUpdate: Boolean;
WaitForFirstSpawn: Boolean; // set to `true` in server, used to spawn a player on first full state request
+ FullUpdateSent: Boolean;
RCONAuth: Boolean;
Voted: Boolean;
+ Crimes: Integer;
+ AuthTime: LongWord;
+ MsgTime: LongWord;
Transfer: TNetFileTransfer; // only one transfer may be active
NetOut: array [0..1] of TMsg;
end;
NetPongSock: ENetSocket = ENET_SOCKET_NULL;
NetUseMaster: Boolean = True;
- NetSlistIP: string = 'mpms.doom2d.org';
- NetSlistPort: Word = 25665;
- NetSlistList: string = 'deadsoftware.ru:25665';
+ NetMasterList: string = 'mpms.doom2d.org:25665, deadsoftware.ru:25665';
NetClientIP: string = '127.0.0.1';
NetClientPort: Word = 25666;
NetMaxClients: Byte = 255;
NetBannedHosts: array of TBanRecord;
+ NetAutoBanLimit: Integer = 5;
+ NetAutoBanPerm: Boolean = True;
+ NetAutoBanWarn: Boolean = False;
+ NetAutoBanForTimeout: Boolean = False;
+
+ NetAuthTimeout: Integer = 30 * 1000;
+ NetPacketTimeout: Integer = 60 * 1000;
+
NetState: Integer = NET_STATE_NONE;
NetMyID: Integer = -1;
NetGotEverything: Boolean = False;
NetGotKeys: Boolean = False;
+ NetDeafLevel: Integer = 0;
+
{$IFDEF USE_MINIUPNPC}
NetPortForwarded: Word = 0;
NetPongForwarded: Boolean = False;
function g_Net_Host(IPAddr: LongWord; Port: enet_uint16; MaxClients: Cardinal = 16): Boolean;
procedure g_Net_Host_Die();
-procedure g_Net_Host_Send(ID: Integer; Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
-function g_Net_Host_Update(): enet_size_t;
+procedure g_Net_Host_Send(ID: Integer; Reliable: Boolean);
+procedure g_Net_Host_Update();
+procedure g_Net_Host_Kick(ID: Integer; Reason: enet_uint32);
+procedure g_Net_Host_Ban(ID: Integer; Perm: Boolean);
+procedure g_Net_Host_Ban(C: pTNetClient; Perm: Boolean);
function g_Net_Connect(IP: string; Port: enet_uint16): Boolean;
procedure g_Net_Disconnect(Forced: Boolean = False);
-procedure g_Net_Client_Send(Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
-function g_Net_Client_Update(): enet_size_t;
-function g_Net_Client_UpdateWhileLoading(): enet_size_t;
+procedure g_Net_Client_Send(Reliable: Boolean);
+procedure g_Net_Client_Update();
function g_Net_Client_ByName(Name: string): pTNetClient;
function g_Net_Client_ByPlayer(PID: Word): pTNetClient;
function g_Net_ClientName_ByID(ID: Integer): string;
-procedure g_Net_SendData(Data: AByte; peer: pENetPeer; Reliable: Boolean; Chan: Byte = NET_CHAN_DOWNLOAD);
-//function g_Net_Wait_Event(msgId: Word): TMemoryStream;
-//function g_Net_Wait_FileInfo (var tf: TNetFileTransfer; asMap: Boolean; out resList: TStringList): Integer;
-
function IpToStr(IP: LongWord): string;
function StrToIp(IPstr: string; var IP: LongWord): Boolean;
-function g_Net_IsHostBanned(IP: LongWord; Perm: Boolean = False): Boolean;
-procedure g_Net_BanHost(IP: LongWord; Perm: Boolean = True); overload;
-procedure g_Net_BanHost(IP: string; Perm: Boolean = True); overload;
-function g_Net_UnbanHost(IP: string): Boolean; overload;
-function g_Net_UnbanHost(IP: LongWord): Boolean; overload;
-procedure g_Net_UnbanNonPermHosts();
+function g_Net_IsAddressBanned(IP: LongWord; Perm: Boolean = False): Boolean;
+procedure g_Net_BanAddress(IP: LongWord; Perm: Boolean = True); overload;
+procedure g_Net_BanAddress(IP: string; Perm: Boolean = True); overload;
+function g_Net_UnbanAddress(IP: string): Boolean; overload;
+function g_Net_UnbanAddress(IP: LongWord): Boolean; overload;
+procedure g_Net_UnbanNonPerm();
procedure g_Net_SaveBanList();
+procedure g_Net_Penalize(C: pTNetClient; Reason: string);
+
procedure g_Net_DumpStart();
procedure g_Net_DumpSendBuffer();
procedure g_Net_DumpRecvBuffer(Buf: penet_uint8; Len: LongWord);
end;
procedure g_Net_InitLowLevel ();
+ var v: ENetVersion;
begin
+ v := enet_linked_version();
+ e_LogWritefln('ENet Version: %s.%s.%s', [ENET_VERSION_GET_MAJOR(v), ENET_VERSION_GET_MINOR(v), ENET_VERSION_GET_PATCH(v)]);
if enet_init_success then raise Exception.Create('wuta?!');
enet_init_success := (enet_initialize() = 0);
end;
e_KeyPressed(JOY3_JUMP)
end;
-
//**************************************************************************
//
// file transfer declaraions and host packet processor
procedure killClientByFT (var nc: TNetClient);
begin
e_LogWritefln('disconnected client #%d due to file transfer error', [nc.ID], TMsgType.Warning);
- enet_peer_disconnect(nc.Peer, NET_DISC_FILE_TIMEOUT);
+ g_Net_Host_Kick(nc.ID, NET_DISC_FILE_TIMEOUT);
clearNetClientTransfers(nc);
g_Net_Slist_ServerPlayerLeaves();
end;
if (m.CurSize < 1) then exit;
pkt := enet_packet_create(m.Data, m.CurSize, ENET_PACKET_FLAG_RELIABLE);
if not Assigned(pkt) then begin killClientByFT(nc); exit; end;
- if (enet_peer_send(nc.Peer, NET_CHAN_DOWNLOAD_EX, pkt) <> 0) then begin killClientByFT(nc); exit; end;
+ if (enet_peer_send(nc.Peer, NET_CHAN_DOWNLOAD, pkt) <> 0) then begin killClientByFT(nc); exit; end;
result := true;
end;
if (m.CurSize < 1) then exit;
pkt := enet_packet_create(m.Data, m.CurSize, ENET_PACKET_FLAG_RELIABLE);
if not Assigned(pkt) then exit;
- if (enet_peer_send(NetPeer, NET_CHAN_DOWNLOAD_EX, pkt) <> 0) then exit;
+ if (enet_peer_send(NetPeer, NET_CHAN_DOWNLOAD, pkt) <> 0) then exit;
result := true;
end;
exit;
end;
+ // don't time out clients during a file transfer
+ if (NetAuthTimeout > 0) then
+ nc^.AuthTime := gTime + NetAuthTimeout;
+ if (NetPacketTimeout > 0) then
+ nc^.MsgTime := gTime + NetPacketTimeout;
+
tf := @NetClients[nid].Transfer;
tf.lastAckTime := GetTimerMS();
ENET_EVENT_TYPE_RECEIVE:
begin
freePacket := true;
- if (ev.channelID <> NET_CHAN_DOWNLOAD_EX) then
+ if (ev.channelID <> NET_CHAN_DOWNLOAD) then
begin
//e_LogWritefln('g_Net_Wait_MapInfo: skip message from non-transfer channel', []);
freePacket := false;
rc := msg.ReadLongInt();
if (rc < 0) or (rc > 1024) then
begin
- e_LogWritefln('g_Net_Wait_Event: invalid number of map external resources (%d)', [rc]);
+ e_LogWritefln('g_Net_Wait_MapInfo: invalid number of map external resources (%d)', [rc]);
Result := -1;
exit;
end;
end
else
begin
- e_LogWritefln('g_Net_Wait_Event: invalid server packet type', []);
+ e_LogWritefln('g_Net_Wait_MapInfo: invalid server packet type', []);
Result := -1;
exit;
end;
end;
if (freePacket) then begin freePacket := false; enet_packet_destroy(ev.packet); end;
end;
- ProcessLoading();
+
+ ProcessLoading(False);
if g_Net_UserRequestExit() then
begin
g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' user abort', True);
ENET_EVENT_TYPE_RECEIVE:
begin
freePacket := true;
- if (ev.channelID <> NET_CHAN_DOWNLOAD_EX) then
+ if (ev.channelID <> NET_CHAN_DOWNLOAD) then
begin
- //e_LogWriteln('g_Net_Wait_Event: skip message from non-transfer channel');
+ //e_LogWriteln('g_Net_RequestResFileInfo: skip message from non-transfer channel');
freePacket := false;
g_Net_Client_HandlePacket(ev.packet, g_Net_ClientLightMsgHandler);
if (g_Res_received_map_start < 0) then begin result := -666; exit; end;
ett := getNewTimeoutEnd();
if (ev.packet.dataLength < 1) then
begin
- e_LogWriteln('g_Net_Wait_Event: invalid server packet (no data)');
+ e_LogWriteln('g_Net_RequestResFileInfo: invalid server packet (no data)');
Result := -1;
exit;
end;
end;
if (freePacket) then begin freePacket := false; enet_packet_destroy(ev.packet); end;
end;
- ProcessLoading();
+
+ ProcessLoading(False);
if g_Net_UserRequestExit() then
begin
g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' user abort', True);
ENET_EVENT_TYPE_RECEIVE:
begin
freePacket := true;
- if (ev.channelID <> NET_CHAN_DOWNLOAD_EX) then
+ if (ev.channelID <> NET_CHAN_DOWNLOAD) then
begin
- //e_LogWritefln('g_Net_Wait_Event: skip message from non-transfer channel', []);
+ //e_LogWritefln('g_Net_ReceiveResourceFile: skip message from non-transfer channel', []);
freePacket := false;
g_Net_Client_HandlePacket(ev.packet, g_Net_ClientLightMsgHandler);
if (g_Res_received_map_start < 0) then begin result := -666; exit; end;
end;
if (freePacket) then begin freePacket := false; enet_packet_destroy(ev.packet); end;
end;
- ProcessLoading();
+
+ ProcessLoading(False);
if g_Net_UserRequestExit() then
begin
g_Console_Add(_lc[I_NET_MSG_ERROR] + _lc[I_NET_ERR_CONN] + ' user abort', True);
begin
Readln(F, IPstr);
if StrToIp(IPstr, IP) then
- g_Net_BanHost(IP);
+ g_Net_BanAddress(IP);
end;
CloseFile(F);
g_Net_SaveBanList();
I: Integer;
begin
F := 0;
- Chan := NET_CHAN_GAME;
+ Chan := NET_CHAN_UNRELIABLE;
if NetMode = NET_SERVER then
for T := NET_UNRELIABLE to NET_RELIABLE do
begin
- if NetBuf[T].CurSize > 0 then
- begin
- P := enet_packet_create(NetBuf[T].Data, NetBuf[T].CurSize, F);
- if not Assigned(P) then continue;
- enet_host_broadcast(NetHost, Chan, P);
- NetBuf[T].Clear();
- end;
-
for I := Low(NetClients) to High(NetClients) do
begin
if not NetClients[I].Used then continue;
// next and last iteration is always RELIABLE
F := LongWord(ENET_PACKET_FLAG_RELIABLE);
- Chan := NET_CHAN_IMPORTANT;
+ Chan := NET_CHAN_RELIABLE;
end
else if NetMode = NET_CLIENT then
for T := NET_UNRELIABLE to NET_RELIABLE do
end;
// next and last iteration is always RELIABLE
F := LongWord(ENET_PACKET_FLAG_RELIABLE);
- Chan := NET_CHAN_IMPORTANT;
+ Chan := NET_CHAN_RELIABLE;
end;
end;
NetAddr.host := IPAddr;
NetAddr.port := Port;
- if NetForwardPorts then NetPortThread := BeginThread(ForwardThread);
-
- NetHost := enet_host_create(@NetAddr, NET_MAXCLIENTS, NET_CHANS, 0, 0);
+ NetHost := enet_host_create(@NetAddr, NET_MAXCLIENTS, NET_CHANNELS, 0, 0);
if (NetHost = nil) then
begin
Exit;
end;
+ if NetForwardPorts then NetPortThread := BeginThread(ForwardThread);
+
NetPongSock := enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM);
if NetPongSock <> ENET_SOCKET_NULL then
begin
enet_peer_reset(NetClients[I].Peer);
NetClients[I].Peer := nil;
NetClients[I].Used := False;
+ NetClients[I].Player := 0;
+ NetClients[I].Crimes := 0;
+ NetClients[I].AuthTime := 0;
+ NetClients[I].MsgTime := 0;
NetClients[I].NetOut[NET_UNRELIABLE].Free();
NetClients[I].NetOut[NET_RELIABLE].Free();
end;
end;
-procedure g_Net_Host_Send(ID: Integer; Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
+procedure g_Net_Host_Send(ID: Integer; Reliable: Boolean);
var
T: Integer;
begin
- if (Reliable) then
- T := NET_RELIABLE
- else
- T := NET_UNRELIABLE;
+ if Reliable
+ then T := NET_RELIABLE
+ else T := NET_UNRELIABLE;
if (ID >= 0) then
begin
end
else
begin
- // write size first
- NetBuf[T].Write(Integer(NetOut.CurSize));
- NetBuf[T].Write(NetOut);
+ for ID := Low(NetClients) to High(NetClients) do
+ begin
+ if NetClients[ID].Used then
+ begin
+ // write size first
+ NetClients[ID].NetOut[T].Write(Integer(NetOut.CurSize));
+ NetClients[ID].NetOut[T].Write(NetOut);
+ end;
+ end;
end;
if NetDump then g_Net_DumpSendBuffer();
NetOut.Clear();
end;
+procedure g_Net_Host_Disconnect_Client(ID: Integer; Force: Boolean = False);
+var
+ TP: TPlayer;
+ TC: pTNetClient;
+begin
+ TC := @NetClients[ID];
+ if (TC = nil) then Exit;
+ clearNetClient(NetClients[ID]);
+ if not (TC^.Used) then Exit;
+
+ TP := g_Player_Get(TC^.Player);
+
+ if TP <> nil then
+ begin
+ TP.Lives := 0;
+ TP.Kill(K_SIMPLEKILL, 0, HIT_DISCON);
+ g_Console_Add(Format(_lc[I_PLAYER_LEAVE], [TP.Name]), True);
+ e_WriteLog('NET: Client ' + TP.Name + ' [' + IntToStr(TC^.ID) + '] disconnected.', TMsgType.Notify);
+ g_Player_Remove(TP.UID);
+ end;
+
+ if (TC^.Peer^.data <> nil) then
+ begin
+ FreeMemory(TC^.Peer^.data);
+ TC^.Peer^.data := nil;
+ end;
+
+ if (Force) then
+ enet_peer_reset(TC^.Peer);
+
+ TC^.Used := False;
+ TC^.State := NET_STATE_NONE;
+ TC^.Peer := nil;
+ TC^.Player := 0;
+ TC^.Crimes := 0;
+ TC^.AuthTime := 0;
+ TC^.MsgTime := 0;
+ TC^.RequestedFullUpdate := False;
+ TC^.FullUpdateSent := False;
+ TC^.WaitForFirstSpawn := False;
+ TC^.NetOut[NET_UNRELIABLE].Free();
+ TC^.NetOut[NET_RELIABLE].Free();
+
+ g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_HOST_DISC], [ID]));
+ Dec(NetClientCount);
+
+ if NetUseMaster then g_Net_Slist_ServerPlayerLeaves();
+end;
+
+procedure g_Net_Host_Kick(ID: Integer; Reason: enet_uint32);
+var
+ Peer: pENetPeer;
+ TC: pTNetClient;
+begin
+ TC := @NetClients[ID];
+ if (TC <> nil) and TC^.Used and (TC^.Peer <> nil) then
+ begin
+ Peer := TC^.Peer;
+ g_Net_Host_Disconnect_Client(ID);
+ enet_peer_disconnect(Peer, Reason);
+ end;
+end;
+
procedure g_Net_Host_CheckPings();
var
ClAddr: ENetAddress;
Ping: array [0..9] of Byte;
NPl: Byte;
begin
- if NetPongSock = ENET_SOCKET_NULL then Exit;
+ if (NetPongSock = ENET_SOCKET_NULL) or (NetHost = nil) then Exit;
Buf.data := Addr(Ping[0]);
Buf.dataLength := 2+8;
NetOut.Clear();
NetOut.Write(Byte(Ord('D')));
NetOut.Write(Byte(Ord('F')));
- NetOut.Write(NetPort);
+ NetOut.Write(NetHost.address.port);
NetOut.Write(ClTime);
TMasterHost.writeInfo(NetOut);
NPl := 0;
end;
end;
+procedure g_Net_Host_CheckTimeouts();
+var
+ ID: Integer;
+begin
+ for ID := Low(NetClients) to High(NetClients) do
+ begin
+ with NetClients[ID] do
+ begin
+ if (Peer = nil) or (State = NET_STATE_NONE) then continue;
+ if (State = NET_STATE_AUTH) and (AuthTime > 0) and (AuthTime <= gTime) then
+ begin
+ g_Net_Penalize(@NetClients[ID], 'auth taking too long');
+ AuthTime := gTime + 1000; // do it every second to give them a chance
+ end
+ else if (State = NET_STATE_GAME) and (MsgTime > 0) and (MsgTime <= gTime) then
+ begin
+ // client hasn't sent packets in a while; either ban em or kick em
+ if (NetAutoBanForTimeout) then
+ begin
+ g_Net_Penalize(@NetClients[ID], 'message timeout');
+ MsgTime := gTime + (NetPacketTimeout div 2) + 500; // wait less for the next check
+ end
+ else
+ begin
+ e_LogWritefln('NET: client #%u (cid #%u) timed out', [ID, Player]);
+ g_Net_Host_Disconnect_Client(ID, True);
+ end;
+ end;
+ end;
+ end;
+end;
+
-function g_Net_Host_Update(): enet_size_t;
+procedure g_Net_Host_Update();
var
IP: string;
Port: Word;
ID: Integer;
TC: pTNetClient;
- TP: TPlayer;
begin
IP := '';
- Result := 0;
if NetUseMaster then g_Net_Slist_Pulse();
g_Net_Host_CheckPings();
+ g_Net_Host_CheckTimeouts();
while (enet_host_service(NetHost, @NetEvent, 0) > 0) do
begin
Port := NetEvent.Peer^.address.port;
g_Console_Add(_lc[I_NET_MSG] +
Format(_lc[I_NET_MSG_HOST_CONN], [IP, Port]));
+ e_WriteLog('NET: Connection request from ' + IP + '.', TMsgType.Notify);
if (NetEvent.data <> NET_PROTOCOL_VER) then
begin
g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
_lc[I_NET_DISC_PROTOCOL]);
- NetEvent.peer^.data := GetMemory(SizeOf(Byte));
- Byte(NetEvent.peer^.data^) := 255;
+ e_WriteLog('NET: Connection request from ' + IP + ' rejected: version mismatch',
+ TMsgType.Notify);
enet_peer_disconnect(NetEvent.peer, NET_DISC_PROTOCOL);
- enet_host_flush(NetHost);
+ Exit;
+ end;
+
+ if g_Net_IsAddressBanned(NetEvent.Peer^.address.host) then
+ begin
+ g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
+ _lc[I_NET_DISC_BAN]);
+ e_WriteLog('NET: Connection request from ' + IP + ' rejected: banned',
+ TMsgType.Notify);
+ enet_peer_disconnect(NetEvent.Peer, NET_DISC_BAN);
Exit;
end;
begin
g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
_lc[I_NET_DISC_FULL]);
- NetEvent.Peer^.data := GetMemory(SizeOf(Byte));
- Byte(NetEvent.peer^.data^) := 255;
+ e_WriteLog('NET: Connection request from ' + IP + ' rejected: server full',
+ TMsgType.Notify);
enet_peer_disconnect(NetEvent.peer, NET_DISC_FULL);
- enet_host_flush(NetHost);
Exit;
end;
NetClients[ID].Peer^.data := GetMemory(SizeOf(Byte));
Byte(NetClients[ID].Peer^.data^) := ID;
NetClients[ID].State := NET_STATE_AUTH;
+ NetClients[ID].Player := 0;
+ NetClients[ID].Crimes := 0;
NetClients[ID].RCONAuth := False;
NetClients[ID].NetOut[NET_UNRELIABLE].Alloc(NET_BUFSIZE*2);
NetClients[ID].NetOut[NET_RELIABLE].Alloc(NET_BUFSIZE*2);
+ if (NetAuthTimeout > 0) then
+ NetClients[ID].AuthTime := gTime + NetAuthTimeout
+ else
+ NetClients[ID].AuthTime := 0;
+ if (NetPacketTimeout > 0) then
+ NetClients[ID].MsgTime := gTime + NetPacketTimeout
+ else
+ NetClients[ID].MsgTime := 0;
clearNetClientTransfers(NetClients[ID]); // just in case
enet_peer_timeout(NetEvent.peer, ENET_PEER_TIMEOUT_LIMIT * 2, ENET_PEER_TIMEOUT_MINIMUM * 2, ENET_PEER_TIMEOUT_MAXIMUM * 2);
ENET_EVENT_TYPE_RECEIVE:
begin
//e_LogWritefln('RECEIVE: chan=%u', [NetEvent.channelID]);
- if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then
+ if (NetEvent.channelID = NET_CHAN_DOWNLOAD) then
begin
ProcessDownloadExPacket();
end
else
begin
+ if NetEvent.peer^.data = nil then Exit;
+
ID := Byte(NetEvent.peer^.data^);
if ID > High(NetClients) then Exit;
TC := @NetClients[ID];
+ if (NetPacketTimeout > 0) then
+ TC^.MsgTime := gTime + NetPacketTimeout;
+
if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
g_Net_Host_HandlePacket(TC, NetEvent.packet, g_Net_HostMsgHandler);
end;
ENET_EVENT_TYPE_DISCONNECT:
begin
- ID := Byte(NetEvent.peer^.data^);
- if ID > High(NetClients) then Exit;
- clearNetClient(NetClients[ID]);
- TC := @NetClients[ID];
- if TC = nil then Exit;
-
- if not (TC^.Used) then Exit;
-
- TP := g_Player_Get(TC^.Player);
-
- if TP <> nil then
+ if NetEvent.peer^.data <> nil then
begin
- TP.Lives := 0;
- TP.Kill(K_SIMPLEKILL, 0, HIT_DISCON);
- g_Console_Add(Format(_lc[I_PLAYER_LEAVE], [TP.Name]), True);
- e_WriteLog('NET: Client ' + TP.Name + ' [' + IntToStr(ID) + '] disconnected.', TMsgType.Notify);
- g_Player_Remove(TP.UID);
+ ID := Byte(NetEvent.peer^.data^);
+ if ID > High(NetClients) then Exit;
+ g_Net_Host_Disconnect_Client(ID);
end;
-
- TC^.Used := False;
- TC^.State := NET_STATE_NONE;
- TC^.Peer := nil;
- TC^.Player := 0;
- TC^.RequestedFullUpdate := False;
- TC^.WaitForFirstSpawn := False;
- TC^.NetOut[NET_UNRELIABLE].Free();
- TC^.NetOut[NET_RELIABLE].Free();
-
- FreeMemory(NetEvent.peer^.data);
- NetEvent.peer^.data := nil;
- g_Console_Add(_lc[I_NET_MSG] + Format(_lc[I_NET_MSG_HOST_DISC], [ID]));
- Dec(NetClientCount);
-
- if NetUseMaster then g_Net_Slist_ServerPlayerLeaves();
end;
end;
end;
e_WriteLog('NET: Disconnected', TMsgType.Notify);
end;
-procedure g_Net_Client_Send(Reliable: Boolean; Chan: Byte = NET_CHAN_GAME);
+procedure g_Net_Client_Send(Reliable: Boolean);
var
T: Integer;
begin
- if (Reliable) then
- T := NET_RELIABLE
- else
- T := NET_UNRELIABLE;
+ if Reliable
+ then T := NET_RELIABLE
+ else T := NET_UNRELIABLE;
// write size first
NetBuf[T].Write(Integer(NetOut.CurSize));
g_Net_Flush(); // FIXME: for now, send immediately
end;
-function g_Net_Client_Update(): enet_size_t;
+procedure g_Net_Client_Update();
begin
- Result := 0;
while (NetHost <> nil) and (enet_host_service(NetHost, @NetEvent, 0) > 0) do
begin
case NetEvent.kind of
ENET_EVENT_TYPE_RECEIVE:
begin
- if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then continue; // ignore all download packets, they're processed by separate code
if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
g_Net_Client_HandlePacket(NetEvent.packet, g_Net_ClientMsgHandler);
end;
ENET_EVENT_TYPE_DISCONNECT:
begin
g_Net_Disconnect(True);
- Result := 1;
Exit;
end;
end;
end
end;
-function g_Net_Client_UpdateWhileLoading(): enet_size_t;
-begin
- Result := 0;
- while (enet_host_service(NetHost, @NetEvent, 0) > 0) do
- begin
- case NetEvent.kind of
- ENET_EVENT_TYPE_RECEIVE:
- begin
- if (NetEvent.channelID = NET_CHAN_DOWNLOAD_EX) then continue; // ignore all download packets, they're processed by separate code
- if NetDump then g_Net_DumpRecvBuffer(NetEvent.packet^.data, NetEvent.packet^.dataLength);
- g_Net_Client_HandlePacket(NetEvent.packet, g_Net_ClientLightMsgHandler);
- end;
-
- ENET_EVENT_TYPE_DISCONNECT:
- begin
- g_Net_Disconnect(True);
- Result := 1;
- Exit;
- end;
- end;
- end;
- g_Net_Flush();
-end;
-
function g_Net_Connect(IP: string; Port: enet_uint16): Boolean;
var
OuterLoop: Boolean;
NetInitDone := True;
end;
- NetHost := enet_host_create(nil, 1, NET_CHANS, 0, 0);
+ NetHost := enet_host_create(nil, 1, NET_CHANNELS, 0, 0);
if (NetHost = nil) then
begin
enet_address_set_host(@NetAddr, PChar(Addr(IP[1])));
NetAddr.port := Port;
- NetPeer := enet_host_connect(NetHost, @NetAddr, NET_CHANS, NET_PROTOCOL_VER);
+ NetPeer := enet_host_connect(NetHost, @NetAddr, NET_CHANNELS, NET_PROTOCOL_VER);
if (NetPeer = nil) then
begin
g_Console_Add(Format(_lc[I_NET_MSG_PORTS], [Integer(Port), Integer(NET_PING_PORT)]), True);
end;
- ProcessLoading(true);
-
+ ProcessLoading(True);
if e_KeyPressed(IK_SPACE) or e_KeyPressed(IK_ESCAPE) or e_KeyPressed(VK_ESCAPE) or
e_KeyPressed(JOY0_JUMP) or e_KeyPressed(JOY1_JUMP) or e_KeyPressed(JOY2_JUMP) or e_KeyPressed(JOY3_JUMP) then
OuterLoop := False;
pl := g_Player_Get(NetClients[a].Player);
if pl = nil then Exit;
Result := pl.Name;
+ Exit;
end;
-end;
+ Result := 'Client #' + IntToStr(ID);
+ end;
-procedure g_Net_SendData(Data: AByte; peer: pENetPeer; Reliable: Boolean; Chan: Byte = NET_CHAN_DOWNLOAD);
-var
- P: pENetPacket;
- F: enet_uint32;
- dataLength: Cardinal;
-begin
- dataLength := Length(Data);
-
- if (Reliable) then
- F := LongWord(ENET_PACKET_FLAG_RELIABLE)
- else
- F := 0;
-
- if (peer <> nil) then
- begin
- P := enet_packet_create(@Data[0], dataLength, F);
- if not Assigned(P) then Exit;
- enet_peer_send(peer, Chan, P);
- end
- else
- begin
- P := enet_packet_create(@Data[0], dataLength, F);
- if not Assigned(P) then Exit;
- enet_host_broadcast(NetHost, Chan, P);
- end;
-
- enet_host_flush(NetHost);
-end;
-
-function g_Net_IsHostBanned(IP: LongWord; Perm: Boolean = False): Boolean;
+function g_Net_IsAddressBanned(IP: LongWord; Perm: Boolean = False): Boolean;
var
I: Integer;
begin
end;
end;
-procedure g_Net_BanHost(IP: LongWord; Perm: Boolean = True); overload;
+procedure g_Net_BanAddress(IP: LongWord; Perm: Boolean = True); overload;
var
I, P: Integer;
begin
if IP = 0 then
Exit;
- if g_Net_IsHostBanned(IP, Perm) then
+ if g_Net_IsAddressBanned(IP, Perm) then
Exit;
P := -1;
NetBannedHosts[P].Perm := Perm;
end;
-procedure g_Net_BanHost(IP: string; Perm: Boolean = True); overload;
+procedure g_Net_BanAddress(IP: string; Perm: Boolean = True); overload;
var
a: LongWord;
b: Boolean;
begin
b := StrToIp(IP, a);
if b then
- g_Net_BanHost(a, Perm);
+ g_Net_BanAddress(a, Perm);
end;
-procedure g_Net_UnbanNonPermHosts();
+procedure g_Net_UnbanNonPerm();
var
I: Integer;
begin
end;
end;
-function g_Net_UnbanHost(IP: string): Boolean; overload;
+function g_Net_UnbanAddress(IP: string): Boolean; overload;
var
a: LongWord;
begin
Result := StrToIp(IP, a);
if Result then
- Result := g_Net_UnbanHost(a);
+ Result := g_Net_UnbanAddress(a);
end;
-function g_Net_UnbanHost(IP: LongWord): Boolean; overload;
+function g_Net_UnbanAddress(IP: LongWord): Boolean; overload;
var
I: Integer;
begin
end
end;
+procedure g_Net_Host_Ban(C: pTNetClient; Perm: Boolean);
+var
+ KickReason: enet_uint32;
+ Name: string;
+begin
+ if (not C^.Used) then
+ exit;
+
+ if Perm then
+ KickReason := NET_DISC_BAN
+ else
+ KickReason := NET_DISC_TEMPBAN;
+
+ Name := g_Net_ClientName_ByID(C^.ID);
+
+ g_Net_BanAddress(C^.Peer^.address.host, Perm);
+ g_Net_Host_Kick(C^.ID, KickReason);
+ g_Console_Add(Format(_lc[I_PLAYER_BAN], [Name]));
+ MH_SEND_GameEvent(NET_EV_PLAYER_BAN, 0, Name);
+ g_Net_Slist_ServerPlayerLeaves();
+ g_Net_SaveBanList();
+end;
+
+procedure g_Net_Host_Ban(ID: Integer; Perm: Boolean);
+begin
+ if (ID < 0) or (ID > High(NetClients)) then
+ exit;
+ g_Net_Host_Ban(@NetClients[ID], Perm);
+end;
+
+procedure g_Net_Penalize(C: pTNetClient; Reason: string);
+var
+ s: string;
+begin
+ e_LogWritefln('NET: client #%u (cid #%u) triggered a penalty (%d/%d): %s',
+ [C^.ID, C^.Player, C^.Crimes + 1, NetAutoBanLimit, Reason]);
+
+ if (NetAutoBanLimit <= 0) then Exit;
+
+ if (C^.Crimes >= NetAutoBanLimit) then
+ begin
+ // we have tried asking nicely before, now it is time to die
+ e_LogWritefln('NET: client #%u (cid #%u) force kicked',
+ [C^.ID, C^.Player]);
+ g_Net_Host_Disconnect_Client(C^.ID, True);
+ Exit;
+ end;
+
+ Inc(C^.Crimes);
+
+ if (NetAutoBanWarn) then
+ MH_SEND_Chat('You have been warned by the server: ' + Reason, NET_CHAT_SYSTEM, C^.ID);
+
+ if (C^.Crimes >= NetAutoBanLimit) then
+ begin
+
+ end;
+end;
+
procedure g_Net_DumpStart();
begin
if NetMode = NET_SERVER then
begin
Result := False;
- if NetPortForwarded = NetPort then
+ if NetHost = nil then
+ exit;
+
+ if NetPortForwarded = NetHost.address.port then
begin
Result := True;
exit;
exit;
end;
- StrPort := IntToStr(NetPort);
+ StrPort := IntToStr(NetHost.address.port);
I := UPNP_AddPortMapping(
Urls.controlURL, Addr(data.first.servicetype[1]),
PChar(StrPort), PChar(StrPort), Addr(LanAddr[0]), PChar('D2DF'),
if I <> 0 then
begin
- conwritefln('forwarding port %d failed: error %d', [NetPort, I]);
+ conwritefln('forwarding port %d failed: error %d', [NetHost.address.port, I]);
FreeUPNPDevList(DevList);
FreeUPNPUrls(@Urls);
exit;
end;
end;
- conwritefln('forwarded port %d successfully', [NetPort]);
+ conwritefln('forwarded port %d successfully', [NetHost.address.port]);
NetIGDControl := AnsiString(Urls.controlURL);
NetIGDService := data.first.servicetype;
- NetPortForwarded := NetPort;
+ NetPortForwarded := NetHost.address.port;
FreeUPNPDevList(DevList);
FreeUPNPUrls(@Urls);
if NetPongForwarded then
begin
NetPongForwarded := False;
- StrPort := IntToStr(NetPortForwarded + 1);
+ StrPort := IntToStr(NET_PING_PORT);
I := UPNP_DeletePortMapping(
PChar(NetIGDControl), Addr(NetIGDService[1]),
PChar(StrPort), PChar('UDP'), nil
);
- conwritefln(' port %d: %d', [NetPortForwarded + 1, I]);
+ conwritefln(' port %d: %d', [NET_PING_PORT, I]);
end;
NetPortForwarded := 0;
SetLength(NetServerName, 64);
g_Net_Slist_ServerRenamed();
end;
- g_Console_Add(cmd + ' = "' + NetServerName + '"');
+ g_Console_Add(cmd + ' "' + NetServerName + '"');
end;
'sv_passwd':
begin
SetLength(NetPassword, 24);
g_Net_Slist_ServerRenamed();
end;
- g_Console_Add(cmd + ' = "' + AnsiLowerCase(NetPassword) + '"');
+ g_Console_Add(cmd + ' "' + AnsiLowerCase(NetPassword) + '"');
end;
'sv_maxplrs':
begin
if b > NetMaxClients then
begin
s := g_Player_Get(NetClients[a].Player).Name;
- enet_peer_disconnect(NetClients[a].Peer, NET_DISC_FULL);
+ g_Net_Host_Kick(NetClients[a].ID, NET_DISC_FULL);
g_Console_Add(Format(_lc[I_PLAYER_KICK], [s]));
MH_SEND_GameEvent(NET_EV_PLAYER_KICK, 0, s);
end;
g_Net_Slist_ServerRenamed();
end;
end;
- g_Console_Add(cmd + ' = ' + IntToStr(NetMaxClients));
+ g_Console_Add(cmd + ' ' + IntToStr(NetMaxClients));
end;
'sv_public':
begin
if (Length(P) > 1) then
begin
- NetUseMaster := StrToIntDef(P[1], Byte(NetUseMaster)) > 0;
+ NetUseMaster := StrToIntDef(P[1], Byte(NetUseMaster)) <> 0;
if NetUseMaster then g_Net_Slist_Public() else g_Net_Slist_Private();
end;
- g_Console_Add(cmd + ' = ' + IntToStr(Byte(NetUseMaster)));
+ g_Console_Add(cmd + ' ' + IntToStr(Byte(NetUseMaster)));
+ end;
+ 'sv_port':
+ begin
+ if (Length(P) > 1) then
+ begin
+ if not g_Game_IsNet then
+ NetPort := nclamp(StrToIntDef(P[1], NetPort), 0, $FFFF)
+ else
+ g_Console_Add(_lc[I_MSG_NOT_NETGAME]);
+ end;
+ g_Console_Add(cmd + ' ' + IntToStr(Ord(NetUseMaster)));
end;
end;
end;
conRegVar('cl_predictself', @NetPredictSelf, '', 'predict local player');
conRegVar('cl_forceplayerupdate', @NetForcePlayerUpdate, '', 'update net players on NET_MSG_PLRPOS');
conRegVar('cl_interp', @NetInterpLevel, '', 'net player interpolation steps');
+ conRegVar('cl_last_ip', @NetClientIP, '', 'address of the last you have connected to');
+ conRegVar('cl_last_port', @NetClientPort, '', 'port of the last server you have connected to');
+ conRegVar('cl_deafen', @NetDeafLevel, '', 'filter server messages (0-3)');
+
conRegVar('sv_forwardports', @NetForwardPorts, '', 'forward server port using miniupnpc (requires server restart)');
+ conRegVar('sv_rcon', @NetAllowRCON, '', 'enable remote console');
+ conRegVar('sv_rcon_password', @NetRCONPassword, '', 'remote console password');
+ conRegVar('sv_update_interval', @NetUpdateRate, '', 'unreliable update interval');
+ conRegVar('sv_reliable_interval', @NetRelupdRate, '', 'reliable update interval');
+ conRegVar('sv_master_interval', @NetMasterRate, '', 'master server update interval');
+
+ conRegVar('sv_autoban_threshold', @NetAutoBanLimit, '', 'max crimes before autoban (0 = no autoban)');
+ conRegVar('sv_autoban_permanent', @NetAutoBanPerm, '', 'whether autobans are permanent');
+ conRegVar('sv_autoban_warn', @NetAutoBanWarn, '', 'send warnings to the client when he triggers penalties');
+ conRegVar('sv_autoban_packet_timeout', @NetAutoBanForTimeout, '', 'autoban for packet timeouts');
+
+ conRegVar('sv_auth_timeout', @NetAuthTimeout, '', 'number of msec in which connecting clients must complete auth (0 = unlimited)');
+ conRegVar('sv_packet_timeout', @NetPacketTimeout, '', 'number of msec the client must idle to be kicked (0 = unlimited)');
+
+ conRegVar('net_master_list', @NetMasterList, '', 'list of master servers');
+
SetLength(NetClients, 0);
g_Net_DownloadTimeout := 60;
NetIn.Alloc(NET_BUFSIZE);