netconn.c File Reference

#include "quakedef.h"
#include "thread.h"
#include "lhnet.h"
#include "hmac.h"
#include "mdfour.h"
#include <time.h>

Include dependency graph for netconn.c:

Go to the source code of this file.

Macros
#define	DPMASTER_COUNT   sizeof(sv_masters) / sizeof(cvar_t)
#define	DPMASTER_PORT   27950
#define	QWMASTER_COUNT   sizeof(sv_qwmasters) / sizeof(cvar_t)
#define	QWMASTER_PORT   27000

Typedefs
typedef qbool(*	rcon_matchfunc_t) (lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)

Functions
static qbool	hmac_mdfour_challenge_matching (lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
static qbool	hmac_mdfour_time_matching (lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
static void	Net_Heartbeat_f (cmd_state_t *cmd)
void	Net_Stats_f (cmd_state_t *cmd)
static int	NetConn_AddCryptoFlag (crypto_t *crypto)
static void	NetConn_BuildChallengeString (char *buffer, int bufferlength)
static qbool	NetConn_BuildStatusResponse (const char *challenge, char *out_msg, size_t out_size, qbool fullstatus)
	(div0) build the full response only if possible; better a getinfo response than no response at all if getstatus won't fit
qbool	NetConn_CanSend (netconn_t *conn)
lhnetsocket_t *	NetConn_ChooseClientSocketForAddress (lhnetaddress_t *address)
lhnetsocket_t *	NetConn_ChooseServerSocketForAddress (lhnetaddress_t *address)
static void	NetConn_CL_UpdateSockets_Callback (cvar_t *var)
void	NetConn_ClearFlood (lhnetaddress_t *peeraddress, server_floodaddress_t *floodlist, size_t floodlength)
void	NetConn_ClientFrame (void)
static int	NetConn_ClientParsePacket (lhnetsocket_t *mysocket, unsigned char *data, int length, lhnetaddress_t *peeraddress)
void	NetConn_Close (netconn_t *conn)
void	NetConn_CloseClientPorts (void)
void	NetConn_CloseServerPorts (void)
static void	NetConn_ConnectionEstablished (lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress, protocolversion_t initialprotocol)
qbool	NetConn_HaveClientPorts (void)
qbool	NetConn_HaveServerPorts (void)
void	NetConn_Heartbeat (int priority)
void	NetConn_Init (void)
int	NetConn_IsLocalGame (void)
netconn_t *	NetConn_Open (lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress)
static void	NetConn_OpenClientPort (const char *addressstring, lhnetaddresstype_t addresstype, int defaultport)
void	NetConn_OpenClientPorts (void)
static qbool	NetConn_OpenServerPort (const char *addressstring, lhnetaddresstype_t addresstype, int defaultport, int range)
void	NetConn_OpenServerPorts (int opennetports)
static qbool	NetConn_PreventFlood (lhnetaddress_t *peeraddress, server_floodaddress_t *floodlist, size_t floodlength, double floodtime, qbool renew)
int	NetConn_Read (lhnetsocket_t *mysocket, void *data, int maxlength, lhnetaddress_t *peeraddress)
static int	NetConn_ReceivedMessage (netconn_t *conn, const unsigned char *data, size_t length, protocolversion_t protocol, double newtimeout)
int	NetConn_SendUnreliableMessage (netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate, int burstsize, qbool quakesignon_suppressreliables)
void	NetConn_ServerFrame (void)
static int	NetConn_ServerParsePacket (lhnetsocket_t *mysocket, unsigned char *data, int length, lhnetaddress_t *peeraddress)
void	NetConn_Shutdown (void)
static void	NetConn_sv_netport_Callback (cvar_t *var)
static void	NetConn_UpdateCleartime (double *cleartime, int rate, int burstsize, int len)
void	NetConn_UpdateSockets (void)
int	NetConn_Write (lhnetsocket_t *mysocket, const void *data, int length, const lhnetaddress_t *peeraddress)
int	NetConn_WriteString (lhnetsocket_t *mysocket, const char *string, const lhnetaddress_t *peeraddress)
static qbool	plaintext_matching (lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
static void	PrintStats (netconn_t *conn)
static const char *	RCon_Authenticate (lhnetaddress_t *peeraddress, const char *password, const char *s, const char *endpos, rcon_matchfunc_t comparator, const char *cs, int cslen)
	returns a string describing the user level, or NULL for auth failure
static void	RCon_Execute (lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress, const char *addressstring2, const char *userlevel, const char *s, const char *endpos, qbool proquakeprotocol)

Variables
challenge_t	challenges [MAX_CHALLENGES]
sizebuf_t	cl_message
static unsigned char	cl_message_buf [NET_MAXMESSAGE]
char	cl_net_extresponse [NET_EXTRESPONSE_MAX][1400]
unsigned	cl_net_extresponse_count = 0
unsigned	cl_net_extresponse_last = 0
cvar_t	cl_netport = {CF_CLIENT, "cl_port", "0", "forces client to use chosen port number if not 0"}
static unsigned	cl_numsockets
char	cl_readstring [MAX_INPUTLINE]
static lhnetsocket_t *	cl_sockets [16]
static int	clientport = -1
static int	clientport2 = -1
cvar_t	developer_networking = {CF_CLIENT | CF_SERVER, "developer_networking", "0", "prints all received and sent packets (recommended only for debugging)"}
static cvar_t	gameversion = {CF_SERVER, "gameversion", "0", "version of game data (mod-specific) to be sent to querying clients"}
static cvar_t	gameversion_max = {CF_CLIENT | CF_SERVER, "gameversion_max", "-1", "maximum version of game data (mod-specific), when client and server gameversion mismatch in the server browser the server is shown as incompatible; if -1, gameversion is used alone"}
static cvar_t	gameversion_min = {CF_CLIENT | CF_SERVER, "gameversion_min", "-1", "minimum version of game data (mod-specific), when client and server gameversion mismatch in the server browser the server is shown as incompatible; if -1, gameversion is used alone"}
cvar_t	hostname = {CF_SERVER | CF_ARCHIVE, "hostname", "UNNAMED", "server message to show in server browser"}
static int	hostport = -1
unsigned	masterquerycount = 0
double	masterquerytime = -1000
unsigned	masterreplycount = 0
cvar_t	net_address = {CF_CLIENT | CF_SERVER, "net_address", "", "network address to open ipv4 ports on (if empty, use default interfaces)"}
cvar_t	net_address_ipv6 = {CF_CLIENT | CF_SERVER, "net_address_ipv6", "", "network address to open ipv6 ports on (if empty, use default interfaces)"}
cvar_t	net_burstreserve = {CF_SERVER, "net_burstreserve", "0.3", "how much of the burst time to reserve for packet size spikes"}
cvar_t	net_challengefloodblockingtimeout = {CF_SERVER, "net_challengefloodblockingtimeout", "0.5", "when a challenge packet is received, it will block all future challenge packets from that IP address for this many seconds (cuts down on challenge floods). DarkPlaces clients retry once per second, so this should be <= 1. Failure here may lead to connect attempts failing."}
cvar_t	net_connect_entnum_ofs = {CF_SERVER, "net_connect_entnum_ofs", "0", "entity number offset of human clients (for developer testing only)"}
cvar_t	net_connectfloodblockingtimeout = {CF_SERVER, "net_connectfloodblockingtimeout", "5", "when a connection packet is received, it will block all future connect packets from that IP address for this many seconds (cuts down on connect floods). Note that this does not include retries from the same IP; these are handled earlier and let in."}
cvar_t	net_connecttimeout = {CF_CLIENT | CF_SERVER, "net_connecttimeout","15", "after requesting a connection, the client must reply within this many seconds or be dropped (cuts down on connect floods). Must be above 10 seconds."}
cvar_t	net_fakelag = {CF_CLIENT, "net_fakelag","0", "lags local loopback connection by this much ping time (useful to play more fairly on your own server with people with higher pings)"}
static cvar_t	net_fakeloss_receive = {CF_CLIENT, "net_fakeloss_receive","0", "drops this percentage of incoming packets, useful for testing network protocol robustness (jerky movement, effects failing to start, sounds failing to play, etc)"}
static cvar_t	net_fakeloss_send = {CF_CLIENT, "net_fakeloss_send","0", "drops this percentage of outgoing packets, useful for testing network protocol robustness (jerky movement, prediction errors, etc)"}
cvar_t	net_getstatusfloodblockingtimeout = {CF_SERVER, "net_getstatusfloodblockingtimeout", "1", "when a getstatus packet is received, it will block all future getstatus packets from that IP address for this many seconds (cuts down on getstatus floods). DarkPlaces retries every net_slist_timeout seconds, and qstat retries once per second, so this should be <= 1. Failure here may lead to server not showing up in the server list."}
cvar_t	net_messagetimeout = {CF_CLIENT | CF_SERVER, "net_messagetimeout","300", "drops players who have not sent any packets for this many seconds"}
cvar_t	net_sourceaddresscheck = {CF_CLIENT, "net_sourceaddresscheck", "1", "compare the source IP address for replies (more secure, may break some bad multihoming setups"}
cvar_t	net_test = {CF_CLIENT | CF_SERVER, "net_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"}
static cvar_t	net_tos_dscp = {CF_CLIENT | CF_ARCHIVE, "net_tos_dscp", "32", "DiffServ Codepoint for network sockets (may need game restart to apply)"}
cvar_t	net_usesizelimit = {CF_SERVER, "net_usesizelimit", "2", "use packet size limiting (0: never, 1: in non-CSQC mode, 2: always)"}
netconn_t *	netconn_list = NULL
mempool_t *	netconn_mempool = NULL
void *	netconn_mutex = NULL
static double	nextheartbeattime = 0
static cvar_t	rcon_restricted_commands = {CF_SERVER, "rcon_restricted_commands", "", "allowed commands for rcon when the restricted mode password was used"}
static cvar_t	rcon_restricted_password = {CF_SERVER | CF_PRIVATE, "rcon_restricted_password", "", "password to authenticate rcon commands in restricted mode; may be set to a string of the form user1:pass1 user2:pass2 user3:pass3 to allow multiple user accounts - the client then has to specify ONE of these combinations"}
cvar_t	rcon_secure
cvar_t	rcon_secure_challengetimeout
static cvar_t	rcon_secure_maxdiff = {CF_SERVER, "rcon_secure_maxdiff", "5", "maximum time difference between rcon request and server system clock (to protect against replay attack)"}
uint8_t	serverlist_querystage = 0
	bitfield because in theory we could be doing QW & DP simultaneously
unsigned	serverquerycount = 0
unsigned	serverreplycount = 0
static cvar_t	sv_heartbeatperiod = {CF_SERVER | CF_ARCHIVE, "sv_heartbeatperiod", "120", "how often to send heartbeat in seconds (only used if sv_public is 1)"}
static cvar_t	sv_masters []
sizebuf_t	sv_message
static unsigned char	sv_message_buf [NET_MAXMESSAGE]
char	sv_net_extresponse [NET_EXTRESPONSE_MAX][1400]
unsigned	sv_net_extresponse_count = 0
unsigned	sv_net_extresponse_last = 0
cvar_t	sv_netport = {CF_SERVER, "port", "26000", "server port for players to connect to"}
static unsigned	sv_numsockets
cvar_t	sv_public = {CF_SERVER, "sv_public", "0", "1: advertises this server on the master server (so that players can find it in the server browser); 0: allow direct queries only; -1: do not respond to direct queries; -2: do not allow anyone to connect; -3: already block at getchallenge level"}
cvar_t	sv_public_rejectreason = {CF_SERVER, "sv_public_rejectreason", "The server is closing.", "Rejection reason for connects when sv_public is -2"}
char	sv_readstring [MAX_INPUTLINE]
static lhnetsocket_t *	sv_sockets [16]
cvar_t	sv_status_privacy

Macro Definition Documentation

DPMASTER_COUNT

#define DPMASTER_COUNT   sizeof(sv_masters) / sizeof(cvar_t)

Definition at line 125 of file netconn.c.

Referenced by NetConn_Heartbeat(), and NetConn_Init().

DPMASTER_PORT

#define DPMASTER_PORT   27950

Definition at line 33 of file netconn.c.

Referenced by NetConn_Heartbeat().

QWMASTER_COUNT

#define QWMASTER_COUNT   sizeof(sv_qwmasters) / sizeof(cvar_t)

Definition at line 126 of file netconn.c.

Referenced by NetConn_Init().

QWMASTER_PORT

#define QWMASTER_PORT   27000

Definition at line 32 of file netconn.c.

Typedef Documentation

rcon_matchfunc_t

typedef qbool(* rcon_matchfunc_t) (lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)

Definition at line 2986 of file netconn.c.

Function Documentation

hmac_mdfour_challenge_matching()

static qbool hmac_mdfour_challenge_matching ( lhnetaddress_t * peeraddress, const char * password, const char * hash, const char * s, int slen )

static

Definition at line 3009 of file netconn.c.

{
    char mdfourbuf[16];
    int i;
 
    if (!password[0]) {
        Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
        return false;
    }
 
    if(slen < (int)(sizeof(challenges[0].string)) - 1)
        return false;
 
    // validate the challenge
    for (i = 0;i < MAX_CHALLENGES;i++)
        if(challenges[i].time > 0)
            if (!LHNETADDRESS_Compare(peeraddress, &challenges[i].address) && !strncmp(challenges[i].string, s, sizeof(challenges[0].string) - 1))
                break;
    // if the challenge is not recognized, drop the packet
    if (i == MAX_CHALLENGES)
        return false;
 
    if(!HMAC_MDFOUR_16BYTES((unsigned char *) mdfourbuf, (unsigned char *) s, slen, (unsigned char *) password, (int)strlen(password)))
        return false;
 
    if(memcmp(mdfourbuf, hash, 16))
        return false;
 
    // unmark challenge to prevent replay attacks
    challenges[i].time = 0;
 
    return true;
}

References challenges, CON_ERROR, Con_Print(), HMAC_MDFOUR_16BYTES, i, LHNETADDRESS_Compare(), MAX_CHALLENGES, strlen(), challenge_t::time, and time.

Referenced by NetConn_ServerParsePacket().

hmac_mdfour_time_matching()

static qbool hmac_mdfour_time_matching ( lhnetaddress_t * peeraddress, const char * password, const char * hash, const char * s, int slen )

static

Definition at line 2988 of file netconn.c.

{
    char mdfourbuf[16];
    long t1, t2;
 
    if (!password[0]) {
        Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
        return false;
    }
 
    t1 = (long) time(NULL);
    t2 = strtol(s, NULL, 0);
    if(labs(t1 - t2) > rcon_secure_maxdiff.integer)
        return false;
 
    if(!HMAC_MDFOUR_16BYTES((unsigned char *) mdfourbuf, (unsigned char *) s, slen, (unsigned char *) password, (int)strlen(password)))
        return false;
 
    return !memcmp(mdfourbuf, hash, 16);
}

References CON_ERROR, Con_Print(), HMAC_MDFOUR_16BYTES, cvar_t::integer, NULL, rcon_secure_maxdiff, strlen(), and time.

Referenced by NetConn_ServerParsePacket().

Net_Heartbeat_f()

static void Net_Heartbeat_f ( cmd_state_t * cmd )

static

Definition at line 4017 of file netconn.c.

{
    if (sv.active)
        NetConn_Heartbeat(2);
    else
        Con_Print("No server running, can not heartbeat to master server.\n");
}

References server_t::active, Con_Print(), NetConn_Heartbeat(), and sv.

Referenced by NetConn_Init().

Net_Stats_f()

void Net_Stats_f

(

cmd_state_t *

cmd

)

Definition at line 4042 of file netconn.c.

{
    netconn_t *conn;
    Con_Print("connections                =\n");
    for (conn = netconn_list;conn;conn = conn->next)
        PrintStats(conn);
}

References Con_Print(), netconn_list, netconn_t::next, and PrintStats().

Referenced by NetConn_Init().

NetConn_AddCryptoFlag()

static int NetConn_AddCryptoFlag ( crypto_t * crypto )

static

Definition at line 823 of file netconn.c.

{
    // HACK: if an encrypted connection is used, randomly set some unused
    // flags. When AES encryption is enabled, that will make resends differ
    // from the original, so that e.g. substring filters in a router/IPS
    // are unlikely to match a second time. See also "startkeylogger".
    int flag = 0;
    if (crypto->authenticated)
    {
        // Let's always set at least one of the bits.
        int r = rand() % 7 + 1;
        if (r & 1)
            flag |= NETFLAG_CRYPTO0;
        if (r & 2)
            flag |= NETFLAG_CRYPTO1;
        if (r & 4)
            flag |= NETFLAG_CRYPTO2;
    }
    return flag;
}

References crypto_t::authenticated, NETFLAG_CRYPTO0, NETFLAG_CRYPTO1, NETFLAG_CRYPTO2, and r.

Referenced by NetConn_ReceivedMessage(), and NetConn_SendUnreliableMessage().

NetConn_BuildChallengeString()

static void NetConn_BuildChallengeString ( char * buffer, int bufferlength )

static

Definition at line 2741 of file netconn.c.

{
    int i;
    char c;
    for (i = 0;i < bufferlength - 1;i++)
    {
        do
        {
            c = rand () % (127 - 33) + 33;
        } while (c == '\\' || c == ';' || c == '"' || c == '%' || c == '/');
        buffer[i] = c;
    }
    buffer[i] = 0;
}

References buffer, and i.

Referenced by NetConn_ServerParsePacket().

NetConn_BuildStatusResponse()

static qbool NetConn_BuildStatusResponse ( const char * challenge, char * out_msg, size_t out_size, qbool fullstatus )

static

(div0) build the full response only if possible; better a getinfo response than no response at all if getstatus won't fit

\TODO: we should add more information for the full status string

Definition at line 2757 of file netconn.c.

{
    prvm_prog_t *prog = SVVM_prog;
    char qcstatus[256];
    unsigned int nb_clients = 0, nb_bots = 0, i;
    int length;
    char teambuf[3];
    const char *crypto_idstring;
    const char *worldstatusstr;
 
    // How many clients are there?
    for (i = 0;i < (unsigned int)svs.maxclients;i++)
    {
        if (svs.clients[i].active)
        {
            nb_clients++;
            if (!svs.clients[i].netconnection)
                nb_bots++;
        }
    }
 
    *qcstatus = 0;
    worldstatusstr = PRVM_GetString(prog, PRVM_serverglobalstring(worldstatus));
    if(worldstatusstr && *worldstatusstr)
    {
        char *p;
        const char *q;
        p = qcstatus;
        for(q = worldstatusstr; *q && (size_t)(p - qcstatus) < (sizeof(qcstatus) - 1); ++q)
            if(*q != '\\' && *q != '\n')
                *p++ = *q;
        *p = 0;
    }
 
    crypto_idstring = Crypto_GetInfoResponseDataString();
    length = dpsnprintf(out_msg, out_size,
                        "\377\377\377\377%s\x0A"
                        "\\gamename\\%s\\modname\\%s\\gameversion\\%d\\sv_maxclients\\%d"
                        "\\clients\\%d\\bots\\%d\\mapname\\%s\\hostname\\%s\\protocol\\%d"
                        "%s%s"
                        "%s%s"
                        "%s%s"
                        "%s",
                        fullstatus ? "statusResponse" : "infoResponse",
                        gamenetworkfiltername, com_modname, gameversion.integer, svs.maxclients,
                        nb_clients, nb_bots, sv.worldbasename, hostname.string, NET_PROTOCOL_VERSION,
                        *qcstatus ? "\\qcstatus\\" : "", qcstatus,
                        challenge ? "\\challenge\\" : "", challenge ? challenge : "",
                        crypto_idstring ? "\\d0_blind_id\\" : "", crypto_idstring ? crypto_idstring : "",
                        fullstatus ? "\n" : "");
 
    // Make sure it fits in the buffer
    if (length < 0)
        goto bad;
 
    if (fullstatus)
    {
        char *ptr;
        int left;
        int savelength;
 
        savelength = length;
 
        ptr = out_msg + length;
        left = (int)out_size - length;
 
        for (i = 0;i < (unsigned int)svs.maxclients;i++)
        {
            client_t *client = &svs.clients[i];
            if (client->active)
            {
                int nameind, cleanind, pingvalue;
                char curchar;
                char cleanname [sizeof(client->name)];
                const char *statusstr;
                prvm_edict_t *ed;
 
                // Remove all characters '"' and '\' in the player name
                nameind = 0;
                cleanind = 0;
                do
                {
                    curchar = client->name[nameind++];
                    if (curchar != '"' && curchar != '\\')
                    {
                        cleanname[cleanind++] = curchar;
                        if (cleanind == sizeof(cleanname) - 1)
                            break;
                    }
                } while (curchar != '\0');
                cleanname[cleanind] = 0; // cleanind is always a valid index even at this point
 
                pingvalue = (int)(client->ping * 1000.0f);
                if(client->netconnection)
                    pingvalue = bound(1, pingvalue, 9999);
                else
                    pingvalue = 0;
 
                *qcstatus = 0;
                ed = PRVM_EDICT_NUM(i + 1);
                statusstr = PRVM_GetString(prog, PRVM_serveredictstring(ed, clientstatus));
                if(statusstr && *statusstr)
                {
                    char *p;
                    const char *q;
                    p = qcstatus;
                    for(q = statusstr; *q && p != qcstatus + sizeof(qcstatus) - 1; ++q)
                        if(*q != '\\' && *q != '"' && !ISWHITESPACE(*q))
                            *p++ = *q;
                    *p = 0;
                }
 
                if (IS_NEXUIZ_DERIVED(gamemode) && (teamplay.integer > 0))
                {
                    if(client->frags == -666) // spectator
                        dp_strlcpy(teambuf, " 0", sizeof(teambuf));
                    else if(client->colors == 0x44) // red team
                        dp_strlcpy(teambuf, " 1", sizeof(teambuf));
                    else if(client->colors == 0xDD) // blue team
                        dp_strlcpy(teambuf, " 2", sizeof(teambuf));
                    else if(client->colors == 0xCC) // yellow team
                        dp_strlcpy(teambuf, " 3", sizeof(teambuf));
                    else if(client->colors == 0x99) // pink team
                        dp_strlcpy(teambuf, " 4", sizeof(teambuf));
                    else
                        dp_strlcpy(teambuf, " 0", sizeof(teambuf));
                }
                else
                    *teambuf = 0;
 
                // note: team number is inserted according to SoF2 protocol
                if(*qcstatus)
                    length = dpsnprintf(ptr, left, "%s %d%s \"%s\"\n",
                                        qcstatus,
                                        pingvalue,
                                        teambuf,
                                        cleanname);
                else
                    length = dpsnprintf(ptr, left, "%d %d%s \"%s\"\n",
                                        client->frags,
                                        pingvalue,
                                        teambuf,
                                        cleanname);
 
                if(length < 0)
                {
                    // out of space?
                    // turn it into an infoResponse!
                    out_msg[savelength] = 0;
                    memcpy(out_msg + 4, "infoResponse\x0A", 13);
                    memmove(out_msg + 17, out_msg + 19, savelength - 19);
                    break;
                }
                left -= length;
                ptr += length;
            }
        }
    }
 
    return true;
 
bad:
    return false;
}

References client_t::active, bound, server_static_t::clients, clientstatus, client_t::colors, com_modname, Crypto_GetInfoResponseDataString(), crypto_idstring, dp_strlcpy, dpsnprintf(), client_t::frags, gamemode, gamenetworkfiltername, gameversion, hostname, i, int(), cvar_t::integer, IS_NEXUIZ_DERIVED, ISWHITESPACE, length, server_static_t::maxclients, client_t::name, NET_PROTOCOL_VERSION, client_t::netconnection, client_t::ping, PRVM_EDICT_NUM, PRVM_GetString(), PRVM_serveredictstring, PRVM_serverglobalstring, cvar_t::string, sv, svs, SVVM_prog, teamplay, server_t::worldbasename, and worldstatus.

Referenced by NetConn_ServerParsePacket().

NetConn_CanSend()

qbool NetConn_CanSend

(

netconn_t *

conn

)

Definition at line 789 of file netconn.c.

{
    conn->outgoing_packetcounter = (conn->outgoing_packetcounter + 1) % NETGRAPH_PACKETS;
    conn->outgoing_netgraph[conn->outgoing_packetcounter].time            = host.realtime;
    conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes = NETGRAPH_NOPACKET;
    conn->outgoing_netgraph[conn->outgoing_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
    conn->outgoing_netgraph[conn->outgoing_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
    conn->outgoing_netgraph[conn->outgoing_packetcounter].cleartime       = conn->cleartime;
    if (host.realtime > conn->cleartime)
        return true;
    else
    {
        conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes = NETGRAPH_CHOKEDPACKET;
        return false;
    }
}

References netgraphitem_t::ackbytes, netconn_t::cleartime, netgraphitem_t::cleartime, host, NETGRAPH_CHOKEDPACKET, NETGRAPH_NOPACKET, NETGRAPH_PACKETS, netconn_t::outgoing_netgraph, netconn_t::outgoing_packetcounter, host_static_t::realtime, netgraphitem_t::reliablebytes, netgraphitem_t::time, and netgraphitem_t::unreliablebytes.

Referenced by CL_SendMove(), and SV_SendClientDatagram().

NetConn_ChooseClientSocketForAddress()

lhnetsocket_t * NetConn_ChooseClientSocketForAddress

(

lhnetaddress_t *

address

)

Definition at line 1198 of file netconn.c.

{
    unsigned i;
    lhnetaddresstype_t a = LHNETADDRESS_GetAddressType(address);
 
    for (i = 0;i < cl_numsockets;i++)
        if (cl_sockets[i] && LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i])) == a)
            return cl_sockets[i];
    return NULL;
}

References a, cl_numsockets, cl_sockets, i, LHNET_AddressFromSocket(), LHNETADDRESS_GetAddressType(), and NULL.

Referenced by CL_EstablishConnection(), CL_Packet_f(), CL_PQRcon_f(), CL_Rcon_f(), and Log_DestBuffer_Flush_NoLock().

NetConn_ChooseServerSocketForAddress()

lhnetsocket_t * NetConn_ChooseServerSocketForAddress

(

lhnetaddress_t *

address

)

Definition at line 1209 of file netconn.c.

{
    unsigned i;
    lhnetaddresstype_t a = LHNETADDRESS_GetAddressType(address);
 
    for (i = 0;i < sv_numsockets;i++)
        if (sv_sockets[i] && LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(sv_sockets[i])) == a)
            return sv_sockets[i];
    return NULL;
}

References a, i, LHNET_AddressFromSocket(), LHNETADDRESS_GetAddressType(), NULL, sv_numsockets, and sv_sockets.

Referenced by CL_Packet_f(), Log_DestBuffer_Flush_NoLock(), and NetConn_Heartbeat().

NetConn_CL_UpdateSockets_Callback()

static void NetConn_CL_UpdateSockets_Callback ( cvar_t * var )

static

Definition at line 1272 of file netconn.c.

{
    if(cls.state != ca_dedicated)
    {
        if (clientport2 != var->integer)
        {
            clientport2 = var->integer;
            if (cls.state == ca_connected)
                Con_Print("Changing \"cl_port\" will not take effect until you reconnect.\n");
        }
 
        if (cls.state == ca_disconnected && clientport != clientport2)
        {
            clientport = clientport2;
            NetConn_CloseClientPorts();
        }
        if (cl_numsockets == 0)
            NetConn_OpenClientPorts();
    }
}

References ca_connected, ca_dedicated, ca_disconnected, cl_numsockets, clientport, clientport2, cls, Con_Print(), cvar_t::integer, NetConn_CloseClientPorts(), NetConn_OpenClientPorts(), and client_static_t::state.

Referenced by NetConn_Init().

NetConn_ClearFlood()

void NetConn_ClearFlood	(	lhnetaddress_t *	peeraddress,
		server_floodaddress_t *	floodlist,
		size_t	floodlength )

Definition at line 2966 of file netconn.c.

{
    size_t floodslotnum;
    lhnetaddress_t noportpeeraddress;
    // see if this is a connect flood
    noportpeeraddress = *peeraddress;
    LHNETADDRESS_SetPort(&noportpeeraddress, 0);
    for (floodslotnum = 0;floodslotnum < floodlength;floodslotnum++)
    {
        if (floodlist[floodslotnum].lasttime && LHNETADDRESS_Compare(&noportpeeraddress, &floodlist[floodslotnum].address) == 0)
        {
            // this address matches an ongoing flood address
            // remove the ban
            floodlist[floodslotnum].address.addresstype = LHNETADDRESSTYPE_NONE;
            floodlist[floodslotnum].lasttime = 0;
            //Con_Printf("Flood cleared!\n");
        }
    }
}

References server_floodaddress_t::address, lhnetaddress_t::addresstype, server_floodaddress_t::lasttime, LHNETADDRESS_Compare(), LHNETADDRESS_SetPort(), and LHNETADDRESSTYPE_NONE.

Referenced by NetConn_Close().

NetConn_ClientFrame()

void NetConn_ClientFrame

(

void

)

Definition at line 2674 of file netconn.c.

{
    unsigned i;
    int length;
    lhnetaddress_t peeraddress;
    unsigned char readbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
 
    NetConn_UpdateSockets();
 
    if (cls.connect_trying && cls.connect_nextsendtime < host.realtime)
    {
        if (cls.connect_remainingtries > 0)
        {
            cls.connect_remainingtries--;
            dpsnprintf(cl_connect_status, sizeof(cl_connect_status), "Connect: sending initial request, %i %s left...", cls.connect_remainingtries, cls.connect_remainingtries == 1 ? "retry" : "retries");
        }
        else
        {
            char address[128];
 
            cls.connect_trying = false;
            LHNETADDRESS_ToString(&cls.connect_address, address, sizeof(address), true);
            dp_strlcpy(cl_connect_status, "Connect: failed, no reply", sizeof(cl_connect_status));
            Con_Printf(CON_ERROR "%s from %s\n", cl_connect_status, address);
            return;
        }
        cls.connect_nextsendtime = host.realtime + 1;
 
        // try challenge first (newer DP server or QW)
        NetConn_WriteString(cls.connect_mysocket, "\377\377\377\377getchallenge", &cls.connect_address);
        // then try netquake as a fallback (old server, or netquake)
        SZ_Clear(&cl_message);
        // save space for the header, filled in later
        MSG_WriteLong(&cl_message, 0);
        MSG_WriteByte(&cl_message, CCREQ_CONNECT);
        MSG_WriteString(&cl_message, "QUAKE");
        MSG_WriteByte(&cl_message, NET_PROTOCOL_VERSION);
        // extended proquake stuff
        MSG_WriteByte(&cl_message, 1); // mod = MOD_PROQUAKE
        // this version matches ProQuake 3.40, the first version to support
        // the NAT fix, and it only supports the NAT fix for ProQuake 3.40 or
        // higher clients, so we pretend we are that version...
        MSG_WriteByte(&cl_message, 34); // version * 10
        MSG_WriteByte(&cl_message, 0); // flags
        MSG_WriteLong(&cl_message, 0); // password
        // write the packetsize now...
        StoreBigLong(cl_message.data, NETFLAG_CTL | (cl_message.cursize & NETFLAG_LENGTH_MASK));
        NetConn_Write(cls.connect_mysocket, cl_message.data, cl_message.cursize, &cls.connect_address);
        SZ_Clear(&cl_message);
    }
 
    for (i = 0;i < cl_numsockets;i++)
    {
        while (cl_sockets[i] && (length = NetConn_Read(cl_sockets[i], readbuffer, sizeof(readbuffer), &peeraddress)) > 0)
        {
//          R_TimeReport("clientreadnetwork");
            NetConn_ClientParsePacket(cl_sockets[i], readbuffer, length, &peeraddress);
//          R_TimeReport("clientparsepacket");
        }
    }
#ifdef CONFIG_MENU
    NetConn_QueryQueueFrame();
#endif
    if (cls.netcon && host.realtime > cls.netcon->timeout && !sv.active)
        CL_DisconnectEx(true, "Connection timed out");
}

References server_t::active, CCREQ_CONNECT, cl_connect_status, CL_DisconnectEx(), cl_message, cl_numsockets, cl_sockets, cls, CON_ERROR, Con_Printf(), client_static_t::connect_address, client_static_t::connect_mysocket, client_static_t::connect_nextsendtime, client_static_t::connect_remainingtries, client_static_t::connect_trying, sizebuf_t::cursize, sizebuf_t::data, dp_strlcpy, dpsnprintf(), host, i, length, LHNETADDRESS_ToString(), MSG_WriteByte(), MSG_WriteLong(), MSG_WriteString(), NET_HEADERSIZE, NET_MAXMESSAGE, NET_PROTOCOL_VERSION, client_static_t::netcon, NetConn_ClientParsePacket(), NetConn_Read(), NetConn_UpdateSockets(), NetConn_Write(), NetConn_WriteString(), NETFLAG_CTL, NETFLAG_LENGTH_MASK, host_static_t::realtime, StoreBigLong(), sv, SZ_Clear(), and netconn_t::timeout.

Referenced by CL_Frame(), and CL_KeepaliveMessage().

NetConn_ClientParsePacket()

static int NetConn_ClientParsePacket ( lhnetsocket_t * mysocket, unsigned char * data, int length, lhnetaddress_t * peeraddress )

static

Definition at line 2019 of file netconn.c.

{
    qbool fromserver;
    int ret, c;
    char *string, addressstring2[128];
    char stringbuf[16384];
    char senddata[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
    size_t sendlength;
#ifdef CONFIG_MENU
    char infostringvalue[MAX_INPUTLINE];
#endif
 
    // quakeworld ingame packet
    fromserver = cls.netcon && mysocket == cls.netcon->mysocket && !LHNETADDRESS_Compare(&cls.netcon->peeraddress, peeraddress);
 
    // convert the address to a string incase we need it
    LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
 
    if (length >= 5 && data[0] == 255 && data[1] == 255 && data[2] == 255 && data[3] == 255)
    {
        // received a command string - strip off the packaging and put it
        // into our string buffer with NULL termination
        data += 4;
        length -= 4;
        length = min(length, (int)sizeof(stringbuf) - 1);
        memcpy(stringbuf, data, length);
        stringbuf[length] = 0;
        string = stringbuf;
 
        if (developer_networking.integer)
        {
            Con_Printf("NetConn_ClientParsePacket: %s sent us a command:\n", addressstring2);
            Com_HexDumpToConsole(data, length);
        }
 
        sendlength = sizeof(senddata) - 4;
        switch(Crypto_ClientParsePacket(string, length, senddata+4, &sendlength, peeraddress, addressstring2))
        {
            case CRYPTO_NOMATCH:
                // nothing to do
                break;
            case CRYPTO_MATCH:
                if(sendlength)
                {
                    memcpy(senddata, "\377\377\377\377", 4);
                    NetConn_Write(mysocket, senddata, (int)sendlength+4, peeraddress);
                }
                break;
            case CRYPTO_DISCARD:
                if(sendlength)
                {
                    memcpy(senddata, "\377\377\377\377", 4);
                    NetConn_Write(mysocket, senddata, (int)sendlength+4, peeraddress);
                }
                return true;
                break;
            case CRYPTO_REPLACE:
                string = senddata+4;
                length = (int)sendlength;
                break;
        }
 
        if (length >= 10 && !memcmp(string, "challenge ", 10) && cls.rcon_trying)
        {
            int i = 0, j;
            for (j = 0;j < MAX_RCONS;j++)
            {
                // note: this value from i is used outside the loop too...
                i = (cls.rcon_ringpos + j) % MAX_RCONS;
                if(cls.rcon_commands[i][0])
                    if (!LHNETADDRESS_Compare(peeraddress, &cls.rcon_addresses[i]))
                        break;
            }
            if (j < MAX_RCONS)
            {
                char buf[1500];
                char argbuf[1500];
                const char *e;
                int n;
                dpsnprintf(argbuf, sizeof(argbuf), "%s %s", string + 10, cls.rcon_commands[i]);
                memcpy(buf, "\377\377\377\377srcon HMAC-MD4 CHALLENGE ", 29);
 
                e = strchr(rcon_password.string, ' ');
                n = e ? e-rcon_password.string : (int)strlen(rcon_password.string);
 
                if(HMAC_MDFOUR_16BYTES((unsigned char *) (buf + 29), (unsigned char *) argbuf, (int)strlen(argbuf), (unsigned char *) rcon_password.string, n))
                {
                    int k;
                    buf[45] = ' ';
                    dp_strlcpy(buf + 46, argbuf, sizeof(buf) - 46);
                    NetConn_Write(mysocket, buf, 46 + (int)strlen(buf + 46), peeraddress);
                    cls.rcon_commands[i][0] = 0;
                    --cls.rcon_trying;
 
                    for (k = 0;k < MAX_RCONS;k++)
                        if(cls.rcon_commands[k][0])
                            if (!LHNETADDRESS_Compare(peeraddress, &cls.rcon_addresses[k]))
                                break;
                    if(k < MAX_RCONS)
                    {
                        int l;
                        NetConn_WriteString(mysocket, "\377\377\377\377getchallenge", peeraddress);
                        // extend the timeout on other requests as we asked for a challenge
                        for (l = 0;l < MAX_RCONS;l++)
                            if(cls.rcon_commands[l][0])
                                if (!LHNETADDRESS_Compare(peeraddress, &cls.rcon_addresses[l]))
                                    cls.rcon_timeout[l] = host.realtime + rcon_secure_challengetimeout.value;
                    }
 
                    return true; // we used up the challenge, so we can't use this oen for connecting now anyway
                }
            }
        }
        if (length >= 10 && !memcmp(string, "challenge ", 10) && cls.connect_trying)
        {
            // darkplaces or quake3
            char protocolnames[1400];
 
            if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
                Con_Printf(CON_WARN "ignoring challenge message from wrong server %s\n", addressstring2);
                return true;
            }
            Con_DPrintf("\"%s\" received, sending connect request back to %s\n", string, addressstring2);
            dp_strlcpy(cl_connect_status, "Connect: replying to challenge...", sizeof(cl_connect_status));
 
            Protocol_Names(protocolnames, sizeof(protocolnames));
            // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
            InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
            // TODO: add userinfo stuff here instead of using NQ commands?
            memcpy(senddata, "\377\377\377\377", 4);
            dpsnprintf(senddata+4, sizeof(senddata)-4, "connect\\protocol\\darkplaces 3\\protocols\\%s%s\\challenge\\%s", protocolnames, cls.connect_userinfo, string + 10);
            NetConn_WriteString(mysocket, senddata, peeraddress);
            return true;
        }
        if (length == 6 && !memcmp(string, "accept", 6) && cls.connect_trying)
        {
            // darkplaces or quake3
            if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
                Con_Printf(CON_WARN "ignoring accept message from wrong server %s\n", addressstring2);
                return true;
            }
            NetConn_ConnectionEstablished(mysocket, peeraddress, PROTOCOL_DARKPLACES3);
            return true;
        }
        if (length > 7 && !memcmp(string, "reject ", 7) && cls.connect_trying)
        {
            if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
                Con_Printf(CON_WARN "ignoring reject message from wrong server %s\n", addressstring2);
                return true;
            }
            cls.connect_trying = false;
            string += 7;
            length = min(length - 7, (int)sizeof(cl_connect_status) - 1);
            dpsnprintf(cl_connect_status, sizeof(cl_connect_status), "Connect: rejected, %.*s", length, string);
            Con_Printf(CON_ERROR "Connect: rejected by %s\n" CON_ERROR "%.*s\n", addressstring2, length, string);
            return true;
        }
#ifdef CONFIG_MENU
        if(key_dest != key_game)
        {
            if (length >= 15 && !memcmp(string, "statusResponse\x0A", 15))
            {
                serverlist_info_t *info;
                char *p;
                int n;
 
                string += 15;
                // search the cache for this server and update it
                // the challenge is (ab)used to return the query time
                InfoString_GetValue(string, "challenge", infostringvalue, sizeof(infostringvalue));
                n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2, infostringvalue);
                if (n < 0)
                    return true;
 
                info = &serverlist_cache[n].info;
                p = strchr(string, '\n');
                if(p)
                {
                    *p = 0; // cut off the string there
                    ++p;
                    info->players_len = dp_strlcpy(info->players, p, sizeof(info->players));
                }
                else
                {
                    Con_Printf("statusResponse without players block?\n");
                    info->players_len = info->players[0] = 0;
                }
                info->game_len     = InfoString_GetValue(string, "gamename", info->game,     sizeof(info->game));
                info->mod_len      = InfoString_GetValue(string, "modname",  info->mod,      sizeof(info->mod));
                info->map_len      = InfoString_GetValue(string, "mapname",  info->map,      sizeof(info->map));
                info->name_len     = InfoString_GetValue(string, "hostname", info->name,     sizeof(info->name));
                info->qcstatus_len = InfoString_GetValue(string, "qcstatus", info->qcstatus, sizeof(info->qcstatus));
                info->protocol    = InfoString_GetValue(string, "protocol"     , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : -1;
                info->numplayers  = InfoString_GetValue(string, "clients"      , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
                info->numbots     = InfoString_GetValue(string, "bots"         , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : -1;
                info->maxplayers  = InfoString_GetValue(string, "sv_maxclients", infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
                info->gameversion = InfoString_GetValue(string, "gameversion"  , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
                info->numhumans = info->numplayers - max(0, info->numbots);
                info->freeslots = info->maxplayers - info->numplayers;
 
                NetConn_ClientParsePacket_ServerList_UpdateCache(n);
 
                return true;
            }
            if (length >= 13 && !memcmp(string, "infoResponse\x0A", 13))
            {
                serverlist_info_t *info;
                int n;
 
                string += 13;
                // search the cache for this server and update it
                // the challenge is (ab)used to return the query time
                InfoString_GetValue(string, "challenge", infostringvalue, sizeof(infostringvalue));
                n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2, infostringvalue);
                if (n < 0)
                    return true;
 
                info = &serverlist_cache[n].info;
                info->players_len = info->players[0] = 0;
                info->game_len     = InfoString_GetValue(string, "gamename", info->game,     sizeof(info->game));
                info->mod_len      = InfoString_GetValue(string, "modname",  info->mod,      sizeof(info->mod));
                info->map_len      = InfoString_GetValue(string, "mapname",  info->map,      sizeof(info->map));
                info->name_len     = InfoString_GetValue(string, "hostname", info->name,     sizeof(info->name));
                info->qcstatus_len = InfoString_GetValue(string, "qcstatus", info->qcstatus, sizeof(info->qcstatus));
                info->protocol    = InfoString_GetValue(string, "protocol"     , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : -1;
                info->numplayers  = InfoString_GetValue(string, "clients"      , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
                info->numbots     = InfoString_GetValue(string, "bots"         , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : -1;
                info->maxplayers  = InfoString_GetValue(string, "sv_maxclients", infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
                info->gameversion = InfoString_GetValue(string, "gameversion"  , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
                info->numhumans = info->numplayers - max(0, info->numbots);
                info->freeslots = info->maxplayers - info->numplayers;
 
                NetConn_ClientParsePacket_ServerList_UpdateCache(n);
 
                return true;
            }
            if (!strncmp(string, "getserversResponse\\", 19) && serverlist_cachecount < SERVERLIST_TOTALSIZE)
            {
                // Extract the IP addresses
                data += 18;
                length -= 18;
                NetConn_ClientParsePacket_ServerList_ParseDPList(peeraddress, addressstring2, data, length, false);
                return true;
            }
            if (!strncmp(string, "getserversExtResponse", 21) && serverlist_cachecount < SERVERLIST_TOTALSIZE)
            {
                // Extract the IP addresses
                data += 21;
                length -= 21;
                NetConn_ClientParsePacket_ServerList_ParseDPList(peeraddress, addressstring2, data, length, true);
                return true;
            }
            if (!memcmp(string, "d\n", 2) && serverlist_cachecount < SERVERLIST_TOTALSIZE)
            {
                // Extract the IP addresses
                data += 2;
                length -= 2;
                NetConn_ClientParsePacket_ServerList_ParseQWList(peeraddress, addressstring2, data, length);
                return true;
            }
        }
#endif
        if (!strncmp(string, "extResponse ", 12))
        {
            ++cl_net_extresponse_count;
            if(cl_net_extresponse_count > NET_EXTRESPONSE_MAX)
                cl_net_extresponse_count = NET_EXTRESPONSE_MAX;
            cl_net_extresponse_last = (cl_net_extresponse_last + 1) % NET_EXTRESPONSE_MAX;
            dpsnprintf(cl_net_extresponse[cl_net_extresponse_last], sizeof(cl_net_extresponse[cl_net_extresponse_last]), "\"%s\" %s", addressstring2, string + 12);
            return true;
        }
        if (!strncmp(string, "ping", 4))
        {
            if (developer_extra.integer)
                Con_DPrintf("Received ping from %s, sending ack\n", addressstring2);
            NetConn_WriteString(mysocket, "\377\377\377\377ack", peeraddress);
            return true;
        }
        if (!strncmp(string, "ack", 3))
            return true;
        // QuakeWorld compatibility
        if (length > 1 && string[0] == 'c' && (string[1] == '-' || (string[1] >= '0' && string[1] <= '9')) && cls.connect_trying)
        {
            // challenge message
            if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
                Con_Printf(CON_WARN "ignoring c message from wrong server %s\n", addressstring2);
                return true;
            }
            Con_DPrintf("challenge %s received, sending QuakeWorld connect request back to %s\n", string + 1, addressstring2);
            dp_strlcpy(cl_connect_status, "Connect: replying to challenge...", sizeof(cl_connect_status));
 
            cls.qw_qport = qport.integer;
            // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
            InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
            memcpy(senddata, "\377\377\377\377", 4);
            dpsnprintf(senddata+4, sizeof(senddata)-4, "connect %i %i %i \"%s%s\"\n", 28, cls.qw_qport, atoi(string + 1), cls.userinfo, cls.connect_userinfo);
            NetConn_WriteString(mysocket, senddata, peeraddress);
            return true;
        }
        if (length >= 1 && string[0] == 'j' && cls.connect_trying)
        {
            // accept message
            if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
                Con_Printf(CON_WARN "ignoring j message from wrong server %s\n", addressstring2);
                return true;
            }
            NetConn_ConnectionEstablished(mysocket, peeraddress, PROTOCOL_QUAKEWORLD);
            return true;
        }
        if (length > 2 && !memcmp(string, "n\\", 2))
        {
#ifdef CONFIG_MENU
            serverlist_info_t *info;
            int n;
            const char *s;
 
            // qw server status
            if (serverlist_consoleoutput && developer_networking.integer >= 2)
                Con_Printf("QW server status from server at %s:\n%s\n", addressstring2, string + 1);
 
            string += 1;
            // search the cache for this server and update it
            n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2, NULL);
            if (n < 0)
                return true;
 
            info = &serverlist_cache[n].info;
            dp_strlcpy(info->game, "QuakeWorld", sizeof(info->game));
            info->mod_len  = InfoString_GetValue(string, "*gamedir", info->mod, sizeof(info->mod));
            info->map_len  = InfoString_GetValue(string, "map"     , info->map, sizeof(info->map));
            info->name_len = InfoString_GetValue(string, "hostname", info->name, sizeof(info->name));
            info->protocol = 0;
            info->numplayers = 0; // updated below
            info->numhumans = 0; // updated below
            info->maxplayers  = InfoString_GetValue(string, "maxclients" , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
            info->gameversion = InfoString_GetValue(string, "gameversion", infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
 
            // count active players on server
            // (we could gather more info, but we're just after the number)
            s = strchr(string, '\n');
            if (s)
            {
                s++;
                while (s < string + length)
                {
                    for (;s < string + length && *s != '\n';s++)
                        ;
                    if (s >= string + length)
                        break;
                    info->numplayers++;
                    info->numhumans++;
                    s++;
                }
            }
 
            NetConn_ClientParsePacket_ServerList_UpdateCache(n);
#endif
            return true;
        }
        if (string[0] == 'n')
        {
            // qw print command, used by rcon replies too
            if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address) && LHNETADDRESS_Compare(peeraddress, &cls.rcon_address)) {
                Con_Printf(CON_WARN "ignoring n message from wrong server %s\n", addressstring2);
                return true;
            }
            Con_Printf("QW print command from server at %s:\n%s\n", addressstring2, string + 1);
        }
        // we may not have liked the packet, but it was a command packet, so
        // we're done processing this packet now
        return true;
    }
    // quakeworld ingame packet
    if (fromserver && cls.protocol == PROTOCOL_QUAKEWORLD && length >= 8 && (ret = NetConn_ReceivedMessage(cls.netcon, data, length, cls.protocol, net_messagetimeout.value)) == 2)
    {
        ret = 0;
        CL_ParseServerMessage();
        return ret;
    }
    // netquake control packets, supported for compatibility only
    if (length >= 5 && BuffBigLong(data) == ((int)NETFLAG_CTL | length) && !ENCRYPTION_REQUIRED)
    {
#ifdef CONFIG_MENU
        int n;
        serverlist_info_t *info;
#endif
 
        data += 4;
        length -= 4;
        SZ_Clear(&cl_message);
        SZ_Write(&cl_message, data, length);
        MSG_BeginReading(&cl_message);
        c = MSG_ReadByte(&cl_message);
        switch (c)
        {
        case CCREP_ACCEPT:
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: received CCREP_ACCEPT from %s.\n", addressstring2);
            if (cls.connect_trying)
            {
                lhnetaddress_t clientportaddress;
                if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
                    Con_Printf(CON_WARN "ignoring CCREP_ACCEPT message from wrong server %s\n", addressstring2);
                    break;
                }
                clientportaddress = *peeraddress;
                LHNETADDRESS_SetPort(&clientportaddress, MSG_ReadLong(&cl_message));
                // extra ProQuake stuff
                if (length >= 6)
                    cls.proquake_servermod = MSG_ReadByte(&cl_message); // MOD_PROQUAKE
                else
                    cls.proquake_servermod = 0;
                if (length >= 7)
                    cls.proquake_serverversion = MSG_ReadByte(&cl_message); // version * 10
                else
                    cls.proquake_serverversion = 0;
                if (length >= 8)
                    cls.proquake_serverflags = MSG_ReadByte(&cl_message); // flags (mainly PQF_CHEATFREE)
                else
                    cls.proquake_serverflags = 0;
                if (cls.proquake_servermod == 1)
                    Con_Printf("Connected to ProQuake %.1f server, enabling precise aim\n", cls.proquake_serverversion / 10.0f);
                // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
                InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
                NetConn_ConnectionEstablished(mysocket, &clientportaddress, PROTOCOL_QUAKE);
            }
            break;
        case CCREP_REJECT:
            if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address))
            {
                Con_Printf(CON_WARN "ignoring CCREP_REJECT message from wrong server %s\n", addressstring2);
                break;
            }
            cls.connect_trying = false;
            dpsnprintf(cl_connect_status, sizeof(cl_connect_status), "Connect: rejected, %s", MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
            Con_Printf(CON_ERROR "Connect: rejected by %s\n%s\n", addressstring2, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
            break;
        case CCREP_SERVER_INFO:
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: received CCREP_SERVER_INFO from %s.\n", addressstring2);
#ifdef CONFIG_MENU
            // LadyHavoc: because the quake server may report weird addresses
            // we just ignore it and keep the real address
            MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
            // search the cache for this server and update it
            n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2, NULL);
            if (n < 0)
                break;
 
            info = &serverlist_cache[n].info;
            info->game_len = dp_strlcpy(info->game, "Quake", sizeof(info->game));
            info->mod_len  = dp_strlcpy(info->mod, "", sizeof(info->mod)); // mod name is not specified
            info->name_len = dp_strlcpy(info->name, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(info->name));
            info->map_len  = dp_strlcpy(info->map, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(info->map));
            info->numplayers = MSG_ReadByte(&cl_message);
            info->maxplayers = MSG_ReadByte(&cl_message);
            info->protocol = MSG_ReadByte(&cl_message);
 
            NetConn_ClientParsePacket_ServerList_UpdateCache(n);
#endif
            break;
        case CCREP_RCON: // RocketGuy: ProQuake rcon support
            if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.rcon_address)) {
                Con_Printf(CON_WARN "ignoring CCREP_RCON message from wrong server %s\n", addressstring2);
                break;
            }
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: received CCREP_RCON from %s.\n", addressstring2);
 
            Con_Printf("%s\n", MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
            break;
        case CCREP_PLAYER_INFO:
            // we got a CCREP_PLAYER_INFO??
            //if (developer_extra.integer)
                Con_Printf("Datagram_ParseConnectionless: received CCREP_PLAYER_INFO from %s.\n", addressstring2);
            break;
        case CCREP_RULE_INFO:
            // we got a CCREP_RULE_INFO??
            //if (developer_extra.integer)
                Con_Printf("Datagram_ParseConnectionless: received CCREP_RULE_INFO from %s.\n", addressstring2);
            break;
        default:
            break;
        }
        SZ_Clear(&cl_message);
        // we may not have liked the packet, but it was a valid control
        // packet, so we're done processing this packet now
        return true;
    }
    ret = 0;
    if (fromserver && length >= (int)NET_HEADERSIZE && (ret = NetConn_ReceivedMessage(cls.netcon, data, length, cls.protocol, net_messagetimeout.value)) == 2)
        CL_ParseServerMessage();
    return ret;
}

References buf, BuffBigLong(), CCREP_ACCEPT, CCREP_PLAYER_INFO, CCREP_RCON, CCREP_REJECT, CCREP_RULE_INFO, CCREP_SERVER_INFO, cl_connect_status, cl_message, cl_net_extresponse, cl_net_extresponse_count, cl_net_extresponse_last, CL_ParseServerMessage(), cl_readstring, cls, Com_HexDumpToConsole(), Con_DPrintf(), CON_ERROR, Con_Printf(), CON_WARN, client_static_t::connect_address, client_static_t::connect_trying, client_static_t::connect_userinfo, Crypto_ClientParsePacket(), CRYPTO_DISCARD, CRYPTO_HEADERSIZE, CRYPTO_MATCH, CRYPTO_NOMATCH, CRYPTO_REPLACE, data, developer_extra, developer_networking, dp_strlcpy, dpsnprintf(), ENCRYPTION_REQUIRED, HMAC_MDFOUR_16BYTES, host, i, InfoString_GetValue(), InfoString_SetValue(), int(), cvar_t::integer, key_dest, key_game, length, LHNETADDRESS_Compare(), LHNETADDRESS_SetPort(), LHNETADDRESS_ToString(), max, MAX_INPUTLINE, MAX_RCONS, min, MSG_BeginReading(), MSG_ReadByte, MSG_ReadLong, MSG_ReadString(), netconn_t::mysocket, n, NET_EXTRESPONSE_MAX, NET_HEADERSIZE, NET_MAXMESSAGE, net_messagetimeout, net_sourceaddresscheck, client_static_t::netcon, NetConn_ConnectionEstablished(), NetConn_ReceivedMessage(), NetConn_Write(), NetConn_WriteString(), NETFLAG_CTL, NULL, netconn_t::peeraddress, client_static_t::proquake_serverflags, client_static_t::proquake_servermod, client_static_t::proquake_serverversion, client_static_t::protocol, PROTOCOL_DARKPLACES3, Protocol_Names(), PROTOCOL_QUAKE, PROTOCOL_QUAKEWORLD, qport, client_static_t::qw_qport, client_static_t::rcon_address, client_static_t::rcon_addresses, client_static_t::rcon_commands, rcon_password, client_static_t::rcon_ringpos, rcon_secure_challengetimeout, client_static_t::rcon_timeout, client_static_t::rcon_trying, host_static_t::realtime, ret, SERVERLIST_TOTALSIZE, cvar_t::string, string, strlen(), SZ_Clear(), SZ_Write(), client_static_t::userinfo, and cvar_t::value.

Referenced by NetConn_ClientFrame().

NetConn_Close()

void NetConn_Close

(

netconn_t *

conn

)

Definition at line 1240 of file netconn.c.

{
    netconn_t *c;
    // remove connection from list
 
    // allow the client to reconnect immediately
    NetConn_ClearFlood(&(conn->peeraddress), sv.connectfloodaddresses, sizeof(sv.connectfloodaddresses) / sizeof(sv.connectfloodaddresses[0]));
 
    if (conn == netconn_list)
        netconn_list = conn->next;
    else
    {
        for (c = netconn_list;c;c = c->next)
        {
            if (c->next == conn)
            {
                c->next = conn->next;
                break;
            }
        }
        // not found in list, we'll avoid crashing here...
        if (!c)
            return;
    }
    // free connection
    Mem_Free(conn);
}

References server_t::connectfloodaddresses, Mem_Free, NetConn_ClearFlood(), netconn_list, netconn_t::next, netconn_t::peeraddress, and sv.

Referenced by CL_DisconnectEx(), and SV_DropClient().

NetConn_CloseClientPorts()

void NetConn_CloseClientPorts

(

void

)

Definition at line 1062 of file netconn.c.

{
    for (;cl_numsockets > 0;cl_numsockets--)
        if (cl_sockets[cl_numsockets - 1])
            LHNET_CloseSocket(cl_sockets[cl_numsockets - 1]);
}

References cl_numsockets, cl_sockets, and LHNET_CloseSocket().

Referenced by NetConn_CL_UpdateSockets_Callback(), NetConn_OpenClientPorts(), and NetConn_Shutdown().

NetConn_CloseServerPorts()

void NetConn_CloseServerPorts

(

void

)

Definition at line 1121 of file netconn.c.

{
    for (;sv_numsockets > 0;sv_numsockets--)
        if (sv_sockets[sv_numsockets - 1])
            LHNET_CloseSocket(sv_sockets[sv_numsockets - 1]);
}

References LHNET_CloseSocket(), sv_numsockets, and sv_sockets.

Referenced by Log_DestBuffer_Flush_NoLock(), NetConn_OpenServerPorts(), NetConn_Shutdown(), and SV_Shutdown().

NetConn_ConnectionEstablished()

static void NetConn_ConnectionEstablished ( lhnetsocket_t * mysocket, lhnetaddress_t * peeraddress, protocolversion_t initialprotocol )

static

Definition at line 1641 of file netconn.c.

{
    crypto_t *crypto;
 
    cls.connect_trying = false;
    // Disconnect from the current server or stop demo playback
    if(cls.state == ca_connected || cls.demoplayback)
        CL_Disconnect();
    // allocate a net connection to keep track of things
    cls.netcon = NetConn_Open(mysocket, peeraddress);
    dp_strlcpy(cl_connect_status, "Connection established", sizeof(cl_connect_status));
    crypto = &cls.netcon->crypto;
    if(cls.crypto.authenticated)
    {
        Crypto_FinishInstance(crypto, &cls.crypto);
        Con_Printf("%s connection to %s has been established: server is %s@%s%.*s, I am %.*s@%s%.*s\n",
                crypto->use_aes ? "Encrypted" : "Authenticated",
                cls.netcon->address,
                crypto->server_idfp[0] ? crypto->server_idfp : "-",
                (crypto->server_issigned || !crypto->server_keyfp[0]) ? "" : "~",
                crypto_keyfp_recommended_length, crypto->server_keyfp[0] ? crypto->server_keyfp : "-",
                crypto_keyfp_recommended_length, crypto->client_idfp[0] ? crypto->client_idfp : "-",
                (crypto->client_issigned || !crypto->client_keyfp[0]) ? "" : "~",
                crypto_keyfp_recommended_length, crypto->client_keyfp[0] ? crypto->client_keyfp : "-"
                );
    }
    else
        Con_Printf("%s to %s\n", cl_connect_status, cls.netcon->address);
 
    key_dest = key_game;
#ifdef CONFIG_MENU
    m_state = m_none;
#endif
    cls.demonum = -1;           // not in the demo loop now
    cls.state = ca_connected;
    cls.signon = 0;             // need all the signon messages before playing
    cls.protocol = initialprotocol;
    // reset move sequence numbering on this new connection
    cls.servermovesequence = 0;
    if (cls.protocol == PROTOCOL_QUAKEWORLD)
        CL_ForwardToServer("new");
    if (cls.protocol == PROTOCOL_QUAKE)
    {
        // write a keepalive (clc_nop) as it seems to greatly improve the
        // chances of connecting to a netquake server
        sizebuf_t msg;
        unsigned char buf[4];
        memset(&msg, 0, sizeof(msg));
        msg.data = buf;
        msg.maxsize = sizeof(buf);
        MSG_WriteChar(&msg, clc_nop);
        NetConn_SendUnreliableMessage(cls.netcon, &msg, cls.protocol, 10000, 0, false);
    }
}

References netconn_t::address, crypto_t::authenticated, buf, ca_connected, cl_connect_status, CL_Disconnect(), CL_ForwardToServer(), clc_nop, crypto_t::client_idfp, crypto_t::client_issigned, crypto_t::client_keyfp, cls, Con_Printf(), client_static_t::connect_trying, client_static_t::crypto, netconn_t::crypto, Crypto_FinishInstance(), crypto_keyfp_recommended_length, sizebuf_t::data, client_static_t::demonum, client_static_t::demoplayback, dp_strlcpy, key_dest, key_game, m_none, m_state, sizebuf_t::maxsize, MSG_WriteChar(), client_static_t::netcon, NetConn_Open(), NetConn_SendUnreliableMessage(), client_static_t::protocol, PROTOCOL_QUAKE, PROTOCOL_QUAKEWORLD, crypto_t::server_idfp, crypto_t::server_issigned, crypto_t::server_keyfp, client_static_t::servermovesequence, client_static_t::signon, client_static_t::state, and crypto_t::use_aes.

Referenced by NetConn_ClientParsePacket().

NetConn_HaveClientPorts()

qbool NetConn_HaveClientPorts

(

void

)

Definition at line 1052 of file netconn.c.

{
    return !!cl_numsockets;
}

References cl_numsockets.

Referenced by Log_DestBuffer_Flush_NoLock().

NetConn_HaveServerPorts()

qbool NetConn_HaveServerPorts

(

void

)

Definition at line 1057 of file netconn.c.

{
    return !!sv_numsockets;
}

References sv_numsockets.

Referenced by Log_DestBuffer_Flush_NoLock().

NetConn_Heartbeat()

void NetConn_Heartbeat

(

int

priority

)

Definition at line 3984 of file netconn.c.

{
    lhnetaddress_t masteraddress;
    uint8_t masternum;
    lhnetsocket_t *mysocket;
 
    // if it's a state change (client connected), limit next heartbeat to no
    // more than 30 sec in the future
    if (priority == 1 && nextheartbeattime > host.realtime + 30.0)
        nextheartbeattime = host.realtime + 30.0;
 
    // limit heartbeatperiod to 30 to 270 second range,
    // lower limit is to avoid abusing master servers with excess traffic,
    // upper limit is to avoid timing out on the master server (which uses
    // 300 sec timeout)
    if (sv_heartbeatperiod.value < 30)
        Cvar_SetValueQuick(&sv_heartbeatperiod, 30);
    if (sv_heartbeatperiod.value > 270)
        Cvar_SetValueQuick(&sv_heartbeatperiod, 270);
 
    // make advertising optional and don't advertise singleplayer games, and
    // only send a heartbeat as often as the admin wants
    if (sv.active && sv_public.integer > 0 && svs.maxclients >= 2 && (priority > 1 || host.realtime > nextheartbeattime))
    {
        nextheartbeattime = host.realtime + sv_heartbeatperiod.value;
        for (masternum = 0; masternum < DPMASTER_COUNT; ++masternum)
            if (sv_masters[masternum].string[0]
            && LHNETADDRESS_FromString(&masteraddress, sv_masters[masternum].string, DPMASTER_PORT)
            && (mysocket = NetConn_ChooseServerSocketForAddress(&masteraddress)))
                NetConn_WriteString(mysocket, "\377\377\377\377heartbeat DarkPlaces\x0A", &masteraddress);
    }
}

References server_t::active, Cvar_SetValueQuick(), DPMASTER_COUNT, DPMASTER_PORT, host, cvar_t::integer, LHNETADDRESS_FromString(), server_static_t::maxclients, NetConn_ChooseServerSocketForAddress(), NetConn_WriteString(), nextheartbeattime, host_static_t::realtime, sv, sv_heartbeatperiod, sv_masters, sv_public, svs, and cvar_t::value.

Referenced by Net_Heartbeat_f(), NetConn_ServerParsePacket(), SV_DropClient(), SV_Frame(), SV_Shutdown(), SV_SpawnServer(), and SV_ThreadFunc().

NetConn_Init()

void NetConn_Init

(

void

)

Definition at line 4094 of file netconn.c.

{
    int i;
    unsigned j;
    lhnetaddress_t tempaddress;
 
    netconn_mempool = Mem_AllocPool("network connections", 0, NULL);
    Cmd_AddCommand(CF_SHARED, "net_stats", Net_Stats_f, "print network statistics");
#ifdef CONFIG_MENU
    Cmd_AddCommand(CF_CLIENT, "net_slist", Net_Slist_f, "query dp master servers and print all server information");
    Cmd_AddCommand(CF_CLIENT, "net_slistqw", Net_SlistQW_f, "query qw master servers and print all server information");
    Cmd_AddCommand(CF_CLIENT, "net_refresh", Net_Refresh_f, "query dp master servers and refresh all server information");
#endif
    Cmd_AddCommand(CF_SERVER, "heartbeat", Net_Heartbeat_f, "send a heartbeat to the master server (updates your server information)");
    Cvar_RegisterVariable(&net_test);
    Cvar_RegisterVariable(&net_usesizelimit);
    Cvar_RegisterVariable(&net_burstreserve);
    Cvar_RegisterVariable(&rcon_restricted_password);
    Cvar_RegisterVariable(&rcon_restricted_commands);
    Cvar_RegisterVariable(&rcon_secure_maxdiff);
 
#ifdef CONFIG_MENU
    Cvar_RegisterVariable(&net_slist_debug);
    Cvar_RegisterVariable(&net_slist_favorites);
    Cvar_RegisterCallback(&net_slist_favorites, NetConn_UpdateFavorites_c);
    Cvar_RegisterVariable(&net_slist_interval);
    Cvar_RegisterVariable(&net_slist_maxping);
    Cvar_RegisterVariable(&net_slist_maxtries);
    Cvar_RegisterVariable(&net_slist_pause);
    Cvar_RegisterCallback(&net_slist_pause, ServerList_RebuildViewList);
    Cvar_RegisterVariable(&net_slist_queriespersecond);
    Cvar_RegisterVariable(&net_slist_queriesperframe);
    Cvar_RegisterVariable(&net_slist_timeout);
#endif
 
#ifdef IP_TOS // register cvar only if supported
    Cvar_RegisterVariable(&net_tos_dscp);
#endif
    Cvar_RegisterVariable(&net_messagetimeout);
    Cvar_RegisterVariable(&net_connecttimeout);
    Cvar_RegisterVariable(&net_connect_entnum_ofs);
    Cvar_RegisterVariable(&net_connectfloodblockingtimeout);
    Cvar_RegisterVariable(&net_challengefloodblockingtimeout);
    Cvar_RegisterVariable(&net_getstatusfloodblockingtimeout);
    Cvar_RegisterVariable(&net_sourceaddresscheck);
    Cvar_RegisterVariable(&net_fakelag);
    Cvar_RegisterVariable(&net_fakeloss_send);
    Cvar_RegisterVariable(&net_fakeloss_receive);
    Cvar_RegisterVirtual(&net_fakelag, "cl_netlocalping");
    Cvar_RegisterVirtual(&net_fakeloss_send, "cl_netpacketloss_send");
    Cvar_RegisterVirtual(&net_fakeloss_receive, "cl_netpacketloss_receive");
    Cvar_RegisterVariable(&hostname);
    Cvar_RegisterVariable(&developer_networking);
    Cvar_RegisterVariable(&cl_netport);
    Cvar_RegisterCallback(&cl_netport, NetConn_CL_UpdateSockets_Callback);
    Cvar_RegisterVariable(&sv_netport);
    Cvar_RegisterCallback(&sv_netport, NetConn_sv_netport_Callback);
    Cvar_RegisterVariable(&net_address);
    Cvar_RegisterVariable(&net_address_ipv6);
    Cvar_RegisterVariable(&sv_public);
    Cvar_RegisterVariable(&sv_public_rejectreason);
    Cvar_RegisterVariable(&sv_heartbeatperiod);
    for (j = 0; j < DPMASTER_COUNT; ++j)
        Cvar_RegisterVariable(&sv_masters[j]);
#ifdef CONFIG_MENU
    for (j = 0; j < QWMASTER_COUNT; ++j)
        Cvar_RegisterVariable(&sv_qwmasters[j]);
#endif
    Cvar_RegisterVariable(&gameversion);
    Cvar_RegisterVariable(&gameversion_min);
    Cvar_RegisterVariable(&gameversion_max);
// COMMANDLINEOPTION: Server: -ip <ipaddress> sets the ip address of this machine for purposes of networking (default 0.0.0.0 also known as INADDR_ANY), use only if you have multiple network adapters and need to choose one specifically.
    if ((i = Sys_CheckParm("-ip")) && i + 1 < sys.argc)
    {
        if (LHNETADDRESS_FromString(&tempaddress, sys.argv[i + 1], 0) == 1)
        {
            Con_Printf("-ip option used, setting net_address to \"%s\"\n", sys.argv[i + 1]);
            Cvar_SetQuick(&net_address, sys.argv[i + 1]);
        }
        else
            Con_Printf(CON_ERROR "-ip option used, but unable to parse the address \"%s\"\n", sys.argv[i + 1]);
    }
// COMMANDLINEOPTION: Server: -port <portnumber> sets the port to use for a server (default 26000, the same port as QUAKE itself), useful if you host multiple servers on your machine
    if (((i = Sys_CheckParm("-port")) || (i = Sys_CheckParm("-ipport")) || (i = Sys_CheckParm("-udpport"))) && i + 1 < sys.argc)
    {
        i = atoi(sys.argv[i + 1]);
        if (i >= 0 && i < 65536)
        {
            Con_Printf("-port option used, setting port cvar to %i\n", i);
            Cvar_SetValueQuick(&sv_netport, i);
        }
        else
            Con_Printf(CON_ERROR "-port option used, but %i is not a valid port number\n", i);
    }
    cl_numsockets = 0;
    sv_numsockets = 0;
    cl_message.data = cl_message_buf;
    cl_message.maxsize = sizeof(cl_message_buf);
    cl_message.cursize = 0;
    sv_message.data = sv_message_buf;
    sv_message.maxsize = sizeof(sv_message_buf);
    sv_message.cursize = 0;
    LHNET_Init();
    if (Thread_HasThreads())
        netconn_mutex = Thread_CreateMutex();
}

References sys_t::argc, sys_t::argv, CF_CLIENT, CF_SERVER, CF_SHARED, cl_message, cl_message_buf, cl_netport, cl_numsockets, Cmd_AddCommand(), CON_ERROR, Con_Printf(), sizebuf_t::cursize, Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), Cvar_SetQuick(), Cvar_SetValueQuick(), sizebuf_t::data, developer_networking, DPMASTER_COUNT, gameversion, gameversion_max, gameversion_min, hostname, i, LHNET_Init(), LHNETADDRESS_FromString(), sizebuf_t::maxsize, Mem_AllocPool, net_address, net_address_ipv6, net_burstreserve, net_challengefloodblockingtimeout, net_connect_entnum_ofs, net_connectfloodblockingtimeout, net_connecttimeout, net_fakelag, net_fakeloss_receive, net_fakeloss_send, net_getstatusfloodblockingtimeout, Net_Heartbeat_f(), net_messagetimeout, net_sourceaddresscheck, Net_Stats_f(), net_test, net_tos_dscp, net_usesizelimit, NetConn_CL_UpdateSockets_Callback(), netconn_mempool, netconn_mutex, NetConn_sv_netport_Callback(), NULL, QWMASTER_COUNT, rcon_restricted_commands, rcon_restricted_password, rcon_secure_maxdiff, sv_heartbeatperiod, sv_masters, sv_message, sv_message_buf, sv_netport, sv_numsockets, sv_public, sv_public_rejectreason, sys, Sys_CheckParm(), Thread_CreateMutex, and Thread_HasThreads().

Referenced by Host_Init().

NetConn_IsLocalGame()

int NetConn_IsLocalGame

(

void

)

Definition at line 1696 of file netconn.c.

{
    if (cls.state == ca_connected && sv.active && cl.maxclients == 1)
        return true;
    return false;
}

References server_t::active, ca_connected, cl, cls, client_state_t::maxclients, client_static_t::state, and sv.

Referenced by CL_ParseServerInfo().

NetConn_Open()

netconn_t * NetConn_Open	(	lhnetsocket_t *	mysocket,
		lhnetaddress_t *	peeraddress )

Definition at line 1220 of file netconn.c.

{
    netconn_t *conn;
    conn = (netconn_t *)Mem_Alloc(netconn_mempool, sizeof(*conn));
    conn->mysocket = mysocket;
    conn->peeraddress = *peeraddress;
    conn->lastMessageTime = host.realtime;
    conn->message.data = conn->messagedata;
    conn->message.maxsize = sizeof(conn->messagedata);
    conn->message.cursize = 0;
    // LadyHavoc: (inspired by ProQuake) use a short connect timeout to
    // reduce effectiveness of connection request floods
    conn->timeout = host.realtime + net_connecttimeout.value;
    LHNETADDRESS_ToString(&conn->peeraddress, conn->address, sizeof(conn->address), true);
    conn->next = netconn_list;
    netconn_list = conn;
    return conn;
}

References netconn_t::address, sizebuf_t::cursize, sizebuf_t::data, host, netconn_t::lastMessageTime, LHNETADDRESS_ToString(), sizebuf_t::maxsize, Mem_Alloc, netconn_t::message, netconn_t::messagedata, netconn_t::mysocket, net_connecttimeout, netconn_list, netconn_mempool, netconn_t::next, netconn_t::peeraddress, host_static_t::realtime, netconn_t::timeout, and cvar_t::value.

Referenced by NetConn_ConnectionEstablished(), and NetConn_ServerParsePacket().

NetConn_OpenClientPort()

static void NetConn_OpenClientPort ( const char * addressstring, lhnetaddresstype_t addresstype, int defaultport )

static

Definition at line 1069 of file netconn.c.

{
    lhnetaddress_t address;
    lhnetsocket_t *s;
    int success;
    char addressstring2[1024];
    if (addressstring && addressstring[0])
        success = LHNETADDRESS_FromString(&address, addressstring, defaultport);
    else
        success = LHNETADDRESS_FromPort(&address, addresstype, defaultport);
    if (success)
    {
        if ((s = LHNET_OpenSocket_Connectionless(&address)))
        {
            cl_sockets[cl_numsockets++] = s;
            LHNETADDRESS_ToString(LHNET_AddressFromSocket(s), addressstring2, sizeof(addressstring2), true);
            if (addresstype != LHNETADDRESSTYPE_LOOP)
                Con_Printf("Client opened a socket on address %s\n", addressstring2);
        }
        else
        {
            LHNETADDRESS_ToString(&address, addressstring2, sizeof(addressstring2), true);
            Con_Printf(CON_ERROR "Client failed to open a socket on address %s\n", addressstring2);
        }
    }
    else
        Con_Printf(CON_ERROR "Client unable to parse address %s\n", addressstring);
}

References cl_numsockets, cl_sockets, CON_ERROR, Con_Printf(), LHNET_AddressFromSocket(), LHNET_OpenSocket_Connectionless(), LHNETADDRESS_FromPort(), LHNETADDRESS_FromString(), LHNETADDRESS_ToString(), and LHNETADDRESSTYPE_LOOP.

Referenced by NetConn_OpenClientPorts().

NetConn_OpenClientPorts()

void NetConn_OpenClientPorts

(

void

)

Definition at line 1098 of file netconn.c.

{
    int port;
    NetConn_CloseClientPorts();
 
    SV_LockThreadMutex(); // FIXME recursive?
    Crypto_LoadKeys(); // client sockets
    SV_UnlockThreadMutex();
 
    port = bound(0, cl_netport.integer, 65535);
    if (cl_netport.integer != port)
        Cvar_SetValueQuick(&cl_netport, port);
    if(port == 0)
        Con_Printf("Client using an automatically assigned port\n");
    else
        Con_Printf("Client using port %i\n", port);
    NetConn_OpenClientPort(NULL, LHNETADDRESSTYPE_LOOP, 2);
    NetConn_OpenClientPort(net_address.string, LHNETADDRESSTYPE_INET4, port);
#ifndef NOSUPPORTIPV6
    NetConn_OpenClientPort(net_address_ipv6.string, LHNETADDRESSTYPE_INET6, port);
#endif
}

References bound, cl_netport, Con_Printf(), Crypto_LoadKeys(), Cvar_SetValueQuick(), cvar_t::integer, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, net_address, net_address_ipv6, NetConn_CloseClientPorts(), NetConn_OpenClientPort(), NULL, cvar_t::string, SV_LockThreadMutex, and SV_UnlockThreadMutex.

Referenced by NetConn_CL_UpdateSockets_Callback().

NetConn_OpenServerPort()

static qbool NetConn_OpenServerPort ( const char * addressstring, lhnetaddresstype_t addresstype, int defaultport, int range )

static

Definition at line 1128 of file netconn.c.

{
    lhnetaddress_t address;
    lhnetsocket_t *s;
    int port;
    char addressstring2[1024];
    int success;
 
    for (port = defaultport; port <= defaultport + range; port++)
    {
        if (addressstring && addressstring[0])
            success = LHNETADDRESS_FromString(&address, addressstring, port);
        else
            success = LHNETADDRESS_FromPort(&address, addresstype, port);
        if (success)
        {
            if ((s = LHNET_OpenSocket_Connectionless(&address)))
            {
                sv_sockets[sv_numsockets++] = s;
                LHNETADDRESS_ToString(LHNET_AddressFromSocket(s), addressstring2, sizeof(addressstring2), true);
                if (addresstype != LHNETADDRESSTYPE_LOOP)
                    Con_Printf("Server listening on address %s\n", addressstring2);
                return true;
            }
            else
            {
                LHNETADDRESS_ToString(&address, addressstring2, sizeof(addressstring2), true);
                Con_Printf(CON_ERROR "Server failed to open socket on address %s\n", addressstring2);
            }
        }
        else
        {
            Con_Printf(CON_ERROR "Server unable to parse address %s\n", addressstring);
            // if it cant parse one address, it wont be able to parse another for sure
            return false;
        }
    }
    return false;
}

References CON_ERROR, Con_Printf(), LHNET_AddressFromSocket(), LHNET_OpenSocket_Connectionless(), LHNETADDRESS_FromPort(), LHNETADDRESS_FromString(), LHNETADDRESS_ToString(), LHNETADDRESSTYPE_LOOP, sv_numsockets, and sv_sockets.

Referenced by NetConn_OpenServerPorts().

NetConn_OpenServerPorts()

void NetConn_OpenServerPorts

(

int

opennetports

)

Definition at line 1168 of file netconn.c.

{
    int port;
    NetConn_CloseServerPorts();
 
    SV_LockThreadMutex(); // FIXME recursive?
    Crypto_LoadKeys(); // server sockets
    SV_UnlockThreadMutex();
 
    NetConn_UpdateSockets();
    port = bound(0, sv_netport.integer, 65535);
    if (port == 0)
        port = 26000;
    if (sv_netport.integer != port)
        Cvar_SetValueQuick(&sv_netport, port);
    if (cls.state != ca_dedicated)
        NetConn_OpenServerPort(NULL, LHNETADDRESSTYPE_LOOP, 1, 1);
    if (opennetports)
    {
#ifndef NOSUPPORTIPV6
        qbool ip4success = NetConn_OpenServerPort(net_address.string, LHNETADDRESSTYPE_INET4, port, 100);
        NetConn_OpenServerPort(net_address_ipv6.string, LHNETADDRESSTYPE_INET6, port, ip4success ? 1 : 100);
#else
        NetConn_OpenServerPort(net_address.string, LHNETADDRESSTYPE_INET4, port, 100);
#endif
    }
    if (sv_numsockets == 0)
        Host_Error("NetConn_OpenServerPorts: unable to open any ports!");
}

References bound, ca_dedicated, cls, Crypto_LoadKeys(), Cvar_SetValueQuick(), Host_Error(), cvar_t::integer, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, net_address, net_address_ipv6, NetConn_CloseServerPorts(), NetConn_OpenServerPort(), NetConn_UpdateSockets(), NULL, client_static_t::state, cvar_t::string, SV_LockThreadMutex, sv_netport, sv_numsockets, and SV_UnlockThreadMutex.

Referenced by Log_DestBuffer_Flush_NoLock(), and SV_SpawnServer().

NetConn_PreventFlood()

static qbool NetConn_PreventFlood ( lhnetaddress_t * peeraddress, server_floodaddress_t * floodlist, size_t floodlength, double floodtime, qbool renew )

static

Definition at line 2923 of file netconn.c.

{
    size_t floodslotnum, bestfloodslotnum;
    double bestfloodtime;
    lhnetaddress_t noportpeeraddress;
    // see if this is a connect flood
    noportpeeraddress = *peeraddress;
    LHNETADDRESS_SetPort(&noportpeeraddress, 0);
    bestfloodslotnum = 0;
    bestfloodtime = floodlist[bestfloodslotnum].lasttime;
    for (floodslotnum = 0;floodslotnum < floodlength;floodslotnum++)
    {
        if (bestfloodtime >= floodlist[floodslotnum].lasttime)
        {
            bestfloodtime = floodlist[floodslotnum].lasttime;
            bestfloodslotnum = floodslotnum;
        }
        if (floodlist[floodslotnum].lasttime && LHNETADDRESS_Compare(&noportpeeraddress, &floodlist[floodslotnum].address) == 0)
        {
            // this address matches an ongoing flood address
            if (host.realtime < floodlist[floodslotnum].lasttime + floodtime)
            {
                if(renew)
                {
                    // renew the ban on this address so it does not expire
                    // until the flood has subsided
                    floodlist[floodslotnum].lasttime = host.realtime;
                }
                //Con_Printf("Flood detected!\n");
                return true;
            }
            // the flood appears to have subsided, so allow this
            bestfloodslotnum = floodslotnum; // reuse the same slot
            break;
        }
    }
    // begin a new timeout on this address
    floodlist[bestfloodslotnum].address = noportpeeraddress;
    floodlist[bestfloodslotnum].lasttime = host.realtime;
    //Con_Printf("Flood detection initiated!\n");
    return false;
}

References server_floodaddress_t::address, host, server_floodaddress_t::lasttime, LHNETADDRESS_Compare(), LHNETADDRESS_SetPort(), and host_static_t::realtime.

Referenced by NetConn_ServerParsePacket().

NetConn_Read()

int NetConn_Read	(	lhnetsocket_t *	mysocket,
		void *	data,
		int	maxlength,
		lhnetaddress_t *	peeraddress )

Definition at line 726 of file netconn.c.

{
    int length;
    unsigned i;
 
    if (mysocket->address.addresstype == LHNETADDRESSTYPE_LOOP && netconn_mutex)
        Thread_LockMutex(netconn_mutex);
    length = LHNET_Read(mysocket, data, maxlength, peeraddress);
    if (mysocket->address.addresstype == LHNETADDRESSTYPE_LOOP && netconn_mutex)
        Thread_UnlockMutex(netconn_mutex);
    if (length == 0)
        return 0;
    if (net_fakeloss_receive.integer)
        for (i = 0;i < cl_numsockets;i++)
            if (cl_sockets[i] == mysocket && (rand() % 100) < net_fakeloss_receive.integer)
                return 0;
    if (developer_networking.integer)
    {
        char addressstring[128], addressstring2[128];
        LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), addressstring, sizeof(addressstring), true);
        if (length > 0)
        {
            LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
            Con_Printf("LHNET_Read(%p (%s), %p, %i, %p) = %i from %s:\n", (void *)mysocket, addressstring, (void *)data, maxlength, (void *)peeraddress, length, addressstring2);
            Com_HexDumpToConsole((unsigned char *)data, length);
        }
        else
            Con_Printf("LHNET_Read(%p (%s), %p, %i, %p) = %i\n", (void *)mysocket, addressstring, (void *)data, maxlength, (void *)peeraddress, length);
    }
    return length;
}

References lhnetsocket_t::address, lhnetaddress_t::addresstype, cl_numsockets, cl_sockets, Com_HexDumpToConsole(), Con_Printf(), data, developer_networking, i, cvar_t::integer, length, LHNET_AddressFromSocket(), LHNET_Read(), LHNETADDRESS_ToString(), LHNETADDRESSTYPE_LOOP, net_fakeloss_receive, netconn_mutex, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by NetConn_ClientFrame(), and NetConn_ServerFrame().

NetConn_ReceivedMessage()

static int NetConn_ReceivedMessage ( netconn_t * conn, const unsigned char * data, size_t length, protocolversion_t protocol, double newtimeout )

static

Definition at line 1331 of file netconn.c.

{
    int originallength = (int)length;
    unsigned char sendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
    unsigned char cryptosendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
    unsigned char cryptoreadbuffer[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
    if (length < 8)
        return 0;
 
    if (protocol == PROTOCOL_QUAKEWORLD)
    {
        unsigned int sequence, sequence_ack;
        qbool reliable_ack, reliable_message;
        int count;
        //int qport;
 
        sequence = LittleLong(*((int *)(data + 0)));
        sequence_ack = LittleLong(*((int *)(data + 4)));
        data += 8;
        length -= 8;
 
        if (conn != cls.netcon)
        {
            // server only
            if (length < 2)
                return 0;
            // TODO: use qport to identify that this client really is who they say they are?  (and elsewhere in the code to identify the connection without a port match?)
            //qport = LittleShort(*((int *)(data + 8)));
            data += 2;
            length -= 2;
        }
 
        conn->packetsReceived++;
        reliable_message = (sequence >> 31) != 0;
        reliable_ack = (sequence_ack >> 31) != 0;
        sequence &= ~(1u<<31);
        sequence_ack &= ~(1u<<31);
        if (sequence <= conn->qw.incoming_sequence)
        {
            //Con_DPrint("Got a stale datagram\n");
            return 0;
        }
        count = sequence - (conn->qw.incoming_sequence + 1);
        if (count > 0)
        {
            conn->droppedDatagrams += count;
            //Con_DPrintf("Dropped %u datagram(s)\n", count);
            // If too may packets have been dropped, only write the
            // last NETGRAPH_PACKETS ones to the netgraph. Why?
            // Because there's no point in writing more than
            // these as the netgraph is going to be full anyway.
            if (count > NETGRAPH_PACKETS)
                count = NETGRAPH_PACKETS;
            while (count--)
            {
                conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
                conn->incoming_netgraph[conn->incoming_packetcounter].time            = host.realtime;
                conn->incoming_netgraph[conn->incoming_packetcounter].cleartime       = conn->incoming_cleartime;
                conn->incoming_netgraph[conn->incoming_packetcounter].unreliablebytes = NETGRAPH_LOSTPACKET;
                conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
                conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
            }
        }
        conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
        conn->incoming_netgraph[conn->incoming_packetcounter].time            = host.realtime;
        conn->incoming_netgraph[conn->incoming_packetcounter].cleartime       = conn->incoming_cleartime;
        conn->incoming_netgraph[conn->incoming_packetcounter].unreliablebytes = originallength + 28;
        conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
        conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
        NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
 
        // limit bursts to one packet in size ("dialup mode" emulating old behaviour)
        if (net_test.integer)
        {
            if (conn->cleartime < host.realtime)
                conn->cleartime = host.realtime;
        }
 
        if (reliable_ack == conn->qw.reliable_sequence)
        {
            // received, now we will be able to send another reliable message
            conn->sendMessageLength = 0;
            conn->reliableMessagesReceived++;
        }
        conn->qw.incoming_sequence = sequence;
        if (conn == cls.netcon)
            cls.qw_incoming_sequence = conn->qw.incoming_sequence;
        conn->qw.incoming_acknowledged = sequence_ack;
        conn->qw.incoming_reliable_acknowledged = reliable_ack;
        if (reliable_message)
            conn->qw.incoming_reliable_sequence ^= 1;
        conn->lastMessageTime = host.realtime;
        conn->timeout = host.realtime + newtimeout;
        conn->unreliableMessagesReceived++;
        if (conn == cls.netcon)
        {
            SZ_Clear(&cl_message);
            SZ_Write(&cl_message, data, (int)length);
            MSG_BeginReading(&cl_message);
        }
        else
        {
            SZ_Clear(&sv_message);
            SZ_Write(&sv_message, data, (int)length);
            MSG_BeginReading(&sv_message);
        }
        return 2;
    }
    else
    {
        unsigned int count;
        unsigned int flags;
        unsigned int sequence;
        size_t qlength;
        const void *sendme;
        size_t sendmelen;
 
        originallength = (int)length;
        data = (const unsigned char *) Crypto_DecryptPacket(&conn->crypto, data, length, cryptoreadbuffer, &length, sizeof(cryptoreadbuffer));
        if(!data)
            return 0;
        if(length < 8)
            return 0;
 
        qlength = (unsigned int)BuffBigLong(data);
        flags = qlength & ~NETFLAG_LENGTH_MASK;
        qlength &= NETFLAG_LENGTH_MASK;
        // control packets were already handled
        if (!(flags & NETFLAG_CTL) && qlength == length)
        {
            sequence = BuffBigLong(data + 4);
            conn->packetsReceived++;
            data += 8;
            length -= 8;
            if (flags & NETFLAG_UNRELIABLE)
            {
                if (sequence >= conn->nq.unreliableReceiveSequence)
                {
                    if (sequence > conn->nq.unreliableReceiveSequence)
                    {
                        count = sequence - conn->nq.unreliableReceiveSequence;
                        conn->droppedDatagrams += count;
                        //Con_DPrintf("Dropped %u datagram(s)\n", count);
                        // If too may packets have been dropped, only write the
                        // last NETGRAPH_PACKETS ones to the netgraph. Why?
                        // Because there's no point in writing more than
                        // these as the netgraph is going to be full anyway.
                        if (count > NETGRAPH_PACKETS)
                            count = NETGRAPH_PACKETS;
                        while (count--)
                        {
                            conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
                            conn->incoming_netgraph[conn->incoming_packetcounter].time            = host.realtime;
                            conn->incoming_netgraph[conn->incoming_packetcounter].cleartime       = conn->incoming_cleartime;
                            conn->incoming_netgraph[conn->incoming_packetcounter].unreliablebytes = NETGRAPH_LOSTPACKET;
                            conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
                            conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
                        }
                    }
                    conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
                    conn->incoming_netgraph[conn->incoming_packetcounter].time            = host.realtime;
                    conn->incoming_netgraph[conn->incoming_packetcounter].cleartime       = conn->incoming_cleartime;
                    conn->incoming_netgraph[conn->incoming_packetcounter].unreliablebytes = originallength + 28;
                    conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
                    conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
                    NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
 
                    conn->nq.unreliableReceiveSequence = sequence + 1;
                    conn->lastMessageTime = host.realtime;
                    conn->timeout = host.realtime + newtimeout;
                    conn->unreliableMessagesReceived++;
                    if (length > 0)
                    {
                        if (conn == cls.netcon)
                        {
                            SZ_Clear(&cl_message);
                            SZ_Write(&cl_message, data, (int)length);
                            MSG_BeginReading(&cl_message);
                        }
                        else
                        {
                            SZ_Clear(&sv_message);
                            SZ_Write(&sv_message, data, (int)length);
                            MSG_BeginReading(&sv_message);
                        }
                        return 2;
                    }
                }
                //else
                //  Con_DPrint("Got a stale datagram\n");
                return 1;
            }
            else if (flags & NETFLAG_ACK)
            {
                conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes += originallength + 28;
                NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
 
                if (sequence == (conn->nq.sendSequence - 1))
                {
                    if (sequence == conn->nq.ackSequence)
                    {
                        conn->nq.ackSequence++;
                        if (conn->nq.ackSequence != conn->nq.sendSequence)
                            Con_DPrint("ack sequencing error\n");
                        conn->lastMessageTime = host.realtime;
                        conn->timeout = host.realtime + newtimeout;
                        if (conn->sendMessageLength > MAX_PACKETFRAGMENT)
                        {
                            unsigned int packetLen;
                            unsigned int dataLen;
                            unsigned int eom;
 
                            conn->sendMessageLength -= MAX_PACKETFRAGMENT;
                            memmove(conn->sendMessage, conn->sendMessage+MAX_PACKETFRAGMENT, conn->sendMessageLength);
 
                            if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
                            {
                                dataLen = conn->sendMessageLength;
                                eom = NETFLAG_EOM;
                            }
                            else
                            {
                                dataLen = MAX_PACKETFRAGMENT;
                                eom = 0;
                            }
 
                            packetLen = NET_HEADERSIZE + dataLen;
 
                            StoreBigLong(sendbuffer, packetLen | (NETFLAG_DATA | eom | NetConn_AddCryptoFlag(&conn->crypto)));
                            StoreBigLong(sendbuffer + 4, conn->nq.sendSequence);
                            memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
 
                            conn->nq.sendSequence++;
 
                            sendme = Crypto_EncryptPacket(&conn->crypto, &sendbuffer, packetLen, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
                            if (sendme && NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress) == (int)sendmelen)
                            {
                                conn->lastSendTime = host.realtime;
                                conn->packetsSent++;
                            }
                        }
                        else
                            conn->sendMessageLength = 0;
                    }
                    //else
                    //  Con_DPrint("Duplicate ACK received\n");
                }
                //else
                //  Con_DPrint("Stale ACK received\n");
                return 1;
            }
            else if (flags & NETFLAG_DATA)
            {
                unsigned char temppacket[8];
                conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   += originallength + 28;
                NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
 
                conn->outgoing_netgraph[conn->outgoing_packetcounter].ackbytes        += 8 + 28;
 
                StoreBigLong(temppacket, 8 | NETFLAG_ACK | NetConn_AddCryptoFlag(&conn->crypto));
                StoreBigLong(temppacket + 4, sequence);
                sendme = Crypto_EncryptPacket(&conn->crypto, temppacket, 8, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
                if(sendme)
                    NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress);
                if (sequence == conn->nq.receiveSequence)
                {
                    conn->lastMessageTime = host.realtime;
                    conn->timeout = host.realtime + newtimeout;
                    conn->nq.receiveSequence++;
                    if( conn->receiveMessageLength + length <= (int)sizeof( conn->receiveMessage ) ) {
                        memcpy(conn->receiveMessage + conn->receiveMessageLength, data, length);
                        conn->receiveMessageLength += (int)length;
                    } else {
                        Con_Printf( "Reliable message (seq: %i) too big for message buffer!\n"
                                    "Dropping the message!\n", sequence );
                        conn->receiveMessageLength = 0;
                        return 1;
                    }
                    if (flags & NETFLAG_EOM)
                    {
                        conn->reliableMessagesReceived++;
                        length = conn->receiveMessageLength;
                        conn->receiveMessageLength = 0;
                        if (length > 0)
                        {
                            if (conn == cls.netcon)
                            {
                                SZ_Clear(&cl_message);
                                SZ_Write(&cl_message, conn->receiveMessage, (int)length);
                                MSG_BeginReading(&cl_message);
                            }
                            else
                            {
                                SZ_Clear(&sv_message);
                                SZ_Write(&sv_message, conn->receiveMessage, (int)length);
                                MSG_BeginReading(&sv_message);
                            }
                            return 2;
                        }
                    }
                }
                else
                    conn->receivedDuplicateCount++;
                return 1;
            }
        }
    }
    return 0;
}

References netgraphitem_t::ackbytes, netconn_t::netconn_nq_s::ackSequence, BuffBigLong(), cl_message, cl_rate, cl_rate_burstsize, netconn_t::cleartime, netgraphitem_t::cleartime, cls, Con_DPrint(), Con_Printf(), count, netconn_t::crypto, Crypto_DecryptPacket(), Crypto_EncryptPacket(), CRYPTO_HEADERSIZE, data, netconn_t::droppedDatagrams, flags, host, netconn_t::netconn_qw_s::incoming_acknowledged, netconn_t::incoming_cleartime, netconn_t::incoming_netgraph, netconn_t::incoming_packetcounter, netconn_t::netconn_qw_s::incoming_reliable_acknowledged, netconn_t::netconn_qw_s::incoming_reliable_sequence, netconn_t::netconn_qw_s::incoming_sequence, int(), cvar_t::integer, netconn_t::lastMessageTime, netconn_t::lastSendTime, length, LittleLong, MAX_PACKETFRAGMENT, MSG_BeginReading(), netconn_t::mysocket, NET_HEADERSIZE, NET_MAXMESSAGE, net_test, client_static_t::netcon, NetConn_AddCryptoFlag(), NetConn_UpdateCleartime(), NetConn_Write(), NETFLAG_ACK, NETFLAG_CTL, NETFLAG_DATA, NETFLAG_EOM, NETFLAG_LENGTH_MASK, NETFLAG_UNRELIABLE, NETGRAPH_LOSTPACKET, NETGRAPH_NOPACKET, NETGRAPH_PACKETS, netconn_t::nq, netconn_t::outgoing_netgraph, netconn_t::outgoing_packetcounter, netconn_t::packetsReceived, netconn_t::packetsSent, netconn_t::peeraddress, PROTOCOL_QUAKEWORLD, netconn_t::qw, client_static_t::qw_incoming_sequence, host_static_t::realtime, netconn_t::receivedDuplicateCount, netconn_t::receiveMessage, netconn_t::receiveMessageLength, netconn_t::netconn_nq_s::receiveSequence, netconn_t::netconn_qw_s::reliable_sequence, netgraphitem_t::reliablebytes, netconn_t::reliableMessagesReceived, netconn_t::sendMessage, netconn_t::sendMessageLength, netconn_t::netconn_nq_s::sendSequence, StoreBigLong(), sv_message, SZ_Clear(), SZ_Write(), netgraphitem_t::time, netconn_t::timeout, netgraphitem_t::unreliablebytes, netconn_t::unreliableMessagesReceived, and netconn_t::netconn_nq_s::unreliableReceiveSequence.

Referenced by NetConn_ClientParsePacket(), and NetConn_ServerParsePacket().

NetConn_SendUnreliableMessage()

int NetConn_SendUnreliableMessage	(	netconn_t *	conn,
		sizebuf_t *	data,
		protocolversion_t	protocol,
		int	rate,
		int	burstsize,
		qbool	quakesignon_suppressreliables )

Definition at line 844 of file netconn.c.

{
    int totallen = 0;
    unsigned char sendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
    unsigned char cryptosendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
 
    // if this packet was supposedly choked, but we find ourselves sending one
    // anyway, make sure the size counting starts at zero
    // (this mostly happens on level changes and disconnects and such)
    if (conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes == NETGRAPH_CHOKEDPACKET)
        conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes = NETGRAPH_NOPACKET;
 
    conn->outgoing_netgraph[conn->outgoing_packetcounter].cleartime = conn->cleartime;
 
    if (protocol == PROTOCOL_QUAKEWORLD)
    {
        int packetLen;
        qbool sendreliable;
 
        // note that it is ok to send empty messages to the qw server,
        // otherwise it won't respond to us at all
 
        sendreliable = false;
        // if the remote side dropped the last reliable message, resend it
        if (conn->qw.incoming_acknowledged > conn->qw.last_reliable_sequence && conn->qw.incoming_reliable_acknowledged != conn->qw.reliable_sequence)
            sendreliable = true;
        // if the reliable transmit buffer is empty, copy the current message out
        if (!conn->sendMessageLength && conn->message.cursize)
        {
            memcpy (conn->sendMessage, conn->message.data, conn->message.cursize);
            conn->sendMessageLength = conn->message.cursize;
            SZ_Clear(&conn->message); // clear the message buffer
            conn->qw.reliable_sequence ^= 1;
            sendreliable = true;
        }
        // outgoing unreliable packet number, and outgoing reliable packet number (0 or 1)
        StoreLittleLong(sendbuffer, conn->outgoing_unreliable_sequence | (((unsigned int)sendreliable)<<31));
        // last received unreliable packet number, and last received reliable packet number (0 or 1)
        StoreLittleLong(sendbuffer + 4, conn->qw.incoming_sequence | (((unsigned int)conn->qw.incoming_reliable_sequence)<<31));
        packetLen = 8;
        conn->outgoing_unreliable_sequence++;
        // client sends qport in every packet
        if (conn == cls.netcon)
        {
            *((short *)(sendbuffer + 8)) = LittleShort(cls.qw_qport);
            packetLen += 2;
            // also update cls.qw_outgoing_sequence
            cls.qw_outgoing_sequence = conn->outgoing_unreliable_sequence;
        }
        if (packetLen + (sendreliable ? conn->sendMessageLength : 0) > 1400)
        {
            Con_Printf ("NetConn_SendUnreliableMessage: reliable message too big %u\n", data->cursize);
            return -1;
        }
 
        conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes += packetLen + 28;
 
        // add the reliable message if there is one
        if (sendreliable)
        {
            conn->outgoing_netgraph[conn->outgoing_packetcounter].reliablebytes += conn->sendMessageLength + 28;
            memcpy(sendbuffer + packetLen, conn->sendMessage, conn->sendMessageLength);
            packetLen += conn->sendMessageLength;
            conn->qw.last_reliable_sequence = conn->outgoing_unreliable_sequence;
        }
 
        // add the unreliable message if possible
        if (packetLen + data->cursize <= 1400)
        {
            conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes += data->cursize + 28;
            memcpy(sendbuffer + packetLen, data->data, data->cursize);
            packetLen += data->cursize;
        }
 
        NetConn_Write(conn->mysocket, (void *)&sendbuffer, packetLen, &conn->peeraddress);
 
        conn->packetsSent++;
        conn->unreliableMessagesSent++;
 
        totallen += packetLen + 28;
    }
    else
    {
        unsigned int packetLen;
        unsigned int dataLen;
        unsigned int eom;
        const void *sendme;
        size_t sendmelen;
 
        // if a reliable message fragment has been lost, send it again
        if (conn->sendMessageLength && (host.realtime - conn->lastSendTime) > 1.0)
        {
            if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
            {
                dataLen = conn->sendMessageLength;
                eom = NETFLAG_EOM;
            }
            else
            {
                dataLen = MAX_PACKETFRAGMENT;
                eom = 0;
            }
 
            packetLen = NET_HEADERSIZE + dataLen;
 
            StoreBigLong(sendbuffer, packetLen | (NETFLAG_DATA | eom | NetConn_AddCryptoFlag(&conn->crypto)));
            StoreBigLong(sendbuffer + 4, conn->nq.sendSequence - 1);
            memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
 
            conn->outgoing_netgraph[conn->outgoing_packetcounter].reliablebytes += packetLen + 28;
 
            sendme = Crypto_EncryptPacket(&conn->crypto, &sendbuffer, packetLen, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
            if (sendme && NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress) == (int)sendmelen)
            {
                conn->lastSendTime = host.realtime;
                conn->packetsReSent++;
            }
 
            totallen += (int)sendmelen + 28;
        }
 
        // if we have a new reliable message to send, do so
        if (!conn->sendMessageLength && conn->message.cursize && !quakesignon_suppressreliables)
        {
            if (conn->message.cursize > (int)sizeof(conn->sendMessage))
            {
                Con_Printf("NetConn_SendUnreliableMessage: reliable message too big (%u > %u)\n", conn->message.cursize, (int)sizeof(conn->sendMessage));
                conn->message.overflowed = true;
                return -1;
            }
 
            if (developer_networking.integer && conn == cls.netcon)
            {
                Con_Print("client sending reliable message to server:\n");
                SZ_HexDumpToConsole(&conn->message);
            }
 
            memcpy(conn->sendMessage, conn->message.data, conn->message.cursize);
            conn->sendMessageLength = conn->message.cursize;
            SZ_Clear(&conn->message);
 
            if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
            {
                dataLen = conn->sendMessageLength;
                eom = NETFLAG_EOM;
            }
            else
            {
                dataLen = MAX_PACKETFRAGMENT;
                eom = 0;
            }
 
            packetLen = NET_HEADERSIZE + dataLen;
 
            StoreBigLong(sendbuffer, packetLen | (NETFLAG_DATA | eom | NetConn_AddCryptoFlag(&conn->crypto)));
            StoreBigLong(sendbuffer + 4, conn->nq.sendSequence);
            memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
 
            conn->nq.sendSequence++;
 
            conn->outgoing_netgraph[conn->outgoing_packetcounter].reliablebytes += packetLen + 28;
 
            sendme = Crypto_EncryptPacket(&conn->crypto, &sendbuffer, packetLen, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
            if(sendme)
                NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress);
 
            conn->lastSendTime = host.realtime;
            conn->packetsSent++;
            conn->reliableMessagesSent++;
 
            totallen += (int)sendmelen + 28;
        }
 
        // if we have an unreliable message to send, do so
        if (data->cursize)
        {
            packetLen = NET_HEADERSIZE + data->cursize;
 
            if (packetLen > (int)sizeof(sendbuffer))
            {
                Con_Printf("NetConn_SendUnreliableMessage: message too big %u\n", data->cursize);
                return -1;
            }
 
            StoreBigLong(sendbuffer, packetLen | NETFLAG_UNRELIABLE | NetConn_AddCryptoFlag(&conn->crypto));
            StoreBigLong(sendbuffer + 4, conn->outgoing_unreliable_sequence);
            memcpy(sendbuffer + NET_HEADERSIZE, data->data, data->cursize);
 
            conn->outgoing_unreliable_sequence++;
 
            conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes += packetLen + 28;
 
            sendme = Crypto_EncryptPacket(&conn->crypto, &sendbuffer, packetLen, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
            if(sendme)
                NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress);
 
            conn->packetsSent++;
            conn->unreliableMessagesSent++;
 
            totallen += (int)sendmelen + 28;
        }
    }
 
    NetConn_UpdateCleartime(&conn->cleartime, rate, burstsize, totallen);
 
    return 0;
}

References netconn_t::cleartime, netgraphitem_t::cleartime, cls, Con_Print(), Con_Printf(), netconn_t::crypto, Crypto_EncryptPacket(), CRYPTO_HEADERSIZE, sizebuf_t::cursize, data, sizebuf_t::data, developer_networking, host, netconn_t::netconn_qw_s::incoming_acknowledged, netconn_t::netconn_qw_s::incoming_reliable_acknowledged, netconn_t::netconn_qw_s::incoming_reliable_sequence, netconn_t::netconn_qw_s::incoming_sequence, int(), cvar_t::integer, netconn_t::netconn_qw_s::last_reliable_sequence, netconn_t::lastSendTime, LittleShort, MAX_PACKETFRAGMENT, netconn_t::message, netconn_t::mysocket, NET_HEADERSIZE, NET_MAXMESSAGE, client_static_t::netcon, NetConn_AddCryptoFlag(), NetConn_UpdateCleartime(), NetConn_Write(), NETFLAG_DATA, NETFLAG_EOM, NETFLAG_UNRELIABLE, NETGRAPH_CHOKEDPACKET, NETGRAPH_NOPACKET, netconn_t::nq, netconn_t::outgoing_netgraph, netconn_t::outgoing_packetcounter, netconn_t::outgoing_unreliable_sequence, sizebuf_t::overflowed, netconn_t::packetsReSent, netconn_t::packetsSent, netconn_t::peeraddress, PROTOCOL_QUAKEWORLD, netconn_t::qw, client_static_t::qw_outgoing_sequence, client_static_t::qw_qport, host_static_t::realtime, netconn_t::netconn_qw_s::reliable_sequence, netgraphitem_t::reliablebytes, netconn_t::reliableMessagesSent, netconn_t::sendMessage, netconn_t::sendMessageLength, netconn_t::netconn_nq_s::sendSequence, StoreBigLong(), StoreLittleLong(), SZ_Clear(), SZ_HexDumpToConsole(), netgraphitem_t::unreliablebytes, and netconn_t::unreliableMessagesSent.

Referenced by CL_DisconnectEx(), CL_KeepaliveMessage(), CL_SendMove(), NetConn_ConnectionEstablished(), SV_DropClient(), and SV_SendClientDatagram().

NetConn_ServerFrame()

void NetConn_ServerFrame

(

void

)

Definition at line 3861 of file netconn.c.

{
    unsigned i;
    int length;
    lhnetaddress_t peeraddress;
    unsigned char readbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
 
    for (i = 0;i < sv_numsockets;i++)
        while (sv_sockets[i] && (length = NetConn_Read(sv_sockets[i], readbuffer, sizeof(readbuffer), &peeraddress)) > 0)
            NetConn_ServerParsePacket(sv_sockets[i], readbuffer, length, &peeraddress);
}

References i, length, NET_HEADERSIZE, NET_MAXMESSAGE, NetConn_Read(), NetConn_ServerParsePacket(), sv_numsockets, and sv_sockets.

Referenced by SV_Frame(), and SV_ThreadFunc().

NetConn_ServerParsePacket()

static int NetConn_ServerParsePacket ( lhnetsocket_t * mysocket, unsigned char * data, int length, lhnetaddress_t * peeraddress )

static

Definition at line 3193 of file netconn.c.

{
    int i, ret, clientnum, best;
    double besttime;
    char *string, response[2800], addressstring2[128];
    static char stringbuf[16384]; // server only
    qbool islocal = (LHNETADDRESS_GetAddressType(peeraddress) == LHNETADDRESSTYPE_LOOP);
    char senddata[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
    size_t sendlength, response_len;
    char infostringvalue[MAX_INPUTLINE];
 
    if (!sv.active)
        return false;
 
    // convert the address to a string incase we need it
    LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
 
    // see if we can identify the sender as a local player
    // (this is necessary for rcon to send a reliable reply if the client is
    //  actually on the server, not sending remotely)
    for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
        if (host_client->netconnection && host_client->netconnection->mysocket == mysocket && !LHNETADDRESS_Compare(&host_client->netconnection->peeraddress, peeraddress))
            break;
    if (i == svs.maxclients)
        host_client = NULL;
 
    if (length >= 5 && data[0] == 255 && data[1] == 255 && data[2] == 255 && data[3] == 255)
    {
        // received a command string - strip off the packaging and put it
        // into our string buffer with NULL termination
        data += 4;
        length -= 4;
        length = min(length, (int)sizeof(stringbuf) - 1);
        memcpy(stringbuf, data, length);
        stringbuf[length] = 0;
        string = stringbuf;
 
        if (developer_extra.integer)
        {
            Con_Printf("NetConn_ServerParsePacket: %s sent us a command:\n", addressstring2);
            Com_HexDumpToConsole(data, length);
        }
 
        sendlength = sizeof(senddata) - 4;
        switch(Crypto_ServerParsePacket(string, length, senddata+4, &sendlength, peeraddress))
        {
            case CRYPTO_NOMATCH:
                // nothing to do
                break;
            case CRYPTO_MATCH:
                if(sendlength)
                {
                    memcpy(senddata, "\377\377\377\377", 4);
                    NetConn_Write(mysocket, senddata, (int)sendlength+4, peeraddress);
                }
                break;
            case CRYPTO_DISCARD:
                if(sendlength)
                {
                    memcpy(senddata, "\377\377\377\377", 4);
                    NetConn_Write(mysocket, senddata, (int)sendlength+4, peeraddress);
                }
                return true;
                break;
            case CRYPTO_REPLACE:
                string = senddata+4;
                length = (int)sendlength;
                break;
        }
 
        if (length >= 12 && !memcmp(string, "getchallenge", 12) && (islocal || sv_public.integer > -3))
        {
            for (i = 0, best = 0, besttime = host.realtime;i < MAX_CHALLENGES;i++)
            {
                if(challenges[i].time > 0)
                    if (!LHNETADDRESS_Compare(peeraddress, &challenges[i].address))
                        break;
                if (besttime > challenges[i].time)
                    besttime = challenges[best = i].time;
            }
            // if we did not find an exact match, choose the oldest and
            // update address and string
            if (i == MAX_CHALLENGES)
            {
                i = best;
                challenges[i].address = *peeraddress;
                NetConn_BuildChallengeString(challenges[i].string, sizeof(challenges[i].string));
            }
            else
            {
                // flood control: drop if requesting challenge too often
                if(challenges[i].time > host.realtime - net_challengefloodblockingtimeout.value)
                    return true;
            }
            challenges[i].time = host.realtime;
            // send the challenge
            memcpy(response, "\377\377\377\377", 4);
            dpsnprintf(response+4, sizeof(response)-4, "challenge %s", challenges[i].string);
            response_len = strlen(response) + 1;
            Crypto_ServerAppendToChallenge(string, length, response, &response_len, sizeof(response));
            NetConn_Write(mysocket, response, (int)response_len, peeraddress);
            return true;
        }
        if (length > 8 && !memcmp(string, "connect\\", 8))
        {
            client_t *client;
            crypto_t *crypto = Crypto_ServerGetInstance(peeraddress);
            string += 7;
            length -= 7;
 
            if(crypto && crypto->authenticated)
            {
                // no need to check challenge
                if(crypto_developer.integer)
                {
                    Con_Printf("%s connection to %s is being established: client is %s@%s%.*s, I am %.*s@%s%.*s\n",
                            crypto->use_aes ? "Encrypted" : "Authenticated",
                            addressstring2,
                            crypto->client_idfp[0] ? crypto->client_idfp : "-",
                            (crypto->client_issigned || !crypto->client_keyfp[0]) ? "" : "~",
                            crypto_keyfp_recommended_length, crypto->client_keyfp[0] ? crypto->client_keyfp : "-",
                            crypto_keyfp_recommended_length, crypto->server_idfp[0] ? crypto->server_idfp : "-",
                            (crypto->server_issigned || !crypto->server_keyfp[0]) ? "" : "~",
                            crypto_keyfp_recommended_length, crypto->server_keyfp[0] ? crypto->server_keyfp : "-"
                          );
                }
            }
            else
            {
                if (InfoString_GetValue(string, "challenge", infostringvalue, sizeof(infostringvalue)))
                {
                    // validate the challenge
                    for (i = 0;i < MAX_CHALLENGES;i++)
                        if(challenges[i].time > 0)
                            if (!LHNETADDRESS_Compare(peeraddress, &challenges[i].address) && !strcmp(challenges[i].string, infostringvalue))
                                break;
                    // if the challenge is not recognized, drop the packet
                    if (i == MAX_CHALLENGES)
                        return true;
                }
            }
 
            if(InfoString_GetValue(string, "message", infostringvalue, sizeof(infostringvalue)))
                Con_DPrintf("Connecting client %s sent us the message: %s\n", addressstring2, infostringvalue);
 
            if(!(islocal || sv_public.integer > -2))
            {
                if (developer_extra.integer)
                    Con_Printf("Datagram_ParseConnectionless: sending \"reject %s\" to %s.\n", sv_public_rejectreason.string, addressstring2);
                memcpy(response, "\377\377\377\377", 4);
                dpsnprintf(response+4, sizeof(response)-4, "reject %s", sv_public_rejectreason.string);
                NetConn_WriteString(mysocket, response, peeraddress);
                return true;
            }
 
            // check engine protocol
            if(!InfoString_GetValue(string, "protocol", infostringvalue, sizeof(infostringvalue)) || strcmp(infostringvalue, "darkplaces 3"))
            {
                if (developer_extra.integer)
                    Con_Printf("Datagram_ParseConnectionless: sending \"reject Wrong game protocol.\" to %s.\n", addressstring2);
                NetConn_WriteString(mysocket, "\377\377\377\377reject Wrong game protocol.", peeraddress);
                return true;
            }
 
            // see if this is a duplicate connection request or a disconnected
            // client who is rejoining to the same client slot
            for (clientnum = 0, client = svs.clients;clientnum < svs.maxclients;clientnum++, client++)
            {
                if (client->netconnection && LHNETADDRESS_Compare(peeraddress, &client->netconnection->peeraddress) == 0)
                {
                    // this is a known client...
                    if(crypto && crypto->authenticated)
                    {
                        // reject if changing key!
                        if(client->netconnection->crypto.authenticated)
                        {
                            if(
                                    strcmp(client->netconnection->crypto.client_idfp, crypto->client_idfp)
                                    ||
                                    strcmp(client->netconnection->crypto.server_idfp, crypto->server_idfp)
                                    ||
                                    strcmp(client->netconnection->crypto.client_keyfp, crypto->client_keyfp)
                                    ||
                                    strcmp(client->netconnection->crypto.server_keyfp, crypto->server_keyfp)
                              )
                            {
                                if (developer_extra.integer)
                                    Con_Printf("Datagram_ParseConnectionless: sending \"reject Attempt to change key of crypto.\" to %s.\n", addressstring2);
                                NetConn_WriteString(mysocket, "\377\377\377\377reject Attempt to change key of crypto.", peeraddress);
                                return true;
                            }
                        }
                    }
                    else
                    {
                        // reject if downgrading!
                        if(client->netconnection->crypto.authenticated)
                        {
                            if (developer_extra.integer)
                                Con_Printf("Datagram_ParseConnectionless: sending \"reject Attempt to downgrade crypto.\" to %s.\n", addressstring2);
                            NetConn_WriteString(mysocket, "\377\377\377\377reject Attempt to downgrade crypto.", peeraddress);
                            return true;
                        }
                    }
                    if (client->begun)
                    {
                        // client crashed and is coming back,
                        // keep their stuff intact
                        if (developer_extra.integer)
                            Con_Printf("Datagram_ParseConnectionless: sending \"accept\" to %s.\n", addressstring2);
                        NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
                        if(crypto && crypto->authenticated)
                            Crypto_FinishInstance(&client->netconnection->crypto, crypto);
                        SV_SendServerinfo(client);
                    }
                    else
                    {
                        // client is still trying to connect,
                        // so we send a duplicate reply
                        if (developer_extra.integer)
                            Con_Printf("Datagram_ParseConnectionless: sending duplicate accept to %s.\n", addressstring2);
                        if(crypto && crypto->authenticated)
                            Crypto_FinishInstance(&client->netconnection->crypto, crypto);
                        NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
                    }
                    return true;
                }
            }
 
            if (NetConn_PreventFlood(peeraddress, sv.connectfloodaddresses, sizeof(sv.connectfloodaddresses) / sizeof(sv.connectfloodaddresses[0]), net_connectfloodblockingtimeout.value, true))
                return true;
 
            // find an empty client slot for this new client
            for (clientnum = 0; clientnum < svs.maxclients; clientnum++)
            {
                netconn_t *conn;
                int offset_clientnum = (net_connect_entnum_ofs.integer > 0)
                        ? (clientnum + net_connect_entnum_ofs.integer) % svs.maxclients
                        : clientnum;
 
                if (!svs.clients[offset_clientnum].active && (conn = NetConn_Open(mysocket, peeraddress)))
                {
                    // allocated connection
                    if (developer_extra.integer)
                        Con_Printf("Datagram_ParseConnectionless: sending \"accept\" to %s.\n", conn->address);
                    NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
                    // now set up the client
                    if(crypto && crypto->authenticated)
                        Crypto_FinishInstance(&conn->crypto, crypto);
                    SV_ConnectClient(offset_clientnum, conn);
                    NetConn_Heartbeat(1);
                    return true;
                }
            }
 
            // no empty slots found - server is full
            if (developer_extra.integer)
                Con_Printf("Datagram_ParseConnectionless: sending \"reject Server is full.\" to %s.\n", addressstring2);
            NetConn_WriteString(mysocket, "\377\377\377\377reject Server is full.", peeraddress);
 
            return true;
        }
        if (length >= 7 && !memcmp(string, "getinfo", 7) && (islocal || sv_public.integer > -1))
        {
            const char *challenge = NULL;
 
            if (NetConn_PreventFlood(peeraddress, sv.getstatusfloodaddresses, sizeof(sv.getstatusfloodaddresses) / sizeof(sv.getstatusfloodaddresses[0]), net_getstatusfloodblockingtimeout.value, false))
                return true;
 
            // If there was a challenge in the getinfo message
            if (length > 8 && string[7] == ' ')
                challenge = string + 8;
 
            if (NetConn_BuildStatusResponse(challenge, response, sizeof(response), false))
            {
                if (developer_extra.integer)
                    Con_DPrintf("Sending reply to master %s - %s\n", addressstring2, response);
                NetConn_WriteString(mysocket, response, peeraddress);
            }
            return true;
        }
        if (length >= 9 && !memcmp(string, "getstatus", 9) && (islocal || sv_public.integer > -1))
        {
            const char *challenge = NULL;
 
            if (NetConn_PreventFlood(peeraddress, sv.getstatusfloodaddresses, sizeof(sv.getstatusfloodaddresses) / sizeof(sv.getstatusfloodaddresses[0]), net_getstatusfloodblockingtimeout.value, false))
                return true;
 
            // If there was a challenge in the getinfo message
            if (length > 10 && string[9] == ' ')
                challenge = string + 10;
 
            if (NetConn_BuildStatusResponse(challenge, response, sizeof(response), true))
            {
                if (developer_extra.integer)
                    Con_DPrintf("Sending reply to client %s - %s\n", addressstring2, response);
                NetConn_WriteString(mysocket, response, peeraddress);
            }
            return true;
        }
        if (length >= 37 && !memcmp(string, "srcon HMAC-MD4 TIME ", 20))
        {
            char *password = string + 20;
            char *timeval = string + 37;
            char *s = strchr(timeval, ' ');
            char *endpos = string + length + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
            const char *userlevel;
 
            if(rcon_secure.integer > 1)
                return true;
 
            if(!s)
                return true; // invalid packet
            ++s;
 
            userlevel = RCon_Authenticate(peeraddress, password, s, endpos, hmac_mdfour_time_matching, timeval, endpos - timeval - 1); // not including the appended \0 into the HMAC
            RCon_Execute(mysocket, peeraddress, addressstring2, userlevel, s, endpos, false);
            return true;
        }
        if (length >= 42 && !memcmp(string, "srcon HMAC-MD4 CHALLENGE ", 25))
        {
            char *password = string + 25;
            char *challenge = string + 42;
            char *s = strchr(challenge, ' ');
            char *endpos = string + length + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
            const char *userlevel;
            if(!s)
                return true; // invalid packet
            ++s;
 
            userlevel = RCon_Authenticate(peeraddress, password, s, endpos, hmac_mdfour_challenge_matching, challenge, endpos - challenge - 1); // not including the appended \0 into the HMAC
            RCon_Execute(mysocket, peeraddress, addressstring2, userlevel, s, endpos, false);
            return true;
        }
        if (length >= 5 && !memcmp(string, "rcon ", 5))
        {
            int j;
            char *s = string + 5;
            char *endpos = string + length + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
            char password[64];
 
            if(rcon_secure.integer > 0)
                return true;
 
            for (j = 0;!ISWHITESPACE(*s);s++)
                if (j < (int)sizeof(password) - 1)
                    password[j++] = *s;
            if(ISWHITESPACE(*s) && s != endpos) // skip leading ugly space
                ++s;
            password[j] = 0;
            if (!ISWHITESPACE(password[0]))
            {
                const char *userlevel = RCon_Authenticate(peeraddress, password, s, endpos, plaintext_matching, NULL, 0);
                RCon_Execute(mysocket, peeraddress, addressstring2, userlevel, s, endpos, false);
            }
            return true;
        }
        if (!strncmp(string, "extResponse ", 12))
        {
            ++sv_net_extresponse_count;
            if(sv_net_extresponse_count > NET_EXTRESPONSE_MAX)
                sv_net_extresponse_count = NET_EXTRESPONSE_MAX;
            sv_net_extresponse_last = (sv_net_extresponse_last + 1) % NET_EXTRESPONSE_MAX;
            dpsnprintf(sv_net_extresponse[sv_net_extresponse_last], sizeof(sv_net_extresponse[sv_net_extresponse_last]), "'%s' %s", addressstring2, string + 12);
            return true;
        }
        if (!strncmp(string, "ping", 4))
        {
            if (developer_extra.integer)
                Con_DPrintf("Received ping from %s, sending ack\n", addressstring2);
            NetConn_WriteString(mysocket, "\377\377\377\377ack", peeraddress);
            return true;
        }
        if (!strncmp(string, "ack", 3))
            return true;
        // we may not have liked the packet, but it was a command packet, so
        // we're done processing this packet now
        return true;
    }
    // netquake control packets, supported for compatibility only, and only
    // when running game protocols that are normally served via this connection
    // protocol
    // (this protects more modern protocols against being used for
    //  Quake packet flood Denial Of Service attacks)
    if (length >= 5 && (i = BuffBigLong(data)) && (i & (~NETFLAG_LENGTH_MASK)) == (int)NETFLAG_CTL && (i & NETFLAG_LENGTH_MASK) == length && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3) && !ENCRYPTION_REQUIRED)
    {
        int c;
        int protocolnumber;
        const char *protocolname;
        client_t *knownclient;
        client_t *newclient;
        data += 4;
        length -= 4;
        SZ_Clear(&sv_message);
        SZ_Write(&sv_message, data, length);
        MSG_BeginReading(&sv_message);
        c = MSG_ReadByte(&sv_message);
        switch (c)
        {
        case CCREQ_CONNECT:
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_CONNECT from %s.\n", addressstring2);
            if(!(islocal || sv_public.integer > -2))
            {
                if (developer_extra.integer)
                    Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_REJECT \"%s\" to %s.\n", sv_public_rejectreason.string, addressstring2);
                SZ_Clear(&sv_message);
                // save space for the header, filled in later
                MSG_WriteLong(&sv_message, 0);
                MSG_WriteByte(&sv_message, CCREP_REJECT);
                MSG_WriteUnterminatedString(&sv_message, sv_public_rejectreason.string);
                MSG_WriteString(&sv_message, "\n");
                StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
                NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
                SZ_Clear(&sv_message);
                break;
            }
 
            protocolname = MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring));
            protocolnumber = MSG_ReadByte(&sv_message);
            if (strcmp(protocolname, "QUAKE") || protocolnumber != NET_PROTOCOL_VERSION)
            {
                if (developer_extra.integer)
                    Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_REJECT \"Incompatible version.\" to %s.\n", addressstring2);
                SZ_Clear(&sv_message);
                // save space for the header, filled in later
                MSG_WriteLong(&sv_message, 0);
                MSG_WriteByte(&sv_message, CCREP_REJECT);
                MSG_WriteString(&sv_message, "Incompatible version.\n");
                StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
                NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
                SZ_Clear(&sv_message);
                break;
            }
 
            // see if this connect request comes from a known client
            for (clientnum = 0, knownclient = svs.clients;clientnum < svs.maxclients;clientnum++, knownclient++)
            {
                if (knownclient->netconnection && LHNETADDRESS_Compare(peeraddress, &knownclient->netconnection->peeraddress) == 0)
                {
                    // this is either a duplicate connection request
                    // or coming back from a timeout
                    // (if so, keep their stuff intact)
 
                    crypto_t *crypto = Crypto_ServerGetInstance(peeraddress);
                    if((crypto && crypto->authenticated) || knownclient->netconnection->crypto.authenticated)
                    {
                        if (developer_extra.integer)
                            Con_Printf("Datagram_ParseConnectionless: sending CCREP_REJECT \"Attempt to downgrade crypto.\" to %s.\n", addressstring2);
                        SZ_Clear(&sv_message);
                        // save space for the header, filled in later
                        MSG_WriteLong(&sv_message, 0);
                        MSG_WriteByte(&sv_message, CCREP_REJECT);
                        MSG_WriteString(&sv_message, "Attempt to downgrade crypto.\n");
                        StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
                        NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
                        SZ_Clear(&sv_message);
                        return true;
                    }
 
                    // send a reply
                    if (developer_extra.integer)
                        Con_DPrintf("Datagram_ParseConnectionless: sending duplicate CCREP_ACCEPT to %s.\n", addressstring2);
                    SZ_Clear(&sv_message);
                    // save space for the header, filled in later
                    MSG_WriteLong(&sv_message, 0);
                    MSG_WriteByte(&sv_message, CCREP_ACCEPT);
                    MSG_WriteLong(&sv_message, LHNETADDRESS_GetPort(LHNET_AddressFromSocket(knownclient->netconnection->mysocket)));
                    StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
                    NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
                    SZ_Clear(&sv_message);
 
                    // if client is already spawned, re-send the
                    // serverinfo message as they'll need it to play
                    if (knownclient->begun)
                        SV_SendServerinfo(knownclient);
                    return true;
                }
            }
 
            // this is a new client, check for connection flood
            if (NetConn_PreventFlood(peeraddress, sv.connectfloodaddresses, sizeof(sv.connectfloodaddresses) / sizeof(sv.connectfloodaddresses[0]), net_connectfloodblockingtimeout.value, true))
                break;
 
            // find a slot for the new client
            for (clientnum = 0, newclient = svs.clients;clientnum < svs.maxclients;clientnum++, newclient++)
            {
                netconn_t *conn;
                if (!newclient->active && (newclient->netconnection = conn = NetConn_Open(mysocket, peeraddress)) != NULL)
                {
                    // connect to the client
                    // everything is allocated, just fill in the details
                    dp_strlcpy (conn->address, addressstring2, sizeof (conn->address));
                    if (developer_extra.integer)
                        Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_ACCEPT to %s.\n", addressstring2);
                    // send back the info about the server connection
                    SZ_Clear(&sv_message);
                    // save space for the header, filled in later
                    MSG_WriteLong(&sv_message, 0);
                    MSG_WriteByte(&sv_message, CCREP_ACCEPT);
                    MSG_WriteLong(&sv_message, LHNETADDRESS_GetPort(LHNET_AddressFromSocket(conn->mysocket)));
                    StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
                    NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
                    SZ_Clear(&sv_message);
                    // now set up the client struct
                    SV_ConnectClient(clientnum, conn);
                    NetConn_Heartbeat(1);
                    return true;
                }
            }
 
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_REJECT \"Server is full.\" to %s.\n", addressstring2);
            // no room; try to let player know
            SZ_Clear(&sv_message);
            // save space for the header, filled in later
            MSG_WriteLong(&sv_message, 0);
            MSG_WriteByte(&sv_message, CCREP_REJECT);
            MSG_WriteString(&sv_message, "Server is full.\n");
            StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
            NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
            SZ_Clear(&sv_message);
            break;
        case CCREQ_SERVER_INFO:
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_SERVER_INFO from %s.\n", addressstring2);
            if(!(islocal || sv_public.integer > -1))
                break;
 
            if (NetConn_PreventFlood(peeraddress, sv.getstatusfloodaddresses, sizeof(sv.getstatusfloodaddresses) / sizeof(sv.getstatusfloodaddresses[0]), net_getstatusfloodblockingtimeout.value, false))
                break;
 
            if (sv.active && !strcmp(MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring)), "QUAKE"))
            {
                int numclients;
                char myaddressstring[128];
                if (developer_extra.integer)
                    Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_SERVER_INFO to %s.\n", addressstring2);
                SZ_Clear(&sv_message);
                // save space for the header, filled in later
                MSG_WriteLong(&sv_message, 0);
                MSG_WriteByte(&sv_message, CCREP_SERVER_INFO);
                LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), myaddressstring, sizeof(myaddressstring), true);
                MSG_WriteString(&sv_message, myaddressstring);
                MSG_WriteString(&sv_message, hostname.string);
                MSG_WriteString(&sv_message, sv.worldbasename);
                // How many clients are there?
                for (i = 0, numclients = 0;i < svs.maxclients;i++)
                    if (svs.clients[i].active)
                        numclients++;
                MSG_WriteByte(&sv_message, numclients);
                MSG_WriteByte(&sv_message, svs.maxclients);
                MSG_WriteByte(&sv_message, NET_PROTOCOL_VERSION);
                StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
                NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
                SZ_Clear(&sv_message);
            }
            break;
        case CCREQ_PLAYER_INFO:
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_PLAYER_INFO from %s.\n", addressstring2);
            if(!(islocal || sv_public.integer > -1))
                break;
 
            if (NetConn_PreventFlood(peeraddress, sv.getstatusfloodaddresses, sizeof(sv.getstatusfloodaddresses) / sizeof(sv.getstatusfloodaddresses[0]), net_getstatusfloodblockingtimeout.value, false))
                break;
 
            if (sv.active)
            {
                int playerNumber, activeNumber, clientNumber;
                client_t *client;
 
                playerNumber = MSG_ReadByte(&sv_message);
                activeNumber = -1;
                for (clientNumber = 0, client = svs.clients; clientNumber < svs.maxclients; clientNumber++, client++)
                    if (client->active && ++activeNumber == playerNumber)
                        break;
                if (clientNumber != svs.maxclients)
                {
                    SZ_Clear(&sv_message);
                    // save space for the header, filled in later
                    MSG_WriteLong(&sv_message, 0);
                    MSG_WriteByte(&sv_message, CCREP_PLAYER_INFO);
                    MSG_WriteByte(&sv_message, playerNumber);
                    MSG_WriteString(&sv_message, client->name);
                    MSG_WriteLong(&sv_message, client->colors);
                    MSG_WriteLong(&sv_message, client->frags);
                    MSG_WriteLong(&sv_message, (int)(host.realtime - client->connecttime));
                    if(sv_status_privacy.integer)
                        MSG_WriteString(&sv_message, client->netconnection ? "hidden" : "botclient");
                    else
                        MSG_WriteString(&sv_message, client->netconnection ? client->netconnection->address : "botclient");
                    StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
                    NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
                    SZ_Clear(&sv_message);
                }
            }
            break;
        case CCREQ_RULE_INFO:
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_RULE_INFO from %s.\n", addressstring2);
            if(!(islocal || sv_public.integer > -1))
                break;
 
            // no flood check here, as it only returns one cvar for one cvar and clients may iterate quickly
 
            if (sv.active)
            {
                char *prevCvarName;
                cvar_t *var;
 
                // find the search start location
                prevCvarName = MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring));
                var = Cvar_FindVarAfter(&cvars_all, prevCvarName, CF_NOTIFY);
 
                // send the response
                SZ_Clear(&sv_message);
                // save space for the header, filled in later
                MSG_WriteLong(&sv_message, 0);
                MSG_WriteByte(&sv_message, CCREP_RULE_INFO);
                if (var)
                {
                    MSG_WriteString(&sv_message, var->name);
                    MSG_WriteString(&sv_message, var->string);
                }
                StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
                NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
                SZ_Clear(&sv_message);
            }
            break;
        case CCREQ_RCON:
            if (developer_extra.integer)
                Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_RCON from %s.\n", addressstring2);
            if (sv.active && !rcon_secure.integer)
            {
                char password[2048];
                char cmd[2048];
                char *s;
                char *endpos;
                const char *userlevel;
                dp_strlcpy(password, MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring)), sizeof(password));
                dp_strlcpy(cmd, MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring)), sizeof(cmd));
                s = cmd;
                endpos = cmd + strlen(cmd) + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
                userlevel = RCon_Authenticate(peeraddress, password, s, endpos, plaintext_matching, NULL, 0);
                RCon_Execute(mysocket, peeraddress, addressstring2, userlevel, s, endpos, true);
                return true;
            }
            break;
        default:
            break;
        }
        SZ_Clear(&sv_message);
        // we may not have liked the packet, but it was a valid control
        // packet, so we're done processing this packet now
        return true;
    }
    if (host_client)
    {
        if ((ret = NetConn_ReceivedMessage(host_client->netconnection, data, length, sv.protocol, host_client->begun ? net_messagetimeout.value : net_connecttimeout.value)) == 2)
        {
            SV_ReadClientMessage();
            return ret;
        }
    }
    return 0;
}

References client_t::active, server_t::active, challenge_t::address, netconn_t::address, crypto_t::authenticated, client_t::begun, BuffBigLong(), CCREP_ACCEPT, CCREP_PLAYER_INFO, CCREP_REJECT, CCREP_RULE_INFO, CCREP_SERVER_INFO, CCREQ_CONNECT, CCREQ_PLAYER_INFO, CCREQ_RCON, CCREQ_RULE_INFO, CCREQ_SERVER_INFO, CF_NOTIFY, challenges, crypto_t::client_idfp, crypto_t::client_issigned, crypto_t::client_keyfp, server_static_t::clients, cmd(), client_t::colors, Com_HexDumpToConsole(), Con_DPrintf(), Con_Printf(), server_t::connectfloodaddresses, client_t::connecttime, netconn_t::crypto, crypto_developer, CRYPTO_DISCARD, Crypto_FinishInstance(), CRYPTO_HEADERSIZE, crypto_keyfp_recommended_length, CRYPTO_MATCH, CRYPTO_NOMATCH, CRYPTO_REPLACE, Crypto_ServerAppendToChallenge(), Crypto_ServerGetInstance(), Crypto_ServerParsePacket(), sizebuf_t::cursize, Cvar_FindVarAfter(), cvars_all, data, sizebuf_t::data, developer_extra, dp_strlcpy, dpsnprintf(), ENCRYPTION_REQUIRED, client_t::frags, server_t::getstatusfloodaddresses, hmac_mdfour_challenge_matching(), hmac_mdfour_time_matching(), host, host_client, hostname, i, InfoString_GetValue(), int(), cvar_t::integer, ISWHITESPACE, length, LHNET_AddressFromSocket(), LHNETADDRESS_Compare(), LHNETADDRESS_GetAddressType(), LHNETADDRESS_GetPort(), LHNETADDRESS_ToString(), LHNETADDRESSTYPE_LOOP, MAX_CHALLENGES, MAX_INPUTLINE, server_static_t::maxclients, min, MSG_BeginReading(), MSG_ReadByte, MSG_ReadString(), MSG_WriteByte(), MSG_WriteLong(), MSG_WriteString(), MSG_WriteUnterminatedString(), netconn_t::mysocket, client_t::name, cvar_t::name, net_challengefloodblockingtimeout, net_connect_entnum_ofs, net_connectfloodblockingtimeout, net_connecttimeout, NET_EXTRESPONSE_MAX, net_getstatusfloodblockingtimeout, NET_HEADERSIZE, NET_MAXMESSAGE, net_messagetimeout, NET_PROTOCOL_VERSION, NetConn_BuildChallengeString(), NetConn_BuildStatusResponse(), NetConn_Heartbeat(), NetConn_Open(), NetConn_PreventFlood(), NetConn_ReceivedMessage(), NetConn_Write(), NetConn_WriteString(), client_t::netconnection, NETFLAG_CTL, NETFLAG_LENGTH_MASK, NULL, netconn_t::peeraddress, plaintext_matching(), server_t::protocol, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, RCon_Authenticate(), RCon_Execute(), rcon_secure, host_static_t::realtime, ret, crypto_t::server_idfp, crypto_t::server_issigned, crypto_t::server_keyfp, StoreBigLong(), cvar_t::string, string, strlen(), sv, SV_ConnectClient(), sv_message, sv_net_extresponse, sv_net_extresponse_count, sv_net_extresponse_last, sv_public, sv_public_rejectreason, SV_ReadClientMessage(), sv_readstring, SV_SendServerinfo(), sv_status_privacy, svs, SZ_Clear(), SZ_Write(), challenge_t::time, time, crypto_t::use_aes, cvar_t::value, and server_t::worldbasename.

Referenced by NetConn_ServerFrame().

NetConn_Shutdown()

void NetConn_Shutdown

(

void

)

Definition at line 4201 of file netconn.c.

{
    NetConn_CloseClientPorts();
    NetConn_CloseServerPorts();
    LHNET_Shutdown();
    if (netconn_mutex)
        Thread_DestroyMutex(netconn_mutex);
    netconn_mutex = NULL;
}

References LHNET_Shutdown(), NetConn_CloseClientPorts(), NetConn_CloseServerPorts(), netconn_mutex, NULL, and Thread_DestroyMutex.

Referenced by Host_Shutdown().

NetConn_sv_netport_Callback()

static void NetConn_sv_netport_Callback ( cvar_t * var )

static

Definition at line 1296 of file netconn.c.

{
    if (hostport != var->integer)
    {
        hostport = var->integer;
        if (sv.active)
            Con_Print("Changing \"port\" will not take effect until \"map\" command is executed.\n");
    }
}

References server_t::active, Con_Print(), hostport, cvar_t::integer, and sv.

Referenced by NetConn_Init().

NetConn_UpdateCleartime()

static void NetConn_UpdateCleartime ( double * cleartime, int rate, int burstsize, int len )

static

Definition at line 806 of file netconn.c.

{
    double bursttime = burstsize / (double)rate;
 
    // delay later packets to obey rate limit
    if (*cleartime < host.realtime - bursttime)
        *cleartime = host.realtime - bursttime;
    *cleartime = *cleartime + len / (double)rate;
 
    // limit bursts to one packet in size ("dialup mode" emulating old behaviour)
    if (net_test.integer)
    {
        if (*cleartime < host.realtime)
            *cleartime = host.realtime;
    }
}

References host, cvar_t::integer, net_test, and host_static_t::realtime.

Referenced by NetConn_ReceivedMessage(), and NetConn_SendUnreliableMessage().

NetConn_UpdateSockets()

void NetConn_UpdateSockets

(

void

)

Definition at line 1306 of file netconn.c.

{
    int i, j;
 
    // TODO add logic to automatically close sockets if needed
    LHNET_DefaultDSCP(net_tos_dscp.integer);
 
    for (j = 0;j < MAX_RCONS;j++)
    {
        i = (cls.rcon_ringpos + j + 1) % MAX_RCONS;
        if(cls.rcon_commands[i][0])
        {
            if(host.realtime > cls.rcon_timeout[i])
            {
                char s[128];
                LHNETADDRESS_ToString(&cls.rcon_addresses[i], s, sizeof(s), true);
                Con_Printf("rcon to %s (for command %s) failed: challenge request timed out\n", s, cls.rcon_commands[i]);
                cls.rcon_commands[i][0] = 0;
                --cls.rcon_trying;
                break;
            }
        }
    }
}

References cls, Con_Printf(), host, i, cvar_t::integer, LHNET_DefaultDSCP(), LHNETADDRESS_ToString(), MAX_RCONS, net_tos_dscp, client_static_t::rcon_addresses, client_static_t::rcon_commands, client_static_t::rcon_ringpos, client_static_t::rcon_timeout, client_static_t::rcon_trying, and host_static_t::realtime.

Referenced by CL_EstablishConnection(), CL_PlayDemo(), CL_StartVideo(), Host_Frame(), NetConn_ClientFrame(), and NetConn_OpenServerPorts().

NetConn_Write()

int NetConn_Write	(	lhnetsocket_t *	mysocket,
		const void *	data,
		int	length,
		const lhnetaddress_t *	peeraddress )

Definition at line 758 of file netconn.c.

{
    int ret;
    unsigned i;
 
    if (net_fakeloss_send.integer)
        for (i = 0;i < cl_numsockets;i++)
            if (cl_sockets[i] == mysocket && (rand() % 100) < net_fakeloss_send.integer)
                return length;
    if (mysocket->address.addresstype == LHNETADDRESSTYPE_LOOP && netconn_mutex)
        Thread_LockMutex(netconn_mutex);
    ret = LHNET_Write(mysocket, data, length, peeraddress);
    if (mysocket->address.addresstype == LHNETADDRESSTYPE_LOOP && netconn_mutex)
        Thread_UnlockMutex(netconn_mutex);
    if (developer_networking.integer)
    {
        char addressstring[128], addressstring2[128];
        LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), addressstring, sizeof(addressstring), true);
        LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
        Con_Printf("LHNET_Write(%p (%s), %p, %i, %p (%s)) = %i%s\n", (void *)mysocket, addressstring, (void *)data, length, (void *)peeraddress, addressstring2, length, ret == length ? "" : " (ERROR)");
        Com_HexDumpToConsole((unsigned char *)data, length);
    }
    return ret;
}

References lhnetsocket_t::address, lhnetaddress_t::addresstype, cl_numsockets, cl_sockets, Com_HexDumpToConsole(), Con_Printf(), data, developer_networking, i, cvar_t::integer, length, LHNET_AddressFromSocket(), LHNET_Write(), LHNETADDRESS_ToString(), LHNETADDRESSTYPE_LOOP, net_fakeloss_send, netconn_mutex, ret, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by CL_Packet_f(), CL_PQRcon_f(), CL_Rcon_f(), Con_Rcon_Redirect_Flush(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ReceivedMessage(), NetConn_SendUnreliableMessage(), NetConn_ServerParsePacket(), and NetConn_WriteString().

NetConn_WriteString()

int NetConn_WriteString	(	lhnetsocket_t *	mysocket,
		const char *	string,
		const lhnetaddress_t *	peeraddress )

Definition at line 783 of file netconn.c.

{
    // note this does not include the trailing NULL because we add that in the parser
    return NetConn_Write(mysocket, string, (int)strlen(string), peeraddress);
}

References NetConn_Write(), and strlen().

Referenced by CL_Rcon_f(), Log_DestBuffer_Flush_NoLock(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_Heartbeat(), and NetConn_ServerParsePacket().

plaintext_matching()

static qbool plaintext_matching ( lhnetaddress_t * peeraddress, const char * password, const char * hash, const char * s, int slen )

static

Definition at line 3043 of file netconn.c.

{
    if (!password[0]) {
        Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
        return false;
    }
 
    return !strcmp(password, hash);
}

References CON_ERROR, and Con_Print().

Referenced by NetConn_ServerParsePacket().

PrintStats()

static void PrintStats ( netconn_t * conn )

static

Definition at line 4025 of file netconn.c.

{
    if ((cls.state == ca_connected && cls.protocol == PROTOCOL_QUAKEWORLD) || (sv.active && sv.protocol == PROTOCOL_QUAKEWORLD))
        Con_Printf("address=%21s canSend=%u sendSeq=%6u recvSeq=%6u\n", conn->address, !conn->sendMessageLength, conn->outgoing_unreliable_sequence, conn->qw.incoming_sequence);
    else
        Con_Printf("address=%21s canSend=%u sendSeq=%6u recvSeq=%6u\n", conn->address, !conn->sendMessageLength, conn->nq.sendSequence, conn->nq.receiveSequence);
    Con_Printf("unreliable messages sent   = %i\n", conn->unreliableMessagesSent);
    Con_Printf("unreliable messages recv   = %i\n", conn->unreliableMessagesReceived);
    Con_Printf("reliable messages sent     = %i\n", conn->reliableMessagesSent);
    Con_Printf("reliable messages received = %i\n", conn->reliableMessagesReceived);
    Con_Printf("packetsSent                = %i\n", conn->packetsSent);
    Con_Printf("packetsReSent              = %i\n", conn->packetsReSent);
    Con_Printf("packetsReceived            = %i\n", conn->packetsReceived);
    Con_Printf("receivedDuplicateCount     = %i\n", conn->receivedDuplicateCount);
    Con_Printf("droppedDatagrams           = %i\n", conn->droppedDatagrams);
}

References server_t::active, netconn_t::address, ca_connected, cls, Con_Printf(), netconn_t::droppedDatagrams, netconn_t::netconn_qw_s::incoming_sequence, netconn_t::nq, netconn_t::outgoing_unreliable_sequence, netconn_t::packetsReceived, netconn_t::packetsReSent, netconn_t::packetsSent, client_static_t::protocol, server_t::protocol, PROTOCOL_QUAKEWORLD, netconn_t::qw, netconn_t::receivedDuplicateCount, netconn_t::netconn_nq_s::receiveSequence, netconn_t::reliableMessagesReceived, netconn_t::reliableMessagesSent, netconn_t::sendMessageLength, netconn_t::netconn_nq_s::sendSequence, client_static_t::state, sv, netconn_t::unreliableMessagesReceived, and netconn_t::unreliableMessagesSent.

Referenced by Net_Stats_f().

RCon_Authenticate()

static const char * RCon_Authenticate ( lhnetaddress_t * peeraddress, const char * password, const char * s, const char * endpos, rcon_matchfunc_t comparator, const char * cs, int cslen )

static

returns a string describing the user level, or NULL for auth failure

Definition at line 3054 of file netconn.c.

{
    const char *text, *userpass_start, *userpass_end, *userpass_startpass;
    static char buf[MAX_INPUTLINE];
    qbool hasquotes;
    qbool restricted = false;
    qbool have_usernames = false;
    static char vabuf[1024];
 
    userpass_start = rcon_password.string;
    while((userpass_end = strchr(userpass_start, ' ')))
    {
        have_usernames = true;
        dp_ustr2stp(buf, sizeof(buf), userpass_start, userpass_end - userpass_start);
        if(buf[0])  // Ignore empty entries due to leading/duplicate space.
            if(comparator(peeraddress, buf, password, cs, cslen))
                goto allow;
        userpass_start = userpass_end + 1;
    }
    if(userpass_start[0])  // Ignore empty trailing entry due to trailing space or password not set.
    {
        userpass_end = userpass_start + strlen(userpass_start);
        if(comparator(peeraddress, userpass_start, password, cs, cslen))
            goto allow;
    }
 
    restricted = true;
    have_usernames = false;
    userpass_start = rcon_restricted_password.string;
    while((userpass_end = strchr(userpass_start, ' ')))
    {
        have_usernames = true;
        dp_ustr2stp(buf, sizeof(buf), userpass_start, userpass_end - userpass_start);
        if(buf[0])  // Ignore empty entries due to leading/duplicate space.
            if(comparator(peeraddress, buf, password, cs, cslen))
                goto check;
        userpass_start = userpass_end + 1;
    }
    if(userpass_start[0])  // Ignore empty trailing entry due to trailing space or password not set.
    {
        userpass_end = userpass_start + strlen(userpass_start);
        if(comparator(peeraddress, userpass_start, password, cs, cslen))
            goto check;
    }
    
    return NULL; // DENIED
 
check:
    for(text = s; text != endpos; ++text)
        if((signed char) *text > 0 && ((signed char) *text < (signed char) ' ' || *text == ';'))
            return NULL; // block possible exploits against the parser/alias expansion
 
    while(s != endpos)
    {
        size_t l = strlen(s);
        if(l)
        {
            hasquotes = (strchr(s, '"') != NULL);
            // sorry, we can't allow these substrings in wildcard expressions,
            // as they can mess with the argument counts
            text = rcon_restricted_commands.string;
            while(COM_ParseToken_Console(&text))
            {
                // com_token now contains a pattern to check for...
                if(strchr(com_token, '*') || strchr(com_token, '?')) // wildcard expression, * can only match a SINGLE argument
                {
                    if(!hasquotes)
                        if(matchpattern_with_separator(s, com_token, true, " ", true)) // note how we excluded tab, newline etc. above
                            goto match;
                }
                else if(strchr(com_token, ' ')) // multi-arg expression? must match in whole
                {
                    if(!strcmp(com_token, s))
                        goto match;
                }
                else // single-arg expression? must match the beginning of the command
                {
                    if(!strcmp(com_token, s))
                        goto match;
                    if(!memcmp(va(vabuf, sizeof(vabuf), "%s ", com_token), s, strlen(com_token) + 1))
                        goto match;
                }
            }
            // if we got here, nothing matched!
            return NULL;
        }
match:
        s += l + 1;
    }
 
allow:
    userpass_startpass = strchr(userpass_start, ':');
    if(have_usernames && userpass_startpass && userpass_startpass < userpass_end)
        return va(vabuf, sizeof(vabuf), "%srcon (username %.*s)", restricted ? "restricted " : "", (int)(userpass_startpass-userpass_start), userpass_start);
 
    return va(vabuf, sizeof(vabuf), "%srcon", restricted ? "restricted " : "");
}

References buf, COM_ParseToken_Console(), com_token, dp_ustr2stp(), matchpattern_with_separator(), MAX_INPUTLINE, NULL, rcon_password, rcon_restricted_commands, rcon_restricted_password, cvar_t::string, strlen(), and va().

Referenced by NetConn_ServerParsePacket().

RCon_Execute()

static void RCon_Execute ( lhnetsocket_t * mysocket, lhnetaddress_t * peeraddress, const char * addressstring2, const char * userlevel, const char * s, const char * endpos, qbool proquakeprotocol )

static

Definition at line 3152 of file netconn.c.

{
    if(userlevel)
    {
        // looks like a legitimate rcon command with the correct password
        const char *s_ptr = s;
        Con_Printf("server received %s command from %s: ", userlevel, host_client ? host_client->name : addressstring2);
        while(s_ptr != endpos)
        {
            size_t l = strlen(s_ptr);
            if(l)
                Con_Printf(" %s;", s_ptr);
            s_ptr += l + 1;
        }
        Con_Printf("\n");
 
        if (!host_client || !host_client->netconnection || LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
            Con_Rcon_Redirect_Init(mysocket, peeraddress, proquakeprotocol);
        while(s != endpos)
        {
            size_t l = strlen(s);
            if(l)
            {
                client_t *host_client_save = host_client;
                Cmd_PreprocessAndExecuteString(cmd_local, s, l, src_local, true);
                host_client = host_client_save;
                // in case it is a command that changes host_client (like restart)
            }
            s += l + 1;
        }
        Con_Rcon_Redirect_End();
    }
    else
    {
        if (!host_client || !host_client->netconnection || LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
            Con_Rcon_Redirect_Init(mysocket, peeraddress, proquakeprotocol);
        Con_Printf(CON_ERROR "server denied rcon access to %s\n", host_client ? host_client->name : addressstring2);
        Con_Rcon_Redirect_End();
    }
}

References cmd_local, Cmd_PreprocessAndExecuteString(), CON_ERROR, Con_Printf(), Con_Rcon_Redirect_End(), Con_Rcon_Redirect_Init(), host_client, LHNETADDRESS_GetAddressType(), LHNETADDRESSTYPE_LOOP, client_t::name, client_t::netconnection, netconn_t::peeraddress, src_local, and strlen().

Referenced by NetConn_ServerParsePacket().

Variable Documentation

challenges

challenge_t challenges[MAX_CHALLENGES]

Definition at line 123 of file netconn.c.

Referenced by Crypto_ServerParsePacket_Internal(), hmac_mdfour_challenge_matching(), and NetConn_ServerParsePacket().

cl_message

sizebuf_t cl_message

Definition at line 71 of file netconn.c.

Referenced by CL_KeepaliveMessage(), CL_Parse_DumpPacket(), CL_ParseBaseline(), CL_ParseBeam(), CL_ParseClientdata(), CL_ParseDownload(), CL_ParseEffect(), CL_ParseEffect2(), CL_ParseParticleEffect(), CL_ParsePointParticles(), CL_ParsePointParticles1(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseStaticSound(), CL_ParseTempEntity(), CL_ParseTrailParticles(), CL_ReadDemoMessage(), CL_VM_Parse_TempEntity(), CSQC_ReadEntities(), EntityFrame4_CL_ReadFrame(), EntityFrame5_CL_ReadFrame(), EntityFrame_CL_ReadFrame(), EntityFrameQuake_ReadEntity(), EntityFrameQW_CL_ReadFrame(), EntityState5_ReadUpdate(), EntityState_ReadExtendBits(), EntityState_ReadFields(), EntityStateQW_ReadEntityUpdate(), EntityStateQW_ReadPlayerUpdate(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_Init(), NetConn_ReceivedMessage(), QW_CL_ParseDownload(), QW_CL_ParseModelList(), QW_CL_ParseNails(), QW_CL_ParseSoundList(), QW_CL_ServerInfo(), QW_CL_SetInfo(), QW_CL_UpdateUserInfo(), SHOWLMP_decodehide(), SHOWLMP_decodeshow(), V_ParseDamage(), VM_CL_ReadAngle(), VM_CL_ReadByte(), VM_CL_ReadChar(), VM_CL_ReadCoord(), VM_CL_ReadFloat(), VM_CL_ReadLong(), VM_CL_ReadPicture(), VM_CL_ReadShort(), and VM_CL_ReadString().

cl_message_buf

unsigned char cl_message_buf[NET_MAXMESSAGE]

static

Definition at line 73 of file netconn.c.

Referenced by NetConn_Init().

cl_net_extresponse

char cl_net_extresponse[NET_EXTRESPONSE_MAX][1400]

Definition at line 160 of file netconn.c.

Referenced by NetConn_ClientParsePacket(), and VM_CL_getextresponse().

cl_net_extresponse_count

unsigned cl_net_extresponse_count = 0

Definition at line 161 of file netconn.c.

Referenced by NetConn_ClientParsePacket(), and VM_CL_getextresponse().

cl_net_extresponse_last

unsigned cl_net_extresponse_last = 0

Definition at line 162 of file netconn.c.

Referenced by NetConn_ClientParsePacket(), and VM_CL_getextresponse().

cl_netport

cvar_t cl_netport = {CF_CLIENT, "cl_port", "0", "forces client to use chosen port number if not 0"}

Definition at line 155 of file netconn.c.

{CF_CLIENT, "cl_port", "0", "forces client to use chosen port number if not 0"};

Referenced by CL_DisconnectEx(), CL_Init(), NetConn_Init(), and NetConn_OpenClientPorts().

cl_numsockets

unsigned cl_numsockets

static

Definition at line 146 of file netconn.c.

Referenced by NetConn_ChooseClientSocketForAddress(), NetConn_CL_UpdateSockets_Callback(), NetConn_ClientFrame(), NetConn_CloseClientPorts(), NetConn_HaveClientPorts(), NetConn_Init(), NetConn_OpenClientPort(), NetConn_Read(), and NetConn_Write().

cl_readstring

char cl_readstring[MAX_INPUTLINE]

Definition at line 75 of file netconn.c.

Referenced by CL_ParseServerInfo(), CL_ParseServerMessage(), CL_ParseTempEntity(), NetConn_ClientParsePacket(), QW_CL_ParseModelList(), QW_CL_ParseSoundList(), QW_CL_ServerInfo(), QW_CL_SetInfo(), QW_CL_UpdateUserInfo(), SHOWLMP_decodehide(), SHOWLMP_decodeshow(), VM_CL_ReadPicture(), and VM_CL_ReadString().

cl_sockets

lhnetsocket_t* cl_sockets[16]

static

Definition at line 147 of file netconn.c.

Referenced by NetConn_ChooseClientSocketForAddress(), NetConn_ClientFrame(), NetConn_CloseClientPorts(), NetConn_OpenClientPort(), NetConn_Read(), and NetConn_Write().

clientport

int clientport = -1

static

Definition at line 1268 of file netconn.c.

Referenced by NetConn_CL_UpdateSockets_Callback().

clientport2

int clientport2 = -1

static

Definition at line 1269 of file netconn.c.

Referenced by NetConn_CL_UpdateSockets_Callback().

developer_networking

cvar_t developer_networking = {CF_CLIENT | CF_SERVER, "developer_networking", "0", "prints all received and sent packets (recommended only for debugging)"}

Definition at line 89 of file netconn.c.

{CF_CLIENT | CF_SERVER, "developer_networking", "0", "prints all received and sent packets (recommended only for debugging)"};

Referenced by Crypto_DecryptPacket(), Crypto_EncryptPacket(), NetConn_ClientParsePacket(), NetConn_Init(), NetConn_Read(), NetConn_SendUnreliableMessage(), NetConn_Write(), and SV_ReadClientMessage().

gameversion

cvar_t gameversion = {CF_SERVER, "gameversion", "0", "version of game data (mod-specific) to be sent to querying clients"}

static

Definition at line 108 of file netconn.c.

{CF_SERVER, "gameversion", "0", "version of game data (mod-specific) to be sent to querying clients"};

Referenced by NetConn_BuildStatusResponse(), and NetConn_Init().

gameversion_max

cvar_t gameversion_max = {CF_CLIENT | CF_SERVER, "gameversion_max", "-1", "maximum version of game data (mod-specific), when client and server gameversion mismatch in the server browser the server is shown as incompatible; if -1, gameversion is used alone"}

static

Definition at line 110 of file netconn.c.

{CF_CLIENT | CF_SERVER, "gameversion_max", "-1", "maximum version of game data (mod-specific), when client and server gameversion mismatch in the server browser the server is shown as incompatible; if -1, gameversion is used alone"};

Referenced by NetConn_Init().

gameversion_min

cvar_t gameversion_min = {CF_CLIENT | CF_SERVER, "gameversion_min", "-1", "minimum version of game data (mod-specific), when client and server gameversion mismatch in the server browser the server is shown as incompatible; if -1, gameversion is used alone"}

static

Definition at line 109 of file netconn.c.

{CF_CLIENT | CF_SERVER, "gameversion_min", "-1", "minimum version of game data (mod-specific), when client and server gameversion mismatch in the server browser the server is shown as incompatible; if -1, gameversion is used alone"};

Referenced by NetConn_Init().

hostname

cvar_t hostname = {CF_SERVER | CF_ARCHIVE, "hostname", "UNNAMED", "server message to show in server browser"}

Definition at line 88 of file netconn.c.

{CF_SERVER | CF_ARCHIVE, "hostname", "UNNAMED", "server message to show in server browser"};

Referenced by M_GameOptions_Draw(), M_GameOptions_Key(), NetConn_BuildStatusResponse(), NetConn_Init(), NetConn_ServerParsePacket(), SV_Pause_f(), SV_Say(), SV_SpawnServer(), and SV_Tell_f().

hostport

int hostport = -1

static

Definition at line 1293 of file netconn.c.

Referenced by NetConn_sv_netport_Callback().

masterquerycount

unsigned masterquerycount = 0

Definition at line 118 of file netconn.c.

Referenced by M_ServerList_Draw(), and VM_M_getserverliststat().

masterquerytime

double masterquerytime = -1000

Definition at line 117 of file netconn.c.

Referenced by M_ServerList_Draw().

masterreplycount

unsigned masterreplycount = 0

Definition at line 119 of file netconn.c.

Referenced by M_ServerList_Draw(), and VM_M_getserverliststat().

net_address

cvar_t net_address = {CF_CLIENT | CF_SERVER, "net_address", "", "network address to open ipv4 ports on (if empty, use default interfaces)"}

Definition at line 157 of file netconn.c.

{CF_CLIENT | CF_SERVER, "net_address", "", "network address to open ipv4 ports on (if empty, use default interfaces)"};

Referenced by NetConn_Init(), NetConn_OpenClientPorts(), and NetConn_OpenServerPorts().

net_address_ipv6

cvar_t net_address_ipv6 = {CF_CLIENT | CF_SERVER, "net_address_ipv6", "", "network address to open ipv6 ports on (if empty, use default interfaces)"}

Definition at line 158 of file netconn.c.

{CF_CLIENT | CF_SERVER, "net_address_ipv6", "", "network address to open ipv6 ports on (if empty, use default interfaces)"};

Referenced by NetConn_Init(), NetConn_OpenClientPorts(), and NetConn_OpenServerPorts().

net_burstreserve

cvar_t net_burstreserve = {CF_SERVER, "net_burstreserve", "0.3", "how much of the burst time to reserve for packet size spikes"}

Definition at line 80 of file netconn.c.

{CF_SERVER, "net_burstreserve", "0.3", "how much of the burst time to reserve for packet size spikes"};

Referenced by NetConn_Init(), and SV_SendClientDatagram().

net_challengefloodblockingtimeout

cvar_t net_challengefloodblockingtimeout = {CF_SERVER, "net_challengefloodblockingtimeout", "0.5", "when a challenge packet is received, it will block all future challenge packets from that IP address for this many seconds (cuts down on challenge floods). DarkPlaces clients retry once per second, so this should be <= 1. Failure here may lead to connect attempts failing."}

Definition at line 85 of file netconn.c.

{CF_SERVER, "net_challengefloodblockingtimeout", "0.5", "when a challenge packet is received, it will block all future challenge packets from that IP address for this many seconds (cuts down on challenge floods). DarkPlaces clients retry once per second, so this should be <= 1. Failure here may lead to connect attempts failing."};

Referenced by NetConn_Init(), and NetConn_ServerParsePacket().

net_connect_entnum_ofs

cvar_t net_connect_entnum_ofs = {CF_SERVER, "net_connect_entnum_ofs", "0", "entity number offset of human clients (for developer testing only)"}

Definition at line 83 of file netconn.c.

{CF_SERVER, "net_connect_entnum_ofs", "0", "entity number offset of human clients (for developer testing only)"};

Referenced by NetConn_Init(), and NetConn_ServerParsePacket().

net_connectfloodblockingtimeout

cvar_t net_connectfloodblockingtimeout = {CF_SERVER, "net_connectfloodblockingtimeout", "5", "when a connection packet is received, it will block all future connect packets from that IP address for this many seconds (cuts down on connect floods). Note that this does not include retries from the same IP; these are handled earlier and let in."}

Definition at line 84 of file netconn.c.

{CF_SERVER, "net_connectfloodblockingtimeout", "5", "when a connection packet is received, it will block all future connect packets from that IP address for this many seconds (cuts down on connect floods). Note that this does not include retries from the same IP; these are handled earlier and let in."};

Referenced by NetConn_Init(), and NetConn_ServerParsePacket().

net_connecttimeout

cvar_t net_connecttimeout = {CF_CLIENT | CF_SERVER, "net_connecttimeout","15", "after requesting a connection, the client must reply within this many seconds or be dropped (cuts down on connect floods). Must be above 10 seconds."}

Definition at line 82 of file netconn.c.

{CF_CLIENT | CF_SERVER, "net_connecttimeout","15", "after requesting a connection, the client must reply within this many seconds or be dropped (cuts down on connect floods). Must be above 10 seconds."};

Referenced by NetConn_Init(), NetConn_Open(), NetConn_ServerParsePacket(), and SV_SendServerinfo().

net_fakelag

cvar_t net_fakelag = {CF_CLIENT, "net_fakelag","0", "lags local loopback connection by this much ping time (useful to play more fairly on your own server with people with higher pings)"}

Definition at line 91 of file netconn.c.

{CF_CLIENT, "net_fakelag","0", "lags local loopback connection by this much ping time (useful to play more fairly on your own server with people with higher pings)"};

Referenced by LHNET_Read(), and NetConn_Init().

net_fakeloss_receive

cvar_t net_fakeloss_receive = {CF_CLIENT, "net_fakeloss_receive","0", "drops this percentage of incoming packets, useful for testing network protocol robustness (jerky movement, effects failing to start, sounds failing to play, etc)"}

static

Definition at line 93 of file netconn.c.

{CF_CLIENT, "net_fakeloss_receive","0", "drops this percentage of incoming packets, useful for testing network protocol robustness (jerky movement, effects failing to start, sounds failing to play, etc)"};

Referenced by NetConn_Init(), and NetConn_Read().

net_fakeloss_send

cvar_t net_fakeloss_send = {CF_CLIENT, "net_fakeloss_send","0", "drops this percentage of outgoing packets, useful for testing network protocol robustness (jerky movement, prediction errors, etc)"}

static

Definition at line 92 of file netconn.c.

{CF_CLIENT, "net_fakeloss_send","0", "drops this percentage of outgoing packets, useful for testing network protocol robustness (jerky movement, prediction errors, etc)"};

Referenced by NetConn_Init(), and NetConn_Write().

net_getstatusfloodblockingtimeout

cvar_t net_getstatusfloodblockingtimeout = {CF_SERVER, "net_getstatusfloodblockingtimeout", "1", "when a getstatus packet is received, it will block all future getstatus packets from that IP address for this many seconds (cuts down on getstatus floods). DarkPlaces retries every net_slist_timeout seconds, and qstat retries once per second, so this should be <= 1. Failure here may lead to server not showing up in the server list."}

Definition at line 86 of file netconn.c.

{CF_SERVER, "net_getstatusfloodblockingtimeout", "1", "when a getstatus packet is received, it will block all future getstatus packets from that IP address for this many seconds (cuts down on getstatus floods). DarkPlaces retries every net_slist_timeout seconds, and qstat retries once per second, so this should be <= 1. Failure here may lead to server not showing up in the server list."};

Referenced by NetConn_Init(), and NetConn_ServerParsePacket().

net_messagetimeout

cvar_t net_messagetimeout = {CF_CLIENT | CF_SERVER, "net_messagetimeout","300", "drops players who have not sent any packets for this many seconds"}

Definition at line 81 of file netconn.c.

{CF_CLIENT | CF_SERVER, "net_messagetimeout","300", "drops players who have not sent any packets for this many seconds"};

Referenced by NetConn_ClientParsePacket(), NetConn_Init(), and NetConn_ServerParsePacket().

net_sourceaddresscheck

cvar_t net_sourceaddresscheck = {CF_CLIENT, "net_sourceaddresscheck", "1", "compare the source IP address for replies (more secure, may break some bad multihoming setups"}

Definition at line 87 of file netconn.c.

{CF_CLIENT, "net_sourceaddresscheck", "1", "compare the source IP address for replies (more secure, may break some bad multihoming setups"};

Referenced by Crypto_ClientParsePacket(), NetConn_ClientParsePacket(), and NetConn_Init().

net_test

cvar_t net_test = {CF_CLIENT | CF_SERVER, "net_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"}

Definition at line 78 of file netconn.c.

{CF_CLIENT | CF_SERVER, "net_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};

Referenced by NetConn_Init(), NetConn_ReceivedMessage(), and NetConn_UpdateCleartime().

net_tos_dscp

cvar_t net_tos_dscp = {CF_CLIENT | CF_ARCHIVE, "net_tos_dscp", "32", "DiffServ Codepoint for network sockets (may need game restart to apply)"}

static

Definition at line 107 of file netconn.c.

{CF_CLIENT | CF_ARCHIVE, "net_tos_dscp", "32", "DiffServ Codepoint for network sockets (may need game restart to apply)"};

Referenced by NetConn_Init(), and NetConn_UpdateSockets().

net_usesizelimit

cvar_t net_usesizelimit = {CF_SERVER, "net_usesizelimit", "2", "use packet size limiting (0: never, 1: in non-CSQC mode, 2: always)"}

Definition at line 79 of file netconn.c.

{CF_SERVER, "net_usesizelimit", "2", "use packet size limiting (0: never, 1: in non-CSQC mode, 2: always)"};

Referenced by NetConn_Init(), and SV_SendClientDatagram().

netconn_list

netconn_t* netconn_list = NULL

Definition at line 151 of file netconn.c.

Referenced by Net_Stats_f(), NetConn_Close(), and NetConn_Open().

netconn_mempool

mempool_t* netconn_mempool = NULL

Definition at line 152 of file netconn.c.

Referenced by NetConn_Init(), and NetConn_Open().

netconn_mutex

void* netconn_mutex = NULL

Definition at line 153 of file netconn.c.

Referenced by NetConn_Init(), NetConn_Read(), NetConn_Shutdown(), and NetConn_Write().

nextheartbeattime

double nextheartbeattime = 0

static

Definition at line 69 of file netconn.c.

Referenced by NetConn_Heartbeat().

rcon_restricted_commands

cvar_t rcon_restricted_commands = {CF_SERVER, "rcon_restricted_commands", "", "allowed commands for rcon when the restricted mode password was used"}

static

Definition at line 112 of file netconn.c.

{CF_SERVER, "rcon_restricted_commands", "", "allowed commands for rcon when the restricted mode password was used"};

Referenced by NetConn_Init(), and RCon_Authenticate().

rcon_restricted_password

cvar_t rcon_restricted_password = {CF_SERVER | CF_PRIVATE, "rcon_restricted_password", "", "password to authenticate rcon commands in restricted mode; may be set to a string of the form user1:pass1 user2:pass2 user3:pass3 to allow multiple user accounts - the client then has to specify ONE of these combinations"}

static

Definition at line 111 of file netconn.c.

{CF_SERVER | CF_PRIVATE, "rcon_restricted_password", "", "password to authenticate rcon commands in restricted mode; may be set to a string of the form user1:pass1 user2:pass2 user3:pass3 to allow multiple user accounts - the client then has to specify ONE of these combinations"};

Referenced by NetConn_Init(), and RCon_Authenticate().

rcon_secure

cvar_t rcon_secure

extern

Definition at line 90 of file console.c.

{CF_CLIENT | CF_SERVER, "rcon_secure", "0", "force secure rcon authentication (1 = time based, 2 = challenge based); NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password"};

Referenced by Con_Init(), and NetConn_ServerParsePacket().

rcon_secure_challengetimeout

cvar_t rcon_secure_challengetimeout

extern

Definition at line 91 of file console.c.

{CF_CLIENT, "rcon_secure_challengetimeout", "5", "challenge-based secure rcon: time out requests if no challenge came within this time interval"};

Referenced by Con_Init(), and NetConn_ClientParsePacket().

rcon_secure_maxdiff

cvar_t rcon_secure_maxdiff = {CF_SERVER, "rcon_secure_maxdiff", "5", "maximum time difference between rcon request and server system clock (to protect against replay attack)"}

static

Definition at line 113 of file netconn.c.

{CF_SERVER, "rcon_secure_maxdiff", "5", "maximum time difference between rcon request and server system clock (to protect against replay attack)"};

Referenced by hmac_mdfour_time_matching(), and NetConn_Init().

serverlist_querystage

uint8_t serverlist_querystage = 0

bitfield because in theory we could be doing QW & DP simultaneously

Definition at line 129 of file netconn.c.

Referenced by CL_Frame().

serverquerycount

unsigned serverquerycount = 0

Definition at line 120 of file netconn.c.

Referenced by M_ServerList_Draw(), and VM_M_getserverliststat().

serverreplycount

unsigned serverreplycount = 0

Definition at line 121 of file netconn.c.

Referenced by M_ServerList_Draw(), and VM_M_getserverliststat().

sv_heartbeatperiod

cvar_t sv_heartbeatperiod = {CF_SERVER | CF_ARCHIVE, "sv_heartbeatperiod", "120", "how often to send heartbeat in seconds (only used if sv_public is 1)"}

static

Definition at line 38 of file netconn.c.

{CF_SERVER | CF_ARCHIVE, "sv_heartbeatperiod", "120", "how often to send heartbeat in seconds (only used if sv_public is 1)"};

Referenced by NetConn_Heartbeat(), and NetConn_Init().

sv_masters

cvar_t sv_masters[]

static

Initial value:

=
{
    {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master1", "", "user-chosen master server 1"},
    {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master2", "", "user-chosen master server 2"},
    {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master3", "", "user-chosen master server 3"},
    {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master4", "", "user-chosen master server 4"},
    {CF_CLIENT | CF_SERVER, "sv_masterextra1", "dpmaster.deathmask.net", "dpmaster.deathmask.net - default master server 1 (admin: Willis)"},
    {CF_CLIENT | CF_SERVER, "sv_masterextra2", "dpmaster.tchr.no", "dpmaster.tchr.no - default master server 2 (admin: tChr)"},
    {CF_CLIENT | CF_SERVER, "sv_masterextra3", "dpm.dpmaster.org:27777", "dpm.dpmaster.org - default master server 3 (admin: gazby/soylent_cow)"},
}

Definition at line 41 of file netconn.c.

{
    {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master1", "", "user-chosen master server 1"},
    {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master2", "", "user-chosen master server 2"},
    {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master3", "", "user-chosen master server 3"},
    {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master4", "", "user-chosen master server 4"},
    {CF_CLIENT | CF_SERVER, "sv_masterextra1", "dpmaster.deathmask.net", "dpmaster.deathmask.net - default master server 1 (admin: Willis)"},
    {CF_CLIENT | CF_SERVER, "sv_masterextra2", "dpmaster.tchr.no", "dpmaster.tchr.no - default master server 2 (admin: tChr)"},
    {CF_CLIENT | CF_SERVER, "sv_masterextra3", "dpm.dpmaster.org:27777", "dpm.dpmaster.org - default master server 3 (admin: gazby/soylent_cow)"},
};

Referenced by NetConn_Heartbeat(), and NetConn_Init().

sv_message

sizebuf_t sv_message

Definition at line 72 of file netconn.c.

Referenced by NetConn_Init(), NetConn_ReceivedMessage(), NetConn_ServerParsePacket(), SV_ReadClientMessage(), and SV_ReadClientMove().

sv_message_buf

unsigned char sv_message_buf[NET_MAXMESSAGE]

static

Definition at line 74 of file netconn.c.

Referenced by NetConn_Init().

sv_net_extresponse

char sv_net_extresponse[NET_EXTRESPONSE_MAX][1400]

Definition at line 164 of file netconn.c.

Referenced by NetConn_ServerParsePacket(), and VM_SV_getextresponse().

sv_net_extresponse_count

unsigned sv_net_extresponse_count = 0

Definition at line 165 of file netconn.c.

Referenced by NetConn_ServerParsePacket(), and VM_SV_getextresponse().

sv_net_extresponse_last

unsigned sv_net_extresponse_last = 0

Definition at line 166 of file netconn.c.

Referenced by NetConn_ServerParsePacket(), and VM_SV_getextresponse().

sv_netport

cvar_t sv_netport = {CF_SERVER, "port", "26000", "server port for players to connect to"}

Definition at line 156 of file netconn.c.

{CF_SERVER, "port", "26000", "server port for players to connect to"};

Referenced by CL_Packet_f(), CL_PQRcon_f(), CL_Rcon_f(), M_LanConfig_Key(), NetConn_Init(), NetConn_OpenServerPorts(), and SV_Init().

sv_numsockets

unsigned sv_numsockets

static

Definition at line 148 of file netconn.c.

Referenced by NetConn_ChooseServerSocketForAddress(), NetConn_CloseServerPorts(), NetConn_HaveServerPorts(), NetConn_Init(), NetConn_OpenServerPort(), NetConn_OpenServerPorts(), and NetConn_ServerFrame().

sv_public

cvar_t sv_public = {CF_SERVER, "sv_public", "0", "1: advertises this server on the master server (so that players can find it in the server browser); 0: allow direct queries only; -1: do not respond to direct queries; -2: do not allow anyone to connect; -3: already block at getchallenge level"}

Definition at line 36 of file netconn.c.

{CF_SERVER, "sv_public", "0", "1: advertises this server on the master server (so that players can find it in the server browser); 0: allow direct queries only; -1: do not respond to direct queries; -2: do not allow anyone to connect; -3: already block at getchallenge level"};

Referenced by Crypto_ServerParsePacket_Internal(), M_GameOptions_Draw(), M_NetStart_Change(), NetConn_Heartbeat(), NetConn_Init(), NetConn_ServerParsePacket(), and SV_ServerOptions().

sv_public_rejectreason

cvar_t sv_public_rejectreason = {CF_SERVER, "sv_public_rejectreason", "The server is closing.", "Rejection reason for connects when sv_public is -2"}

Definition at line 37 of file netconn.c.

{CF_SERVER, "sv_public_rejectreason", "The server is closing.", "Rejection reason for connects when sv_public is -2"};

Referenced by NetConn_Init(), and NetConn_ServerParsePacket().

sv_readstring

char sv_readstring[MAX_INPUTLINE]

Definition at line 76 of file netconn.c.

Referenced by NetConn_ServerParsePacket(), and SV_ReadClientMessage().

sv_sockets

lhnetsocket_t* sv_sockets[16]

static

Definition at line 149 of file netconn.c.

Referenced by NetConn_ChooseServerSocketForAddress(), NetConn_CloseServerPorts(), NetConn_OpenServerPort(), and NetConn_ServerFrame().

sv_status_privacy

cvar_t sv_status_privacy

extern

Definition at line 30 of file sv_ccmds.c.

{CF_SERVER | CF_ARCHIVE, "sv_status_privacy", "0", "do not show IP addresses in 'status' replies to clients"};

Referenced by NetConn_ServerParsePacket(), SV_InitOperatorCommands(), and SV_Status_f().