mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-12-12 21:52:32 +00:00
dbd3d6502a
I never liked it, but with C2x coming out, it's best to handle bools properly. I haven't gone through all the uses of int as bool (I'll leave that for fixing when I encounter them), but this gets QF working with both c2x (really, gnu2x because of raw strings).
1169 lines
29 KiB
C
1169 lines
29 KiB
C
/*
|
|
net_dgrm.c
|
|
|
|
Datagram network driver.
|
|
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
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:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_STRING_H
|
|
# include <string.h>
|
|
#endif
|
|
#ifdef HAVE_STRINGS_H
|
|
# include <strings.h>
|
|
#endif
|
|
|
|
#include "QF/cmd.h"
|
|
#include "QF/cvar.h"
|
|
#include "QF/sys.h"
|
|
#include "QF/heapsort.h"
|
|
#include "QF/keys.h"
|
|
#include "QF/qendian.h"
|
|
#include "QF/msg.h"
|
|
#include "QF/qargs.h"
|
|
#include "QF/screen.h"
|
|
|
|
#include "netmain.h"
|
|
|
|
//FIXME these should not be here!!!
|
|
#include "client/screen.h"
|
|
#include "../nq/include/client.h"
|
|
#include "../nq/include/server.h"
|
|
|
|
// This is enables a simple IP banning mechanism
|
|
#define BAN_TEST
|
|
|
|
#ifdef BAN_TEST
|
|
#if defined(_WIN32)
|
|
#include "winquake.h"
|
|
typedef uint32_t in_addr_t;
|
|
#else
|
|
# include <sys/socket.h>
|
|
# include <netinet/in.h>
|
|
# include <arpa/inet.h>
|
|
#endif
|
|
#endif // BAN_TEST
|
|
|
|
#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 int net_landriverlevel;
|
|
|
|
/* statistic counters */
|
|
int packetsSent = 0;
|
|
int packetsReSent = 0;
|
|
int packetsReceived = 0;
|
|
int receivedDuplicateCount = 0;
|
|
int shortPacketCount = 0;
|
|
int droppedDatagrams;
|
|
|
|
static int myDriverLevel;
|
|
|
|
static byte dgrm_send_packet_data[MAX_DATAGRAM + NET_HEADERSIZE];
|
|
static sizebuf_t dgrm_send_packet = {
|
|
.data = dgrm_send_packet_data,
|
|
.maxsize = sizeof (dgrm_send_packet_data),
|
|
};
|
|
|
|
static byte dgrm_receive_packet_data[MAX_DATAGRAM + NET_HEADERSIZE];
|
|
static sizebuf_t dgrm_receive_packet = {
|
|
.data = dgrm_receive_packet_data,
|
|
.maxsize = sizeof (dgrm_receive_packet_data),
|
|
};
|
|
static qmsg_t dgrm_message = {
|
|
.message = &dgrm_receive_packet,
|
|
};
|
|
|
|
// FIXME: MENUCODE
|
|
//extern int m_return_state;
|
|
//extern int m_state;
|
|
//extern bool m_return_onerror;
|
|
//extern char m_return_reason[32];
|
|
|
|
|
|
#ifdef BAN_TEST
|
|
in_addr_t banAddr = 0x00000000;
|
|
in_addr_t banMask = 0xffffffff;
|
|
|
|
static void
|
|
NET_Ban_f (void)
|
|
{
|
|
char addrStr[32]; //FIXME: overflow
|
|
char maskStr[32]; //FIXME: overflow
|
|
__attribute__((format(PRINTF, 1, 2))) void (*print) (const char *fmt, ...);
|
|
|
|
if (cmd_source == src_command) {
|
|
if (!sv.active) {
|
|
CL_Cmd_ForwardToServer ();
|
|
return;
|
|
}
|
|
print = Sys_Printf;
|
|
} else {
|
|
if (*sv_globals.deathmatch && !host_client->privileged) {
|
|
return;
|
|
}
|
|
print = SV_ClientPrintf;
|
|
}
|
|
|
|
switch (Cmd_Argc ()) {
|
|
case 1:
|
|
if (banAddr) {
|
|
struct in_addr t;
|
|
t.s_addr = banAddr;
|
|
strcpy (addrStr, inet_ntoa (t));
|
|
t.s_addr = banMask;
|
|
strcpy (maskStr, inet_ntoa (t));
|
|
print ("Banning %s [%s]\n", addrStr, maskStr);
|
|
} else {
|
|
print ("Banning not active\n");
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
if (strcasecmp (Cmd_Argv (1), "off") == 0) {
|
|
banAddr = 0x00000000;
|
|
} else {
|
|
banAddr = inet_addr (Cmd_Argv (1));
|
|
}
|
|
banMask = 0xffffffff;
|
|
break;
|
|
|
|
case 3:
|
|
banAddr = inet_addr (Cmd_Argv (1));
|
|
banMask = inet_addr (Cmd_Argv (2));
|
|
break;
|
|
|
|
default:
|
|
print ("BAN ip_address [mask]\n");
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
int
|
|
Datagram_SendMessage (qsocket_t *sock, sizebuf_t *data)
|
|
{
|
|
unsigned packetLen;
|
|
unsigned dataLen;
|
|
unsigned eom;
|
|
|
|
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;
|
|
|
|
SZ_Clear (&dgrm_send_packet);
|
|
MSG_WriteLongBE (&dgrm_send_packet, packetLen | (NETFLAG_DATA | eom));
|
|
MSG_WriteLongBE (&dgrm_send_packet, sock->sendSequence++);
|
|
MSG_WriteBytes (&dgrm_send_packet, sock->sendMessage, dataLen);
|
|
|
|
sock->canSend = false;
|
|
|
|
if (sfunc.Write (sock->socket, dgrm_send_packet.data,
|
|
dgrm_send_packet.cursize, &sock->addr) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
sock->lastSendTime = net_time;
|
|
packetsSent++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int
|
|
SendMessageNext (qsocket_t *sock)
|
|
{
|
|
unsigned packetLen;
|
|
unsigned dataLen;
|
|
unsigned eom;
|
|
|
|
if (sock->sendMessageLength <= MAX_DATAGRAM) {
|
|
dataLen = sock->sendMessageLength;
|
|
eom = NETFLAG_EOM;
|
|
} else {
|
|
dataLen = MAX_DATAGRAM;
|
|
eom = 0;
|
|
}
|
|
packetLen = NET_HEADERSIZE + dataLen;
|
|
|
|
SZ_Clear (&dgrm_send_packet);
|
|
MSG_WriteLongBE (&dgrm_send_packet, packetLen | (NETFLAG_DATA | eom));
|
|
MSG_WriteLongBE (&dgrm_send_packet, sock->sendSequence++);
|
|
MSG_WriteBytes (&dgrm_send_packet, sock->sendMessage, dataLen);
|
|
|
|
sock->sendNext = false;
|
|
|
|
if (sfunc.Write (sock->socket, dgrm_send_packet.data,
|
|
dgrm_send_packet.cursize, &sock->addr) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
sock->lastSendTime = net_time;
|
|
packetsSent++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int
|
|
ReSendMessage (qsocket_t *sock)
|
|
{
|
|
unsigned packetLen;
|
|
unsigned dataLen;
|
|
unsigned eom;
|
|
|
|
if (sock->sendMessageLength <= MAX_DATAGRAM) {
|
|
dataLen = sock->sendMessageLength;
|
|
eom = NETFLAG_EOM;
|
|
} else {
|
|
dataLen = MAX_DATAGRAM;
|
|
eom = 0;
|
|
}
|
|
packetLen = NET_HEADERSIZE + dataLen;
|
|
|
|
SZ_Clear (&dgrm_send_packet);
|
|
MSG_WriteLongBE (&dgrm_send_packet, packetLen | (NETFLAG_DATA | eom));
|
|
MSG_WriteLongBE (&dgrm_send_packet, sock->sendSequence - 1);
|
|
MSG_WriteBytes (&dgrm_send_packet, sock->sendMessage, dataLen);
|
|
|
|
sock->sendNext = false;
|
|
|
|
if (sfunc.Write (sock->socket, dgrm_send_packet.data,
|
|
dgrm_send_packet.cursize, &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;
|
|
}
|
|
|
|
|
|
__attribute__((const)) bool
|
|
Datagram_CanSendUnreliableMessage (qsocket_t *sock)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
|
|
int
|
|
Datagram_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data)
|
|
{
|
|
int packetLen;
|
|
|
|
packetLen = NET_HEADERSIZE + data->cursize;
|
|
|
|
SZ_Clear (&dgrm_send_packet);
|
|
MSG_WriteLongBE (&dgrm_send_packet, packetLen | NETFLAG_UNRELIABLE);
|
|
MSG_WriteLongBE (&dgrm_send_packet, sock->unreliableSendSequence++);
|
|
MSG_WriteBytes (&dgrm_send_packet, data->data, data->cursize);
|
|
|
|
if (sfunc.Write (sock->socket, dgrm_send_packet.data,
|
|
dgrm_send_packet.cursize, &sock->addr) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
packetsSent++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
int
|
|
Datagram_GetMessage (qsocket_t *sock)
|
|
{
|
|
unsigned length;
|
|
unsigned flags;
|
|
int ret = 0;
|
|
netadr_t readaddr;
|
|
unsigned sequence;
|
|
unsigned count;
|
|
|
|
/// If there is an outstanding reliable packet and more than 1 second has
|
|
/// passed, resend the packet.
|
|
if (!sock->canSend) {
|
|
if ((net_time - sock->lastSendTime) > 1.0) {
|
|
ReSendMessage (sock);
|
|
}
|
|
}
|
|
|
|
while (1) {
|
|
SZ_Clear (&dgrm_receive_packet);
|
|
length = sfunc.Read (sock->socket, dgrm_receive_packet.data,
|
|
dgrm_receive_packet.maxsize, &readaddr);
|
|
dgrm_receive_packet.cursize = length;
|
|
|
|
// if ((rand() & 255) > 220)
|
|
// continue;
|
|
|
|
if (length == 0) {
|
|
break;
|
|
}
|
|
|
|
if ((int) length == -1) {
|
|
Sys_Printf ("Read error\n");
|
|
return -1;
|
|
}
|
|
|
|
if (sfunc.AddrCompare (&readaddr, &sock->addr) != 0) {
|
|
continue;
|
|
}
|
|
|
|
if (length < NET_HEADERSIZE) {
|
|
shortPacketCount++;
|
|
continue;
|
|
}
|
|
|
|
MSG_BeginReading (&dgrm_message);
|
|
length = MSG_ReadLongBE (&dgrm_message);
|
|
|
|
flags = length & (~NETFLAG_LENGTH_MASK);
|
|
length &= NETFLAG_LENGTH_MASK;
|
|
|
|
if (flags & NETFLAG_CTL) {
|
|
continue;
|
|
}
|
|
|
|
sequence = MSG_ReadLongBE (&dgrm_message);
|
|
packetsReceived++;
|
|
|
|
if (flags & NETFLAG_UNRELIABLE) {
|
|
if (sequence < sock->unreliableReceiveSequence) {
|
|
Sys_MaskPrintf (SYS_net, "Got a stale datagram\n");
|
|
ret = 0;
|
|
break;
|
|
}
|
|
if (sequence != sock->unreliableReceiveSequence) {
|
|
count = sequence - sock->unreliableReceiveSequence;
|
|
droppedDatagrams += count;
|
|
Sys_MaskPrintf (SYS_net, "Dropped %u datagram(s)\n", count);
|
|
}
|
|
sock->unreliableReceiveSequence = sequence + 1;
|
|
|
|
length -= NET_HEADERSIZE;
|
|
|
|
/// Copy unreliable data to net_message
|
|
SZ_Clear (net_message->message);
|
|
byte *buf = SZ_GetSpace (net_message->message, length);
|
|
MSG_ReadBytes (&dgrm_message, buf, length);
|
|
|
|
ret = 2;
|
|
break;
|
|
}
|
|
|
|
if (flags & NETFLAG_ACK) {
|
|
if (sequence != (sock->sendSequence - 1)) {
|
|
Sys_MaskPrintf (SYS_net, "Stale ACK received\n");
|
|
continue;
|
|
}
|
|
if (sequence == sock->ackSequence) {
|
|
sock->ackSequence++;
|
|
if (sock->ackSequence != sock->sendSequence) {
|
|
Sys_MaskPrintf (SYS_net, "ack sequencing error\n");
|
|
}
|
|
} else {
|
|
Sys_MaskPrintf (SYS_net, "Duplicate ACK received\n");
|
|
continue;
|
|
}
|
|
sock->sendMessageLength -= MAX_DATAGRAM;
|
|
if (sock->sendMessageLength > 0) {
|
|
memcpy (sock->sendMessage, sock->sendMessage + MAX_DATAGRAM,
|
|
sock->sendMessageLength);
|
|
sock->sendNext = true;
|
|
} else {
|
|
sock->sendMessageLength = 0;
|
|
sock->canSend = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (flags & NETFLAG_DATA) {
|
|
SZ_Clear (&dgrm_send_packet);
|
|
MSG_WriteLongBE (&dgrm_send_packet, NET_HEADERSIZE | NETFLAG_ACK);
|
|
MSG_WriteLongBE (&dgrm_send_packet, sequence);
|
|
sfunc.Write (sock->socket, dgrm_send_packet.data,
|
|
dgrm_send_packet.cursize, &readaddr);
|
|
|
|
if (sequence != sock->receiveSequence) {
|
|
receivedDuplicateCount++;
|
|
continue;
|
|
}
|
|
sock->receiveSequence++;
|
|
|
|
length -= NET_HEADERSIZE;
|
|
|
|
if (flags & NETFLAG_EOM) {
|
|
SZ_Clear (net_message->message);
|
|
SZ_Write (net_message->message, sock->receiveMessage,
|
|
sock->receiveMessageLength);
|
|
byte *buf = SZ_GetSpace (net_message->message, length);
|
|
MSG_ReadBytes (&dgrm_message, buf, length);
|
|
sock->receiveMessageLength = 0;
|
|
|
|
ret = 1;
|
|
break;
|
|
}
|
|
|
|
/// Append reliable data to sock->receiveMessage.
|
|
MSG_ReadBytes (&dgrm_message,
|
|
sock->receiveMessage + sock->receiveMessageLength,
|
|
length);
|
|
sock->receiveMessageLength += length;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (sock->sendNext) {
|
|
SendMessageNext (sock);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void
|
|
PrintStats (qsocket_t *s)
|
|
{
|
|
Sys_Printf ("canSend = %4u \n", s->canSend);
|
|
Sys_Printf ("sendSeq = %4u ", s->sendSequence);
|
|
Sys_Printf ("recvSeq = %4u \n", s->receiveSequence);
|
|
Sys_Printf ("\n");
|
|
}
|
|
|
|
static void
|
|
NET_Stats_f (void)
|
|
{
|
|
qsocket_t *s;
|
|
|
|
if (Cmd_Argc () == 1) {
|
|
Sys_Printf ("unreliable messages sent = %i\n",
|
|
unreliableMessagesSent);
|
|
Sys_Printf ("unreliable messages recv = %i\n",
|
|
unreliableMessagesReceived);
|
|
Sys_Printf ("reliable messages sent = %i\n", messagesSent);
|
|
Sys_Printf ("reliable messages received = %i\n", messagesReceived);
|
|
Sys_Printf ("packetsSent = %i\n", packetsSent);
|
|
Sys_Printf ("packetsReSent = %i\n", packetsReSent);
|
|
Sys_Printf ("packetsReceived = %i\n", packetsReceived);
|
|
Sys_Printf ("receivedDuplicateCount = %i\n",
|
|
receivedDuplicateCount);
|
|
Sys_Printf ("shortPacketCount = %i\n", shortPacketCount);
|
|
Sys_Printf ("droppedDatagrams = %i\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 (strcasecmp (Cmd_Argv (1), s->address) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (s == NULL) {
|
|
for (s = net_freeSockets; s; s = s->next) {
|
|
if (strcasecmp (Cmd_Argv (1), s->address) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (s == NULL) {
|
|
return;
|
|
}
|
|
PrintStats (s);
|
|
}
|
|
}
|
|
|
|
int
|
|
Datagram_Init (void)
|
|
{
|
|
int i;
|
|
int csock;
|
|
|
|
myDriverLevel = net_driverlevel;
|
|
Cmd_AddCommand ("net_stats", NET_Stats_f, "No Description");
|
|
|
|
if (COM_CheckParm ("-nolan")) {
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < net_numlandrivers; i++) {
|
|
csock = net_landrivers[i].Init ();
|
|
if (csock == -1) {
|
|
continue;
|
|
}
|
|
net_landrivers[i].initialized = true;
|
|
net_landrivers[i].controlSock = csock;
|
|
}
|
|
|
|
#ifdef BAN_TEST
|
|
Cmd_AddCommand ("ban", NET_Ban_f, "No Description");
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void
|
|
Datagram_Shutdown (void)
|
|
{
|
|
int 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.CloseSocket (sock->socket);
|
|
}
|
|
|
|
|
|
void
|
|
Datagram_Listen (bool state)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < net_numlandrivers; i++) {
|
|
if (net_landrivers[i].initialized) {
|
|
net_landrivers[i].Listen (state);
|
|
}
|
|
}
|
|
}
|
|
|
|
static const cvar_t **cvar_list;
|
|
static int num_cvars;
|
|
|
|
static int
|
|
dg_cvar_cmp (const void *_a, const void *_b)
|
|
{
|
|
const cvar_t * const *a = _a;
|
|
const cvar_t * const *b = _b;
|
|
return strcmp ((*a)->name, (*b)->name);
|
|
}
|
|
|
|
static int
|
|
dg_cvar_select (const cvar_t *cvar, void *data)
|
|
{
|
|
if (cvar->flags & CVAR_SERVERINFO) {
|
|
*(int *)data += 1;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static qsocket_t *
|
|
_Datagram_CheckNewConnections (void)
|
|
{
|
|
netadr_t clientaddr;
|
|
netadr_t newaddr;
|
|
int newsock;
|
|
int acceptsock;
|
|
qsocket_t *sock;
|
|
qsocket_t *s;
|
|
int len;
|
|
int command;
|
|
int control;
|
|
int ret;
|
|
|
|
acceptsock = dfunc.CheckNewConnections ();
|
|
if (acceptsock == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
SZ_Clear (net_message->message);
|
|
|
|
len = dfunc.Read (acceptsock, net_message->message->data,
|
|
net_message->message->maxsize, &clientaddr);
|
|
if (len < (int) sizeof (int)) {
|
|
return NULL;
|
|
}
|
|
|
|
net_message->message->cursize = len;
|
|
|
|
MSG_BeginReading (net_message);
|
|
control = MSG_ReadLongBE (net_message);
|
|
if (control == -1) {
|
|
return NULL;
|
|
}
|
|
if ((control & (~NETFLAG_LENGTH_MASK)) != (int) NETFLAG_CTL) {
|
|
return NULL;
|
|
}
|
|
if ((control & NETFLAG_LENGTH_MASK) != len) {
|
|
return NULL;
|
|
}
|
|
|
|
command = MSG_ReadByte (net_message);
|
|
if (command == CCREQ_SERVER_INFO) {
|
|
if (strcmp (MSG_ReadString (net_message), "QUAKE") != 0) {
|
|
return NULL;
|
|
}
|
|
|
|
SZ_Clear (net_message->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREP_SERVER_INFO);
|
|
dfunc.GetSocketAddr (acceptsock, &newaddr);
|
|
MSG_WriteString (net_message->message, dfunc.AddrToString (&newaddr));
|
|
MSG_WriteString (net_message->message, hostname);
|
|
MSG_WriteString (net_message->message, sv.name);
|
|
MSG_WriteByte (net_message->message, net_activeconnections);
|
|
MSG_WriteByte (net_message->message, svs.maxclients);
|
|
MSG_WriteByte (net_message->message, NET_PROTOCOL_VERSION);
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (acceptsock, net_message->message->data,
|
|
net_message->message->cursize, &clientaddr);
|
|
SZ_Clear (net_message->message);
|
|
return NULL;
|
|
}
|
|
|
|
if (command == CCREQ_PLAYER_INFO) {
|
|
int playerNumber;
|
|
int activeNumber;
|
|
unsigned clientNumber;
|
|
client_t *client;
|
|
|
|
playerNumber = MSG_ReadByte (net_message);
|
|
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->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREP_PLAYER_INFO);
|
|
MSG_WriteByte (net_message->message, playerNumber);
|
|
MSG_WriteString (net_message->message, client->name);
|
|
MSG_WriteLong (net_message->message, client->colors);
|
|
MSG_WriteLong (net_message->message, SVfloat (client->edict, frags));
|
|
MSG_WriteLong (net_message->message,
|
|
(int) (net_time - client->netconnection->connecttime));
|
|
MSG_WriteString (net_message->message, client->netconnection->address);
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (acceptsock, net_message->message->data,
|
|
net_message->message->cursize, &clientaddr);
|
|
SZ_Clear (net_message->message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if (command == CCREQ_RULE_INFO) {
|
|
const char *prevCvarName;
|
|
const cvar_t *var;
|
|
|
|
// find the search start location
|
|
prevCvarName = MSG_ReadString (net_message);
|
|
if (*prevCvarName) {
|
|
cvar_t key = { .name = prevCvarName };
|
|
var = bsearch (&key, cvar_list, num_cvars, sizeof (cvar_t *),
|
|
dg_cvar_cmp);
|
|
if (!var)
|
|
return 0;
|
|
var++;
|
|
} else {
|
|
if (cvar_list) {
|
|
free (cvar_list);
|
|
}
|
|
num_cvars = 0;
|
|
cvar_list = Cvar_Select (dg_cvar_select, &num_cvars);
|
|
heapsort (cvar_list, num_cvars, sizeof (cvar_t *), dg_cvar_cmp);
|
|
var = cvar_list[0];
|
|
}
|
|
|
|
// send the response
|
|
|
|
SZ_Clear (net_message->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREP_RULE_INFO);
|
|
if (var) {
|
|
MSG_WriteString (net_message->message, var->name);
|
|
MSG_WriteString (net_message->message, Cvar_VarString (var));
|
|
}
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (acceptsock, net_message->message->data,
|
|
net_message->message->cursize, &clientaddr);
|
|
SZ_Clear (net_message->message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if (command != CCREQ_CONNECT) {
|
|
return NULL;
|
|
}
|
|
|
|
if (strcmp (MSG_ReadString (net_message), "QUAKE") != 0) {
|
|
return NULL;
|
|
}
|
|
|
|
if (MSG_ReadByte (net_message) != NET_PROTOCOL_VERSION) {
|
|
SZ_Clear (net_message->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREP_REJECT);
|
|
MSG_WriteString (net_message->message, "Incompatible version.\n");
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (acceptsock, net_message->message->data,
|
|
net_message->message->cursize, &clientaddr);
|
|
SZ_Clear (net_message->message);
|
|
return NULL;
|
|
}
|
|
#ifdef BAN_TEST
|
|
// check for a ban
|
|
if (clientaddr.family == AF_INET) {
|
|
unsigned testAddr;
|
|
|
|
memcpy (&testAddr, clientaddr.ip, 4);
|
|
if ((testAddr & banMask) == banAddr) {
|
|
SZ_Clear (net_message->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREP_REJECT);
|
|
MSG_WriteString (net_message->message, "You have been banned.\n");
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (acceptsock, net_message->message->data,
|
|
net_message->message->cursize, &clientaddr);
|
|
SZ_Clear (net_message->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->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREP_ACCEPT);
|
|
dfunc.GetSocketAddr (s->socket, &newaddr);
|
|
MSG_WriteLong (net_message->message,
|
|
dfunc.GetSocketPort (&newaddr));
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (acceptsock, net_message->message->data,
|
|
net_message->message->cursize, &clientaddr);
|
|
SZ_Clear (net_message->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
|
|
Sys_MaskPrintf (SYS_net, "closing stale socket %d %g\n", ret,
|
|
net_time - s->connecttime);
|
|
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->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREP_REJECT);
|
|
MSG_WriteString (net_message->message, "Server is full.\n");
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (acceptsock, net_message->message->data,
|
|
net_message->message->cursize, &clientaddr);
|
|
SZ_Clear (net_message->message);
|
|
return NULL;
|
|
}
|
|
// allocate a network socket
|
|
newsock = dfunc.OpenSocket (0);
|
|
if (newsock == -1) {
|
|
Sys_MaskPrintf (SYS_net, "failed to open socket");
|
|
NET_FreeQSocket (sock);
|
|
return NULL;
|
|
}
|
|
// connect to the client
|
|
if (dfunc.Connect (newsock, &clientaddr) == -1) {
|
|
Sys_MaskPrintf (SYS_net, "failed to connect client");
|
|
dfunc.CloseSocket (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->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREP_ACCEPT);
|
|
dfunc.GetSocketAddr (newsock, &newaddr);
|
|
MSG_WriteLong (net_message->message, dfunc.GetSocketPort (&newaddr));
|
|
// MSG_WriteString(net_message->message, dfunc.AddrToString(&newaddr));
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (acceptsock, net_message->message->data,
|
|
net_message->message->cursize, &clientaddr);
|
|
SZ_Clear (net_message->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)
|
|
{
|
|
int ret;
|
|
netadr_t readaddr;
|
|
netadr_t myaddr;
|
|
int control;
|
|
|
|
dfunc.GetSocketAddr (dfunc.controlSock, &myaddr);
|
|
if (xmit) {
|
|
SZ_Clear (net_message->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREQ_SERVER_INFO);
|
|
MSG_WriteString (net_message->message, "QUAKE");
|
|
MSG_WriteByte (net_message->message, NET_PROTOCOL_VERSION);
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Broadcast (dfunc.controlSock, net_message->message->data,
|
|
net_message->message->cursize);
|
|
SZ_Clear (net_message->message);
|
|
}
|
|
|
|
while ((ret = dfunc.Read (dfunc.controlSock, net_message->message->data,
|
|
net_message->message->maxsize, &readaddr)) > 0) {
|
|
if (ret < (int) sizeof (int)) {
|
|
continue;
|
|
}
|
|
|
|
net_message->message->cursize = ret;
|
|
|
|
// don't answer our own query
|
|
if (dfunc.AddrCompare (&readaddr, &myaddr) >= 0) {
|
|
continue;
|
|
}
|
|
|
|
MSG_BeginReading (net_message);
|
|
control = MSG_ReadLongBE (net_message);
|
|
if (control == -1) {
|
|
continue;
|
|
}
|
|
if ((control & (~NETFLAG_LENGTH_MASK)) != (int) NETFLAG_CTL) {
|
|
continue;
|
|
}
|
|
if ((control & NETFLAG_LENGTH_MASK) != ret) {
|
|
continue;
|
|
}
|
|
|
|
if (MSG_ReadByte (net_message) != CCREP_SERVER_INFO) {
|
|
continue;
|
|
}
|
|
|
|
const char *addrstr = MSG_ReadString (net_message);
|
|
dfunc.GetAddrFromName (addrstr, &readaddr);
|
|
|
|
const char *name = MSG_ReadString (net_message);
|
|
const char *map = MSG_ReadString (net_message);
|
|
int users = MSG_ReadByte (net_message);
|
|
int maxusers = MSG_ReadByte (net_message);
|
|
int protocol = MSG_ReadByte (net_message);
|
|
const char *cname = dfunc.AddrToString (&readaddr);
|
|
|
|
if (protocol != NET_PROTOCOL_VERSION) {
|
|
char *new_name = alloca (strlen (name) + 2);
|
|
new_name[0] = '*';
|
|
strcpy (new_name + 1, name);
|
|
name = new_name;
|
|
}
|
|
|
|
NET_AddCachedHost (name, map, cname, users, maxusers, net_driverlevel,
|
|
net_landriverlevel, &readaddr);
|
|
}
|
|
}
|
|
|
|
void
|
|
Datagram_SearchForHosts (bool xmit)
|
|
{
|
|
for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers;
|
|
net_landriverlevel++) {
|
|
if (net_landrivers[net_landriverlevel].initialized) {
|
|
_Datagram_SearchForHosts (xmit);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static qsocket_t *
|
|
_Datagram_Connect (const char *host)
|
|
{
|
|
netadr_t sendaddr;
|
|
netadr_t readaddr;
|
|
qsocket_t *sock;
|
|
int newsock;
|
|
int ret;
|
|
int reps;
|
|
double start_time;
|
|
int control;
|
|
const char *reason;
|
|
|
|
// see if we can resolve the host name
|
|
if (dfunc.GetAddrFromName (host, &sendaddr) == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
newsock = dfunc.OpenSocket (0);
|
|
if (newsock == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
sock = NET_NewQSocket ();
|
|
if (sock == NULL) {
|
|
goto ErrorReturn2;
|
|
}
|
|
sock->socket = newsock;
|
|
sock->landriver = net_landriverlevel;
|
|
|
|
// connect to the host
|
|
if (dfunc.Connect (newsock, &sendaddr) == -1) {
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
// send the connection request
|
|
Sys_Printf ("trying...\n");
|
|
cl.viewstate.time = cl.time;
|
|
CL_UpdateScreen (&cl.viewstate);
|
|
start_time = net_time;
|
|
|
|
for (reps = 0; reps < 3; reps++) {
|
|
SZ_Clear (net_message->message);
|
|
// save space for the header, filled in later
|
|
MSG_WriteLong (net_message->message, 0);
|
|
MSG_WriteByte (net_message->message, CCREQ_CONNECT);
|
|
MSG_WriteString (net_message->message, "QUAKE");
|
|
MSG_WriteByte (net_message->message, NET_PROTOCOL_VERSION);
|
|
MSG_PokeLongBE (net_message->message, 0,
|
|
NETFLAG_CTL | net_message->message->cursize);
|
|
dfunc.Write (newsock, net_message->message->data,
|
|
net_message->message->cursize, &sendaddr);
|
|
SZ_Clear (net_message->message);
|
|
do {
|
|
ret =
|
|
dfunc.Read (newsock, net_message->message->data,
|
|
net_message->message->maxsize, &readaddr);
|
|
// if we got something, validate it
|
|
if (ret > 0) {
|
|
// is it from the right place?
|
|
if (sfunc.AddrCompare (&readaddr, &sendaddr) != 0) {
|
|
Sys_MaskPrintf (SYS_net, "%2d ",
|
|
sfunc.AddrCompare (&readaddr, &sendaddr));
|
|
Sys_MaskPrintf (SYS_net, "%d %s ", readaddr.family,
|
|
sfunc.AddrToString (&readaddr));
|
|
Sys_MaskPrintf (SYS_net, "%d %s\n", sendaddr.family,
|
|
sfunc.AddrToString (&sendaddr));
|
|
ret = 0;
|
|
continue;
|
|
}
|
|
|
|
if (ret < (int) sizeof (int)) {
|
|
ret = 0;
|
|
continue;
|
|
}
|
|
|
|
net_message->message->cursize = ret;
|
|
MSG_BeginReading (net_message);
|
|
|
|
control = MSG_ReadLongBE (net_message);
|
|
if (control == -1) {
|
|
ret = 0;
|
|
continue;
|
|
}
|
|
if ((control & (~NETFLAG_LENGTH_MASK)) != (int) 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;
|
|
}
|
|
Sys_Printf ("still trying...\n");
|
|
cl.viewstate.time = cl.time;
|
|
CL_UpdateScreen (&cl.viewstate);
|
|
start_time = SetNetTime ();
|
|
}
|
|
|
|
if (ret == 0) {
|
|
reason = "No Response";
|
|
Sys_Printf ("%s\n", reason);
|
|
// strcpy (m_return_reason, reason);
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
if (ret == -1) {
|
|
reason = "Network Error";
|
|
Sys_Printf ("%s\n", reason);
|
|
// strcpy (m_return_reason, reason);
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
ret = MSG_ReadByte (net_message);
|
|
if (ret == CCREP_REJECT) {
|
|
reason = MSG_ReadString (net_message);
|
|
Sys_Printf ("%s\n", reason);
|
|
// strncpy (m_return_reason, reason, 31);
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
if (ret == CCREP_ACCEPT) {
|
|
memcpy (&sock->addr, &sendaddr, sizeof (netadr_t));
|
|
dfunc.SetSocketPort (&sock->addr, MSG_ReadLong (net_message));
|
|
} else {
|
|
reason = "Bad Response";
|
|
Sys_Printf ("%s\n", reason);
|
|
// strcpy (m_return_reason, reason);
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
dfunc.GetNameFromAddr (&sendaddr, sock->address);
|
|
|
|
Sys_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";
|
|
Sys_Printf ("%s\n", reason);
|
|
// strcpy (m_return_reason, reason);
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
// FIXME: MENUCODE
|
|
// m_return_onerror = false;
|
|
return sock;
|
|
|
|
ErrorReturn:
|
|
// FIXME: MENUCODE - do something with reason
|
|
Sys_MaskPrintf (SYS_net, "FIXME: MENUCODE - do something with reason\n");
|
|
NET_FreeQSocket (sock);
|
|
ErrorReturn2:
|
|
dfunc.CloseSocket (newsock);
|
|
// FIXME: MENUCODE
|
|
// if (m_return_onerror) {
|
|
// 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;
|
|
|
|
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;
|
|
}
|