cvar_t hostname = {CVAR_SERVER | CVAR_SAVE, "hostname", "UNNAMED", "server message to show in server browser"};
cvar_t developer_networking = {CVAR_CLIENT | CVAR_SERVER, "developer_networking", "0", "prints all received and sent packets (recommended only for debugging)"};
-cvar_t cl_netlocalping = {CVAR_CLIENT, "cl_netlocalping","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 cl_netpacketloss_send = {CVAR_CLIENT, "cl_netpacketloss_send","0", "drops this percentage of outgoing packets, useful for testing network protocol robustness (jerky movement, prediction errors, etc)"};
-static cvar_t cl_netpacketloss_receive = {CVAR_CLIENT, "cl_netpacketloss_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)"};
+cvar_t net_fakelag = {CVAR_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_send = {CVAR_CLIENT, "net_fakeloss_send","0", "drops this percentage of outgoing packets, useful for testing network protocol robustness (jerky movement, prediction errors, etc)"};
+static cvar_t net_fakeloss_receive = {CVAR_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_slist_queriespersecond = {CVAR_CLIENT, "net_slist_queriespersecond", "20", "how many server information requests to send per second"};
static cvar_t net_slist_queriesperframe = {CVAR_CLIENT, "net_slist_queriesperframe", "4", "maximum number of server information requests to send each rendered frame (guards against low framerates causing problems)"};
static cvar_t net_slist_timeout = {CVAR_CLIENT, "net_slist_timeout", "4", "how long to listen for a server information response before giving up"};
static cvar_t net_slist_pause = {CVAR_CLIENT, "net_slist_pause", "0", "when set to 1, the server list won't update until it is set back to 0"};
static cvar_t net_slist_maxtries = {CVAR_CLIENT, "net_slist_maxtries", "3", "how many times to ask the same server for information (more times gives better ping reports but takes longer)"};
-static cvar_t net_slist_favorites = {CVAR_CLIENT | CVAR_SAVE | CVAR_NQUSERINFOHACK, "net_slist_favorites", "", "contains a list of IP addresses and ports to always query explicitly"};
+static cvar_t net_slist_favorites = {CVAR_CLIENT | CVAR_SAVE, "net_slist_favorites", "", "contains a list of IP addresses and ports to always query explicitly"};
static cvar_t net_tos_dscp = {CVAR_CLIENT | CVAR_SAVE, "net_tos_dscp", "32", "DiffServ Codepoint for network sockets (may need game restart to apply)"};
static cvar_t gameversion = {CVAR_SERVER, "gameversion", "0", "version of game data (mod-specific) to be sent to querying clients"};
static cvar_t gameversion_min = {CVAR_CLIENT | CVAR_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"};
#ifdef CONFIG_MENU
/// this is only false if there are still servers left to query
-static qboolean serverlist_querysleep = true;
-static qboolean serverlist_paused = false;
+static qbool serverlist_querysleep = true;
+static qbool serverlist_paused = false;
/// this is pushed a second or two ahead of realtime whenever a master server
/// reply is received, to avoid issuing queries while master replies are still
/// flooding in (which would make a mess of the ping times)
int serverlist_cachecount = 0;
serverlist_entry_t *serverlist_cache = NULL;
-qboolean serverlist_consoleoutput;
+qbool serverlist_consoleoutput;
static int nFavorites = 0;
static lhnetaddress_t favorites[MAX_FAVORITESERVERS];
static int nFavorites_idfp = 0;
static char favorites_idfp[MAX_FAVORITESERVERS][FP64_SIZE+1];
-void NetConn_UpdateFavorites(void)
+void NetConn_UpdateFavorites_c(cvar_t *var)
{
const char *p;
nFavorites = 0;
nFavorites_idfp = 0;
- p = net_slist_favorites.string;
+ p = var->string;
while((size_t) nFavorites < sizeof(favorites) / sizeof(*favorites) && COM_ParseToken_Console(&p))
{
if(com_token[0] != '[' && strlen(com_token) == FP64_SIZE && !strchr(com_token, '.'))
}
/// \returns true if A should be inserted before B
-static qboolean _ServerList_Entry_Compare( serverlist_entry_t *A, serverlist_entry_t *B )
+static qbool _ServerList_Entry_Compare( serverlist_entry_t *A, serverlist_entry_t *B )
{
int result = 0; // > 0 if for numbers A > B and for text if A < B
return A < B;
}
-static qboolean _ServerList_CompareInt( int A, serverlist_maskop_t op, int B )
+static qbool _ServerList_CompareInt( int A, serverlist_maskop_t op, int B )
{
// This should actually be done with some intermediate and end-of-function return
switch( op ) {
}
}
-static qboolean _ServerList_CompareStr( const char *A, serverlist_maskop_t op, const char *B )
+static qbool _ServerList_CompareStr( const char *A, serverlist_maskop_t op, const char *B )
{
int i;
char bufferA[ 1400 ], bufferB[ 1400 ]; // should be more than enough
}
}
-static qboolean _ServerList_Entry_Mask( serverlist_mask_t *mask, serverlist_info_t *info )
+static qbool _ServerList_Entry_Mask( serverlist_mask_t *mask, serverlist_info_t *info )
{
if( !_ServerList_CompareInt( info->ping, mask->tests[SLIF_PING], mask->info.ping ) )
return false;
}
#endif
-void ServerList_QueryList(qboolean resetcache, qboolean querydp, qboolean queryqw, qboolean consoleoutput)
+void ServerList_QueryList(qbool resetcache, qbool querydp, qbool queryqw, qbool consoleoutput)
{
- masterquerytime = realtime;
+ masterquerytime = host.realtime;
masterquerycount = 0;
masterreplycount = 0;
if( resetcache ) {
Thread_UnlockMutex(netconn_mutex);
if (length == 0)
return 0;
- if (cl_netpacketloss_receive.integer)
+ if (net_fakeloss_receive.integer)
for (i = 0;i < cl_numsockets;i++)
- if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss_receive.integer)
+ if (cl_sockets[i] == mysocket && (rand() % 100) < net_fakeloss_receive.integer)
return 0;
if (developer_networking.integer)
{
{
int ret;
int i;
- if (cl_netpacketloss_send.integer)
+ if (net_fakeloss_send.integer)
for (i = 0;i < cl_numsockets;i++)
- if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss_send.integer)
+ 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);
return NetConn_Write(mysocket, string, (int)strlen(string), peeraddress);
}
-qboolean NetConn_CanSend(netconn_t *conn)
+qbool NetConn_CanSend(netconn_t *conn)
{
conn->outgoing_packetcounter = (conn->outgoing_packetcounter + 1) % NETGRAPH_PACKETS;
- conn->outgoing_netgraph[conn->outgoing_packetcounter].time = realtime;
+ 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 (realtime > conn->cleartime)
+ if (host.realtime > conn->cleartime)
return true;
else
{
double bursttime = burstsize / (double)rate;
// delay later packets to obey rate limit
- if (*cleartime < realtime - bursttime)
- *cleartime = realtime - bursttime;
+ 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 < realtime)
- *cleartime = realtime;
+ if (*cleartime < host.realtime)
+ *cleartime = host.realtime;
}
}
return flag;
}
-int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate, int burstsize, qboolean quakesignon_suppressreliables)
+int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate, int burstsize, qbool quakesignon_suppressreliables)
{
int totallen = 0;
unsigned char sendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
if (protocol == PROTOCOL_QUAKEWORLD)
{
int packetLen;
- qboolean sendreliable;
+ qbool sendreliable;
// note that it is ok to send empty messages to the qw server,
// otherwise it won't respond to us at all
size_t sendmelen;
// if a reliable message fragment has been lost, send it again
- if (conn->sendMessageLength && (realtime - conn->lastSendTime) > 1.0)
+ if (conn->sendMessageLength && (host.realtime - conn->lastSendTime) > 1.0)
{
if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
{
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 = realtime;
+ conn->lastSendTime = host.realtime;
conn->packetsReSent++;
}
if(sendme)
NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress);
- conn->lastSendTime = realtime;
+ conn->lastSendTime = host.realtime;
conn->packetsSent++;
conn->reliableMessagesSent++;
return 0;
}
-qboolean NetConn_HaveClientPorts(void)
+qbool NetConn_HaveClientPorts(void)
{
return !!cl_numsockets;
}
-qboolean NetConn_HaveServerPorts(void)
+qbool NetConn_HaveServerPorts(void)
{
return !!sv_numsockets;
}
else
{
LHNETADDRESS_ToString(&address, addressstring2, sizeof(addressstring2), true);
- Con_Errorf("Client failed to open a socket on address %s\n", addressstring2);
+ Con_Printf(CON_ERROR "Client failed to open a socket on address %s\n", addressstring2);
}
}
else
- Con_Errorf("Client unable to parse address %s\n", addressstring);
+ Con_Printf(CON_ERROR "Client unable to parse address %s\n", addressstring);
}
void NetConn_OpenClientPorts(void)
LHNET_CloseSocket(sv_sockets[sv_numsockets - 1]);
}
-static qboolean NetConn_OpenServerPort(const char *addressstring, lhnetaddresstype_t addresstype, int defaultport, int range)
+static qbool NetConn_OpenServerPort(const char *addressstring, lhnetaddresstype_t addresstype, int defaultport, int range)
{
lhnetaddress_t address;
lhnetsocket_t *s;
else
{
LHNETADDRESS_ToString(&address, addressstring2, sizeof(addressstring2), true);
- Con_Errorf("Server failed to open socket on address %s\n", addressstring2);
+ Con_Printf(CON_ERROR "Server failed to open socket on address %s\n", addressstring2);
}
}
else
{
- Con_Errorf("Server unable to parse address %s\n", addressstring);
+ 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;
}
port = bound(0, sv_netport.integer, 65535);
if (port == 0)
port = 26000;
- Con_Printf("Server using port %i\n", port);
if (sv_netport.integer != port)
Cvar_SetValueQuick(&sv_netport, port);
if (cls.state != ca_dedicated)
if (opennetports)
{
#ifndef NOSUPPORTIPV6
- qboolean ip4success = NetConn_OpenServerPort(net_address.string, LHNETADDRESSTYPE_INET4, port, 100);
+ 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);
conn = (netconn_t *)Mem_Alloc(netconn_mempool, sizeof(*conn));
conn->mysocket = mysocket;
conn->peeraddress = *peeraddress;
- conn->lastMessageTime = realtime;
+ 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 = realtime + net_connecttimeout.value;
+ conn->timeout = host.realtime + net_connecttimeout.value;
LHNETADDRESS_ToString(&conn->peeraddress, conn->address, sizeof(conn->address), true);
conn->next = netconn_list;
netconn_list = conn;
i = (cls.rcon_ringpos + j + 1) % MAX_RCONS;
if(cls.rcon_commands[i][0])
{
- if(realtime > cls.rcon_timeout[i])
+ if(host.realtime > cls.rcon_timeout[i])
{
char s[128];
LHNETADDRESS_ToString(&cls.rcon_addresses[i], s, sizeof(s), true);
if (protocol == PROTOCOL_QUAKEWORLD)
{
unsigned int sequence, sequence_ack;
- qboolean reliable_ack, reliable_message;
+ qbool reliable_ack, reliable_message;
int count;
//int qport;
while (count--)
{
conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
- conn->incoming_netgraph[conn->incoming_packetcounter].time = realtime;
+ 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_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
- conn->incoming_netgraph[conn->incoming_packetcounter].time = realtime;
+ 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;
// limit bursts to one packet in size ("dialup mode" emulating old behaviour)
if (net_test.integer)
{
- if (conn->cleartime < realtime)
- conn->cleartime = realtime;
+ if (conn->cleartime < host.realtime)
+ conn->cleartime = host.realtime;
}
if (reliable_ack == conn->qw.reliable_sequence)
conn->qw.incoming_reliable_acknowledged = reliable_ack;
if (reliable_message)
conn->qw.incoming_reliable_sequence ^= 1;
- conn->lastMessageTime = realtime;
- conn->timeout = realtime + newtimeout;
+ conn->lastMessageTime = host.realtime;
+ conn->timeout = host.realtime + newtimeout;
conn->unreliableMessagesReceived++;
if (conn == cls.netcon)
{
while (count--)
{
conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
- conn->incoming_netgraph[conn->incoming_packetcounter].time = realtime;
+ 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_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
- conn->incoming_netgraph[conn->incoming_packetcounter].time = realtime;
+ 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;
NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
conn->nq.unreliableReceiveSequence = sequence + 1;
- conn->lastMessageTime = realtime;
- conn->timeout = realtime + newtimeout;
+ conn->lastMessageTime = host.realtime;
+ conn->timeout = host.realtime + newtimeout;
conn->unreliableMessagesReceived++;
if (length > 0)
{
conn->nq.ackSequence++;
if (conn->nq.ackSequence != conn->nq.sendSequence)
Con_DPrint("ack sequencing error\n");
- conn->lastMessageTime = realtime;
- conn->timeout = realtime + newtimeout;
+ conn->lastMessageTime = host.realtime;
+ conn->timeout = host.realtime + newtimeout;
if (conn->sendMessageLength > MAX_PACKETFRAGMENT)
{
unsigned int packetLen;
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 = realtime;
+ conn->lastSendTime = host.realtime;
conn->packetsSent++;
}
}
NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress);
if (sequence == conn->nq.receiveSequence)
{
- conn->lastMessageTime = realtime;
- conn->timeout = realtime + newtimeout;
+ 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);
if (LHNETADDRESS_GetAddressType(peeraddress) != LHNETADDRESSTYPE_LOOP && sv.active)
{
SV_LockThreadMutex();
- Host_ShutdownServer ();
+ SV_Shutdown ();
SV_UnlockThreadMutex();
}
// allocate a net connection to keep track of things
// reset move sequence numbering on this new connection
cls.servermovesequence = 0;
if (cls.protocol == PROTOCOL_QUAKEWORLD)
- Cmd_ForwardStringToServer("new");
+ CL_ForwardToServer("new");
if (cls.protocol == PROTOCOL_QUAKE)
{
// write a keepalive (clc_nop) as it seems to greatly improve the
// store the data the engine cares about (address and ping)
strlcpy(entry->info.cname, addressstring, sizeof(entry->info.cname));
entry->info.ping = 100000;
- entry->querytime = realtime;
+ entry->querytime = host.realtime;
// if not in the slist menu we should print the server to console
if (serverlist_consoleoutput)
Con_Printf("querying %s\n", addressstring);
++serverlist_cachecount;
}
// if this is the first reply from this server, count it as having replied
- pingtime = (int)((realtime - entry->querytime) * 1000.0 + 0.5);
+ pingtime = (int)((host.realtime - entry->querytime) * 1000.0 + 0.5);
pingtime = bound(0, pingtime, 9999);
if (entry->query == SQS_REFRESHING) {
entry->info.ping = pingtime;
}
// returns true, if it's sensible to continue the processing
-static qboolean NetConn_ClientParsePacket_ServerList_PrepareQuery( int protocol, const char *ipstring, qboolean isfavorite ) {
+static qbool NetConn_ClientParsePacket_ServerList_PrepareQuery( int protocol, const char *ipstring, qbool isfavorite ) {
int n;
serverlist_entry_t *entry;
return true;
}
-static void NetConn_ClientParsePacket_ServerList_ParseDPList(lhnetaddress_t *senderaddress, const unsigned char *data, int length, qboolean isextended)
+static void NetConn_ClientParsePacket_ServerList_ParseDPList(lhnetaddress_t *senderaddress, const unsigned char *data, int length, qbool isextended)
{
masterreplycount++;
if (serverlist_consoleoutput)
// begin or resume serverlist queries
serverlist_querysleep = false;
- serverlist_querywaittime = realtime + 3;
+ serverlist_querywaittime = host.realtime + 3;
}
#endif
static int NetConn_ClientParsePacket(lhnetsocket_t *mysocket, unsigned char *data, int length, lhnetaddress_t *peeraddress)
{
- qboolean fromserver;
+ qbool fromserver;
int ret, c;
char *string, addressstring2[128];
char stringbuf[16384];
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] = realtime + rcon_secure_challengetimeout.value;
+ 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
}
// begin or resume serverlist queries
serverlist_querysleep = false;
- serverlist_querywaittime = realtime + 3;
+ serverlist_querywaittime = host.realtime + 3;
return true;
}
}
// apply a cool down time after master server replies,
// to avoid messing up the ping times on the servers
- if (serverlist_querywaittime > realtime)
+ if (serverlist_querywaittime > host.realtime)
return;
// each time querycounter reaches 1.0 issue a query
// scan serverlist and issue queries as needed
serverlist_querysleep = true;
- timeouttime = realtime - net_slist_timeout.value;
+ timeouttime = host.realtime - net_slist_timeout.value;
for( index = 0, queries = 0 ; index < serverlist_cachecount && queries < maxqueries ; index++ )
{
serverlist_entry_t *entry = &serverlist_cache[ index ];
}
// update the entry fields
- entry->querytime = realtime;
+ entry->querytime = host.realtime;
entry->querycounter++;
// if not in the slist menu we should print the server to console
lhnetaddress_t peeraddress;
unsigned char readbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
NetConn_UpdateSockets();
- if (cls.connect_trying && cls.connect_nextsendtime < realtime)
+ if (cls.connect_trying && cls.connect_nextsendtime < host.realtime)
{
#ifdef CONFIG_MENU
if (cls.connect_remainingtries == 0)
M_Update_Return_Reason("Connect: Waiting 10 seconds for reply");
#endif
- cls.connect_nextsendtime = realtime + 1;
+ cls.connect_nextsendtime = host.realtime + 1;
cls.connect_remainingtries--;
if (cls.connect_remainingtries <= -10)
{
#ifdef CONFIG_MENU
NetConn_QueryQueueFrame();
#endif
- if (cls.netcon && realtime > cls.netcon->timeout && !sv.active)
+ if (cls.netcon && host.realtime > cls.netcon->timeout && !sv.active)
{
Con_Print("Connection timed out\n");
CL_Disconnect();
SV_LockThreadMutex();
- Host_ShutdownServer ();
+ SV_Shutdown ();
SV_UnlockThreadMutex();
}
}
}
/// (div0) build the full response only if possible; better a getinfo response than no response at all if getstatus won't fit
-static qboolean NetConn_BuildStatusResponse(const char* challenge, char* out_msg, size_t out_size, qboolean fullstatus)
+static qbool NetConn_BuildStatusResponse(const char* challenge, char* out_msg, size_t out_size, qbool fullstatus)
{
prvm_prog_t *prog = SVVM_prog;
char qcstatus[256];
return false;
}
-static qboolean NetConn_PreventFlood(lhnetaddress_t *peeraddress, server_floodaddress_t *floodlist, size_t floodlength, double floodtime, qboolean renew)
+static qbool NetConn_PreventFlood(lhnetaddress_t *peeraddress, server_floodaddress_t *floodlist, size_t floodlength, double floodtime, qbool renew)
{
size_t floodslotnum, bestfloodslotnum;
double bestfloodtime;
if (floodlist[floodslotnum].lasttime && LHNETADDRESS_Compare(&noportpeeraddress, &floodlist[floodslotnum].address) == 0)
{
// this address matches an ongoing flood address
- if (realtime < floodlist[floodslotnum].lasttime + floodtime)
+ 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 = realtime;
+ floodlist[floodslotnum].lasttime = host.realtime;
}
//Con_Printf("Flood detected!\n");
return true;
}
// begin a new timeout on this address
floodlist[bestfloodslotnum].address = noportpeeraddress;
- floodlist[bestfloodslotnum].lasttime = realtime;
+ floodlist[bestfloodslotnum].lasttime = host.realtime;
//Con_Printf("Flood detection initiated!\n");
return false;
}
}
}
-typedef qboolean (*rcon_matchfunc_t) (lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen);
+typedef qbool (*rcon_matchfunc_t) (lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen);
-static qboolean hmac_mdfour_time_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)
{
char mdfourbuf[16];
long t1, t2;
if (!password[0]) {
- Con_Error("LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
+ Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
return false;
}
return !memcmp(mdfourbuf, hash, 16);
}
-static qboolean hmac_mdfour_challenge_matching(lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
+static qbool hmac_mdfour_challenge_matching(lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
{
char mdfourbuf[16];
int i;
if (!password[0]) {
- Con_Error("LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
+ Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
return false;
}
return true;
}
-static qboolean plaintext_matching(lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
+static qbool plaintext_matching(lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
{
if (!password[0]) {
- Con_Error("LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
+ Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
return false;
}
{
const char *text, *userpass_start, *userpass_end, *userpass_startpass;
static char buf[MAX_INPUTLINE];
- qboolean hasquotes;
- qboolean restricted = false;
- qboolean have_usernames = false;
+ qbool hasquotes;
+ qbool restricted = false;
+ qbool have_usernames = false;
static char vabuf[1024];
userpass_start = rcon_password.string;
return va(vabuf, sizeof(vabuf), "%srcon", restricted ? "restricted " : "");
}
-static void RCon_Execute(lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress, const char *addressstring2, const char *userlevel, const char *s, const char *endpos, qboolean proquakeprotocol)
+static void RCon_Execute(lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress, const char *addressstring2, const char *userlevel, const char *s, const char *endpos, qbool proquakeprotocol)
{
if(userlevel)
{
if(l)
{
client_t *host_client_save = host_client;
- Cmd_ExecuteString(&cmd_server, s, src_command, true);
+ Cmd_ExecuteString(&cmd_server, s, src_local, true);
host_client = host_client_save;
// in case it is a command that changes host_client (like restart)
}
double besttime;
char *string, response[2800], addressstring2[128];
static char stringbuf[16384]; // server only
- qboolean islocal = (LHNETADDRESS_GetAddressType(peeraddress) == LHNETADDRESSTYPE_LOOP);
+ 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 (length >= 12 && !memcmp(string, "getchallenge", 12) && (islocal || sv_public.integer > -3))
{
- for (i = 0, best = 0, besttime = realtime;i < MAX_CHALLENGES;i++)
+ for (i = 0, best = 0, besttime = host.realtime;i < MAX_CHALLENGES;i++)
{
if(challenges[i].time > 0)
if (!LHNETADDRESS_Compare(peeraddress, &challenges[i].address))
else
{
// flood control: drop if requesting challenge too often
- if(challenges[i].time > realtime - net_challengefloodblockingtimeout.value)
+ if(challenges[i].time > host.realtime - net_challengefloodblockingtimeout.value)
return true;
}
- challenges[i].time = realtime;
+ 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);
MSG_WriteString(&sv_message, client->name);
MSG_WriteLong(&sv_message, client->colors);
MSG_WriteLong(&sv_message, client->frags);
- MSG_WriteLong(&sv_message, (int)(realtime - client->connecttime));
+ MSG_WriteLong(&sv_message, (int)(host.realtime - client->connecttime));
if(sv_status_privacy.integer)
MSG_WriteString(&sv_message, client->netconnection ? "hidden" : "botclient");
else
for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
{
// never timeout loopback connections
- if (host_client->netconnection && realtime > host_client->netconnection->timeout && LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
+ if (host_client->netconnection && host.realtime > host_client->netconnection->timeout && LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
{
Con_Printf("Client \"%s\" connection timed out\n", host_client->name);
SV_DropClient(false);
}
#ifdef CONFIG_MENU
-void NetConn_QueryMasters(qboolean querydp, qboolean queryqw)
+void NetConn_QueryMasters(qbool querydp, qbool queryqw)
{
int i, j;
int masternum;
}
if (!masterquerycount)
{
- Con_Error("Unable to query master servers, no suitable network sockets active.\n");
+ Con_Print(CON_ERROR "Unable to query master servers, no suitable network sockets active.\n");
M_Update_Return_Reason("No network");
}
}
// if it's a state change (client connected), limit next heartbeat to no
// more than 30 sec in the future
- if (priority == 1 && nextheartbeattime > realtime + 30.0)
- nextheartbeattime = realtime + 30.0;
+ 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,
// 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 || realtime > nextheartbeattime))
+ if (sv.active && sv_public.integer > 0 && svs.maxclients >= 2 && (priority > 1 || host.realtime > nextheartbeattime))
{
- nextheartbeattime = realtime + sv_heartbeatperiod.value;
+ nextheartbeattime = host.realtime + sv_heartbeatperiod.value;
for (masternum = 0;sv_masters[masternum].name;masternum++)
if (sv_masters[masternum].string && 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);
int i;
lhnetaddress_t tempaddress;
netconn_mempool = Mem_AllocPool("network connections", 0, NULL);
- Cmd_AddCommand(&cmd_client, "net_stats", Net_Stats_f, "print network statistics");
- Cmd_AddCommand(&cmd_server, "net_stats", Net_Stats_f, "print network statistics");
+ Cmd_AddCommand(CMD_SHARED, "net_stats", Net_Stats_f, "print network statistics");
#ifdef CONFIG_MENU
- Cmd_AddCommand(&cmd_client, "net_slist", Net_Slist_f, "query dp master servers and print all server information");
- Cmd_AddCommand(&cmd_client, "net_slistqw", Net_SlistQW_f, "query qw master servers and print all server information");
- Cmd_AddCommand(&cmd_client, "net_refresh", Net_Refresh_f, "query dp master servers and refresh all server information");
+ Cmd_AddCommand(CMD_CLIENT, "net_slist", Net_Slist_f, "query dp master servers and print all server information");
+ Cmd_AddCommand(CMD_CLIENT, "net_slistqw", Net_SlistQW_f, "query qw master servers and print all server information");
+ Cmd_AddCommand(CMD_CLIENT, "net_refresh", Net_Refresh_f, "query dp master servers and refresh all server information");
#endif
- Cmd_AddCommand(&cmd_server, "heartbeat", Net_Heartbeat_f, "send a heartbeat to the master server (updates your server information)");
+ Cmd_AddCommand(CMD_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(&net_slist_timeout);
Cvar_RegisterVariable(&net_slist_maxtries);
Cvar_RegisterVariable(&net_slist_favorites);
+#ifdef CONFIG_MENU
+ Cvar_RegisterCallback(&net_slist_favorites, NetConn_UpdateFavorites_c);
+#endif
Cvar_RegisterVariable(&net_slist_pause);
if(LHNET_DefaultDSCP(-1) >= 0) // register cvar only if supported
Cvar_RegisterVariable(&net_tos_dscp);
Cvar_RegisterVariable(&net_challengefloodblockingtimeout);
Cvar_RegisterVariable(&net_getstatusfloodblockingtimeout);
Cvar_RegisterVariable(&net_sourceaddresscheck);
- Cvar_RegisterVariable(&cl_netlocalping);
- Cvar_RegisterVariable(&cl_netpacketloss_send);
- Cvar_RegisterVariable(&cl_netpacketloss_receive);
+ Cvar_RegisterVariable(&net_fakelag);
+ Cvar_RegisterVariable(&net_fakeloss_send);
+ Cvar_RegisterVariable(&net_fakeloss_receive);
+ Cvar_RegisterAlias(&net_fakelag, "cl_netlocalping");
+ Cvar_RegisterAlias(&net_fakeloss_send, "cl_netpacketloss_send");
+ Cvar_RegisterAlias(&net_fakeloss_receive, "cl_netpacketloss_receive");
Cvar_RegisterVariable(&hostname);
Cvar_RegisterVariable(&developer_networking);
Cvar_RegisterVariable(&cl_netport);
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 = COM_CheckParm("-ip")) && i + 1 < com_argc)
+ if ((i = Sys_CheckParm("-ip")) && i + 1 < sys.argc)
{
- if (LHNETADDRESS_FromString(&tempaddress, com_argv[i + 1], 0) == 1)
+ if (LHNETADDRESS_FromString(&tempaddress, sys.argv[i + 1], 0) == 1)
{
- Con_Printf("-ip option used, setting net_address to \"%s\"\n", com_argv[i + 1]);
- Cvar_SetQuick(&net_address, com_argv[i + 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_Errorf("-ip option used, but unable to parse the address \"%s\"\n", com_argv[i + 1]);
+ 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 = COM_CheckParm("-port")) || (i = COM_CheckParm("-ipport")) || (i = COM_CheckParm("-udpport"))) && i + 1 < com_argc)
+ if (((i = Sys_CheckParm("-port")) || (i = Sys_CheckParm("-ipport")) || (i = Sys_CheckParm("-udpport"))) && i + 1 < sys.argc)
{
- i = atoi(com_argv[i + 1]);
+ 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_Errorf("-port option used, but %i is not a valid port number\n", i);
+ Con_Printf(CON_ERROR "-port option used, but %i is not a valid port number\n", i);
}
cl_numsockets = 0;
sv_numsockets = 0;
projects / xonotic / darkplaces.git / blobdiff