1426 lines
34 KiB
C
1426 lines
34 KiB
C
/*
|
|
Copyright (C) 1996-2001 Id Software, Inc.
|
|
Copyright (C) 2010-2014 QuakeSpasm developers
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
// This is enables a simple IP banning mechanism
|
|
#define BAN_TEST
|
|
|
|
#include "q_stdinc.h"
|
|
#include "net_sys.h"
|
|
#include "q_defs.h"
|
|
#include "net_defs.h"
|
|
#include "net_dgrm.h"
|
|
|
|
// these two macros are to make the code more readable
|
|
#define sfunc net_landrivers[sock->landriver]
|
|
#define dfunc net_landrivers[net_landriverlevel]
|
|
|
|
static int32_t net_landriverlevel;
|
|
|
|
/* statistic counters */
|
|
static int32_t packetsSent = 0;
|
|
static int32_t packetsReSent = 0;
|
|
static int32_t packetsReceived = 0;
|
|
static int32_t receivedDuplicateCount = 0;
|
|
static int32_t shortPacketCount = 0;
|
|
static int32_t droppedDatagrams;
|
|
|
|
static struct
|
|
{
|
|
uint32_t length;
|
|
uint32_t sequence;
|
|
byte data[MAX_DATAGRAM];
|
|
} packetBuffer;
|
|
|
|
static int32_t myDriverLevel;
|
|
|
|
extern bool m_return_onerror;
|
|
extern char m_return_reason[32];
|
|
|
|
|
|
static char *StrAddr(struct qsockaddr *addr)
|
|
{
|
|
static char buf[34];
|
|
byte *p = (byte *)addr;
|
|
int32_t n;
|
|
|
|
for(n = 0; n < 16; n++)
|
|
sprintf(buf + n * 2, "%02x", *p++);
|
|
return buf;
|
|
}
|
|
|
|
|
|
#if defined(BAN_TEST)
|
|
|
|
static struct in_addr banAddr;
|
|
static struct in_addr banMask;
|
|
|
|
static void NET_Ban_f(void)
|
|
{
|
|
char addrStr [32];
|
|
char maskStr [32];
|
|
void (*print_fn)(const char *fmt, ...) FUNCP_PRINTF(1, 2);
|
|
|
|
if(cmd_source == src_command)
|
|
{
|
|
if(!sv.active)
|
|
{
|
|
Cmd_ForwardToServer();
|
|
return;
|
|
}
|
|
print_fn = Con_Printf;
|
|
}
|
|
else
|
|
{
|
|
if(G_Float(GBL_deathmatch))
|
|
return;
|
|
print_fn = SV_ClientPrintf;
|
|
}
|
|
|
|
switch(Cmd_Argc())
|
|
{
|
|
case 1:
|
|
if(banAddr.s_addr != INADDR_ANY)
|
|
{
|
|
strcpy(addrStr, inet_ntoa(banAddr));
|
|
strcpy(maskStr, inet_ntoa(banMask));
|
|
print_fn("Banning %s [%s]\n", addrStr, maskStr);
|
|
}
|
|
else
|
|
print_fn("Banning not active\n");
|
|
break;
|
|
|
|
case 2:
|
|
if(q_strcasecmp(Cmd_Argv(1), "off") == 0)
|
|
banAddr.s_addr = INADDR_ANY;
|
|
else
|
|
banAddr.s_addr = inet_addr(Cmd_Argv(1));
|
|
banMask.s_addr = INADDR_NONE;
|
|
break;
|
|
|
|
case 3:
|
|
banAddr.s_addr = inet_addr(Cmd_Argv(1));
|
|
banMask.s_addr = inet_addr(Cmd_Argv(2));
|
|
break;
|
|
|
|
default:
|
|
print_fn("BAN ip_address [mask]\n");
|
|
break;
|
|
}
|
|
}
|
|
#endif // BAN_TEST
|
|
|
|
|
|
int32_t Datagram_SendMessage(qsocket_t *sock, sizebuf_t *data)
|
|
{
|
|
uint32_t packetLen;
|
|
uint32_t dataLen;
|
|
uint32_t eom;
|
|
|
|
#if defined(DEBUG)
|
|
if(data->cursize == 0)
|
|
Sys_Error("Datagram_SendMessage: zero length message\n");
|
|
|
|
if(data->cursize > NET_MAXMESSAGE)
|
|
Sys_Error("Datagram_SendMessage: message too big %" PRIu32 "\n", data->cursize);
|
|
|
|
if(sock->canSend == false)
|
|
Sys_Error("SendMessage: called with canSend == false\n");
|
|
#endif
|
|
|
|
memcpy(sock->sendMessage, data->data, data->cursize);
|
|
sock->sendMessageLength = data->cursize;
|
|
|
|
if(data->cursize <= MAX_DATAGRAM)
|
|
{
|
|
dataLen = data->cursize;
|
|
eom = NETFLAG_EOM;
|
|
}
|
|
else
|
|
{
|
|
dataLen = MAX_DATAGRAM;
|
|
eom = 0;
|
|
}
|
|
packetLen = NET_HEADERSIZE + dataLen;
|
|
|
|
packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
|
|
packetBuffer.sequence = BigLong(sock->sendSequence++);
|
|
memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
|
|
|
sock->canSend = false;
|
|
|
|
if(sfunc.Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
|
|
return -1;
|
|
|
|
sock->lastSendTime = net_time;
|
|
packetsSent++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int32_t SendMessageNext(qsocket_t *sock)
|
|
{
|
|
uint32_t packetLen;
|
|
uint32_t dataLen;
|
|
uint32_t eom;
|
|
|
|
if(sock->sendMessageLength <= MAX_DATAGRAM)
|
|
{
|
|
dataLen = sock->sendMessageLength;
|
|
eom = NETFLAG_EOM;
|
|
}
|
|
else
|
|
{
|
|
dataLen = MAX_DATAGRAM;
|
|
eom = 0;
|
|
}
|
|
packetLen = NET_HEADERSIZE + dataLen;
|
|
|
|
packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
|
|
packetBuffer.sequence = BigLong(sock->sendSequence++);
|
|
memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
|
|
|
sock->sendNext = false;
|
|
|
|
if(sfunc.Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
|
|
return -1;
|
|
|
|
sock->lastSendTime = net_time;
|
|
packetsSent++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int32_t ReSendMessage(qsocket_t *sock)
|
|
{
|
|
uint32_t packetLen;
|
|
uint32_t dataLen;
|
|
uint32_t eom;
|
|
|
|
if(sock->sendMessageLength <= MAX_DATAGRAM)
|
|
{
|
|
dataLen = sock->sendMessageLength;
|
|
eom = NETFLAG_EOM;
|
|
}
|
|
else
|
|
{
|
|
dataLen = MAX_DATAGRAM;
|
|
eom = 0;
|
|
}
|
|
packetLen = NET_HEADERSIZE + dataLen;
|
|
|
|
packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
|
|
packetBuffer.sequence = BigLong(sock->sendSequence - 1);
|
|
memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
|
|
|
sock->sendNext = false;
|
|
|
|
if(sfunc.Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
|
|
return -1;
|
|
|
|
sock->lastSendTime = net_time;
|
|
packetsReSent++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
bool Datagram_CanSendMessage(qsocket_t *sock)
|
|
{
|
|
if(sock->sendNext)
|
|
SendMessageNext(sock);
|
|
|
|
return sock->canSend;
|
|
}
|
|
|
|
|
|
bool Datagram_CanSendUnreliableMessage(qsocket_t *sock)
|
|
{
|
|
(void)sock;
|
|
return true;
|
|
}
|
|
|
|
|
|
int32_t Datagram_SendUnreliableMessage(qsocket_t *sock, sizebuf_t *data)
|
|
{
|
|
int32_t packetLen;
|
|
|
|
#if defined(DEBUG)
|
|
if(data->cursize == 0)
|
|
Sys_Error("Datagram_SendUnreliableMessage: zero length message\n");
|
|
|
|
if(data->cursize > MAX_DATAGRAM)
|
|
Sys_Error("Datagram_SendUnreliableMessage: message too big %" PRIu32 "\n", data->cursize);
|
|
#endif
|
|
|
|
packetLen = NET_HEADERSIZE + data->cursize;
|
|
|
|
packetBuffer.length = BigLong(packetLen | NETFLAG_UNRELIABLE);
|
|
packetBuffer.sequence = BigLong(sock->unreliableSendSequence++);
|
|
memcpy(packetBuffer.data, data->data, data->cursize);
|
|
|
|
if(sfunc.Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
|
|
return -1;
|
|
|
|
packetsSent++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
int32_t Datagram_GetMessage(qsocket_t *sock)
|
|
{
|
|
uint32_t length;
|
|
uint32_t flags;
|
|
int32_t ret = 0;
|
|
struct qsockaddr readaddr;
|
|
uint32_t sequence;
|
|
uint32_t count;
|
|
|
|
if(!sock->canSend)
|
|
if((net_time - sock->lastSendTime) > 1.0)
|
|
ReSendMessage(sock);
|
|
|
|
while(1)
|
|
{
|
|
length = (uint32_t) sfunc.Read(sock->socket, (byte *)&packetBuffer,
|
|
NET_DATAGRAMSIZE, &readaddr);
|
|
|
|
// if ((rand() & 255) > 220)
|
|
// continue;
|
|
|
|
if(length == 0)
|
|
break;
|
|
|
|
if(length == (uint32_t) -1)
|
|
{
|
|
Con_Printf("Read error\n");
|
|
return -1;
|
|
}
|
|
|
|
if(sfunc.AddrCompare(&readaddr, &sock->addr) != 0)
|
|
{
|
|
Con_Printf("Forged packet received\n");
|
|
Con_Printf("Expected: %s\n", StrAddr(&sock->addr));
|
|
Con_Printf("Received: %s\n", StrAddr(&readaddr));
|
|
continue;
|
|
}
|
|
|
|
if(length < NET_HEADERSIZE)
|
|
{
|
|
shortPacketCount++;
|
|
continue;
|
|
}
|
|
|
|
length = BigLong(packetBuffer.length);
|
|
flags = length & (~NETFLAG_LENGTH_MASK);
|
|
length &= NETFLAG_LENGTH_MASK;
|
|
|
|
if(flags & NETFLAG_CTL)
|
|
continue;
|
|
|
|
sequence = BigLong(packetBuffer.sequence);
|
|
packetsReceived++;
|
|
|
|
if(flags & NETFLAG_UNRELIABLE)
|
|
{
|
|
if(sequence < sock->unreliableReceiveSequence)
|
|
{
|
|
Con_DPrintf("Got a stale datagram\n");
|
|
ret = 0;
|
|
break;
|
|
}
|
|
if(sequence != sock->unreliableReceiveSequence)
|
|
{
|
|
count = sequence - sock->unreliableReceiveSequence;
|
|
droppedDatagrams += count;
|
|
Con_DPrintf("Dropped %" PRIu32 " datagram(s)\n", count);
|
|
}
|
|
sock->unreliableReceiveSequence = sequence + 1;
|
|
|
|
length -= NET_HEADERSIZE;
|
|
|
|
SZ_Clear(&net_message);
|
|
SZ_Write(&net_message, packetBuffer.data, length);
|
|
|
|
ret = 2;
|
|
break;
|
|
}
|
|
|
|
if(flags & NETFLAG_ACK)
|
|
{
|
|
if(sequence != (sock->sendSequence - 1))
|
|
{
|
|
Con_DPrintf("Stale ACK received\n");
|
|
continue;
|
|
}
|
|
if(sequence == sock->ackSequence)
|
|
{
|
|
sock->ackSequence++;
|
|
if(sock->ackSequence != sock->sendSequence)
|
|
Con_DPrintf("ack sequencing error\n");
|
|
}
|
|
else
|
|
{
|
|
Con_DPrintf("Duplicate ACK received\n");
|
|
continue;
|
|
}
|
|
sock->sendMessageLength -= MAX_DATAGRAM;
|
|
if(sock->sendMessageLength > 0)
|
|
{
|
|
memmove(sock->sendMessage, sock->sendMessage + MAX_DATAGRAM, sock->sendMessageLength);
|
|
sock->sendNext = true;
|
|
}
|
|
else
|
|
{
|
|
sock->sendMessageLength = 0;
|
|
sock->canSend = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if(flags & NETFLAG_DATA)
|
|
{
|
|
packetBuffer.length = BigLong(NET_HEADERSIZE | NETFLAG_ACK);
|
|
packetBuffer.sequence = BigLong(sequence);
|
|
sfunc.Write(sock->socket, (byte *)&packetBuffer, NET_HEADERSIZE, &readaddr);
|
|
|
|
if(sequence != sock->receiveSequence)
|
|
{
|
|
receivedDuplicateCount++;
|
|
continue;
|
|
}
|
|
sock->receiveSequence++;
|
|
|
|
length -= NET_HEADERSIZE;
|
|
|
|
if(flags & NETFLAG_EOM)
|
|
{
|
|
SZ_Clear(&net_message);
|
|
SZ_Write(&net_message, sock->receiveMessage, sock->receiveMessageLength);
|
|
SZ_Write(&net_message, packetBuffer.data, length);
|
|
sock->receiveMessageLength = 0;
|
|
|
|
ret = 1;
|
|
break;
|
|
}
|
|
|
|
memcpy(sock->receiveMessage + sock->receiveMessageLength, packetBuffer.data, length);
|
|
sock->receiveMessageLength += length;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if(sock->sendNext)
|
|
SendMessageNext(sock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void PrintStats(qsocket_t *s)
|
|
{
|
|
Con_Printf("canSend = %4" PRIu32 " \n", s->canSend);
|
|
Con_Printf("sendSeq = %4" PRIu32 " ", s->sendSequence);
|
|
Con_Printf("recvSeq = %4" PRIu32 " \n", s->receiveSequence);
|
|
Con_Printf("\n");
|
|
}
|
|
|
|
static void NET_Stats_f(void)
|
|
{
|
|
qsocket_t *s;
|
|
|
|
if(Cmd_Argc() == 1)
|
|
{
|
|
Con_Printf("unreliable messages sent = %" PRIi32 "\n", unreliableMessagesSent);
|
|
Con_Printf("unreliable messages recv = %" PRIi32 "\n", unreliableMessagesReceived);
|
|
Con_Printf("reliable messages sent = %" PRIi32 "\n", messagesSent);
|
|
Con_Printf("reliable messages received = %" PRIi32 "\n", messagesReceived);
|
|
Con_Printf("packetsSent = %" PRIi32 "\n", packetsSent);
|
|
Con_Printf("packetsReSent = %" PRIi32 "\n", packetsReSent);
|
|
Con_Printf("packetsReceived = %" PRIi32 "\n", packetsReceived);
|
|
Con_Printf("receivedDuplicateCount = %" PRIi32 "\n", receivedDuplicateCount);
|
|
Con_Printf("shortPacketCount = %" PRIi32 "\n", shortPacketCount);
|
|
Con_Printf("droppedDatagrams = %" PRIi32 "\n", droppedDatagrams);
|
|
}
|
|
else if(strcmp(Cmd_Argv(1), "*") == 0)
|
|
{
|
|
for(s = net_activeSockets; s; s = s->next)
|
|
PrintStats(s);
|
|
for(s = net_freeSockets; s; s = s->next)
|
|
PrintStats(s);
|
|
}
|
|
else
|
|
{
|
|
for(s = net_activeSockets; s; s = s->next)
|
|
{
|
|
if(q_strcasecmp(Cmd_Argv(1), s->address) == 0)
|
|
break;
|
|
}
|
|
|
|
if(s == NULL)
|
|
{
|
|
for(s = net_freeSockets; s; s = s->next)
|
|
{
|
|
if(q_strcasecmp(Cmd_Argv(1), s->address) == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(s == NULL)
|
|
return;
|
|
|
|
PrintStats(s);
|
|
}
|
|
}
|
|
|
|
|
|
// recognize ip:port (based on ProQuake)
|
|
static const char *Strip_Port(const char *host)
|
|
{
|
|
static char noport[MAX_QPATH];
|
|
/* array size as in Host_Connect_f() */
|
|
char *p;
|
|
int32_t port;
|
|
|
|
if(!host || !*host)
|
|
return host;
|
|
q_strlcpy(noport, host, sizeof(noport));
|
|
if((p = strrchr(noport, ':')) == NULL)
|
|
return host;
|
|
*p++ = '\0';
|
|
port = atoi(p);
|
|
if(port > 0 && port < 65536 && port != net_hostport)
|
|
{
|
|
net_hostport = port;
|
|
Con_Printf("Port set to %" PRIi32 "\n", net_hostport);
|
|
}
|
|
return noport;
|
|
}
|
|
|
|
|
|
static bool testInProgress = false;
|
|
static int32_t testPollCount;
|
|
static int32_t testDriver;
|
|
static sys_socket_t testSocket;
|
|
|
|
static void Test_Poll(void *unused);
|
|
static PollProcedure testPollProcedure = {NULL, 0.0, Test_Poll};
|
|
|
|
static void Test_Poll(void *unused)
|
|
{
|
|
struct qsockaddr clientaddr;
|
|
int32_t control;
|
|
int32_t len;
|
|
char name[32];
|
|
char address[64];
|
|
int32_t colors;
|
|
int32_t frags;
|
|
int32_t connectTime;
|
|
|
|
(void)unused;
|
|
|
|
net_landriverlevel = testDriver;
|
|
|
|
while(1)
|
|
{
|
|
len = dfunc.Read(testSocket, net_message.data, net_message.maxsize, &clientaddr);
|
|
if(len < (int32_t) sizeof(int32_t))
|
|
break;
|
|
|
|
net_message.cursize = len;
|
|
|
|
MSG_BeginReading();
|
|
control = BigLong(*((int32_t *)net_message.data));
|
|
MSG_ReadLong();
|
|
if(control == -1)
|
|
break;
|
|
if((control & (~NETFLAG_LENGTH_MASK)) != (int32_t)NETFLAG_CTL)
|
|
break;
|
|
if((control & NETFLAG_LENGTH_MASK) != len)
|
|
break;
|
|
|
|
if(MSG_ReadByte() != CCREP_PLAYER_INFO)
|
|
Sys_Error("Unexpected repsonse to Player Info request\n");
|
|
|
|
MSG_ReadByte(); /* playerNumber */
|
|
strcpy(name, MSG_ReadString());
|
|
colors = MSG_ReadLong();
|
|
frags = MSG_ReadLong();
|
|
connectTime = MSG_ReadLong();
|
|
strcpy(address, MSG_ReadString());
|
|
|
|
Con_Printf("%s\n frags:%3" PRIi32 " colors:%" PRIi32 " %" PRIi32 " time:%" PRIi32 "\n %s\n", name, frags, colors >> 4, colors & 0x0f, connectTime / 60, address);
|
|
}
|
|
|
|
testPollCount--;
|
|
if(testPollCount)
|
|
{
|
|
SchedulePollProcedure(&testPollProcedure, 0.1);
|
|
}
|
|
else
|
|
{
|
|
dfunc.Close_Socket(testSocket);
|
|
testInProgress = false;
|
|
}
|
|
}
|
|
|
|
static void Test_f(void)
|
|
{
|
|
const char *host;
|
|
int32_t n;
|
|
int32_t maxusers = MAX_SCOREBOARD;
|
|
struct qsockaddr sendaddr;
|
|
|
|
if(testInProgress)
|
|
return;
|
|
|
|
host = Strip_Port(Cmd_Argv(1));
|
|
|
|
if(host && hostCacheCount)
|
|
{
|
|
for(n = 0; n < hostCacheCount; n++)
|
|
{
|
|
if(q_strcasecmp(host, hostcache[n].name) == 0)
|
|
{
|
|
if(hostcache[n].driver != myDriverLevel)
|
|
continue;
|
|
net_landriverlevel = hostcache[n].ldriver;
|
|
maxusers = hostcache[n].maxusers;
|
|
memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
|
|
break;
|
|
}
|
|
}
|
|
if(n < hostCacheCount)
|
|
goto justdoit;
|
|
}
|
|
|
|
for(net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
|
|
{
|
|
if(!net_landrivers[net_landriverlevel].initialized)
|
|
continue;
|
|
|
|
// see if we can resolve the host name
|
|
if(dfunc.GetAddrFromName(host, &sendaddr) != -1)
|
|
break;
|
|
}
|
|
|
|
if(net_landriverlevel == net_numlandrivers)
|
|
{
|
|
Con_Printf("Could not resolve %s\n", host);
|
|
return;
|
|
}
|
|
|
|
justdoit:
|
|
testSocket = dfunc.Open_Socket(0);
|
|
if(testSocket == INVALID_SOCKET)
|
|
return;
|
|
|
|
testInProgress = true;
|
|
testPollCount = 20;
|
|
testDriver = net_landriverlevel;
|
|
|
|
for(n = 0; n < maxusers; n++)
|
|
{
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREQ_PLAYER_INFO);
|
|
MSG_WriteByte(&net_message, n);
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(testSocket, net_message.data, net_message.cursize, &sendaddr);
|
|
}
|
|
SZ_Clear(&net_message);
|
|
SchedulePollProcedure(&testPollProcedure, 0.1);
|
|
}
|
|
|
|
|
|
static bool test2InProgress = false;
|
|
static int32_t test2Driver;
|
|
static sys_socket_t test2Socket;
|
|
|
|
static void Test2_Poll(void *unused);
|
|
static PollProcedure test2PollProcedure = {NULL, 0.0, Test2_Poll};
|
|
|
|
static void Test2_Poll(void *unused)
|
|
{
|
|
struct qsockaddr clientaddr;
|
|
int32_t control;
|
|
int32_t len;
|
|
char name[256];
|
|
char value[256];
|
|
|
|
(void)unused;
|
|
|
|
net_landriverlevel = test2Driver;
|
|
name[0] = 0;
|
|
|
|
len = dfunc.Read(test2Socket, net_message.data, net_message.maxsize, &clientaddr);
|
|
if(len < (int32_t) sizeof(int32_t))
|
|
goto reschedule;
|
|
|
|
net_message.cursize = len;
|
|
|
|
MSG_BeginReading();
|
|
control = BigLong(*((int32_t *)net_message.data));
|
|
MSG_ReadLong();
|
|
if(control == -1)
|
|
goto error;
|
|
if((control & (~NETFLAG_LENGTH_MASK)) != (int32_t)NETFLAG_CTL)
|
|
goto error;
|
|
if((control & NETFLAG_LENGTH_MASK) != len)
|
|
goto error;
|
|
|
|
if(MSG_ReadByte() != CCREP_RULE_INFO)
|
|
goto error;
|
|
|
|
strcpy(name, MSG_ReadString());
|
|
if(name[0] == 0)
|
|
goto done;
|
|
strcpy(value, MSG_ReadString());
|
|
|
|
Con_Printf("%-16.16s %-16.16s\n", name, value);
|
|
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREQ_RULE_INFO);
|
|
MSG_WriteString(&net_message, name);
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(test2Socket, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
|
|
reschedule:
|
|
SchedulePollProcedure(&test2PollProcedure, 0.05);
|
|
return;
|
|
|
|
error:
|
|
Con_Printf("Unexpected repsonse to Rule Info request\n");
|
|
done:
|
|
dfunc.Close_Socket(test2Socket);
|
|
test2InProgress = false;
|
|
return;
|
|
}
|
|
|
|
static void Test2_f(void)
|
|
{
|
|
const char *host;
|
|
int32_t n;
|
|
struct qsockaddr sendaddr;
|
|
|
|
if(test2InProgress)
|
|
return;
|
|
|
|
host = Strip_Port(Cmd_Argv(1));
|
|
|
|
if(host && hostCacheCount)
|
|
{
|
|
for(n = 0; n < hostCacheCount; n++)
|
|
{
|
|
if(q_strcasecmp(host, hostcache[n].name) == 0)
|
|
{
|
|
if(hostcache[n].driver != myDriverLevel)
|
|
continue;
|
|
net_landriverlevel = hostcache[n].ldriver;
|
|
memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(n < hostCacheCount)
|
|
goto justdoit;
|
|
}
|
|
|
|
for(net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
|
|
{
|
|
if(!net_landrivers[net_landriverlevel].initialized)
|
|
continue;
|
|
|
|
// see if we can resolve the host name
|
|
if(dfunc.GetAddrFromName(host, &sendaddr) != -1)
|
|
break;
|
|
}
|
|
|
|
if(net_landriverlevel == net_numlandrivers)
|
|
{
|
|
Con_Printf("Could not resolve %s\n", host);
|
|
return;
|
|
}
|
|
|
|
justdoit:
|
|
test2Socket = dfunc.Open_Socket(0);
|
|
if(test2Socket == INVALID_SOCKET)
|
|
return;
|
|
|
|
test2InProgress = true;
|
|
test2Driver = net_landriverlevel;
|
|
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREQ_RULE_INFO);
|
|
MSG_WriteString(&net_message, "");
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(test2Socket, net_message.data, net_message.cursize, &sendaddr);
|
|
SZ_Clear(&net_message);
|
|
SchedulePollProcedure(&test2PollProcedure, 0.05);
|
|
}
|
|
|
|
|
|
int32_t Datagram_Init(void)
|
|
{
|
|
int32_t i, num_inited;
|
|
sys_socket_t csock;
|
|
|
|
#if defined(BAN_TEST)
|
|
banAddr.s_addr = INADDR_ANY;
|
|
banMask.s_addr = INADDR_NONE;
|
|
#endif
|
|
myDriverLevel = net_driverlevel;
|
|
|
|
Cmd_AddCommand("net_stats", NET_Stats_f);
|
|
|
|
if(safemode || COM_CheckParm("-nolan"))
|
|
return -1;
|
|
|
|
num_inited = 0;
|
|
for(i = 0; i < net_numlandrivers; i++)
|
|
{
|
|
csock = net_landrivers[i].Init();
|
|
if(csock == INVALID_SOCKET)
|
|
continue;
|
|
net_landrivers[i].initialized = true;
|
|
net_landrivers[i].controlSock = csock;
|
|
num_inited++;
|
|
}
|
|
|
|
if(num_inited == 0)
|
|
return -1;
|
|
|
|
#if defined(BAN_TEST)
|
|
Cmd_AddCommand("ban", NET_Ban_f);
|
|
#endif
|
|
Cmd_AddCommand("test", Test_f);
|
|
Cmd_AddCommand("test2", Test2_f);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void Datagram_Shutdown(void)
|
|
{
|
|
int32_t i;
|
|
|
|
//
|
|
// shutdown the lan drivers
|
|
//
|
|
for(i = 0; i < net_numlandrivers; i++)
|
|
{
|
|
if(net_landrivers[i].initialized)
|
|
{
|
|
net_landrivers[i].Shutdown();
|
|
net_landrivers[i].initialized = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Datagram_Close(qsocket_t *sock)
|
|
{
|
|
sfunc.Close_Socket(sock->socket);
|
|
}
|
|
|
|
|
|
void Datagram_Listen(bool state)
|
|
{
|
|
int32_t i;
|
|
|
|
for(i = 0; i < net_numlandrivers; i++)
|
|
{
|
|
if(net_landrivers[i].initialized)
|
|
net_landrivers[i].Listen(state);
|
|
}
|
|
}
|
|
|
|
|
|
static qsocket_t *Datagram_CheckNewConnections_(void)
|
|
{
|
|
struct qsockaddr clientaddr;
|
|
struct qsockaddr newaddr;
|
|
sys_socket_t newsock;
|
|
sys_socket_t acceptsock;
|
|
qsocket_t *sock;
|
|
qsocket_t *s;
|
|
int32_t len;
|
|
int32_t command;
|
|
int32_t control;
|
|
int32_t ret;
|
|
|
|
acceptsock = dfunc.CheckNewConnections();
|
|
if(acceptsock == INVALID_SOCKET)
|
|
return NULL;
|
|
|
|
SZ_Clear(&net_message);
|
|
|
|
len = dfunc.Read(acceptsock, net_message.data, net_message.maxsize, &clientaddr);
|
|
if(len < (int32_t) sizeof(int32_t))
|
|
return NULL;
|
|
net_message.cursize = len;
|
|
|
|
MSG_BeginReading();
|
|
control = BigLong(*((int32_t *)net_message.data));
|
|
MSG_ReadLong();
|
|
if(control == -1)
|
|
return NULL;
|
|
if((control & (~NETFLAG_LENGTH_MASK)) != (int32_t)NETFLAG_CTL)
|
|
return NULL;
|
|
if((control & NETFLAG_LENGTH_MASK) != len)
|
|
return NULL;
|
|
|
|
command = MSG_ReadByte();
|
|
if(command == CCREQ_SERVER_INFO)
|
|
{
|
|
if(strcmp(MSG_ReadString(), "QUAKE") != 0)
|
|
return NULL;
|
|
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREP_SERVER_INFO);
|
|
dfunc.GetSocketAddr(acceptsock, &newaddr);
|
|
MSG_WriteString(&net_message, dfunc.AddrToString(&newaddr));
|
|
MSG_WriteString(&net_message, hostname.string);
|
|
MSG_WriteString(&net_message, sv.name);
|
|
MSG_WriteByte(&net_message, net_activeconnections);
|
|
MSG_WriteByte(&net_message, svs.maxclients);
|
|
MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
return NULL;
|
|
}
|
|
|
|
if(command == CCREQ_PLAYER_INFO)
|
|
{
|
|
int32_t playerNumber;
|
|
int32_t activeNumber;
|
|
int32_t clientNumber;
|
|
client_t *client;
|
|
|
|
playerNumber = MSG_ReadByte();
|
|
activeNumber = -1;
|
|
|
|
for(clientNumber = 0, client = svs.clients; clientNumber < svs.maxclients; clientNumber++, client++)
|
|
{
|
|
if(client->active)
|
|
{
|
|
activeNumber++;
|
|
if(activeNumber == playerNumber)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(clientNumber == svs.maxclients)
|
|
return NULL;
|
|
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREP_PLAYER_INFO);
|
|
MSG_WriteByte(&net_message, playerNumber);
|
|
MSG_WriteString(&net_message, client->name);
|
|
MSG_WriteLong(&net_message, client->colors);
|
|
MSG_WriteLong(&net_message, (int32_t)ED_Float(client->edict, ED_frags));
|
|
MSG_WriteLong(&net_message, (int32_t)(net_time - client->netconnection->connecttime));
|
|
MSG_WriteString(&net_message, client->netconnection->address);
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if(command == CCREQ_RULE_INFO)
|
|
{
|
|
const char *prevCvarName;
|
|
cvar_t *var;
|
|
|
|
// find the search start location
|
|
prevCvarName = MSG_ReadString();
|
|
var = Cvar_FindVarAfter(prevCvarName, CVAR_SERVERINFO);
|
|
|
|
// send the response
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREP_RULE_INFO);
|
|
if(var)
|
|
{
|
|
MSG_WriteString(&net_message, var->name);
|
|
MSG_WriteString(&net_message, var->string);
|
|
}
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if(command != CCREQ_CONNECT)
|
|
return NULL;
|
|
|
|
if(strcmp(MSG_ReadString(), "QUAKE") != 0)
|
|
return NULL;
|
|
|
|
if(MSG_ReadByte() != NET_PROTOCOL_VERSION)
|
|
{
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREP_REJECT);
|
|
MSG_WriteString(&net_message, "Incompatible version.\n");
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(BAN_TEST)
|
|
// check for a ban
|
|
if(clientaddr.qsa_family == AF_INET)
|
|
{
|
|
in_addr_t testAddr;
|
|
testAddr = ((struct sockaddr_in *)&clientaddr)->sin_addr.s_addr;
|
|
if((testAddr & banMask.s_addr) == banAddr.s_addr)
|
|
{
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREP_REJECT);
|
|
MSG_WriteString(&net_message, "You have been banned.\n");
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
return NULL;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// see if this guy is already connected
|
|
for(s = net_activeSockets; s; s = s->next)
|
|
{
|
|
if(s->driver != net_driverlevel)
|
|
continue;
|
|
ret = dfunc.AddrCompare(&clientaddr, &s->addr);
|
|
if(ret >= 0)
|
|
{
|
|
// is this a duplicate connection reqeust?
|
|
if(ret == 0 && net_time - s->connecttime < 2.0)
|
|
{
|
|
// yes, so send a duplicate reply
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREP_ACCEPT);
|
|
dfunc.GetSocketAddr(s->socket, &newaddr);
|
|
MSG_WriteLong(&net_message, dfunc.GetSocketPort(&newaddr));
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
return NULL;
|
|
}
|
|
// it's somebody coming back in from a crash/disconnect
|
|
// so close the old qsocket and let their retry get them back in
|
|
NET_Close(s);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
// allocate a QSocket
|
|
sock = NET_NewQSocket();
|
|
if(sock == NULL)
|
|
{
|
|
// no room; try to let him know
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREP_REJECT);
|
|
MSG_WriteString(&net_message, "Server is full.\n");
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
return NULL;
|
|
}
|
|
|
|
// allocate a network socket
|
|
newsock = dfunc.Open_Socket(0);
|
|
if(newsock == INVALID_SOCKET)
|
|
{
|
|
NET_FreeQSocket(sock);
|
|
return NULL;
|
|
}
|
|
|
|
// connect to the client
|
|
if(dfunc.Connect(newsock, &clientaddr) == -1)
|
|
{
|
|
dfunc.Close_Socket(newsock);
|
|
NET_FreeQSocket(sock);
|
|
return NULL;
|
|
}
|
|
|
|
// everything is allocated, just fill in the details
|
|
sock->socket = newsock;
|
|
sock->landriver = net_landriverlevel;
|
|
sock->addr = clientaddr;
|
|
strcpy(sock->address, dfunc.AddrToString(&clientaddr));
|
|
|
|
// send him back the info about the server connection he has been allocated
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREP_ACCEPT);
|
|
dfunc.GetSocketAddr(newsock, &newaddr);
|
|
MSG_WriteLong(&net_message, dfunc.GetSocketPort(&newaddr));
|
|
// MSG_WriteString(&net_message, dfunc.AddrToString(&newaddr));
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
|
|
SZ_Clear(&net_message);
|
|
|
|
return sock;
|
|
}
|
|
|
|
qsocket_t *Datagram_CheckNewConnections(void)
|
|
{
|
|
qsocket_t *ret = NULL;
|
|
|
|
for(net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
|
|
{
|
|
if(net_landrivers[net_landriverlevel].initialized)
|
|
{
|
|
if((ret = Datagram_CheckNewConnections_()) != NULL)
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void Datagram_SearchForHosts_(bool xmit)
|
|
{
|
|
int32_t ret;
|
|
int32_t n;
|
|
int32_t i;
|
|
struct qsockaddr readaddr;
|
|
struct qsockaddr myaddr;
|
|
int32_t control;
|
|
|
|
dfunc.GetSocketAddr(dfunc.controlSock, &myaddr);
|
|
if(xmit)
|
|
{
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREQ_SERVER_INFO);
|
|
MSG_WriteString(&net_message, "QUAKE");
|
|
MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Broadcast(dfunc.controlSock, net_message.data, net_message.cursize);
|
|
SZ_Clear(&net_message);
|
|
}
|
|
|
|
while((ret = dfunc.Read(dfunc.controlSock, net_message.data, net_message.maxsize, &readaddr)) > 0)
|
|
{
|
|
if(ret < (int32_t) sizeof(int32_t))
|
|
continue;
|
|
net_message.cursize = ret;
|
|
|
|
// don't answer our own query
|
|
if(dfunc.AddrCompare(&readaddr, &myaddr) >= 0)
|
|
continue;
|
|
|
|
// is the cache full?
|
|
if(hostCacheCount == HOSTCACHESIZE)
|
|
continue;
|
|
|
|
MSG_BeginReading();
|
|
control = BigLong(*((int32_t *)net_message.data));
|
|
MSG_ReadLong();
|
|
if(control == -1)
|
|
continue;
|
|
if((control & (~NETFLAG_LENGTH_MASK)) != (int32_t)NETFLAG_CTL)
|
|
continue;
|
|
if((control & NETFLAG_LENGTH_MASK) != ret)
|
|
continue;
|
|
|
|
if(MSG_ReadByte() != CCREP_SERVER_INFO)
|
|
continue;
|
|
|
|
dfunc.GetAddrFromName(MSG_ReadString(), &readaddr);
|
|
// search the cache for this server
|
|
for(n = 0; n < hostCacheCount; n++)
|
|
{
|
|
if(dfunc.AddrCompare(&readaddr, &hostcache[n].addr) == 0)
|
|
break;
|
|
}
|
|
|
|
// is it already there?
|
|
if(n < hostCacheCount)
|
|
continue;
|
|
|
|
// add it
|
|
hostCacheCount++;
|
|
strcpy(hostcache[n].name, MSG_ReadString());
|
|
strcpy(hostcache[n].map, MSG_ReadString());
|
|
hostcache[n].users = MSG_ReadByte();
|
|
hostcache[n].maxusers = MSG_ReadByte();
|
|
if(MSG_ReadByte() != NET_PROTOCOL_VERSION)
|
|
{
|
|
strcpy(hostcache[n].cname, hostcache[n].name);
|
|
hostcache[n].cname[14] = 0;
|
|
strcpy(hostcache[n].name, "*");
|
|
strcat(hostcache[n].name, hostcache[n].cname);
|
|
}
|
|
memcpy(&hostcache[n].addr, &readaddr, sizeof(struct qsockaddr));
|
|
hostcache[n].driver = net_driverlevel;
|
|
hostcache[n].ldriver = net_landriverlevel;
|
|
strcpy(hostcache[n].cname, dfunc.AddrToString(&readaddr));
|
|
|
|
// check for a name conflict
|
|
for(i = 0; i < hostCacheCount; i++)
|
|
{
|
|
if(i == n)
|
|
continue;
|
|
if(q_strcasecmp(hostcache[n].name, hostcache[i].name) == 0)
|
|
{
|
|
i = strlen(hostcache[n].name);
|
|
if(i < 15 && hostcache[n].name[i - 1] > '8')
|
|
{
|
|
hostcache[n].name[i] = '0';
|
|
hostcache[n].name[i + 1] = 0;
|
|
}
|
|
else
|
|
hostcache[n].name[i - 1]++;
|
|
|
|
i = -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Datagram_SearchForHosts(bool xmit)
|
|
{
|
|
for(net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
|
|
{
|
|
if(hostCacheCount == HOSTCACHESIZE)
|
|
break;
|
|
if(net_landrivers[net_landriverlevel].initialized)
|
|
Datagram_SearchForHosts_(xmit);
|
|
}
|
|
}
|
|
|
|
|
|
static qsocket_t *Datagram_Connect_(const char *host)
|
|
{
|
|
struct qsockaddr sendaddr;
|
|
struct qsockaddr readaddr;
|
|
qsocket_t *sock;
|
|
sys_socket_t newsock;
|
|
int32_t ret;
|
|
int32_t reps;
|
|
double start_time;
|
|
int32_t control;
|
|
const char *reason;
|
|
|
|
// see if we can resolve the host name
|
|
if(dfunc.GetAddrFromName(host, &sendaddr) == -1)
|
|
{
|
|
Con_Printf("Could not resolve %s\n", host);
|
|
return NULL;
|
|
}
|
|
|
|
newsock = dfunc.Open_Socket(0);
|
|
if(newsock == INVALID_SOCKET)
|
|
return NULL;
|
|
|
|
sock = NET_NewQSocket();
|
|
if(sock == NULL)
|
|
goto error2;
|
|
sock->socket = newsock;
|
|
sock->landriver = net_landriverlevel;
|
|
|
|
// connect to the host
|
|
if(dfunc.Connect(newsock, &sendaddr) == -1)
|
|
goto error;
|
|
|
|
// send the connection request
|
|
Con_Printf("trying...\n");
|
|
SCR_UpdateScreen();
|
|
start_time = net_time;
|
|
|
|
for(reps = 0; reps < 3; reps++)
|
|
{
|
|
SZ_Clear(&net_message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong(&net_message, 0);
|
|
MSG_WriteByte(&net_message, CCREQ_CONNECT);
|
|
MSG_WriteString(&net_message, "QUAKE");
|
|
MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
|
|
*((int32_t *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
|
|
dfunc.Write(newsock, net_message.data, net_message.cursize, &sendaddr);
|
|
SZ_Clear(&net_message);
|
|
do
|
|
{
|
|
ret = dfunc.Read(newsock, net_message.data, net_message.maxsize, &readaddr);
|
|
// if we got something, validate it
|
|
if(ret > 0)
|
|
{
|
|
// is it from the right place?
|
|
if(sfunc.AddrCompare(&readaddr, &sendaddr) != 0)
|
|
{
|
|
Con_Printf("wrong reply address\n");
|
|
Con_Printf("Expected: %s | %s\n", dfunc.AddrToString(&sendaddr), StrAddr(&sendaddr));
|
|
Con_Printf("Received: %s | %s\n", dfunc.AddrToString(&readaddr), StrAddr(&readaddr));
|
|
SCR_UpdateScreen();
|
|
ret = 0;
|
|
continue;
|
|
}
|
|
|
|
if(ret < (int32_t) sizeof(int32_t))
|
|
{
|
|
ret = 0;
|
|
continue;
|
|
}
|
|
|
|
net_message.cursize = ret;
|
|
MSG_BeginReading();
|
|
|
|
control = BigLong(*((int32_t *)net_message.data));
|
|
MSG_ReadLong();
|
|
if(control == -1)
|
|
{
|
|
ret = 0;
|
|
continue;
|
|
}
|
|
if((control & (~NETFLAG_LENGTH_MASK)) != (int32_t)NETFLAG_CTL)
|
|
{
|
|
ret = 0;
|
|
continue;
|
|
}
|
|
if((control & NETFLAG_LENGTH_MASK) != ret)
|
|
{
|
|
ret = 0;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
while(ret == 0 && (SetNetTime() - start_time) < 2.5);
|
|
|
|
if(ret)
|
|
break;
|
|
|
|
Con_Printf("still trying...\n");
|
|
SCR_UpdateScreen();
|
|
start_time = SetNetTime();
|
|
}
|
|
|
|
if(ret == 0)
|
|
{
|
|
reason = "No Response";
|
|
Con_Printf("%s\n", reason);
|
|
strcpy(m_return_reason, reason);
|
|
goto error;
|
|
}
|
|
|
|
if(ret == -1)
|
|
{
|
|
reason = "Network error";
|
|
Con_Printf("%s\n", reason);
|
|
strcpy(m_return_reason, reason);
|
|
goto error;
|
|
}
|
|
|
|
ret = MSG_ReadByte();
|
|
if(ret == CCREP_REJECT)
|
|
{
|
|
reason = MSG_ReadString();
|
|
Con_Printf("%s\n", reason);
|
|
q_strlcpy(m_return_reason, reason, sizeof(m_return_reason));
|
|
goto error;
|
|
}
|
|
|
|
if(ret == CCREP_ACCEPT)
|
|
{
|
|
memcpy(&sock->addr, &sendaddr, sizeof(struct qsockaddr));
|
|
dfunc.SetSocketPort(&sock->addr, MSG_ReadLong());
|
|
}
|
|
else
|
|
{
|
|
reason = "Bad Response";
|
|
Con_Printf("%s\n", reason);
|
|
strcpy(m_return_reason, reason);
|
|
goto error;
|
|
}
|
|
|
|
dfunc.GetNameFromAddr(&sendaddr, sock->address);
|
|
|
|
Con_Printf("Connection accepted\n");
|
|
sock->lastMessageTime = SetNetTime();
|
|
|
|
// switch the connection to the specified address
|
|
if(dfunc.Connect(newsock, &sock->addr) == -1)
|
|
{
|
|
reason = "Connect to Game failed";
|
|
Con_Printf("%s\n", reason);
|
|
strcpy(m_return_reason, reason);
|
|
goto error;
|
|
}
|
|
|
|
m_return_onerror = false;
|
|
return sock;
|
|
|
|
error:
|
|
NET_FreeQSocket(sock);
|
|
error2:
|
|
dfunc.Close_Socket(newsock);
|
|
if(m_return_onerror)
|
|
{
|
|
IN_Deactivate(modestate == MS_WINDOWED);
|
|
key_dest = key_menu;
|
|
m_state = m_return_state;
|
|
m_return_onerror = false;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
qsocket_t *Datagram_Connect(const char *host)
|
|
{
|
|
qsocket_t *ret = NULL;
|
|
|
|
host = Strip_Port(host);
|
|
for(net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
|
|
{
|
|
if(net_landrivers[net_landriverlevel].initialized)
|
|
{
|
|
if((ret = Datagram_Connect_(host)) != NULL)
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|