netconn.h File Reference

#include <stdarg.h>
#include "qtypes.h"
#include "crypto.h"
#include "lhnet.h"
#include "common.h"

Include dependency graph for netconn.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	challenge_t
struct	netconn_t::netconn_nq_s
struct	netconn_t::netconn_qw_s
struct	netconn_t
struct	netgraphitem_t

Macros
#define	CCREP_ACCEPT   0x81
#define	CCREP_PLAYER_INFO   0x84
#define	CCREP_RCON   0x86
#define	CCREP_REJECT   0x82
#define	CCREP_RULE_INFO   0x85
#define	CCREP_SERVER_INFO   0x83
#define	CCREQ_CONNECT   0x01
#define	CCREQ_PLAYER_INFO   0x03
#define	CCREQ_RCON   0x05
#define	CCREQ_RULE_INFO   0x04
#define	CCREQ_SERVER_INFO   0x02
#define	MAX_CHALLENGES   128
#define	NET_EXTRESPONSE_MAX   16
#define	NET_HEADERSIZE   (2 * sizeof(unsigned int))
#define	NET_PROTOCOL_VERSION   3
#define	NETFLAG_ACK   0x00020000
#define	NETFLAG_CRYPTO0   0x10000000
#define	NETFLAG_CRYPTO1   0x20000000
#define	NETFLAG_CRYPTO2   0x40000000
#define	NETFLAG_CTL   0x80000000
#define	NETFLAG_DATA   0x00010000
#define	NETFLAG_EOM   0x00080000
#define	NETFLAG_LENGTH_MASK   0x0000ffff
#define	NETFLAG_NAK   0x00040000
#define	NETFLAG_UNRELIABLE   0x00100000
#define	NETGRAPH_CHOKEDPACKET   -2
#define	NETGRAPH_LOSTPACKET   -1
#define	NETGRAPH_NOPACKET   0
#define	NETGRAPH_PACKETS   256

Functions
void	Net_Stats_f (struct cmd_state_s *cmd)
qbool	NetConn_CanSend (netconn_t *conn)
lhnetsocket_t *	NetConn_ChooseClientSocketForAddress (lhnetaddress_t *address)
lhnetsocket_t *	NetConn_ChooseServerSocketForAddress (lhnetaddress_t *address)
void	NetConn_ClientFrame (void)
void	NetConn_Close (netconn_t *conn)
void	NetConn_CloseClientPorts (void)
void	NetConn_CloseServerPorts (void)
qbool	NetConn_HaveClientPorts (void)
qbool	NetConn_HaveServerPorts (void)
void	NetConn_Heartbeat (int priority)
void	NetConn_Init (void)
int	NetConn_IsLocalGame (void)
void	NetConn_Listen (qbool state)
netconn_t *	NetConn_Open (lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress)
void	NetConn_OpenClientPorts (void)
void	NetConn_OpenServerPorts (int opennetports)
int	NetConn_Read (lhnetsocket_t *mysocket, void *data, int maxlength, lhnetaddress_t *peeraddress)
int	NetConn_SendUnreliableMessage (netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate, int burstsize, qbool quakesignon_suppressreliables)
void	NetConn_ServerFrame (void)
void	NetConn_Shutdown (void)
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)

Variables
challenge_t	challenges [MAX_CHALLENGES]
sizebuf_t	cl_message
char	cl_net_extresponse [NET_EXTRESPONSE_MAX][1400]
unsigned	cl_net_extresponse_count
unsigned	cl_net_extresponse_last
struct cvar_s	cl_netport
char	cl_readstring [MAX_INPUTLINE]
struct cvar_s	developer_networking
struct cvar_s	hostname
struct cvar_s	net_address
struct cvar_s	net_address_ipv6
struct cvar_s	net_burstreserve
struct cvar_s	net_fakelag
struct cvar_s	net_usesizelimit
netconn_t *	netconn_list
struct mempool_s *	netconn_mempool
sizebuf_t	sv_message
char	sv_net_extresponse [NET_EXTRESPONSE_MAX][1400]
unsigned	sv_net_extresponse_count
unsigned	sv_net_extresponse_last
struct cvar_s	sv_netport
struct cvar_s	sv_public
char	sv_readstring [MAX_INPUTLINE]

Macro Definition Documentation

CCREP_ACCEPT

#define CCREP_ACCEPT   0x81

Definition at line 125 of file netconn.h.

Referenced by NetConn_ClientParsePacket(), and NetConn_ServerParsePacket().

CCREP_PLAYER_INFO

#define CCREP_PLAYER_INFO   0x84

Definition at line 128 of file netconn.h.

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

CCREP_RCON

#define CCREP_RCON   0x86

Definition at line 130 of file netconn.h.

Referenced by Con_Rcon_Redirect_Init(), and NetConn_ClientParsePacket().

CCREP_REJECT

#define CCREP_REJECT   0x82

Definition at line 126 of file netconn.h.

Referenced by NetConn_ClientParsePacket(), and NetConn_ServerParsePacket().

CCREP_RULE_INFO

#define CCREP_RULE_INFO   0x85

Definition at line 129 of file netconn.h.

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

CCREP_SERVER_INFO

#define CCREP_SERVER_INFO   0x83

Definition at line 127 of file netconn.h.

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

CCREQ_CONNECT

#define CCREQ_CONNECT   0x01

Definition at line 119 of file netconn.h.

Referenced by NetConn_ClientFrame(), and NetConn_ServerParsePacket().

CCREQ_PLAYER_INFO

#define CCREQ_PLAYER_INFO   0x03

Definition at line 121 of file netconn.h.

Referenced by NetConn_ServerParsePacket().

CCREQ_RCON

#define CCREQ_RCON   0x05

Definition at line 123 of file netconn.h.

Referenced by CL_PQRcon_f(), and NetConn_ServerParsePacket().

CCREQ_RULE_INFO

#define CCREQ_RULE_INFO   0x04

Definition at line 122 of file netconn.h.

Referenced by NetConn_ServerParsePacket().

CCREQ_SERVER_INFO

#define CCREQ_SERVER_INFO   0x02

Definition at line 120 of file netconn.h.

Referenced by NetConn_ServerParsePacket().

MAX_CHALLENGES

#define MAX_CHALLENGES   128

Definition at line 476 of file netconn.h.

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

NET_EXTRESPONSE_MAX

#define NET_EXTRESPONSE_MAX   16

Definition at line 48 of file netconn.h.

Referenced by NetConn_ClientParsePacket(), NetConn_ServerParsePacket(), VM_CL_getextresponse(), and VM_SV_getextresponse().

NET_HEADERSIZE

#define NET_HEADERSIZE   (2 * sizeof(unsigned int))

Definition at line 32 of file netconn.h.

Referenced by NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ReceivedMessage(), NetConn_SendUnreliableMessage(), NetConn_ServerFrame(), and NetConn_ServerParsePacket().

NET_PROTOCOL_VERSION

#define NET_PROTOCOL_VERSION   3

Definition at line 47 of file netconn.h.

Referenced by NetConn_BuildStatusResponse(), NetConn_ClientFrame(), and NetConn_ServerParsePacket().

NETFLAG_ACK

#define NETFLAG_ACK   0x00020000

Definition at line 37 of file netconn.h.

Referenced by NetConn_ReceivedMessage().

NETFLAG_CRYPTO0

#define NETFLAG_CRYPTO0   0x10000000

Definition at line 41 of file netconn.h.

Referenced by NetConn_AddCryptoFlag().

NETFLAG_CRYPTO1

#define NETFLAG_CRYPTO1   0x20000000

Definition at line 42 of file netconn.h.

Referenced by NetConn_AddCryptoFlag().

NETFLAG_CRYPTO2

#define NETFLAG_CRYPTO2   0x40000000

Definition at line 43 of file netconn.h.

Referenced by NetConn_AddCryptoFlag().

NETFLAG_CTL

#define NETFLAG_CTL   0x80000000

Definition at line 44 of file netconn.h.

Referenced by CL_PQRcon_f(), Con_Rcon_Redirect_Flush(), Crypto_ClientParsePacket(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ReceivedMessage(), and NetConn_ServerParsePacket().

NETFLAG_DATA

#define NETFLAG_DATA   0x00010000

Definition at line 36 of file netconn.h.

Referenced by NetConn_ReceivedMessage(), and NetConn_SendUnreliableMessage().

NETFLAG_EOM

#define NETFLAG_EOM   0x00080000

Definition at line 39 of file netconn.h.

Referenced by NetConn_ReceivedMessage(), and NetConn_SendUnreliableMessage().

NETFLAG_LENGTH_MASK

#define NETFLAG_LENGTH_MASK   0x0000ffff

Definition at line 35 of file netconn.h.

Referenced by CL_PQRcon_f(), Con_Rcon_Redirect_Flush(), NetConn_ClientFrame(), NetConn_ReceivedMessage(), and NetConn_ServerParsePacket().

NETFLAG_NAK

#define NETFLAG_NAK   0x00040000

Definition at line 38 of file netconn.h.

NETFLAG_UNRELIABLE

#define NETFLAG_UNRELIABLE   0x00100000

Definition at line 40 of file netconn.h.

Referenced by NetConn_ReceivedMessage(), and NetConn_SendUnreliableMessage().

NETGRAPH_CHOKEDPACKET

#define NETGRAPH_CHOKEDPACKET   -2

Definition at line 225 of file netconn.h.

Referenced by NetConn_CanSend(), NetConn_SendUnreliableMessage(), and SCR_DrawNetGraph_DrawGraph().

NETGRAPH_LOSTPACKET

#define NETGRAPH_LOSTPACKET   -1

Definition at line 224 of file netconn.h.

Referenced by CL_SendMove(), NetConn_ReceivedMessage(), SCR_DrawNetGraph_DrawGraph(), SV_ApplyClientMove(), SV_Pings_f(), and SV_Status_f().

NETGRAPH_NOPACKET

#define NETGRAPH_NOPACKET   0

Definition at line 223 of file netconn.h.

Referenced by NetConn_CanSend(), NetConn_ReceivedMessage(), and NetConn_SendUnreliableMessage().

NETGRAPH_PACKETS

#define NETGRAPH_PACKETS   256

Definition at line 222 of file netconn.h.

Referenced by CL_SendMove(), NetConn_CanSend(), NetConn_ReceivedMessage(), SCR_DrawNetGraph_DrawGraph(), SV_ApplyClientMove(), SV_ExecuteClientMoves(), SV_Pings_f(), SV_ReadClientMove(), and SV_Status_f().

Function Documentation

Net_Stats_f()

void Net_Stats_f

(

struct cmd_state_s *

cmd

)

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_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_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_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_Listen()

void NetConn_Listen

(

qbool

state

)

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_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_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_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_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_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_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().

Variable Documentation

challenges

challenge_t challenges[MAX_CHALLENGES]

extern

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

extern

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_net_extresponse

char cl_net_extresponse[NET_EXTRESPONSE_MAX][1400]

extern

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

extern

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

extern

Definition at line 162 of file netconn.c.

Referenced by NetConn_ClientParsePacket(), and VM_CL_getextresponse().

cl_netport

struct cvar_s cl_netport

extern

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_readstring

char cl_readstring[MAX_INPUTLINE]

extern

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().

developer_networking

struct cvar_s developer_networking

extern

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().

hostname

struct cvar_s hostname

extern

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().

net_address

struct cvar_s net_address

extern

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

struct cvar_s net_address_ipv6

extern

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

struct cvar_s net_burstreserve

extern

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_fakelag

struct cvar_s net_fakelag

extern

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_usesizelimit

struct cvar_s net_usesizelimit

extern

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

extern

Definition at line 151 of file netconn.c.

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

netconn_mempool

struct mempool_s* netconn_mempool

extern

Definition at line 152 of file netconn.c.

Referenced by NetConn_Init(), and NetConn_Open().

sv_message

sizebuf_t sv_message

extern

Definition at line 72 of file netconn.c.

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

sv_net_extresponse

char sv_net_extresponse[NET_EXTRESPONSE_MAX][1400]

extern

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

extern

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

extern

Definition at line 166 of file netconn.c.

Referenced by NetConn_ServerParsePacket(), and VM_SV_getextresponse().

sv_netport

struct cvar_s sv_netport

extern

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_public

struct cvar_s sv_public

extern

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_readstring

char sv_readstring[MAX_INPUTLINE]

extern

Definition at line 76 of file netconn.c.

Referenced by NetConn_ServerParsePacket(), and SV_ReadClientMessage().