netconn.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3 Copyright (C) 2002 Mathieu Olivier
   4 Copyright (C) 2003 Ashley Rose Hale (LadyHavoc)
   5
   6 This program is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU General Public License
   8 as published by the Free Software Foundation; either version 2
   9 of the License, or (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14
  15 See the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 */
  22
  23 #include "quakedef.h"
  24 #include "thread.h"
  25 #include "lhnet.h"
  26
  27 // for secure rcon authentication
  28 #include "hmac.h"
  29 #include "mdfour.h"
  30 #include <time.h>
  31
  32 #define QWMASTER_PORT 27000
  33 #define DPMASTER_PORT 27950
  34
  35 // note this defaults on for dedicated servers, off for listen servers
  36 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"};
  37 cvar_t sv_public_rejectreason = {CF_SERVER, "sv_public_rejectreason", "The server is closing.", "Rejection reason for connects when sv_public is -2"};
  38 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)"};
  39 extern cvar_t sv_status_privacy;
  40
  41 static cvar_t sv_masters [] =
  42 {
  43         {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master1", "", "user-chosen master server 1"},
  44         {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master2", "", "user-chosen master server 2"},
  45         {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master3", "", "user-chosen master server 3"},
  46         {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sv_master4", "", "user-chosen master server 4"},
  47         {CF_CLIENT | CF_SERVER, "sv_masterextra1", "dpmaster.deathmask.net", "dpmaster.deathmask.net - default master server 1 (admin: Willis)"},
  48         {CF_CLIENT | CF_SERVER, "sv_masterextra2", "dpmaster.tchr.no", "dpmaster.tchr.no - default master server 2 (admin: tChr)"},
  49         {CF_CLIENT | CF_SERVER, "sv_masterextra3", "dpm.dpmaster.org:27777", "dpm.dpmaster.org - default master server 3 (admin: gazby/soylent_cow)"},
  50 };
  51
  52 #ifdef CONFIG_MENU
  53 static cvar_t sv_qwmasters [] =
  54 {
  55         {CF_CLIENT | CF_ARCHIVE, "sv_qwmaster1", "", "user-chosen qwmaster server 1"},
  56         {CF_CLIENT | CF_ARCHIVE, "sv_qwmaster2", "", "user-chosen qwmaster server 2"},
  57         {CF_CLIENT | CF_ARCHIVE, "sv_qwmaster3", "", "user-chosen qwmaster server 3"},
  58         {CF_CLIENT | CF_ARCHIVE, "sv_qwmaster4", "", "user-chosen qwmaster server 4"},
  59         {CF_CLIENT, "sv_qwmasterextra1", "master.quakeservers.net:27000", "Global master server. (admin: unknown)"},
  60         {CF_CLIENT, "sv_qwmasterextra2", "asgaard.morphos-team.net:27000", "Global master server. (admin: unknown)"},
  61         {CF_CLIENT, "sv_qwmasterextra3", "qwmaster.ocrana.de:27000", "German master server. (admin: unknown)"},
  62         {CF_CLIENT, "sv_qwmasterextra4", "qwmaster.fodquake.net:27000", "Global master server. (admin: unknown)"},
  63 };
  64 #endif
  65
  66 static double nextheartbeattime = 0;
  67
  68 sizebuf_t cl_message;
  69 sizebuf_t sv_message;
  70 static unsigned char cl_message_buf[NET_MAXMESSAGE];
  71 static unsigned char sv_message_buf[NET_MAXMESSAGE];
  72 char cl_readstring[MAX_INPUTLINE];
  73 char sv_readstring[MAX_INPUTLINE];
  74
  75 cvar_t net_test = {CF_CLIENT | CF_SERVER, "net_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
  76 cvar_t net_usesizelimit = {CF_SERVER, "net_usesizelimit", "2", "use packet size limiting (0: never, 1: in non-CSQC mode, 2: always)"};
  77 cvar_t net_burstreserve = {CF_SERVER, "net_burstreserve", "0.3", "how much of the burst time to reserve for packet size spikes"};
  78 cvar_t net_messagetimeout = {CF_CLIENT | CF_SERVER, "net_messagetimeout","300", "drops players who have not sent any packets for this many seconds"};
  79 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."};
  80 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."};
  81 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."};
  82 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."};
  83 cvar_t net_sourceaddresscheck = {CF_CLIENT, "net_sourceaddresscheck", "1", "compare the source IP address for replies (more secure, may break some bad multihoming setups"};
  84 cvar_t hostname = {CF_SERVER | CF_ARCHIVE, "hostname", "UNNAMED", "server message to show in server browser"};
  85 cvar_t developer_networking = {CF_CLIENT | CF_SERVER, "developer_networking", "0", "prints all received and sent packets (recommended only for debugging)"};
  86
  87 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)"};
  88 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)"};
  89 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)"};
  90
  91 #ifdef CONFIG_MENU
  92 static cvar_t net_slist_debug = {CF_CLIENT, "net_slist_debug", "0", "enables verbose messages for master server queries"};
  93 static cvar_t net_slist_favorites = {CF_CLIENT | CF_ARCHIVE, "net_slist_favorites", "", "contains a list of IP addresses and ports to always query explicitly"};
  94 static cvar_t net_slist_interval = {CF_CLIENT, "net_slist_interval", "1", "minimum number of seconds to wait between getstatus queries to the same DP server, must be >= server's net_getstatusfloodblockingtimeout"};
  95 static cvar_t net_slist_maxping = {CF_CLIENT | CF_ARCHIVE, "net_slist_maxping", "420", "server query responses are ignored if their ping in milliseconds is higher than this"};
  96 static cvar_t net_slist_maxtries = {CF_CLIENT, "net_slist_maxtries", "3", "how many times to ask the same server for information (more times gives better ping reports but takes longer)"};
  97 static cvar_t net_slist_pause = {CF_CLIENT, "net_slist_pause", "0", "when set to 1, the server list sorting in the menu won't update until it is set back to 0"};
  98 static cvar_t net_slist_queriespersecond = {CF_CLIENT, "net_slist_queriespersecond", "128", "how many server information requests to send per second"};
  99 static cvar_t net_slist_queriesperframe = {CF_CLIENT, "net_slist_queriesperframe", "2", "maximum number of server information requests to send each rendered frame (guards against low framerates causing problems)"};
 100 static cvar_t net_slist_timeout = {CF_CLIENT, "net_slist_timeout", "4", "minimum number of seconds to wait between status queries to the same QW server, determines which response belongs to which query so low values will cause impossible pings; also a warning is printed if a dpmaster query fails to complete within this time"};
 101 #endif
 102
 103 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)"};
 104 static cvar_t gameversion = {CF_SERVER, "gameversion", "0", "version of game data (mod-specific) to be sent to querying clients"};
 105 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"};
 106 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"};
 107 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"};
 108 static cvar_t rcon_restricted_commands = {CF_SERVER, "rcon_restricted_commands", "", "allowed commands for rcon when the restricted mode password was used"};
 109 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)"};
 110 extern cvar_t rcon_secure;
 111 extern cvar_t rcon_secure_challengetimeout;
 112
 113 double masterquerytime = -1000;
 114 unsigned masterquerycount = 0;
 115 unsigned masterreplycount = 0;
 116 unsigned serverquerycount = 0;
 117 unsigned serverreplycount = 0;
 118
 119 challenge_t challenges[MAX_CHALLENGES];
 120
 121 #define DPMASTER_COUNT sizeof(sv_masters) / sizeof(cvar_t)
 122 #define QWMASTER_COUNT sizeof(sv_qwmasters) / sizeof(cvar_t)
 123
 124 /// bitfield because in theory we could be doing QW & DP simultaneously
 125 uint8_t serverlist_querystage = 0;
 126
 127 #ifdef CONFIG_MENU
 128 #define SLIST_QUERYSTAGE_DPMASTERS 1
 129 #define SLIST_QUERYSTAGE_QWMASTERS 2
 130 #define SLIST_QUERYSTAGE_SERVERS 4
 131
 132 static uint8_t dpmasterstatus[DPMASTER_COUNT] = {0};
 133 static uint8_t qwmasterstatus[QWMASTER_COUNT] = {0};
 134 #define MASTER_TX_QUERY 1    // we sent the query
 135 #define MASTER_RX_RESPONSE 2 // we got at least 1 packet of the response
 136 #define MASTER_RX_COMPLETE 3 // we saw the EOT marker (assumes dpmaster >= 2.0, see dpmaster/doc/techinfo.txt)
 137
 138 /// the hash password for timestamp verification
 139 char serverlist_dpserverquerykey[12]; // challenge_t uses [12]
 140 #endif
 141
 142 static unsigned cl_numsockets;
 143 static lhnetsocket_t *cl_sockets[16];
 144 static unsigned sv_numsockets;
 145 static lhnetsocket_t *sv_sockets[16];
 146
 147 netconn_t *netconn_list = NULL;
 148 mempool_t *netconn_mempool = NULL;
 149 void *netconn_mutex = NULL;
 150
 151 cvar_t cl_netport = {CF_CLIENT, "cl_port", "0", "forces client to use chosen port number if not 0"};
 152 cvar_t sv_netport = {CF_SERVER, "port", "26000", "server port for players to connect to"};
 153 cvar_t net_address = {CF_CLIENT | CF_SERVER, "net_address", "", "network address to open ipv4 ports on (if empty, use default interfaces)"};
 154 cvar_t net_address_ipv6 = {CF_CLIENT | CF_SERVER, "net_address_ipv6", "", "network address to open ipv6 ports on (if empty, use default interfaces)"};
 155
 156 char cl_net_extresponse[NET_EXTRESPONSE_MAX][1400];
 157 unsigned cl_net_extresponse_count = 0;
 158 unsigned cl_net_extresponse_last = 0;
 159
 160 char sv_net_extresponse[NET_EXTRESPONSE_MAX][1400];
 161 unsigned sv_net_extresponse_count = 0;
 162 unsigned sv_net_extresponse_last = 0;
 163
 164 #ifdef CONFIG_MENU
 165 // ServerList interface
 166 serverlist_mask_t serverlist_andmasks[SERVERLIST_ANDMASKCOUNT];
 167 serverlist_mask_t serverlist_ormasks[SERVERLIST_ORMASKCOUNT];
 168
 169 serverlist_infofield_t serverlist_sortbyfield;
 170 unsigned serverlist_sortflags;
 171
 172 unsigned serverlist_viewcount = 0;
 173 uint16_t serverlist_viewlist[SERVERLIST_VIEWLISTSIZE];
 174
 175 unsigned serverlist_maxcachecount = 0;
 176 unsigned serverlist_cachecount = 0;
 177 serverlist_entry_t *serverlist_cache = NULL;
 178
 179 static qbool serverlist_consoleoutput;
 180
 181 static unsigned nFavorites = 0;
 182 static lhnetaddress_t favorites[MAX_FAVORITESERVERS];
 183 static unsigned nFavorites_idfp = 0;
 184 static char favorites_idfp[MAX_FAVORITESERVERS][FP64_SIZE+1];
 185
 186 void NetConn_UpdateFavorites_c(cvar_t *var)
 187 {
 188         const char *p;
 189         nFavorites = 0;
 190         nFavorites_idfp = 0;
 191         p = var->string;
 192         while((size_t) nFavorites < sizeof(favorites) / sizeof(*favorites) && COM_ParseToken_Console(&p))
 193         {
 194                 if(com_token[0] != '[' && strlen(com_token) == FP64_SIZE && !strchr(com_token, '.'))
 195                 // currently 44 bytes, longest possible IPv6 address: 39 bytes, so this works
 196                 // (if v6 address contains port, it must start with '[')
 197                 {
 198                         dp_strlcpy(favorites_idfp[nFavorites_idfp], com_token, sizeof(favorites_idfp[nFavorites_idfp]));
 199                         ++nFavorites_idfp;
 200                 }
 201                 else
 202                 {
 203                         if(LHNETADDRESS_FromString(&favorites[nFavorites], com_token, 26000))
 204                                 ++nFavorites;
 205                 }
 206         }
 207 }
 208
 209 /// helper function to insert a value into the viewset
 210 /// spare entries will be removed
 211 static void _ServerList_ViewList_Helper_InsertBefore(unsigned index, serverlist_entry_t *entry)
 212 {
 213         unsigned i;
 214
 215         if( serverlist_viewcount < SERVERLIST_VIEWLISTSIZE ) {
 216                 i = serverlist_viewcount++;
 217         } else {
 218                 i = SERVERLIST_VIEWLISTSIZE - 1;
 219         }
 220
 221         for( ; i > index ; i-- )
 222                 serverlist_viewlist[ i ] = serverlist_viewlist[ i - 1 ];
 223
 224         serverlist_viewlist[index] = (int)(entry - serverlist_cache);
 225 }
 226
 227 /// we suppose serverlist_viewcount to be valid, ie > 0
 228 static inline void _ServerList_ViewList_Helper_Remove(unsigned index)
 229 {
 230         serverlist_viewcount--;
 231         for( ; index < serverlist_viewcount ; index++ )
 232                 serverlist_viewlist[index] = serverlist_viewlist[index + 1];
 233 }
 234
 235 /// \returns true if A should be inserted before B
 236 static qbool _ServerList_Entry_Compare( serverlist_entry_t *A, serverlist_entry_t *B )
 237 {
 238         int result = 0; // > 0 if for numbers A > B and for text if A < B
 239
 240         if( serverlist_sortflags & SLSF_CATEGORIES )
 241         {
 242                 result = A->info.category - B->info.category;
 243                 if (result != 0)
 244                         return result < 0;
 245         }
 246
 247         if( serverlist_sortflags & SLSF_FAVORITES )
 248         {
 249                 if(A->info.isfavorite != B->info.isfavorite)
 250                         return A->info.isfavorite;
 251         }
 252
 253         switch( serverlist_sortbyfield ) {
 254                 case SLIF_PING:
 255                         result = A->info.ping - B->info.ping;
 256                         break;
 257                 case SLIF_MAXPLAYERS:
 258                         result = A->info.maxplayers - B->info.maxplayers;
 259                         break;
 260                 case SLIF_NUMPLAYERS:
 261                         result = A->info.numplayers - B->info.numplayers;
 262                         break;
 263                 case SLIF_NUMBOTS:
 264                         result = A->info.numbots - B->info.numbots;
 265                         break;
 266                 case SLIF_NUMHUMANS:
 267                         result = A->info.numhumans - B->info.numhumans;
 268                         break;
 269                 case SLIF_FREESLOTS:
 270                         result = A->info.freeslots - B->info.freeslots;
 271                         break;
 272                 case SLIF_PROTOCOL:
 273                         result = A->info.protocol - B->info.protocol;
 274                         break;
 275                 case SLIF_CNAME:
 276                         result = strcmp( B->info.cname, A->info.cname );
 277                         break;
 278                 case SLIF_GAME:
 279                         result = strcasecmp( B->info.game, A->info.game );
 280                         break;
 281                 case SLIF_MAP:
 282                         result = strcasecmp( B->info.map, A->info.map );
 283                         break;
 284                 case SLIF_MOD:
 285                         result = strcasecmp( B->info.mod, A->info.mod );
 286                         break;
 287                 case SLIF_NAME:
 288                         result = strcasecmp( B->info.name, A->info.name );
 289                         break;
 290                 case SLIF_QCSTATUS:
 291                         result = strcasecmp( B->info.qcstatus, A->info.qcstatus ); // not really THAT useful, though
 292                         break;
 293                 case SLIF_CATEGORY:
 294                         result = A->info.category - B->info.category;
 295                         break;
 296                 case SLIF_ISFAVORITE:
 297                         result = !!B->info.isfavorite - !!A->info.isfavorite;
 298                         break;
 299                 default:
 300                         Con_DPrint( "_ServerList_Entry_Compare: Bad serverlist_sortbyfield!\n" );
 301                         break;
 302         }
 303
 304         if (result != 0)
 305         {
 306                 if( serverlist_sortflags & SLSF_DESCENDING )
 307                         return result > 0;
 308                 else
 309                         return result < 0;
 310         }
 311
 312         // if the chosen sort key is identical, sort by index
 313         // (makes this a stable sort, so that later replies from servers won't
 314         //  shuffle the servers around when they have the same ping)
 315         return A < B;
 316 }
 317
 318 static qbool _ServerList_CompareInt( int A, serverlist_maskop_t op, int B )
 319 {
 320         // This should actually be done with some intermediate and end-of-function return
 321         switch( op ) {
 322                 case SLMO_LESS:
 323                         return A < B;
 324                 case SLMO_LESSEQUAL:
 325                         return A <= B;
 326                 case SLMO_EQUAL:
 327                         return A == B;
 328                 case SLMO_GREATER:
 329                         return A > B;
 330                 case SLMO_NOTEQUAL:
 331                         return A != B;
 332                 case SLMO_GREATEREQUAL:
 333                 case SLMO_CONTAINS:
 334                 case SLMO_NOTCONTAIN:
 335                 case SLMO_STARTSWITH:
 336                 case SLMO_NOTSTARTSWITH:
 337                         return A >= B;
 338                 default:
 339                         Con_DPrint( "_ServerList_CompareInt: Bad op!\n" );
 340                         return false;
 341         }
 342 }
 343
 344 static qbool _ServerList_CompareStr( const char *A, serverlist_maskop_t op, const char *B )
 345 {
 346         int i;
 347         char bufferA[ 1400 ], bufferB[ 1400 ]; // should be more than enough
 348         COM_StringDecolorize(A, 0, bufferA, sizeof(bufferA), false);
 349         for (i = 0;i < (int)sizeof(bufferA)-1 && bufferA[i];i++)
 350                 bufferA[i] = (bufferA[i] >= 'A' && bufferA[i] <= 'Z') ? (bufferA[i] + 'a' - 'A') : bufferA[i];
 351         bufferA[i] = 0;
 352         for (i = 0;i < (int)sizeof(bufferB)-1 && B[i];i++)
 353                 bufferB[i] = (B[i] >= 'A' && B[i] <= 'Z') ? (B[i] + 'a' - 'A') : B[i];
 354         bufferB[i] = 0;
 355
 356         // Same here, also using an intermediate & final return would be more appropriate
 357         // A info B mask
 358         switch( op ) {
 359                 case SLMO_CONTAINS:
 360                         return *bufferB && !!strstr( bufferA, bufferB ); // we want a real bool
 361                 case SLMO_NOTCONTAIN:
 362                         return !*bufferB || !strstr( bufferA, bufferB );
 363                 case SLMO_STARTSWITH:
 364                         //Con_Printf("startsWith: %s %s\n", bufferA, bufferB);
 365                         return *bufferB && !memcmp(bufferA, bufferB, strlen(bufferB));
 366                 case SLMO_NOTSTARTSWITH:
 367                         return !*bufferB || memcmp(bufferA, bufferB, strlen(bufferB));
 368                 case SLMO_LESS:
 369                         return strcmp( bufferA, bufferB ) < 0;
 370                 case SLMO_LESSEQUAL:
 371                         return strcmp( bufferA, bufferB ) <= 0;
 372                 case SLMO_EQUAL:
 373                         return strcmp( bufferA, bufferB ) == 0;
 374                 case SLMO_GREATER:
 375                         return strcmp( bufferA, bufferB ) > 0;
 376                 case SLMO_NOTEQUAL:
 377                         return strcmp( bufferA, bufferB ) != 0;
 378                 case SLMO_GREATEREQUAL:
 379                         return strcmp( bufferA, bufferB ) >= 0;
 380                 default:
 381                         Con_DPrint( "_ServerList_CompareStr: Bad op!\n" );
 382                         return false;
 383         }
 384 }
 385
 386 static qbool _ServerList_Entry_Mask( serverlist_mask_t *mask, serverlist_info_t *info )
 387 {
 388         if( !_ServerList_CompareInt( info->ping, mask->tests[SLIF_PING], mask->info.ping ) )
 389                 return false;
 390         if( !_ServerList_CompareInt( info->maxplayers, mask->tests[SLIF_MAXPLAYERS], mask->info.maxplayers ) )
 391                 return false;
 392         if( !_ServerList_CompareInt( info->numplayers, mask->tests[SLIF_NUMPLAYERS], mask->info.numplayers ) )
 393                 return false;
 394         if( !_ServerList_CompareInt( info->numbots, mask->tests[SLIF_NUMBOTS], mask->info.numbots ) )
 395                 return false;
 396         if( !_ServerList_CompareInt( info->numhumans, mask->tests[SLIF_NUMHUMANS], mask->info.numhumans ) )
 397                 return false;
 398         if( !_ServerList_CompareInt( info->freeslots, mask->tests[SLIF_FREESLOTS], mask->info.freeslots ) )
 399                 return false;
 400         if( !_ServerList_CompareInt( info->protocol, mask->tests[SLIF_PROTOCOL], mask->info.protocol ))
 401                 return false;
 402         if( *mask->info.cname
 403                 && !_ServerList_CompareStr( info->cname, mask->tests[SLIF_CNAME], mask->info.cname ) )
 404                 return false;
 405         if( *mask->info.game
 406                 && !_ServerList_CompareStr( info->game, mask->tests[SLIF_GAME], mask->info.game ) )
 407                 return false;
 408         if( *mask->info.mod
 409                 && !_ServerList_CompareStr( info->mod, mask->tests[SLIF_MOD], mask->info.mod ) )
 410                 return false;
 411         if( *mask->info.map
 412                 && !_ServerList_CompareStr( info->map, mask->tests[SLIF_MAP], mask->info.map ) )
 413                 return false;
 414         if( *mask->info.name
 415                 && !_ServerList_CompareStr( info->name, mask->tests[SLIF_NAME], mask->info.name ) )
 416                 return false;
 417         if( *mask->info.qcstatus
 418                 && !_ServerList_CompareStr( info->qcstatus, mask->tests[SLIF_QCSTATUS], mask->info.qcstatus ) )
 419                 return false;
 420         if( *mask->info.players
 421                 && !_ServerList_CompareStr( info->players, mask->tests[SLIF_PLAYERS], mask->info.players ) )
 422                 return false;
 423         if( !_ServerList_CompareInt( info->category, mask->tests[SLIF_CATEGORY], mask->info.category ) )
 424                 return false;
 425         if( !_ServerList_CompareInt( info->isfavorite, mask->tests[SLIF_ISFAVORITE], mask->info.isfavorite ))
 426                 return false;
 427         return true;
 428 }
 429
 430 static void ServerList_ViewList_Insert( serverlist_entry_t *entry )
 431 {
 432         unsigned start, end, mid, i;
 433         lhnetaddress_t addr;
 434
 435         // reject incompatible servers
 436         if(
 437                 entry->info.gameversion != gameversion.integer
 438                 &&
 439                 !(
 440                            gameversion_min.integer >= 0 // min/max range set by user/mod?
 441                         && gameversion_max.integer >= 0
 442                         && gameversion_min.integer <= entry->info.gameversion // version of server in min/max range?
 443                         && gameversion_max.integer >= entry->info.gameversion
 444                  )
 445         )
 446                 return;
 447
 448         // also display entries that are currently being refreshed [11/8/2007 Black]
 449         // bones_was_here: if their previous ping was acceptable (unset if timeout occurs)
 450         if (!entry->info.ping)
 451                 return;
 452
 453         // refresh the "favorite" status
 454         entry->info.isfavorite = false;
 455         if(LHNETADDRESS_FromString(&addr, entry->info.cname, 26000))
 456         {
 457                 char idfp[FP64_SIZE+1];
 458                 for(i = 0; i < nFavorites; ++i)
 459                 {
 460                         if(LHNETADDRESS_Compare(&addr, &favorites[i]) == 0)
 461                         {
 462                                 entry->info.isfavorite = true;
 463                                 break;
 464                         }
 465                 }
 466                 if(Crypto_RetrieveHostKey(&addr, 0, NULL, 0, idfp, sizeof(idfp), NULL, NULL))
 467                 {
 468                         for(i = 0; i < nFavorites_idfp; ++i)
 469                         {
 470                                 if(!strcmp(idfp, favorites_idfp[i]))
 471                                 {
 472                                         entry->info.isfavorite = true;
 473                                         break;
 474                                 }
 475                         }
 476                 }
 477         }
 478
 479         // refresh the "category"
 480         entry->info.category = MR_GetServerListEntryCategory(entry);
 481
 482         // FIXME: change this to be more readable (...)
 483         // now check whether it passes through the masks
 484         for( start = 0 ; start < SERVERLIST_ANDMASKCOUNT && serverlist_andmasks[start].active; start++ )
 485                 if( !_ServerList_Entry_Mask( &serverlist_andmasks[start], &entry->info ) )
 486                         return;
 487
 488         for( start = 0 ; start < SERVERLIST_ORMASKCOUNT && serverlist_ormasks[start].active ; start++ )
 489                 if( _ServerList_Entry_Mask( &serverlist_ormasks[start], &entry->info ) )
 490                         break;
 491         if( start == SERVERLIST_ORMASKCOUNT || (start > 0 && !serverlist_ormasks[start].active) )
 492                 return;
 493
 494         if( !serverlist_viewcount ) {
 495                 _ServerList_ViewList_Helper_InsertBefore( 0, entry );
 496                 return;
 497         }
 498         // ok, insert it, we just need to find out where exactly:
 499
 500         // two special cases
 501         // check whether to insert it as new first item
 502         if( _ServerList_Entry_Compare( entry, ServerList_GetViewEntry(0) ) ) {
 503                 _ServerList_ViewList_Helper_InsertBefore( 0, entry );
 504                 return;
 505         } // check whether to insert it as new last item
 506         else if( !_ServerList_Entry_Compare( entry, ServerList_GetViewEntry(serverlist_viewcount - 1) ) ) {
 507                 _ServerList_ViewList_Helper_InsertBefore( serverlist_viewcount, entry );
 508                 return;
 509         }
 510         start = 0;
 511         end = serverlist_viewcount - 1;
 512         while( end > start + 1 )
 513         {
 514                 mid = (start + end) / 2;
 515                 // test the item that lies in the middle between start and end
 516                 if( _ServerList_Entry_Compare( entry, ServerList_GetViewEntry(mid) ) )
 517                         // the item has to be in the upper half
 518                         end = mid;
 519                 else
 520                         // the item has to be in the lower half
 521                         start = mid;
 522         }
 523         _ServerList_ViewList_Helper_InsertBefore( start + 1, entry );
 524 }
 525
 526 static void ServerList_ViewList_Remove( serverlist_entry_t *entry )
 527 {
 528         unsigned i;
 529
 530         for( i = 0; i < serverlist_viewcount; i++ )
 531         {
 532                 if (ServerList_GetViewEntry(i) == entry)
 533                 {
 534                         _ServerList_ViewList_Helper_Remove(i);
 535                         break;
 536                 }
 537         }
 538 }
 539
 540 void ServerList_RebuildViewList(cvar_t *var)
 541 {
 542         unsigned i;
 543
 544         if (net_slist_pause.integer)
 545                 return;
 546
 547         serverlist_viewcount = 0;
 548         for (i = 0; i < serverlist_cachecount; ++i)
 549                 ServerList_ViewList_Insert(&serverlist_cache[i]);
 550 }
 551
 552 void ServerList_ResetMasks(void)
 553 {
 554         int i;
 555
 556         memset( &serverlist_andmasks, 0, sizeof( serverlist_andmasks ) );
 557         memset( &serverlist_ormasks, 0, sizeof( serverlist_ormasks ) );
 558         // numbots needs to be compared to -1 to always succeed
 559         for(i = 0; i < SERVERLIST_ANDMASKCOUNT; ++i)
 560                 serverlist_andmasks[i].info.numbots = -1;
 561         for(i = 0; i < SERVERLIST_ORMASKCOUNT; ++i)
 562                 serverlist_ormasks[i].info.numbots = -1;
 563 }
 564
 565 void ServerList_GetPlayerStatistics(unsigned *numplayerspointer, unsigned *maxplayerspointer)
 566 {
 567         unsigned i;
 568         unsigned numplayers = 0, maxplayers = 0;
 569
 570         for (i = 0;i < serverlist_cachecount;i++)
 571         {
 572                 if (serverlist_cache[i].info.ping)
 573                 {
 574                         numplayers += serverlist_cache[i].info.numhumans;
 575                         maxplayers += serverlist_cache[i].info.maxplayers;
 576                 }
 577         }
 578         *numplayerspointer = numplayers;
 579         *maxplayerspointer = maxplayers;
 580 }
 581
 582 #if 0
 583 static void _ServerList_Test(void)
 584 {
 585         int i;
 586         if (serverlist_maxcachecount <= 1024)
 587         {
 588                 serverlist_maxcachecount = 1024;
 589                 serverlist_cache = (serverlist_entry_t *)Mem_Realloc(netconn_mempool, (void *)serverlist_cache, sizeof(serverlist_entry_t) * serverlist_maxcachecount);
 590         }
 591         for( i = 0 ; i < 1024 ; i++ ) {
 592                 memset( &serverlist_cache[serverlist_cachecount], 0, sizeof( serverlist_entry_t ) );
 593                 serverlist_cache[serverlist_cachecount].info.ping = 1000 + 1024 - i;
 594                 dpsnprintf( serverlist_cache[serverlist_cachecount].info.name, sizeof(serverlist_cache[serverlist_cachecount].info.name), "Black's ServerList Test %i", i );
 595                 serverlist_cache[serverlist_cachecount].finished = true;
 596                 dpsnprintf( serverlist_cache[serverlist_cachecount].line1, sizeof(serverlist_cache[serverlist_cachecount].info.line1), "%i %s", serverlist_cache[serverlist_cachecount].info.ping, serverlist_cache[serverlist_cachecount].info.name );
 597                 ServerList_ViewList_Insert( &serverlist_cache[serverlist_cachecount] );
 598                 serverlist_cachecount++;
 599         }
 600 }
 601 #endif
 602
 603 /*
 604 ====================
 605 ServerList_BuildDPServerQuery
 606
 607 Generates the string for pinging DP servers with a hash-verified timestamp
 608 to provide reliable pings while preventing ping cheating,
 609 and discard spurious getstatus/getinfo packets.
 610
 611 14 bytes of header including the mandatory space,
 612 22 bytes of base64-encoded hash,
 613 up to 16 bytes of unsigned hexadecimal milliseconds (typically 4-5 bytes sent),
 614 null terminator.
 615
 616 The maximum challenge length (after the space) for existing DP7 servers is 49.
 617 ====================
 618 */
 619 static inline void ServerList_BuildDPServerQuery(char *buffer, size_t buffersize, double querytime)
 620 {
 621         unsigned char hash[24]; // 4*(16/3) rounded up to 4 byte multiple
 622         uint64_t timestamp = querytime * 1000.0; // no rounding up as that could make small pings go <= 0
 623
 624         HMAC_MDFOUR_16BYTES(hash,
 625                 (unsigned char *)&timestamp, sizeof(timestamp),
 626                 (unsigned char *)serverlist_dpserverquerykey, sizeof(serverlist_dpserverquerykey));
 627         base64_encode(hash, 16, sizeof(hash));
 628         dpsnprintf(buffer, buffersize, "\377\377\377\377getstatus %.22s%" PRIx64, hash, timestamp);
 629 }
 630
 631 static void NetConn_BuildChallengeString(char *buffer, int bufferlength);
 632 void ServerList_QueryList(qbool resetcache, qbool querydp, qbool queryqw, qbool consoleoutput)
 633 {
 634         unsigned i;
 635         lhnetaddress_t broadcastaddress;
 636         char dpquery[53]; // theoretical max: 14+22+16+1
 637
 638         if (net_slist_debug.integer)
 639                 Con_Printf("^2Querying master, favourite and LAN servers, reset=%u\n", resetcache);
 640         serverlist_querystage = (querydp ? SLIST_QUERYSTAGE_DPMASTERS : 0) | (queryqw ? SLIST_QUERYSTAGE_QWMASTERS : 0);
 641         masterquerycount = 0;
 642         masterreplycount = 0;
 643         if (resetcache)
 644         {
 645                 serverquerycount = 0;
 646                 serverreplycount = 0;
 647                 serverlist_cachecount = 0;
 648                 serverlist_viewcount = 0;
 649                 serverlist_maxcachecount = 0;
 650                 serverlist_cache = (serverlist_entry_t *)Mem_Realloc(netconn_mempool, (void *)serverlist_cache, sizeof(serverlist_entry_t) * serverlist_maxcachecount);
 651         }
 652         else
 653         {
 654                 // refresh all entries
 655                 for (i = 0; i < serverlist_cachecount; ++i)
 656                 {
 657                         serverlist_entry_t *entry = &serverlist_cache[i];
 658                         entry->responded = false;
 659                 }
 660         }
 661         serverlist_consoleoutput = consoleoutput;
 662
 663         //_ServerList_Test();
 664
 665         NetConn_QueryMasters(querydp, queryqw);
 666
 667         // Generate new DP server query key string
 668         // Used to prevent ping cheating and discard spurious getstatus/getinfo packets
 669         if (!serverlist_querystage) // don't change key while updating
 670                 NetConn_BuildChallengeString(serverlist_dpserverquerykey, sizeof(serverlist_dpserverquerykey));
 671
 672         // LAN search
 673
 674         // Master and and/or favourite queries were likely delayed by DNS lag,
 675         // for correct pings we need to know what host.realtime would be if it were updated now.
 676         masterquerytime = host.realtime + (Sys_DirtyTime() - host.dirtytime);
 677         ServerList_BuildDPServerQuery(dpquery, sizeof(dpquery), masterquerytime);
 678
 679         // 26000 is the default quake server port, servers on other ports will not be found
 680         // note this is IPv4-only, I doubt there are IPv6-only LANs out there
 681         LHNETADDRESS_FromString(&broadcastaddress, "255.255.255.255", 26000);
 682
 683         for (i = 0; i < cl_numsockets; ++i)
 684         {
 685                 if (!cl_sockets[i])
 686                         continue;
 687                 if (LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i])) != LHNETADDRESS_GetAddressType(&broadcastaddress))
 688                         continue;
 689
 690                 if (querydp)
 691                 {
 692                         // search LAN for Quake servers
 693                         SZ_Clear(&cl_message);
 694                         // save space for the header, filled in later
 695                         MSG_WriteLong(&cl_message, 0);
 696                         MSG_WriteByte(&cl_message, CCREQ_SERVER_INFO);
 697                         MSG_WriteString(&cl_message, "QUAKE");
 698                         MSG_WriteByte(&cl_message, NET_PROTOCOL_VERSION);
 699                         StoreBigLong(cl_message.data, NETFLAG_CTL | (cl_message.cursize & NETFLAG_LENGTH_MASK));
 700                         NetConn_Write(cl_sockets[i], cl_message.data, cl_message.cursize, &broadcastaddress);
 701                         SZ_Clear(&cl_message);
 702
 703                         // search LAN for DarkPlaces servers
 704                         NetConn_WriteString(cl_sockets[i], dpquery, &broadcastaddress);
 705                 }
 706
 707                 if (queryqw)
 708                         // search LAN for QuakeWorld servers
 709                         NetConn_WriteString(cl_sockets[i], "\377\377\377\377status\n", &broadcastaddress);
 710         }
 711 }
 712 #endif
 713
 714 // rest
 715
 716 int NetConn_Read(lhnetsocket_t *mysocket, void *data, int maxlength, lhnetaddress_t *peeraddress)
 717 {
 718         int length;
 719         unsigned i;
 720
 721         if (mysocket->address.addresstype == LHNETADDRESSTYPE_LOOP && netconn_mutex)
 722                 Thread_LockMutex(netconn_mutex);
 723         length = LHNET_Read(mysocket, data, maxlength, peeraddress);
 724         if (mysocket->address.addresstype == LHNETADDRESSTYPE_LOOP && netconn_mutex)
 725                 Thread_UnlockMutex(netconn_mutex);
 726         if (length == 0)
 727                 return 0;
 728         if (net_fakeloss_receive.integer)
 729                 for (i = 0;i < cl_numsockets;i++)
 730                         if (cl_sockets[i] == mysocket && (rand() % 100) < net_fakeloss_receive.integer)
 731                                 return 0;
 732         if (developer_networking.integer)
 733         {
 734                 char addressstring[128], addressstring2[128];
 735                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), addressstring, sizeof(addressstring), true);
 736                 if (length > 0)
 737                 {
 738                         LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
 739                         Con_Printf("LHNET_Read(%p (%s), %p, %i, %p) = %i from %s:\n", (void *)mysocket, addressstring, (void *)data, maxlength, (void *)peeraddress, length, addressstring2);
 740                         Com_HexDumpToConsole((unsigned char *)data, length);
 741                 }
 742                 else
 743                         Con_Printf("LHNET_Read(%p (%s), %p, %i, %p) = %i\n", (void *)mysocket, addressstring, (void *)data, maxlength, (void *)peeraddress, length);
 744         }
 745         return length;
 746 }
 747
 748 int NetConn_Write(lhnetsocket_t *mysocket, const void *data, int length, const lhnetaddress_t *peeraddress)
 749 {
 750         int ret;
 751         unsigned i;
 752
 753         if (net_fakeloss_send.integer)
 754                 for (i = 0;i < cl_numsockets;i++)
 755                         if (cl_sockets[i] == mysocket && (rand() % 100) < net_fakeloss_send.integer)
 756                                 return length;
 757         if (mysocket->address.addresstype == LHNETADDRESSTYPE_LOOP && netconn_mutex)
 758                 Thread_LockMutex(netconn_mutex);
 759         ret = LHNET_Write(mysocket, data, length, peeraddress);
 760         if (mysocket->address.addresstype == LHNETADDRESSTYPE_LOOP && netconn_mutex)
 761                 Thread_UnlockMutex(netconn_mutex);
 762         if (developer_networking.integer)
 763         {
 764                 char addressstring[128], addressstring2[128];
 765                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), addressstring, sizeof(addressstring), true);
 766                 LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
 767                 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)");
 768                 Com_HexDumpToConsole((unsigned char *)data, length);
 769         }
 770         return ret;
 771 }
 772
 773 int NetConn_WriteString(lhnetsocket_t *mysocket, const char *string, const lhnetaddress_t *peeraddress)
 774 {
 775         // note this does not include the trailing NULL because we add that in the parser
 776         return NetConn_Write(mysocket, string, (int)strlen(string), peeraddress);
 777 }
 778
 779 qbool NetConn_CanSend(netconn_t *conn)
 780 {
 781         conn->outgoing_packetcounter = (conn->outgoing_packetcounter + 1) % NETGRAPH_PACKETS;
 782         conn->outgoing_netgraph[conn->outgoing_packetcounter].time            = host.realtime;
 783         conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes = NETGRAPH_NOPACKET;
 784         conn->outgoing_netgraph[conn->outgoing_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
 785         conn->outgoing_netgraph[conn->outgoing_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
 786         conn->outgoing_netgraph[conn->outgoing_packetcounter].cleartime       = conn->cleartime;
 787         if (host.realtime > conn->cleartime)
 788                 return true;
 789         else
 790         {
 791                 conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes = NETGRAPH_CHOKEDPACKET;
 792                 return false;
 793         }
 794 }
 795
 796 static void NetConn_UpdateCleartime(double *cleartime, int rate, int burstsize, int len)
 797 {
 798         double bursttime = burstsize / (double)rate;
 799
 800         // delay later packets to obey rate limit
 801         if (*cleartime < host.realtime - bursttime)
 802                 *cleartime = host.realtime - bursttime;
 803         *cleartime = *cleartime + len / (double)rate;
 804
 805         // limit bursts to one packet in size ("dialup mode" emulating old behaviour)
 806         if (net_test.integer)
 807         {
 808                 if (*cleartime < host.realtime)
 809                         *cleartime = host.realtime;
 810         }
 811 }
 812
 813 static int NetConn_AddCryptoFlag(crypto_t *crypto)
 814 {
 815         // HACK: if an encrypted connection is used, randomly set some unused
 816         // flags. When AES encryption is enabled, that will make resends differ
 817         // from the original, so that e.g. substring filters in a router/IPS
 818         // are unlikely to match a second time. See also "startkeylogger".
 819         int flag = 0;
 820         if (crypto->authenticated)
 821         {
 822                 // Let's always set at least one of the bits.
 823                 int r = rand() % 7 + 1;
 824                 if (r & 1)
 825                         flag |= NETFLAG_CRYPTO0;
 826                 if (r & 2)
 827                         flag |= NETFLAG_CRYPTO1;
 828                 if (r & 4)
 829                         flag |= NETFLAG_CRYPTO2;
 830         }
 831         return flag;
 832 }
 833
 834 int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate, int burstsize, qbool quakesignon_suppressreliables)
 835 {
 836         int totallen = 0;
 837         unsigned char sendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
 838         unsigned char cryptosendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
 839
 840         // if this packet was supposedly choked, but we find ourselves sending one
 841         // anyway, make sure the size counting starts at zero
 842         // (this mostly happens on level changes and disconnects and such)
 843         if (conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes == NETGRAPH_CHOKEDPACKET)
 844                 conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes = NETGRAPH_NOPACKET;
 845
 846         conn->outgoing_netgraph[conn->outgoing_packetcounter].cleartime = conn->cleartime;
 847
 848         if (protocol == PROTOCOL_QUAKEWORLD)
 849         {
 850                 int packetLen;
 851                 qbool sendreliable;
 852
 853                 // note that it is ok to send empty messages to the qw server,
 854                 // otherwise it won't respond to us at all
 855
 856                 sendreliable = false;
 857                 // if the remote side dropped the last reliable message, resend it
 858                 if (conn->qw.incoming_acknowledged > conn->qw.last_reliable_sequence && conn->qw.incoming_reliable_acknowledged != conn->qw.reliable_sequence)
 859                         sendreliable = true;
 860                 // if the reliable transmit buffer is empty, copy the current message out
 861                 if (!conn->sendMessageLength && conn->message.cursize)
 862                 {
 863                         memcpy (conn->sendMessage, conn->message.data, conn->message.cursize);
 864                         conn->sendMessageLength = conn->message.cursize;
 865                         SZ_Clear(&conn->message); // clear the message buffer
 866                         conn->qw.reliable_sequence ^= 1;
 867                         sendreliable = true;
 868                 }
 869                 // outgoing unreliable packet number, and outgoing reliable packet number (0 or 1)
 870                 StoreLittleLong(sendbuffer, conn->outgoing_unreliable_sequence | (((unsigned int)sendreliable)<<31));
 871                 // last received unreliable packet number, and last received reliable packet number (0 or 1)
 872                 StoreLittleLong(sendbuffer + 4, conn->qw.incoming_sequence | (((unsigned int)conn->qw.incoming_reliable_sequence)<<31));
 873                 packetLen = 8;
 874                 conn->outgoing_unreliable_sequence++;
 875                 // client sends qport in every packet
 876                 if (conn == cls.netcon)
 877                 {
 878                         *((short *)(sendbuffer + 8)) = LittleShort(cls.qw_qport);
 879                         packetLen += 2;
 880                         // also update cls.qw_outgoing_sequence
 881                         cls.qw_outgoing_sequence = conn->outgoing_unreliable_sequence;
 882                 }
 883                 if (packetLen + (sendreliable ? conn->sendMessageLength : 0) > 1400)
 884                 {
 885                         Con_Printf ("NetConn_SendUnreliableMessage: reliable message too big %u\n", data->cursize);
 886                         return -1;
 887                 }
 888
 889                 conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes += packetLen + 28;
 890
 891                 // add the reliable message if there is one
 892                 if (sendreliable)
 893                 {
 894                         conn->outgoing_netgraph[conn->outgoing_packetcounter].reliablebytes += conn->sendMessageLength + 28;
 895                         memcpy(sendbuffer + packetLen, conn->sendMessage, conn->sendMessageLength);
 896                         packetLen += conn->sendMessageLength;
 897                         conn->qw.last_reliable_sequence = conn->outgoing_unreliable_sequence;
 898                 }
 899
 900                 // add the unreliable message if possible
 901                 if (packetLen + data->cursize <= 1400)
 902                 {
 903                         conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes += data->cursize + 28;
 904                         memcpy(sendbuffer + packetLen, data->data, data->cursize);
 905                         packetLen += data->cursize;
 906                 }
 907
 908                 NetConn_Write(conn->mysocket, (void *)&sendbuffer, packetLen, &conn->peeraddress);
 909
 910                 conn->packetsSent++;
 911                 conn->unreliableMessagesSent++;
 912
 913                 totallen += packetLen + 28;
 914         }
 915         else
 916         {
 917                 unsigned int packetLen;
 918                 unsigned int dataLen;
 919                 unsigned int eom;
 920                 const void *sendme;
 921                 size_t sendmelen;
 922
 923                 // if a reliable message fragment has been lost, send it again
 924                 if (conn->sendMessageLength && (host.realtime - conn->lastSendTime) > 1.0)
 925                 {
 926                         if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
 927                         {
 928                                 dataLen = conn->sendMessageLength;
 929                                 eom = NETFLAG_EOM;
 930                         }
 931                         else
 932                         {
 933                                 dataLen = MAX_PACKETFRAGMENT;
 934                                 eom = 0;
 935                         }
 936
 937                         packetLen = NET_HEADERSIZE + dataLen;
 938
 939                         StoreBigLong(sendbuffer, packetLen | (NETFLAG_DATA | eom | NetConn_AddCryptoFlag(&conn->crypto)));
 940                         StoreBigLong(sendbuffer + 4, conn->nq.sendSequence - 1);
 941                         memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
 942
 943                         conn->outgoing_netgraph[conn->outgoing_packetcounter].reliablebytes += packetLen + 28;
 944
 945                         sendme = Crypto_EncryptPacket(&conn->crypto, &sendbuffer, packetLen, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
 946                         if (sendme && NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress) == (int)sendmelen)
 947                         {
 948                                 conn->lastSendTime = host.realtime;
 949                                 conn->packetsReSent++;
 950                         }
 951
 952                         totallen += (int)sendmelen + 28;
 953                 }
 954
 955                 // if we have a new reliable message to send, do so
 956                 if (!conn->sendMessageLength && conn->message.cursize && !quakesignon_suppressreliables)
 957                 {
 958                         if (conn->message.cursize > (int)sizeof(conn->sendMessage))
 959                         {
 960                                 Con_Printf("NetConn_SendUnreliableMessage: reliable message too big (%u > %u)\n", conn->message.cursize, (int)sizeof(conn->sendMessage));
 961                                 conn->message.overflowed = true;
 962                                 return -1;
 963                         }
 964
 965                         if (developer_networking.integer && conn == cls.netcon)
 966                         {
 967                                 Con_Print("client sending reliable message to server:\n");
 968                                 SZ_HexDumpToConsole(&conn->message);
 969                         }
 970
 971                         memcpy(conn->sendMessage, conn->message.data, conn->message.cursize);
 972                         conn->sendMessageLength = conn->message.cursize;
 973                         SZ_Clear(&conn->message);
 974
 975                         if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
 976                         {
 977                                 dataLen = conn->sendMessageLength;
 978                                 eom = NETFLAG_EOM;
 979                         }
 980                         else
 981                         {
 982                                 dataLen = MAX_PACKETFRAGMENT;
 983                                 eom = 0;
 984                         }
 985
 986                         packetLen = NET_HEADERSIZE + dataLen;
 987
 988                         StoreBigLong(sendbuffer, packetLen | (NETFLAG_DATA | eom | NetConn_AddCryptoFlag(&conn->crypto)));
 989                         StoreBigLong(sendbuffer + 4, conn->nq.sendSequence);
 990                         memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
 991
 992                         conn->nq.sendSequence++;
 993
 994                         conn->outgoing_netgraph[conn->outgoing_packetcounter].reliablebytes += packetLen + 28;
 995
 996                         sendme = Crypto_EncryptPacket(&conn->crypto, &sendbuffer, packetLen, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
 997                         if(sendme)
 998                                 NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress);
 999
1000                         conn->lastSendTime = host.realtime;
1001                         conn->packetsSent++;
1002                         conn->reliableMessagesSent++;
1003
1004                         totallen += (int)sendmelen + 28;
1005                 }
1006
1007                 // if we have an unreliable message to send, do so
1008                 if (data->cursize)
1009                 {
1010                         packetLen = NET_HEADERSIZE + data->cursize;
1011
1012                         if (packetLen > (int)sizeof(sendbuffer))
1013                         {
1014                                 Con_Printf("NetConn_SendUnreliableMessage: message too big %u\n", data->cursize);
1015                                 return -1;
1016                         }
1017
1018                         StoreBigLong(sendbuffer, packetLen | NETFLAG_UNRELIABLE | NetConn_AddCryptoFlag(&conn->crypto));
1019                         StoreBigLong(sendbuffer + 4, conn->outgoing_unreliable_sequence);
1020                         memcpy(sendbuffer + NET_HEADERSIZE, data->data, data->cursize);
1021
1022                         conn->outgoing_unreliable_sequence++;
1023
1024                         conn->outgoing_netgraph[conn->outgoing_packetcounter].unreliablebytes += packetLen + 28;
1025
1026                         sendme = Crypto_EncryptPacket(&conn->crypto, &sendbuffer, packetLen, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
1027                         if(sendme)
1028                                 NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress);
1029
1030                         conn->packetsSent++;
1031                         conn->unreliableMessagesSent++;
1032
1033                         totallen += (int)sendmelen + 28;
1034                 }
1035         }
1036
1037         NetConn_UpdateCleartime(&conn->cleartime, rate, burstsize, totallen);
1038
1039         return 0;
1040 }
1041
1042 qbool NetConn_HaveClientPorts(void)
1043 {
1044         return !!cl_numsockets;
1045 }
1046
1047 qbool NetConn_HaveServerPorts(void)
1048 {
1049         return !!sv_numsockets;
1050 }
1051
1052 void NetConn_CloseClientPorts(void)
1053 {
1054         for (;cl_numsockets > 0;cl_numsockets--)
1055                 if (cl_sockets[cl_numsockets - 1])
1056                         LHNET_CloseSocket(cl_sockets[cl_numsockets - 1]);
1057 }
1058
1059 static void NetConn_OpenClientPort(const char *addressstring, lhnetaddresstype_t addresstype, int defaultport)
1060 {
1061         lhnetaddress_t address;
1062         lhnetsocket_t *s;
1063         int success;
1064         char addressstring2[1024];
1065         if (addressstring && addressstring[0])
1066                 success = LHNETADDRESS_FromString(&address, addressstring, defaultport);
1067         else
1068                 success = LHNETADDRESS_FromPort(&address, addresstype, defaultport);
1069         if (success)
1070         {
1071                 if ((s = LHNET_OpenSocket_Connectionless(&address)))
1072                 {
1073                         cl_sockets[cl_numsockets++] = s;
1074                         LHNETADDRESS_ToString(LHNET_AddressFromSocket(s), addressstring2, sizeof(addressstring2), true);
1075                         if (addresstype != LHNETADDRESSTYPE_LOOP)
1076                                 Con_Printf("Client opened a socket on address %s\n", addressstring2);
1077                 }
1078                 else
1079                 {
1080                         LHNETADDRESS_ToString(&address, addressstring2, sizeof(addressstring2), true);
1081                         Con_Printf(CON_ERROR "Client failed to open a socket on address %s\n", addressstring2);
1082                 }
1083         }
1084         else
1085                 Con_Printf(CON_ERROR "Client unable to parse address %s\n", addressstring);
1086 }
1087
1088 void NetConn_OpenClientPorts(void)
1089 {
1090         int port;
1091         NetConn_CloseClientPorts();
1092
1093         SV_LockThreadMutex(); // FIXME recursive?
1094         Crypto_LoadKeys(); // client sockets
1095         SV_UnlockThreadMutex();
1096
1097         port = bound(0, cl_netport.integer, 65535);
1098         if (cl_netport.integer != port)
1099                 Cvar_SetValueQuick(&cl_netport, port);
1100         if(port == 0)
1101                 Con_Printf("Client using an automatically assigned port\n");
1102         else
1103                 Con_Printf("Client using port %i\n", port);
1104         NetConn_OpenClientPort(NULL, LHNETADDRESSTYPE_LOOP, 2);
1105         NetConn_OpenClientPort(net_address.string, LHNETADDRESSTYPE_INET4, port);
1106 #ifndef NOSUPPORTIPV6
1107         NetConn_OpenClientPort(net_address_ipv6.string, LHNETADDRESSTYPE_INET6, port);
1108 #endif
1109 }
1110
1111 void NetConn_CloseServerPorts(void)
1112 {
1113         for (;sv_numsockets > 0;sv_numsockets--)
1114                 if (sv_sockets[sv_numsockets - 1])
1115                         LHNET_CloseSocket(sv_sockets[sv_numsockets - 1]);
1116 }
1117
1118 static qbool NetConn_OpenServerPort(const char *addressstring, lhnetaddresstype_t addresstype, int defaultport, int range)
1119 {
1120         lhnetaddress_t address;
1121         lhnetsocket_t *s;
1122         int port;
1123         char addressstring2[1024];
1124         int success;
1125
1126         for (port = defaultport; port <= defaultport + range; port++)
1127         {
1128                 if (addressstring && addressstring[0])
1129                         success = LHNETADDRESS_FromString(&address, addressstring, port);
1130                 else
1131                         success = LHNETADDRESS_FromPort(&address, addresstype, port);
1132                 if (success)
1133                 {
1134                         if ((s = LHNET_OpenSocket_Connectionless(&address)))
1135                         {
1136                                 sv_sockets[sv_numsockets++] = s;
1137                                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(s), addressstring2, sizeof(addressstring2), true);
1138                                 if (addresstype != LHNETADDRESSTYPE_LOOP)
1139                                         Con_Printf("Server listening on address %s\n", addressstring2);
1140                                 return true;
1141                         }
1142                         else
1143                         {
1144                                 LHNETADDRESS_ToString(&address, addressstring2, sizeof(addressstring2), true);
1145                                 Con_Printf(CON_ERROR "Server failed to open socket on address %s\n", addressstring2);
1146                         }
1147                 }
1148                 else
1149                 {
1150                         Con_Printf(CON_ERROR "Server unable to parse address %s\n", addressstring);
1151                         // if it cant parse one address, it wont be able to parse another for sure
1152                         return false;
1153                 }
1154         }
1155         return false;
1156 }
1157
1158 void NetConn_OpenServerPorts(int opennetports)
1159 {
1160         int port;
1161         NetConn_CloseServerPorts();
1162
1163         SV_LockThreadMutex(); // FIXME recursive?
1164         Crypto_LoadKeys(); // server sockets
1165         SV_UnlockThreadMutex();
1166
1167         NetConn_UpdateSockets();
1168         port = bound(0, sv_netport.integer, 65535);
1169         if (port == 0)
1170                 port = 26000;
1171         if (sv_netport.integer != port)
1172                 Cvar_SetValueQuick(&sv_netport, port);
1173         if (cls.state != ca_dedicated)
1174                 NetConn_OpenServerPort(NULL, LHNETADDRESSTYPE_LOOP, 1, 1);
1175         if (opennetports)
1176         {
1177 #ifndef NOSUPPORTIPV6
1178                 qbool ip4success = NetConn_OpenServerPort(net_address.string, LHNETADDRESSTYPE_INET4, port, 100);
1179                 NetConn_OpenServerPort(net_address_ipv6.string, LHNETADDRESSTYPE_INET6, port, ip4success ? 1 : 100);
1180 #else
1181                 NetConn_OpenServerPort(net_address.string, LHNETADDRESSTYPE_INET4, port, 100);
1182 #endif
1183         }
1184         if (sv_numsockets == 0)
1185                 Host_Error("NetConn_OpenServerPorts: unable to open any ports!");
1186 }
1187
1188 lhnetsocket_t *NetConn_ChooseClientSocketForAddress(lhnetaddress_t *address)
1189 {
1190         unsigned i;
1191         lhnetaddresstype_t a = LHNETADDRESS_GetAddressType(address);
1192
1193         for (i = 0;i < cl_numsockets;i++)
1194                 if (cl_sockets[i] && LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i])) == a)
1195                         return cl_sockets[i];
1196         return NULL;
1197 }
1198
1199 lhnetsocket_t *NetConn_ChooseServerSocketForAddress(lhnetaddress_t *address)
1200 {
1201         unsigned i;
1202         lhnetaddresstype_t a = LHNETADDRESS_GetAddressType(address);
1203
1204         for (i = 0;i < sv_numsockets;i++)
1205                 if (sv_sockets[i] && LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(sv_sockets[i])) == a)
1206                         return sv_sockets[i];
1207         return NULL;
1208 }
1209
1210 netconn_t *NetConn_Open(lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress)
1211 {
1212         netconn_t *conn;
1213         conn = (netconn_t *)Mem_Alloc(netconn_mempool, sizeof(*conn));
1214         conn->mysocket = mysocket;
1215         conn->peeraddress = *peeraddress;
1216         conn->lastMessageTime = host.realtime;
1217         conn->message.data = conn->messagedata;
1218         conn->message.maxsize = sizeof(conn->messagedata);
1219         conn->message.cursize = 0;
1220         // LadyHavoc: (inspired by ProQuake) use a short connect timeout to
1221         // reduce effectiveness of connection request floods
1222         conn->timeout = host.realtime + net_connecttimeout.value;
1223         LHNETADDRESS_ToString(&conn->peeraddress, conn->address, sizeof(conn->address), true);
1224         conn->next = netconn_list;
1225         netconn_list = conn;
1226         return conn;
1227 }
1228
1229 void NetConn_ClearFlood(lhnetaddress_t *peeraddress, server_floodaddress_t *floodlist, size_t floodlength);
1230 void NetConn_Close(netconn_t *conn)
1231 {
1232         netconn_t *c;
1233         // remove connection from list
1234
1235         // allow the client to reconnect immediately
1236         NetConn_ClearFlood(&(conn->peeraddress), sv.connectfloodaddresses, sizeof(sv.connectfloodaddresses) / sizeof(sv.connectfloodaddresses[0]));
1237
1238         if (conn == netconn_list)
1239                 netconn_list = conn->next;
1240         else
1241         {
1242                 for (c = netconn_list;c;c = c->next)
1243                 {
1244                         if (c->next == conn)
1245                         {
1246                                 c->next = conn->next;
1247                                 break;
1248                         }
1249                 }
1250                 // not found in list, we'll avoid crashing here...
1251                 if (!c)
1252                         return;
1253         }
1254         // free connection
1255         Mem_Free(conn);
1256 }
1257
1258 static int clientport = -1;
1259 static int clientport2 = -1;
1260
1261 // Call on disconnect, during startup, or if cl_port/cl_netport is changed
1262 static void NetConn_CL_UpdateSockets_Callback(cvar_t *var)
1263 {
1264         if(cls.state != ca_dedicated)
1265         {
1266                 if (clientport2 != var->integer)
1267                 {
1268                         clientport2 = var->integer;
1269                         if (cls.state == ca_connected)
1270                                 Con_Print("Changing \"cl_port\" will not take effect until you reconnect.\n");
1271                 }
1272
1273                 if (cls.state == ca_disconnected && clientport != clientport2)
1274                 {
1275                         clientport = clientport2;
1276                         NetConn_CloseClientPorts();
1277                 }
1278                 if (cl_numsockets == 0)
1279                         NetConn_OpenClientPorts();
1280         }
1281 }
1282
1283 static int hostport = -1;
1284
1285 // Call when port/sv_netport is changed
1286 static void NetConn_sv_netport_Callback(cvar_t *var)
1287 {
1288         if (hostport != var->integer)
1289         {
1290                 hostport = var->integer;
1291                 if (sv.active)
1292                         Con_Print("Changing \"port\" will not take effect until \"map\" command is executed.\n");
1293         }
1294 }
1295
1296 void NetConn_UpdateSockets(void)
1297 {
1298         int i, j;
1299
1300         // TODO add logic to automatically close sockets if needed
1301         LHNET_DefaultDSCP(net_tos_dscp.integer);
1302
1303         for (j = 0;j < MAX_RCONS;j++)
1304         {
1305                 i = (cls.rcon_ringpos + j + 1) % MAX_RCONS;
1306                 if(cls.rcon_commands[i][0])
1307                 {
1308                         if(host.realtime > cls.rcon_timeout[i])
1309                         {
1310                                 char s[128];
1311                                 LHNETADDRESS_ToString(&cls.rcon_addresses[i], s, sizeof(s), true);
1312                                 Con_Printf("rcon to %s (for command %s) failed: challenge request timed out\n", s, cls.rcon_commands[i]);
1313                                 cls.rcon_commands[i][0] = 0;
1314                                 --cls.rcon_trying;
1315                                 break;
1316                         }
1317                 }
1318         }
1319 }
1320
1321 static int NetConn_ReceivedMessage(netconn_t *conn, const unsigned char *data, size_t length, protocolversion_t protocol, double newtimeout)
1322 {
1323         int originallength = (int)length;
1324         unsigned char sendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
1325         unsigned char cryptosendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
1326         unsigned char cryptoreadbuffer[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
1327         if (length < 8)
1328                 return 0;
1329
1330         if (protocol == PROTOCOL_QUAKEWORLD)
1331         {
1332                 unsigned int sequence, sequence_ack;
1333                 qbool reliable_ack, reliable_message;
1334                 int count;
1335                 //int qport;
1336
1337                 sequence = LittleLong(*((int *)(data + 0)));
1338                 sequence_ack = LittleLong(*((int *)(data + 4)));
1339                 data += 8;
1340                 length -= 8;
1341
1342                 if (conn != cls.netcon)
1343                 {
1344                         // server only
1345                         if (length < 2)
1346                                 return 0;
1347                         // 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?)
1348                         //qport = LittleShort(*((int *)(data + 8)));
1349                         data += 2;
1350                         length -= 2;
1351                 }
1352
1353                 conn->packetsReceived++;
1354                 reliable_message = (sequence >> 31) != 0;
1355                 reliable_ack = (sequence_ack >> 31) != 0;
1356                 sequence &= ~(1u<<31);
1357                 sequence_ack &= ~(1u<<31);
1358                 if (sequence <= conn->qw.incoming_sequence)
1359                 {
1360                         //Con_DPrint("Got a stale datagram\n");
1361                         return 0;
1362                 }
1363                 count = sequence - (conn->qw.incoming_sequence + 1);
1364                 if (count > 0)
1365                 {
1366                         conn->droppedDatagrams += count;
1367                         //Con_DPrintf("Dropped %u datagram(s)\n", count);
1368                         // If too may packets have been dropped, only write the
1369                         // last NETGRAPH_PACKETS ones to the netgraph. Why?
1370                         // Because there's no point in writing more than
1371                         // these as the netgraph is going to be full anyway.
1372                         if (count > NETGRAPH_PACKETS)
1373                                 count = NETGRAPH_PACKETS;
1374                         while (count--)
1375                         {
1376                                 conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
1377                                 conn->incoming_netgraph[conn->incoming_packetcounter].time            = host.realtime;
1378                                 conn->incoming_netgraph[conn->incoming_packetcounter].cleartime       = conn->incoming_cleartime;
1379                                 conn->incoming_netgraph[conn->incoming_packetcounter].unreliablebytes = NETGRAPH_LOSTPACKET;
1380                                 conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
1381                                 conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
1382                         }
1383                 }
1384                 conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
1385                 conn->incoming_netgraph[conn->incoming_packetcounter].time            = host.realtime;
1386                 conn->incoming_netgraph[conn->incoming_packetcounter].cleartime       = conn->incoming_cleartime;
1387                 conn->incoming_netgraph[conn->incoming_packetcounter].unreliablebytes = originallength + 28;
1388                 conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
1389                 conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
1390                 NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
1391
1392                 // limit bursts to one packet in size ("dialup mode" emulating old behaviour)
1393                 if (net_test.integer)
1394                 {
1395                         if (conn->cleartime < host.realtime)
1396                                 conn->cleartime = host.realtime;
1397                 }
1398
1399                 if (reliable_ack == conn->qw.reliable_sequence)
1400                 {
1401                         // received, now we will be able to send another reliable message
1402                         conn->sendMessageLength = 0;
1403                         conn->reliableMessagesReceived++;
1404                 }
1405                 conn->qw.incoming_sequence = sequence;
1406                 if (conn == cls.netcon)
1407                         cls.qw_incoming_sequence = conn->qw.incoming_sequence;
1408                 conn->qw.incoming_acknowledged = sequence_ack;
1409                 conn->qw.incoming_reliable_acknowledged = reliable_ack;
1410                 if (reliable_message)
1411                         conn->qw.incoming_reliable_sequence ^= 1;
1412                 conn->lastMessageTime = host.realtime;
1413                 conn->timeout = host.realtime + newtimeout;
1414                 conn->unreliableMessagesReceived++;
1415                 if (conn == cls.netcon)
1416                 {
1417                         SZ_Clear(&cl_message);
1418                         SZ_Write(&cl_message, data, (int)length);
1419                         MSG_BeginReading(&cl_message);
1420                 }
1421                 else
1422                 {
1423                         SZ_Clear(&sv_message);
1424                         SZ_Write(&sv_message, data, (int)length);
1425                         MSG_BeginReading(&sv_message);
1426                 }
1427                 return 2;
1428         }
1429         else
1430         {
1431                 unsigned int count;
1432                 unsigned int flags;
1433                 unsigned int sequence;
1434                 size_t qlength;
1435                 const void *sendme;
1436                 size_t sendmelen;
1437
1438                 originallength = (int)length;
1439                 data = (const unsigned char *) Crypto_DecryptPacket(&conn->crypto, data, length, cryptoreadbuffer, &length, sizeof(cryptoreadbuffer));
1440                 if(!data)
1441                         return 0;
1442                 if(length < 8)
1443                         return 0;
1444
1445                 qlength = (unsigned int)BuffBigLong(data);
1446                 flags = qlength & ~NETFLAG_LENGTH_MASK;
1447                 qlength &= NETFLAG_LENGTH_MASK;
1448                 // control packets were already handled
1449                 if (!(flags & NETFLAG_CTL) && qlength == length)
1450                 {
1451                         sequence = BuffBigLong(data + 4);
1452                         conn->packetsReceived++;
1453                         data += 8;
1454                         length -= 8;
1455                         if (flags & NETFLAG_UNRELIABLE)
1456                         {
1457                                 if (sequence >= conn->nq.unreliableReceiveSequence)
1458                                 {
1459                                         if (sequence > conn->nq.unreliableReceiveSequence)
1460                                         {
1461                                                 count = sequence - conn->nq.unreliableReceiveSequence;
1462                                                 conn->droppedDatagrams += count;
1463                                                 //Con_DPrintf("Dropped %u datagram(s)\n", count);
1464                                                 // If too may packets have been dropped, only write the
1465                                                 // last NETGRAPH_PACKETS ones to the netgraph. Why?
1466                                                 // Because there's no point in writing more than
1467                                                 // these as the netgraph is going to be full anyway.
1468                                                 if (count > NETGRAPH_PACKETS)
1469                                                         count = NETGRAPH_PACKETS;
1470                                                 while (count--)
1471                                                 {
1472                                                         conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
1473                                                         conn->incoming_netgraph[conn->incoming_packetcounter].time            = host.realtime;
1474                                                         conn->incoming_netgraph[conn->incoming_packetcounter].cleartime       = conn->incoming_cleartime;
1475                                                         conn->incoming_netgraph[conn->incoming_packetcounter].unreliablebytes = NETGRAPH_LOSTPACKET;
1476                                                         conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
1477                                                         conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
1478                                                 }
1479                                         }
1480                                         conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
1481                                         conn->incoming_netgraph[conn->incoming_packetcounter].time            = host.realtime;
1482                                         conn->incoming_netgraph[conn->incoming_packetcounter].cleartime       = conn->incoming_cleartime;
1483                                         conn->incoming_netgraph[conn->incoming_packetcounter].unreliablebytes = originallength + 28;
1484                                         conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   = NETGRAPH_NOPACKET;
1485                                         conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes        = NETGRAPH_NOPACKET;
1486                                         NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
1487
1488                                         conn->nq.unreliableReceiveSequence = sequence + 1;
1489                                         conn->lastMessageTime = host.realtime;
1490                                         conn->timeout = host.realtime + newtimeout;
1491                                         conn->unreliableMessagesReceived++;
1492                                         if (length > 0)
1493                                         {
1494                                                 if (conn == cls.netcon)
1495                                                 {
1496                                                         SZ_Clear(&cl_message);
1497                                                         SZ_Write(&cl_message, data, (int)length);
1498                                                         MSG_BeginReading(&cl_message);
1499                                                 }
1500                                                 else
1501                                                 {
1502                                                         SZ_Clear(&sv_message);
1503                                                         SZ_Write(&sv_message, data, (int)length);
1504                                                         MSG_BeginReading(&sv_message);
1505                                                 }
1506                                                 return 2;
1507                                         }
1508                                 }
1509                                 //else
1510                                 //      Con_DPrint("Got a stale datagram\n");
1511                                 return 1;
1512                         }
1513                         else if (flags & NETFLAG_ACK)
1514                         {
1515                                 conn->incoming_netgraph[conn->incoming_packetcounter].ackbytes += originallength + 28;
1516                                 NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
1517
1518                                 if (sequence == (conn->nq.sendSequence - 1))
1519                                 {
1520                                         if (sequence == conn->nq.ackSequence)
1521                                         {
1522                                                 conn->nq.ackSequence++;
1523                                                 if (conn->nq.ackSequence != conn->nq.sendSequence)
1524                                                         Con_DPrint("ack sequencing error\n");
1525                                                 conn->lastMessageTime = host.realtime;
1526                                                 conn->timeout = host.realtime + newtimeout;
1527                                                 if (conn->sendMessageLength > MAX_PACKETFRAGMENT)
1528                                                 {
1529                                                         unsigned int packetLen;
1530                                                         unsigned int dataLen;
1531                                                         unsigned int eom;
1532
1533                                                         conn->sendMessageLength -= MAX_PACKETFRAGMENT;
1534                                                         memmove(conn->sendMessage, conn->sendMessage+MAX_PACKETFRAGMENT, conn->sendMessageLength);
1535
1536                                                         if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
1537                                                         {
1538                                                                 dataLen = conn->sendMessageLength;
1539                                                                 eom = NETFLAG_EOM;
1540                                                         }
1541                                                         else
1542                                                         {
1543                                                                 dataLen = MAX_PACKETFRAGMENT;
1544                                                                 eom = 0;
1545                                                         }
1546
1547                                                         packetLen = NET_HEADERSIZE + dataLen;
1548
1549                                                         StoreBigLong(sendbuffer, packetLen | (NETFLAG_DATA | eom | NetConn_AddCryptoFlag(&conn->crypto)));
1550                                                         StoreBigLong(sendbuffer + 4, conn->nq.sendSequence);
1551                                                         memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
1552
1553                                                         conn->nq.sendSequence++;
1554
1555                                                         sendme = Crypto_EncryptPacket(&conn->crypto, &sendbuffer, packetLen, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
1556                                                         if (sendme && NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress) == (int)sendmelen)
1557                                                         {
1558                                                                 conn->lastSendTime = host.realtime;
1559                                                                 conn->packetsSent++;
1560                                                         }
1561                                                 }
1562                                                 else
1563                                                         conn->sendMessageLength = 0;
1564                                         }
1565                                         //else
1566                                         //      Con_DPrint("Duplicate ACK received\n");
1567                                 }
1568                                 //else
1569                                 //      Con_DPrint("Stale ACK received\n");
1570                                 return 1;
1571                         }
1572                         else if (flags & NETFLAG_DATA)
1573                         {
1574                                 unsigned char temppacket[8];
1575                                 conn->incoming_netgraph[conn->incoming_packetcounter].reliablebytes   += originallength + 28;
1576                                 NetConn_UpdateCleartime(&conn->incoming_cleartime, cl_rate.integer, cl_rate_burstsize.integer, originallength + 28);
1577
1578                                 conn->outgoing_netgraph[conn->outgoing_packetcounter].ackbytes        += 8 + 28;
1579
1580                                 StoreBigLong(temppacket, 8 | NETFLAG_ACK | NetConn_AddCryptoFlag(&conn->crypto));
1581                                 StoreBigLong(temppacket + 4, sequence);
1582                                 sendme = Crypto_EncryptPacket(&conn->crypto, temppacket, 8, &cryptosendbuffer, &sendmelen, sizeof(cryptosendbuffer));
1583                                 if(sendme)
1584                                         NetConn_Write(conn->mysocket, sendme, (int)sendmelen, &conn->peeraddress);
1585                                 if (sequence == conn->nq.receiveSequence)
1586                                 {
1587                                         conn->lastMessageTime = host.realtime;
1588                                         conn->timeout = host.realtime + newtimeout;
1589                                         conn->nq.receiveSequence++;
1590                                         if( conn->receiveMessageLength + length <= (int)sizeof( conn->receiveMessage ) ) {
1591                                                 memcpy(conn->receiveMessage + conn->receiveMessageLength, data, length);
1592                                                 conn->receiveMessageLength += (int)length;
1593                                         } else {
1594                                                 Con_Printf( "Reliable message (seq: %i) too big for message buffer!\n"
1595                                                                         "Dropping the message!\n", sequence );
1596                                                 conn->receiveMessageLength = 0;
1597                                                 return 1;
1598                                         }
1599                                         if (flags & NETFLAG_EOM)
1600                                         {
1601                                                 conn->reliableMessagesReceived++;
1602                                                 length = conn->receiveMessageLength;
1603                                                 conn->receiveMessageLength = 0;
1604                                                 if (length > 0)
1605                                                 {
1606                                                         if (conn == cls.netcon)
1607                                                         {
1608                                                                 SZ_Clear(&cl_message);
1609                                                                 SZ_Write(&cl_message, conn->receiveMessage, (int)length);
1610                                                                 MSG_BeginReading(&cl_message);
1611                                                         }
1612                                                         else
1613                                                         {
1614                                                                 SZ_Clear(&sv_message);
1615                                                                 SZ_Write(&sv_message, conn->receiveMessage, (int)length);
1616                                                                 MSG_BeginReading(&sv_message);
1617                                                         }
1618                                                         return 2;
1619                                                 }
1620                                         }
1621                                 }
1622                                 else
1623                                         conn->receivedDuplicateCount++;
1624                                 return 1;
1625                         }
1626                 }
1627         }
1628         return 0;
1629 }
1630
1631 static void NetConn_ConnectionEstablished(lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress, protocolversion_t initialprotocol)
1632 {
1633         crypto_t *crypto;
1634
1635         cls.connect_trying = false;
1636         // Disconnect from the current server or stop demo playback
1637         if(cls.state == ca_connected || cls.demoplayback)
1638                 CL_Disconnect();
1639         // allocate a net connection to keep track of things
1640         cls.netcon = NetConn_Open(mysocket, peeraddress);
1641         dp_strlcpy(cl_connect_status, "Connection established", sizeof(cl_connect_status));
1642         crypto = &cls.netcon->crypto;
1643         if(cls.crypto.authenticated)
1644         {
1645                 Crypto_FinishInstance(crypto, &cls.crypto);
1646                 Con_Printf("%s connection to %s has been established: server is %s@%s%.*s, I am %.*s@%s%.*s\n",
1647                                 crypto->use_aes ? "Encrypted" : "Authenticated",
1648                                 cls.netcon->address,
1649                                 crypto->server_idfp[0] ? crypto->server_idfp : "-",
1650                                 (crypto->server_issigned || !crypto->server_keyfp[0]) ? "" : "~",
1651                                 crypto_keyfp_recommended_length, crypto->server_keyfp[0] ? crypto->server_keyfp : "-",
1652                                 crypto_keyfp_recommended_length, crypto->client_idfp[0] ? crypto->client_idfp : "-",
1653                                 (crypto->client_issigned || !crypto->client_keyfp[0]) ? "" : "~",
1654                                 crypto_keyfp_recommended_length, crypto->client_keyfp[0] ? crypto->client_keyfp : "-"
1655                                 );
1656         }
1657         else
1658                 Con_Printf("%s to %s\n", cl_connect_status, cls.netcon->address);
1659
1660         key_dest = key_game;
1661 #ifdef CONFIG_MENU
1662         m_state = m_none;
1663 #endif
1664         cls.demonum = -1;                       // not in the demo loop now
1665         cls.state = ca_connected;
1666         cls.signon = 0;                         // need all the signon messages before playing
1667         cls.protocol = initialprotocol;
1668         // reset move sequence numbering on this new connection
1669         cls.servermovesequence = 0;
1670         if (cls.protocol == PROTOCOL_QUAKEWORLD)
1671                 CL_ForwardToServer("new");
1672         if (cls.protocol == PROTOCOL_QUAKE)
1673         {
1674                 // write a keepalive (clc_nop) as it seems to greatly improve the
1675                 // chances of connecting to a netquake server
1676                 sizebuf_t msg;
1677                 unsigned char buf[4];
1678                 memset(&msg, 0, sizeof(msg));
1679                 msg.data = buf;
1680                 msg.maxsize = sizeof(buf);
1681                 MSG_WriteChar(&msg, clc_nop);
1682                 NetConn_SendUnreliableMessage(cls.netcon, &msg, cls.protocol, 10000, 0, false);
1683         }
1684 }
1685
1686 int NetConn_IsLocalGame(void)
1687 {
1688         if (cls.state == ca_connected && sv.active && cl.maxclients == 1)
1689                 return true;
1690         return false;
1691 }
1692
1693 #ifdef CONFIG_MENU
1694 static qbool hmac_mdfour_time_matching(lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen);
1695 static int NetConn_ClientParsePacket_ServerList_ProcessReply(const char *addressstring, const char *challenge)
1696 {
1697         unsigned n;
1698         float ping;
1699         double currentrealtime;
1700         serverlist_entry_t *entry;
1701
1702         // search the cache for this server and update it
1703         for (n = 0; n < serverlist_cachecount; ++n)
1704         {
1705                 entry = &serverlist_cache[n];
1706                 if (!strcmp(addressstring, entry->info.cname))
1707                         break;
1708         }
1709
1710         if (n == serverlist_cachecount)
1711         {
1712                 if (net_slist_debug.integer)
1713                         Con_Printf("^6Received LAN broadcast response from %s\n", addressstring);
1714
1715                 // find a slot
1716                 if (serverlist_cachecount == SERVERLIST_TOTALSIZE)
1717                         return -1;
1718
1719                 if (serverlist_maxcachecount <= serverlist_cachecount)
1720                 {
1721                         serverlist_maxcachecount += 64;
1722                         serverlist_cache = (serverlist_entry_t *)Mem_Realloc(netconn_mempool, (void *)serverlist_cache, sizeof(serverlist_entry_t) * serverlist_maxcachecount);
1723                 }
1724                 ++serverlist_cachecount;
1725                 entry = &serverlist_cache[n];
1726
1727                 memset(entry, 0, sizeof(*entry));
1728                 entry->info.cname_len = dp_strlcpy(entry->info.cname, addressstring, sizeof(entry->info.cname));
1729
1730                 // use the broadcast as the first query, NetConn_QueryQueueFrame() will send more
1731                 entry->querytime = masterquerytime;
1732                 // protocol is one of these at all
1733                 // NetConn_ClientParsePacket_ServerList_PrepareQuery() callsites
1734                 entry->protocol = challenge ? PROTOCOL_DARKPLACES7 : PROTOCOL_QUAKEWORLD;
1735
1736                 if (serverlist_consoleoutput)
1737                         Con_Printf("querying %s\n", addressstring);
1738         }
1739
1740         // If the client stalls partway through a frame (test command: `alias a a;a`)
1741         // for correct pings we need to know what host.realtime would be if it were updated now.
1742         currentrealtime = host.realtime + (Sys_DirtyTime() - host.dirtytime);
1743
1744         if (challenge)
1745         {
1746                 unsigned char hash[24]; // 4*(16/3) rounded up to 4 byte multiple
1747                 uint64_t timestamp = strtoull(&challenge[22], NULL, 16);
1748
1749                 HMAC_MDFOUR_16BYTES(hash,
1750                         (unsigned char *)&timestamp, sizeof(timestamp),
1751                         (unsigned char *)serverlist_dpserverquerykey, sizeof(serverlist_dpserverquerykey));
1752                 base64_encode(hash, 16, sizeof(hash));
1753                 if (memcmp(hash, challenge, 22) != 0)
1754                         return -1;
1755
1756                 ping = currentrealtime * 1000.0 - timestamp;
1757         }
1758         else
1759                 ping = 1000 * (currentrealtime - entry->querytime);
1760
1761         if (ping <= 0 || ping > net_slist_maxping.value
1762         || (entry->info.ping && ping > entry->info.ping + 100)) // server loading map, client stall, etc
1763                 return -1;
1764
1765         // never round down to 0, 0 latency is impossible, 0 means no data available
1766         if (ping < 1)
1767                 ping = 1;
1768
1769         if (entry->info.ping)
1770                 entry->info.ping = (entry->info.ping + ping) * 0.5 + 0.5; // "average" biased toward most recent results
1771         else
1772         {
1773                 entry->info.ping = ping + 0.5;
1774                 serverreplycount++;
1775         }
1776         entry->responded = true;
1777
1778         // other server info is updated by the caller
1779         return n;
1780 }
1781
1782 static void NetConn_ClientParsePacket_ServerList_UpdateCache(int n)
1783 {
1784         serverlist_entry_t *entry = &serverlist_cache[n];
1785         serverlist_info_t *info = &entry->info;
1786
1787         // update description strings for engine menu and console output
1788         entry->line1_len = dpsnprintf(entry->line1, sizeof(serverlist_cache[n].line1), "^%c%5.0f^7 ^%c%3u^7/%3u %-65.65s",
1789                    info->ping >= 300 ? '1' : (info->ping >= 200 ? '3' : '7'),
1790                    info->ping ? info->ping : INFINITY, // display inf when a listed server times out and net_slist_pause blocks its removal
1791                    ((info->numhumans > 0 && info->numhumans < info->maxplayers) ? (info->numhumans >= 4 ? '7' : '3') : '1'),
1792                    info->numplayers,
1793                    info->maxplayers,
1794                    info->name);
1795         entry->line2_len = dpsnprintf(entry->line2, sizeof(serverlist_cache[n].line2), "^4%-21.21s %-19.19s ^%c%-17.17s^4 %-20.20s", info->cname, info->game,
1796                         (
1797                          info->gameversion != gameversion.integer
1798                          &&
1799                          !(
1800                                     gameversion_min.integer >= 0 // min/max range set by user/mod?
1801                                  && gameversion_max.integer >= 0
1802                                  && gameversion_min.integer <= info->gameversion // version of server in min/max range?
1803                                  && gameversion_max.integer >= info->gameversion
1804                           )
1805                         ) ? '1' : '4',
1806                         info->mod, info->map);
1807
1808         if(!net_slist_pause.integer)
1809         {
1810                 ServerList_ViewList_Remove(entry);
1811                 ServerList_ViewList_Insert(entry);
1812         }
1813
1814         if (serverlist_consoleoutput)
1815                 Con_Printf("%s\n%s\n", entry->line1, entry->line2);
1816 }
1817
1818 // returns true, if it's sensible to continue the processing
1819 static qbool NetConn_ClientParsePacket_ServerList_PrepareQuery(int protocol, const char *ipstring, qbool isfavorite)
1820 {
1821         unsigned n;
1822         serverlist_entry_t *entry;
1823
1824         // ignore the rest of the message if the serverlist is full
1825         if (serverlist_cachecount == SERVERLIST_TOTALSIZE)
1826                 return false;
1827
1828         for (n = 0; n < serverlist_cachecount; ++n)
1829                 if (!strcmp(ipstring, serverlist_cache[n].info.cname))
1830                         break;
1831
1832         // also ignore it if we have already queried it (other master server response)
1833         if (n < serverlist_cachecount)
1834                 return true;
1835
1836         if (serverlist_maxcachecount <= n)
1837         {
1838                 serverlist_maxcachecount += 64;
1839                 serverlist_cache = (serverlist_entry_t *)Mem_Realloc(netconn_mempool, (void *)serverlist_cache, sizeof(serverlist_entry_t) * serverlist_maxcachecount);
1840         }
1841
1842         entry = &serverlist_cache[n];
1843         memset(entry, 0, sizeof(*entry));
1844         entry->protocol = protocol;
1845         entry->info.cname_len = dp_strlcpy(entry->info.cname, ipstring, sizeof(entry->info.cname));
1846         entry->info.isfavorite = isfavorite;
1847
1848         serverlist_cachecount++;
1849         serverquerycount++;
1850
1851         return true;
1852 }
1853
1854 static void NetConn_ClientParsePacket_ServerList_ParseDPList(lhnetaddress_t *masteraddress, const char *masteraddressstring, const unsigned char *data, int length, qbool isextended)
1855 {
1856         unsigned masternum;
1857         lhnetaddress_t testaddress;
1858
1859         for (masternum = 0; masternum < DPMASTER_COUNT; ++masternum)
1860                 if (sv_masters[masternum].string[0]
1861                 && LHNETADDRESS_FromString(&testaddress, sv_masters[masternum].string, DPMASTER_PORT)
1862                 && LHNETADDRESS_Compare(&testaddress, masteraddress) == 0)
1863                         break;
1864         if (net_sourceaddresscheck.integer && masternum >= DPMASTER_COUNT)
1865         {
1866                 Con_Printf(CON_WARN "ignoring DarkPlaces %sserver list from unrecognised master %s\n", isextended ? "extended " : "", masteraddressstring);
1867                 return;
1868         }
1869
1870         masterreplycount++;
1871         dpmasterstatus[masternum] = MASTER_RX_RESPONSE;
1872         if (serverlist_consoleoutput || net_slist_debug.integer)
1873                 Con_Printf("^5Received DarkPlaces server list %sfrom %s\n", isextended ? "(extended) " : "", sv_masters[masternum].string);
1874
1875         while (length >= 7)
1876         {
1877                 char ipstring [128];
1878
1879                 // IPv4 address
1880                 if (data[0] == '\\')
1881                 {
1882                         unsigned short port = data[5] * 256 + data[6];
1883
1884                         if (port != 0 && (data[1] != 0xFF || data[2] != 0xFF || data[3] != 0xFF || data[4] != 0xFF))
1885                                 dpsnprintf (ipstring, sizeof (ipstring), "%u.%u.%u.%u:%hu", data[1], data[2], data[3], data[4], port);
1886                         else if (port == 0 && data[1] == 'E' && data[2] == 'O' && data[3] == 'T' && data[4] == '\0')
1887                         {
1888                                 dpmasterstatus[masternum] = MASTER_RX_COMPLETE;
1889                                 if (net_slist_debug.integer)
1890                                         Con_Printf("^4End Of Transmission %sfrom %s\n", isextended ? "(extended) " : "", sv_masters[masternum].string);
1891                                 break;
1892                         }
1893
1894                         // move on to next address in packet
1895                         data += 7;
1896                         length -= 7;
1897                 }
1898                 // IPv6 address
1899                 else if (data[0] == '/' && isextended && length >= 19)
1900                 {
1901                         unsigned short port = data[17] * 256 + data[18];
1902
1903                         if (port != 0)
1904                         {
1905 #ifdef WHY_JUST_WHY
1906                                 const char *ifname;
1907                                 char ifnamebuf[16];
1908
1909                                 /// \TODO: make some basic checks of the IP address (broadcast, ...)
1910
1911                                 ifname = LHNETADDRESS_GetInterfaceName(senderaddress, ifnamebuf, sizeof(ifnamebuf));
1912                                 if (ifname != NULL)
1913                                 {
1914                                         dpsnprintf (ipstring, sizeof (ipstring), "[%x:%x:%x:%x:%x:%x:%x:%x%%%s]:%hu",
1915                                                                 (data[1] << 8) | data[2], (data[3] << 8) | data[4], (data[5] << 8) | data[6], (data[7] << 8) | data[8],
1916                                                                 (data[9] << 8) | data[10], (data[11] << 8) | data[12], (data[13] << 8) | data[14], (data[15] << 8) | data[16],
1917                                                                 ifname, port);
1918                                 }
1919                                 else
1920 #endif
1921                                 {
1922                                         dpsnprintf (ipstring, sizeof (ipstring), "[%x:%x:%x:%x:%x:%x:%x:%x]:%hu",
1923                                                                 (data[1] << 8) | data[2], (data[3] << 8) | data[4], (data[5] << 8) | data[6], (data[7] << 8) | data[8],
1924                                                                 (data[9] << 8) | data[10], (data[11] << 8) | data[12], (data[13] << 8) | data[14], (data[15] << 8) | data[16],
1925                                                                 port);
1926                                 }
1927                         }
1928
1929                         // move on to next address in packet
1930                         data += 19;
1931                         length -= 19;
1932                 }
1933                 else
1934                 {
1935                         Con_Print(CON_WARN "Error while parsing the server list\n");
1936                         break;
1937                 }
1938
1939                 if (serverlist_consoleoutput && developer_networking.integer)
1940                         Con_Printf("Requesting info from DarkPlaces server %s\n", ipstring);
1941
1942                 if (!NetConn_ClientParsePacket_ServerList_PrepareQuery(PROTOCOL_DARKPLACES7, ipstring, false))
1943                         break;
1944         }
1945
1946         if (serverlist_querystage & SLIST_QUERYSTAGE_QWMASTERS)
1947                 return; // we must wait if we're also querying QW as it has no EOT marker
1948         // begin or resume serverlist queries
1949         for (masternum = 0; masternum < DPMASTER_COUNT; ++masternum)
1950                 if (dpmasterstatus[masternum] && dpmasterstatus[masternum] < MASTER_RX_COMPLETE)
1951                         break; // was queried but no EOT marker received yet
1952         if (masternum >= DPMASTER_COUNT)
1953         {
1954                 serverlist_querystage = SLIST_QUERYSTAGE_SERVERS;
1955                 if (net_slist_debug.integer)
1956                         Con_Print("^2Starting to query servers early (got EOT from all masters)\n");
1957         }
1958 }
1959
1960 static void NetConn_ClientParsePacket_ServerList_ParseQWList(lhnetaddress_t *masteraddress, const char *masteraddressstring, const unsigned char *data, int length)
1961 {
1962         uint8_t masternum;
1963         lhnetaddress_t testaddress;
1964
1965         for (masternum = 0; masternum < QWMASTER_COUNT; ++masternum)
1966                 if (sv_qwmasters[masternum].string[0]
1967                 && LHNETADDRESS_FromString(&testaddress, sv_qwmasters[masternum].string, QWMASTER_PORT)
1968                 && LHNETADDRESS_Compare(&testaddress, masteraddress) == 0)
1969                         break;
1970         if (net_sourceaddresscheck.integer && masternum >= QWMASTER_COUNT)
1971         {
1972                 Con_Printf(CON_WARN "ignoring QuakeWorld server list from unrecognised master %s\n", masteraddressstring);
1973                 return;
1974         }
1975
1976         masterreplycount++;
1977         qwmasterstatus[masternum] = MASTER_RX_RESPONSE;
1978         if (serverlist_consoleoutput || net_slist_debug.integer)
1979                 Con_Printf("^5Received QuakeWorld server list from %s\n", sv_qwmasters[masternum].string);
1980
1981         while (length >= 6 && (data[0] != 0xFF || data[1] != 0xFF || data[2] != 0xFF || data[3] != 0xFF) && data[4] * 256 + data[5] != 0)
1982         {
1983                 char ipstring[32];
1984
1985                 dpsnprintf (ipstring, sizeof (ipstring), "%u.%u.%u.%u:%u", data[0], data[1], data[2], data[3], data[4] * 256 + data[5]);
1986                 if (serverlist_consoleoutput && developer_networking.integer)
1987                         Con_Printf("Requesting info from QuakeWorld server %s\n", ipstring);
1988
1989                 if (!NetConn_ClientParsePacket_ServerList_PrepareQuery(PROTOCOL_QUAKEWORLD, ipstring, false))
1990                         break;
1991
1992                 // move on to next address in packet
1993                 data += 6;
1994                 length -= 6;
1995         }
1996
1997         // Unlike in NetConn_ClientParsePacket_ServerList_ParseDPList()
1998         // we can't start to query servers early here because QW has no EOT marker.
1999 }
2000 #endif
2001
2002 static int NetConn_ClientParsePacket(lhnetsocket_t *mysocket, unsigned char *data, int length, lhnetaddress_t *peeraddress)
2003 {
2004         qbool fromserver;
2005         int ret, c;
2006         char *string, addressstring2[128];
2007         char stringbuf[16384];
2008         char senddata[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
2009         size_t sendlength;
2010 #ifdef CONFIG_MENU
2011         char infostringvalue[MAX_INPUTLINE];
2012 #endif
2013
2014         // quakeworld ingame packet
2015         fromserver = cls.netcon && mysocket == cls.netcon->mysocket && !LHNETADDRESS_Compare(&cls.netcon->peeraddress, peeraddress);
2016
2017         // convert the address to a string incase we need it
2018         LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
2019
2020         if (length >= 5 && data[0] == 255 && data[1] == 255 && data[2] == 255 && data[3] == 255)
2021         {
2022                 // received a command string - strip off the packaging and put it
2023                 // into our string buffer with NULL termination
2024                 data += 4;
2025                 length -= 4;
2026                 length = min(length, (int)sizeof(stringbuf) - 1);
2027                 memcpy(stringbuf, data, length);
2028                 stringbuf[length] = 0;
2029                 string = stringbuf;
2030
2031                 if (developer_networking.integer)
2032                 {
2033                         Con_Printf("NetConn_ClientParsePacket: %s sent us a command:\n", addressstring2);
2034                         Com_HexDumpToConsole(data, length);
2035                 }
2036
2037                 sendlength = sizeof(senddata) - 4;
2038                 switch(Crypto_ClientParsePacket(string, length, senddata+4, &sendlength, peeraddress, addressstring2))
2039                 {
2040                         case CRYPTO_NOMATCH:
2041                                 // nothing to do
2042                                 break;
2043                         case CRYPTO_MATCH:
2044                                 if(sendlength)
2045                                 {
2046                                         memcpy(senddata, "\377\377\377\377", 4);
2047                                         NetConn_Write(mysocket, senddata, (int)sendlength+4, peeraddress);
2048                                 }
2049                                 break;
2050                         case CRYPTO_DISCARD:
2051                                 if(sendlength)
2052                                 {
2053                                         memcpy(senddata, "\377\377\377\377", 4);
2054                                         NetConn_Write(mysocket, senddata, (int)sendlength+4, peeraddress);
2055                                 }
2056                                 return true;
2057                                 break;
2058                         case CRYPTO_REPLACE:
2059                                 string = senddata+4;
2060                                 length = (int)sendlength;
2061                                 break;
2062                 }
2063
2064                 if (length >= 10 && !memcmp(string, "challenge ", 10) && cls.rcon_trying)
2065                 {
2066                         int i = 0, j;
2067                         for (j = 0;j < MAX_RCONS;j++)
2068                         {
2069                                 // note: this value from i is used outside the loop too...
2070                                 i = (cls.rcon_ringpos + j) % MAX_RCONS;
2071                                 if(cls.rcon_commands[i][0])
2072                                         if (!LHNETADDRESS_Compare(peeraddress, &cls.rcon_addresses[i]))
2073                                                 break;
2074                         }
2075                         if (j < MAX_RCONS)
2076                         {
2077                                 char buf[1500];
2078                                 char argbuf[1500];
2079                                 const char *e;
2080                                 int n;
2081                                 dpsnprintf(argbuf, sizeof(argbuf), "%s %s", string + 10, cls.rcon_commands[i]);
2082                                 memcpy(buf, "\377\377\377\377srcon HMAC-MD4 CHALLENGE ", 29);
2083
2084                                 e = strchr(rcon_password.string, ' ');
2085                                 n = e ? e-rcon_password.string : (int)strlen(rcon_password.string);
2086
2087                                 if(HMAC_MDFOUR_16BYTES((unsigned char *) (buf + 29), (unsigned char *) argbuf, (int)strlen(argbuf), (unsigned char *) rcon_password.string, n))
2088                                 {
2089                                         int k;
2090                                         buf[45] = ' ';
2091                                         dp_strlcpy(buf + 46, argbuf, sizeof(buf) - 46);
2092                                         NetConn_Write(mysocket, buf, 46 + (int)strlen(buf + 46), peeraddress);
2093                                         cls.rcon_commands[i][0] = 0;
2094                                         --cls.rcon_trying;
2095
2096                                         for (k = 0;k < MAX_RCONS;k++)
2097                                                 if(cls.rcon_commands[k][0])
2098                                                         if (!LHNETADDRESS_Compare(peeraddress, &cls.rcon_addresses[k]))
2099                                                                 break;
2100                                         if(k < MAX_RCONS)
2101                                         {
2102                                                 int l;
2103                                                 NetConn_WriteString(mysocket, "\377\377\377\377getchallenge", peeraddress);
2104                                                 // extend the timeout on other requests as we asked for a challenge
2105                                                 for (l = 0;l < MAX_RCONS;l++)
2106                                                         if(cls.rcon_commands[l][0])
2107                                                                 if (!LHNETADDRESS_Compare(peeraddress, &cls.rcon_addresses[l]))
2108                                                                         cls.rcon_timeout[l] = host.realtime + rcon_secure_challengetimeout.value;
2109                                         }
2110
2111                                         return true; // we used up the challenge, so we can't use this oen for connecting now anyway
2112                                 }
2113                         }
2114                 }
2115                 if (length >= 10 && !memcmp(string, "challenge ", 10) && cls.connect_trying)
2116                 {
2117                         // darkplaces or quake3
2118                         char protocolnames[1400];
2119
2120                         if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
2121                                 Con_Printf(CON_WARN "ignoring challenge message from wrong server %s\n", addressstring2);
2122                                 return true;
2123                         }
2124                         Con_DPrintf("\"%s\" received, sending connect request back to %s\n", string, addressstring2);
2125                         dp_strlcpy(cl_connect_status, "Connect: replying to challenge...", sizeof(cl_connect_status));
2126
2127                         Protocol_Names(protocolnames, sizeof(protocolnames));
2128                         // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
2129                         InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
2130                         // TODO: add userinfo stuff here instead of using NQ commands?
2131                         memcpy(senddata, "\377\377\377\377", 4);
2132                         dpsnprintf(senddata+4, sizeof(senddata)-4, "connect\\protocol\\darkplaces 3\\protocols\\%s%s\\challenge\\%s", protocolnames, cls.connect_userinfo, string + 10);
2133                         NetConn_WriteString(mysocket, senddata, peeraddress);
2134                         return true;
2135                 }
2136                 if (length == 6 && !memcmp(string, "accept", 6) && cls.connect_trying)
2137                 {
2138                         // darkplaces or quake3
2139                         if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
2140                                 Con_Printf(CON_WARN "ignoring accept message from wrong server %s\n", addressstring2);
2141                                 return true;
2142                         }
2143                         NetConn_ConnectionEstablished(mysocket, peeraddress, PROTOCOL_DARKPLACES3);
2144                         return true;
2145                 }
2146                 if (length > 7 && !memcmp(string, "reject ", 7) && cls.connect_trying)
2147                 {
2148                         if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
2149                                 Con_Printf(CON_WARN "ignoring reject message from wrong server %s\n", addressstring2);
2150                                 return true;
2151                         }
2152                         cls.connect_trying = false;
2153                         string += 7;
2154                         length = min(length - 7, (int)sizeof(cl_connect_status) - 1);
2155                         dpsnprintf(cl_connect_status, sizeof(cl_connect_status), "Connect: rejected, %.*s", length, string);
2156                         Con_Printf(CON_ERROR "Connect: rejected by %s\n" CON_ERROR "%.*s\n", addressstring2, length, string);
2157                         return true;
2158                 }
2159 #ifdef CONFIG_MENU
2160                 if(key_dest != key_game)
2161                 {
2162                         if (length >= 15 && !memcmp(string, "statusResponse\x0A", 15))
2163                         {
2164                                 serverlist_info_t *info;
2165                                 char *p;
2166                                 int n;
2167
2168                                 string += 15;
2169                                 // search the cache for this server and update it
2170                                 // the challenge is (ab)used to return the query time
2171                                 InfoString_GetValue(string, "challenge", infostringvalue, sizeof(infostringvalue));
2172                                 n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2, infostringvalue);
2173                                 if (n < 0)
2174                                         return true;
2175
2176                                 info = &serverlist_cache[n].info;
2177                                 p = strchr(string, '\n');
2178                                 if(p)
2179                                 {
2180                                         *p = 0; // cut off the string there
2181                                         ++p;
2182                                         info->players_len = dp_strlcpy(info->players, p, sizeof(info->players));
2183                                 }
2184                                 else
2185                                 {
2186                                         Con_Printf("statusResponse without players block?\n");
2187                                         info->players_len = info->players[0] = 0;
2188                                 }
2189                                 info->game_len     = InfoString_GetValue(string, "gamename", info->game,     sizeof(info->game));
2190                                 info->mod_len      = InfoString_GetValue(string, "modname",  info->mod,      sizeof(info->mod));
2191                                 info->map_len      = InfoString_GetValue(string, "mapname",  info->map,      sizeof(info->map));
2192                                 info->name_len     = InfoString_GetValue(string, "hostname", info->name,     sizeof(info->name));
2193                                 info->qcstatus_len = InfoString_GetValue(string, "qcstatus", info->qcstatus, sizeof(info->qcstatus));
2194                                 info->protocol    = InfoString_GetValue(string, "protocol"     , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : -1;
2195                                 info->numplayers  = InfoString_GetValue(string, "clients"      , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
2196                                 info->numbots     = InfoString_GetValue(string, "bots"         , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : -1;
2197                                 info->maxplayers  = InfoString_GetValue(string, "sv_maxclients", infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
2198                                 info->gameversion = InfoString_GetValue(string, "gameversion"  , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
2199                                 info->numhumans = info->numplayers - max(0, info->numbots);
2200                                 info->freeslots = info->maxplayers - info->numplayers;
2201
2202                                 NetConn_ClientParsePacket_ServerList_UpdateCache(n);
2203
2204                                 return true;
2205                         }
2206                         if (length >= 13 && !memcmp(string, "infoResponse\x0A", 13))
2207                         {
2208                                 serverlist_info_t *info;
2209                                 int n;
2210
2211                                 string += 13;
2212                                 // search the cache for this server and update it
2213                                 // the challenge is (ab)used to return the query time
2214                                 InfoString_GetValue(string, "challenge", infostringvalue, sizeof(infostringvalue));
2215                                 n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2, infostringvalue);
2216                                 if (n < 0)
2217                                         return true;
2218
2219                                 info = &serverlist_cache[n].info;
2220                                 info->players_len = info->players[0] = 0;
2221                                 info->game_len     = InfoString_GetValue(string, "gamename", info->game,     sizeof(info->game));
2222                                 info->mod_len      = InfoString_GetValue(string, "modname",  info->mod,      sizeof(info->mod));
2223                                 info->map_len      = InfoString_GetValue(string, "mapname",  info->map,      sizeof(info->map));
2224                                 info->name_len     = InfoString_GetValue(string, "hostname", info->name,     sizeof(info->name));
2225                                 info->qcstatus_len = InfoString_GetValue(string, "qcstatus", info->qcstatus, sizeof(info->qcstatus));
2226                                 info->protocol    = InfoString_GetValue(string, "protocol"     , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : -1;
2227                                 info->numplayers  = InfoString_GetValue(string, "clients"      , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
2228                                 info->numbots     = InfoString_GetValue(string, "bots"         , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : -1;
2229                                 info->maxplayers  = InfoString_GetValue(string, "sv_maxclients", infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
2230                                 info->gameversion = InfoString_GetValue(string, "gameversion"  , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
2231                                 info->numhumans = info->numplayers - max(0, info->numbots);
2232                                 info->freeslots = info->maxplayers - info->numplayers;
2233
2234                                 NetConn_ClientParsePacket_ServerList_UpdateCache(n);
2235
2236                                 return true;
2237                         }
2238                         if (!strncmp(string, "getserversResponse\\", 19) && serverlist_cachecount < SERVERLIST_TOTALSIZE)
2239                         {
2240                                 // Extract the IP addresses
2241                                 data += 18;
2242                                 length -= 18;
2243                                 NetConn_ClientParsePacket_ServerList_ParseDPList(peeraddress, addressstring2, data, length, false);
2244                                 return true;
2245                         }
2246                         if (!strncmp(string, "getserversExtResponse", 21) && serverlist_cachecount < SERVERLIST_TOTALSIZE)
2247                         {
2248                                 // Extract the IP addresses
2249                                 data += 21;
2250                                 length -= 21;
2251                                 NetConn_ClientParsePacket_ServerList_ParseDPList(peeraddress, addressstring2, data, length, true);
2252                                 return true;
2253                         }
2254                         if (!memcmp(string, "d\n", 2) && serverlist_cachecount < SERVERLIST_TOTALSIZE)
2255                         {
2256                                 // Extract the IP addresses
2257                                 data += 2;
2258                                 length -= 2;
2259                                 NetConn_ClientParsePacket_ServerList_ParseQWList(peeraddress, addressstring2, data, length);
2260                                 return true;
2261                         }
2262                 }
2263 #endif
2264                 if (!strncmp(string, "extResponse ", 12))
2265                 {
2266                         ++cl_net_extresponse_count;
2267                         if(cl_net_extresponse_count > NET_EXTRESPONSE_MAX)
2268                                 cl_net_extresponse_count = NET_EXTRESPONSE_MAX;
2269                         cl_net_extresponse_last = (cl_net_extresponse_last + 1) % NET_EXTRESPONSE_MAX;
2270                         dpsnprintf(cl_net_extresponse[cl_net_extresponse_last], sizeof(cl_net_extresponse[cl_net_extresponse_last]), "\"%s\" %s", addressstring2, string + 12);
2271                         return true;
2272                 }
2273                 if (!strncmp(string, "ping", 4))
2274                 {
2275                         if (developer_extra.integer)
2276                                 Con_DPrintf("Received ping from %s, sending ack\n", addressstring2);
2277                         NetConn_WriteString(mysocket, "\377\377\377\377ack", peeraddress);
2278                         return true;
2279                 }
2280                 if (!strncmp(string, "ack", 3))
2281                         return true;
2282                 // QuakeWorld compatibility
2283                 if (length > 1 && string[0] == 'c' && (string[1] == '-' || (string[1] >= '0' && string[1] <= '9')) && cls.connect_trying)
2284                 {
2285                         // challenge message
2286                         if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
2287                                 Con_Printf(CON_WARN "ignoring c message from wrong server %s\n", addressstring2);
2288                                 return true;
2289                         }
2290                         Con_DPrintf("challenge %s received, sending QuakeWorld connect request back to %s\n", string + 1, addressstring2);
2291                         dp_strlcpy(cl_connect_status, "Connect: replying to challenge...", sizeof(cl_connect_status));
2292
2293                         cls.qw_qport = qport.integer;
2294                         // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
2295                         InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
2296                         memcpy(senddata, "\377\377\377\377", 4);
2297                         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);
2298                         NetConn_WriteString(mysocket, senddata, peeraddress);
2299                         return true;
2300                 }
2301                 if (length >= 1 && string[0] == 'j' && cls.connect_trying)
2302                 {
2303                         // accept message
2304                         if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
2305                                 Con_Printf(CON_WARN "ignoring j message from wrong server %s\n", addressstring2);
2306                                 return true;
2307                         }
2308                         NetConn_ConnectionEstablished(mysocket, peeraddress, PROTOCOL_QUAKEWORLD);
2309                         return true;
2310                 }
2311                 if (length > 2 && !memcmp(string, "n\\", 2))
2312                 {
2313 #ifdef CONFIG_MENU
2314                         serverlist_info_t *info;
2315                         int n;
2316                         const char *s;
2317
2318                         // qw server status
2319                         if (serverlist_consoleoutput && developer_networking.integer >= 2)
2320                                 Con_Printf("QW server status from server at %s:\n%s\n", addressstring2, string + 1);
2321
2322                         string += 1;
2323                         // search the cache for this server and update it
2324                         n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2, NULL);
2325                         if (n < 0)
2326                                 return true;
2327
2328                         info = &serverlist_cache[n].info;
2329                         dp_strlcpy(info->game, "QuakeWorld", sizeof(info->game));
2330                         info->mod_len  = InfoString_GetValue(string, "*gamedir", info->mod, sizeof(info->mod));
2331                         info->map_len  = InfoString_GetValue(string, "map"     , info->map, sizeof(info->map));
2332                         info->name_len = InfoString_GetValue(string, "hostname", info->name, sizeof(info->name));
2333                         info->protocol = 0;
2334                         info->numplayers = 0; // updated below
2335                         info->numhumans = 0; // updated below
2336                         info->maxplayers  = InfoString_GetValue(string, "maxclients" , infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
2337                         info->gameversion = InfoString_GetValue(string, "gameversion", infostringvalue, sizeof(infostringvalue)) ? atoi(infostringvalue) : 0;
2338
2339                         // count active players on server
2340                         // (we could gather more info, but we're just after the number)
2341                         s = strchr(string, '\n');
2342                         if (s)
2343                         {
2344                                 s++;
2345                                 while (s < string + length)
2346                                 {
2347                                         for (;s < string + length && *s != '\n';s++)
2348                                                 ;
2349                                         if (s >= string + length)
2350                                                 break;
2351                                         info->numplayers++;
2352                                         info->numhumans++;
2353                                         s++;
2354                                 }
2355                         }
2356
2357                         NetConn_ClientParsePacket_ServerList_UpdateCache(n);
2358 #endif
2359                         return true;
2360                 }
2361                 if (string[0] == 'n')
2362                 {
2363                         // qw print command, used by rcon replies too
2364                         if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address) && LHNETADDRESS_Compare(peeraddress, &cls.rcon_address)) {
2365                                 Con_Printf(CON_WARN "ignoring n message from wrong server %s\n", addressstring2);
2366                                 return true;
2367                         }
2368                         Con_Printf("QW print command from server at %s:\n%s\n", addressstring2, string + 1);
2369                 }
2370                 // we may not have liked the packet, but it was a command packet, so
2371                 // we're done processing this packet now
2372                 return true;
2373         }
2374         // quakeworld ingame packet
2375         if (fromserver && cls.protocol == PROTOCOL_QUAKEWORLD && length >= 8 && (ret = NetConn_ReceivedMessage(cls.netcon, data, length, cls.protocol, net_messagetimeout.value)) == 2)
2376         {
2377                 ret = 0;
2378                 CL_ParseServerMessage();
2379                 return ret;
2380         }
2381         // netquake control packets, supported for compatibility only
2382         if (length >= 5 && BuffBigLong(data) == ((int)NETFLAG_CTL | length) && !ENCRYPTION_REQUIRED)
2383         {
2384 #ifdef CONFIG_MENU
2385                 int n;
2386                 serverlist_info_t *info;
2387 #endif
2388
2389                 data += 4;
2390                 length -= 4;
2391                 SZ_Clear(&cl_message);
2392                 SZ_Write(&cl_message, data, length);
2393                 MSG_BeginReading(&cl_message);
2394                 c = MSG_ReadByte(&cl_message);
2395                 switch (c)
2396                 {
2397                 case CCREP_ACCEPT:
2398                         if (developer_extra.integer)
2399                                 Con_DPrintf("Datagram_ParseConnectionless: received CCREP_ACCEPT from %s.\n", addressstring2);
2400                         if (cls.connect_trying)
2401                         {
2402                                 lhnetaddress_t clientportaddress;
2403                                 if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address)) {
2404                                         Con_Printf(CON_WARN "ignoring CCREP_ACCEPT message from wrong server %s\n", addressstring2);
2405                                         break;
2406                                 }
2407                                 clientportaddress = *peeraddress;
2408                                 LHNETADDRESS_SetPort(&clientportaddress, MSG_ReadLong(&cl_message));
2409                                 // extra ProQuake stuff
2410                                 if (length >= 6)
2411                                         cls.proquake_servermod = MSG_ReadByte(&cl_message); // MOD_PROQUAKE
2412                                 else
2413                                         cls.proquake_servermod = 0;
2414                                 if (length >= 7)
2415                                         cls.proquake_serverversion = MSG_ReadByte(&cl_message); // version * 10
2416                                 else
2417                                         cls.proquake_serverversion = 0;
2418                                 if (length >= 8)
2419                                         cls.proquake_serverflags = MSG_ReadByte(&cl_message); // flags (mainly PQF_CHEATFREE)
2420                                 else
2421                                         cls.proquake_serverflags = 0;
2422                                 if (cls.proquake_servermod == 1)
2423                                         Con_Printf("Connected to ProQuake %.1f server, enabling precise aim\n", cls.proquake_serverversion / 10.0f);
2424                                 // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
2425                                 InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
2426                                 NetConn_ConnectionEstablished(mysocket, &clientportaddress, PROTOCOL_QUAKE);
2427                         }
2428                         break;
2429                 case CCREP_REJECT:
2430                         if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.connect_address))
2431                         {
2432                                 Con_Printf(CON_WARN "ignoring CCREP_REJECT message from wrong server %s\n", addressstring2);
2433                                 break;
2434                         }
2435                         cls.connect_trying = false;
2436                         dpsnprintf(cl_connect_status, sizeof(cl_connect_status), "Connect: rejected, %s", MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
2437                         Con_Printf(CON_ERROR "Connect: rejected by %s\n%s\n", addressstring2, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
2438                         break;
2439                 case CCREP_SERVER_INFO:
2440                         if (developer_extra.integer)
2441                                 Con_DPrintf("Datagram_ParseConnectionless: received CCREP_SERVER_INFO from %s.\n", addressstring2);
2442 #ifdef CONFIG_MENU
2443                         // LadyHavoc: because the quake server may report weird addresses
2444                         // we just ignore it and keep the real address
2445                         MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
2446                         // search the cache for this server and update it
2447                         n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2, NULL);
2448                         if (n < 0)
2449                                 break;
2450
2451                         info = &serverlist_cache[n].info;
2452                         info->game_len = dp_strlcpy(info->game, "Quake", sizeof(info->game));
2453                         info->mod_len  = dp_strlcpy(info->mod, "", sizeof(info->mod)); // mod name is not specified
2454                         info->name_len = dp_strlcpy(info->name, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(info->name));
2455                         info->map_len  = dp_strlcpy(info->map, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(info->map));
2456                         info->numplayers = MSG_ReadByte(&cl_message);
2457                         info->maxplayers = MSG_ReadByte(&cl_message);
2458                         info->protocol = MSG_ReadByte(&cl_message);
2459
2460                         NetConn_ClientParsePacket_ServerList_UpdateCache(n);
2461 #endif
2462                         break;
2463                 case CCREP_RCON: // RocketGuy: ProQuake rcon support
2464                         if (net_sourceaddresscheck.integer && LHNETADDRESS_Compare(peeraddress, &cls.rcon_address)) {
2465                                 Con_Printf(CON_WARN "ignoring CCREP_RCON message from wrong server %s\n", addressstring2);
2466                                 break;
2467                         }
2468                         if (developer_extra.integer)
2469                                 Con_DPrintf("Datagram_ParseConnectionless: received CCREP_RCON from %s.\n", addressstring2);
2470
2471                         Con_Printf("%s\n", MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
2472                         break;
2473                 case CCREP_PLAYER_INFO:
2474                         // we got a CCREP_PLAYER_INFO??
2475                         //if (developer_extra.integer)
2476                                 Con_Printf("Datagram_ParseConnectionless: received CCREP_PLAYER_INFO from %s.\n", addressstring2);
2477                         break;
2478                 case CCREP_RULE_INFO:
2479                         // we got a CCREP_RULE_INFO??
2480                         //if (developer_extra.integer)
2481                                 Con_Printf("Datagram_ParseConnectionless: received CCREP_RULE_INFO from %s.\n", addressstring2);
2482                         break;
2483                 default:
2484                         break;
2485                 }
2486                 SZ_Clear(&cl_message);
2487                 // we may not have liked the packet, but it was a valid control
2488                 // packet, so we're done processing this packet now
2489                 return true;
2490         }
2491         ret = 0;
2492         if (fromserver && length >= (int)NET_HEADERSIZE && (ret = NetConn_ReceivedMessage(cls.netcon, data, length, cls.protocol, net_messagetimeout.value)) == 2)
2493                 CL_ParseServerMessage();
2494         return ret;
2495 }
2496
2497 #ifdef CONFIG_MENU
2498 void NetConn_QueryQueueFrame(void)
2499 {
2500         unsigned index;
2501         unsigned maxqueries;
2502         char dpquery[53]; // theoretical max: 14+22+16+1
2503         double currentrealtime;
2504         static double querycounter = 0;
2505         static unsigned pass = 0, server = 0;
2506         unsigned queriesperserver = bound(1, net_slist_maxtries.integer, 8);
2507
2508         if (!serverlist_querystage)
2509                 return;
2510
2511         // If the client stalls partway through a frame (test command: `alias a a;a`)
2512         // for correct pings we need to know what host.realtime would be if it were updated now.
2513         currentrealtime = host.realtime + (Sys_DirtyTime() - host.dirtytime);
2514
2515         // apply a cool down time after master server replies,
2516         // to avoid messing up the ping times on the servers
2517         if (serverlist_querystage < SLIST_QUERYSTAGE_SERVERS)
2518         {
2519                 if (currentrealtime < masterquerytime + net_slist_timeout.value)
2520                         return;
2521
2522                 // Report the masters that timed out or whose response was incomplete.
2523                 for (index = 0; index < DPMASTER_COUNT; ++index)
2524                         if (dpmasterstatus[index] && dpmasterstatus[index] < MASTER_RX_COMPLETE)
2525                                 Con_Printf(CON_WARN "WARNING: dpmaster %s %s\n", sv_masters[index].string, dpmasterstatus[index] == MASTER_TX_QUERY ? "timed out" : "response incomplete");
2526                 for (index = 0; index < QWMASTER_COUNT; ++index)
2527                         if (qwmasterstatus[index] && qwmasterstatus[index] < MASTER_RX_RESPONSE) // no EOT marker in QW lists
2528                                 Con_Printf(CON_WARN "WARNING: qwmaster %s timed out\n", sv_qwmasters[index].string);
2529
2530                 serverlist_querystage = SLIST_QUERYSTAGE_SERVERS;
2531         }
2532
2533         // each time querycounter reaches 1.0 issue a query
2534         querycounter += cl.realframetime * net_slist_queriespersecond.value;
2535         maxqueries = bound(0, (int)querycounter, net_slist_queriesperframe.integer);
2536         querycounter -= maxqueries;
2537         if (maxqueries == 0)
2538                 return;
2539
2540         if (pass < queriesperserver)
2541         {
2542                 // QW depends on waiting "long enough" between queries that responses "definitely" refer to the most recent querytime
2543                 // DP servers can echo back a timestamp for reliable (and more frequent, see net_slist_interval) pings
2544                 ServerList_BuildDPServerQuery(dpquery, sizeof(dpquery), currentrealtime);
2545
2546                 for (unsigned queries = 0; server < serverlist_cachecount; ++server)
2547                 {
2548                         lhnetaddress_t address;
2549                         unsigned socket;
2550                         serverlist_entry_t *entry = &serverlist_cache[server];
2551
2552                         if (queries >= maxqueries
2553                         || currentrealtime <= entry->querytime + (entry->protocol == PROTOCOL_QUAKEWORLD ? net_slist_timeout : net_slist_interval).value)
2554                                 return; // continue this pass at the current server on a later frame
2555
2556                         LHNETADDRESS_FromString(&address, entry->info.cname, 0);
2557                         if (entry->protocol == PROTOCOL_QUAKEWORLD)
2558                         {
2559                                 for (socket = 0; socket < cl_numsockets; ++socket)
2560                                         if (cl_sockets[socket])
2561                                                 NetConn_WriteString(cl_sockets[socket], "\377\377\377\377status\n", &address);
2562                         }
2563                         else
2564                         {
2565                                 for (socket = 0; socket < cl_numsockets; ++socket)
2566                                         if (cl_sockets[socket])
2567                                                 NetConn_WriteString(cl_sockets[socket], dpquery, &address);
2568                         }
2569
2570                         entry->querytime = currentrealtime;
2571                         queries++;
2572
2573                         if (serverlist_consoleoutput)
2574                                 Con_Printf("querying %25s (%i. try)\n", entry->info.cname, pass + 1);
2575                 }
2576         }
2577         else
2578         {
2579                 // check timeouts
2580                 for (; server < serverlist_cachecount; ++server)
2581                 {
2582                         serverlist_entry_t *entry = &serverlist_cache[server];
2583
2584                         if (!entry->responded // no acceptable response during this refresh cycle
2585                         && entry->info.ping) // visible in the list (has old ping from previous refresh cycle)
2586                         {
2587                                 if (currentrealtime > entry->querytime + net_slist_maxping.integer/1000)
2588                                 {
2589                                         // you have no chance to survive make your timeout
2590                                         serverreplycount--;
2591                                         if(!net_slist_pause.integer)
2592                                                 ServerList_ViewList_Remove(entry);
2593                                         entry->info.ping = 0; // removed later if net_slist_pause
2594                                 }
2595                                 else // still has time
2596                                         return; // continue this pass at the current server on a later frame
2597                         }
2598                 }
2599         }
2600
2601         // We finished the pass, ie didn't stop at maxqueries
2602         // or a server that can't be (re)queried or timed out yet.
2603         ++pass;
2604         server = 0;
2605
2606         if (pass == queriesperserver)
2607         {
2608                 // timeout pass begins next frame
2609                 if (net_slist_debug.integer)
2610                         Con_Printf("^2Finished querying masters and servers in %f\n", currentrealtime - masterquerytime);
2611         }
2612         else if (pass > queriesperserver)
2613         {
2614                 // Nothing else to do until the next refresh cycle.
2615                 if (net_slist_debug.integer)
2616                         Con_Printf("^4Finished checking server timeouts in %f\n", currentrealtime - serverlist_cache[serverlist_cachecount - 1].querytime);
2617                 serverlist_querystage = 0;
2618                 pass = 0;
2619         }
2620 }
2621 #endif
2622
2623 void NetConn_ClientFrame(void)
2624 {
2625         unsigned i;
2626         int length;
2627         lhnetaddress_t peeraddress;
2628         unsigned char readbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
2629
2630         NetConn_UpdateSockets();
2631
2632         if (cls.connect_trying && cls.connect_nextsendtime < host.realtime)
2633         {
2634                 if (cls.connect_remainingtries > 0)
2635                 {
2636                         cls.connect_remainingtries--;
2637                         dpsnprintf(cl_connect_status, sizeof(cl_connect_status), "Connect: sending initial request, %i %s left...", cls.connect_remainingtries, cls.connect_remainingtries == 1 ? "retry" : "retries");
2638                 }
2639                 else
2640                 {
2641                         char address[128];
2642
2643                         cls.connect_trying = false;
2644                         LHNETADDRESS_ToString(&cls.connect_address, address, sizeof(address), true);
2645                         dp_strlcpy(cl_connect_status, "Connect: failed, no reply", sizeof(cl_connect_status));
2646                         Con_Printf(CON_ERROR "%s from %s\n", cl_connect_status, address);
2647                         return;
2648                 }
2649                 cls.connect_nextsendtime = host.realtime + 1;
2650
2651                 // try challenge first (newer DP server or QW)
2652                 NetConn_WriteString(cls.connect_mysocket, "\377\377\377\377getchallenge", &cls.connect_address);
2653                 // then try netquake as a fallback (old server, or netquake)
2654                 SZ_Clear(&cl_message);
2655                 // save space for the header, filled in later
2656                 MSG_WriteLong(&cl_message, 0);
2657                 MSG_WriteByte(&cl_message, CCREQ_CONNECT);
2658                 MSG_WriteString(&cl_message, "QUAKE");
2659                 MSG_WriteByte(&cl_message, NET_PROTOCOL_VERSION);
2660                 // extended proquake stuff
2661                 MSG_WriteByte(&cl_message, 1); // mod = MOD_PROQUAKE
2662                 // this version matches ProQuake 3.40, the first version to support
2663                 // the NAT fix, and it only supports the NAT fix for ProQuake 3.40 or
2664                 // higher clients, so we pretend we are that version...
2665                 MSG_WriteByte(&cl_message, 34); // version * 10
2666                 MSG_WriteByte(&cl_message, 0); // flags
2667                 MSG_WriteLong(&cl_message, 0); // password
2668                 // write the packetsize now...
2669                 StoreBigLong(cl_message.data, NETFLAG_CTL | (cl_message.cursize & NETFLAG_LENGTH_MASK));
2670                 NetConn_Write(cls.connect_mysocket, cl_message.data, cl_message.cursize, &cls.connect_address);
2671                 SZ_Clear(&cl_message);
2672         }
2673
2674         for (i = 0;i < cl_numsockets;i++)
2675         {
2676                 while (cl_sockets[i] && (length = NetConn_Read(cl_sockets[i], readbuffer, sizeof(readbuffer), &peeraddress)) > 0)
2677                 {
2678 //                      R_TimeReport("clientreadnetwork");
2679                         NetConn_ClientParsePacket(cl_sockets[i], readbuffer, length, &peeraddress);
2680 //                      R_TimeReport("clientparsepacket");
2681                 }
2682         }
2683 #ifdef CONFIG_MENU
2684         NetConn_QueryQueueFrame();
2685 #endif
2686         if (cls.netcon && host.realtime > cls.netcon->timeout && !sv.active)
2687                 CL_DisconnectEx(true, "Connection timed out");
2688 }
2689
2690 static void NetConn_BuildChallengeString(char *buffer, int bufferlength)
2691 {
2692         int i;
2693         char c;
2694         for (i = 0;i < bufferlength - 1;i++)
2695         {
2696                 do
2697                 {
2698                         c = rand () % (127 - 33) + 33;
2699                 } while (c == '\\' || c == ';' || c == '"' || c == '%' || c == '/');
2700                 buffer[i] = c;
2701         }
2702         buffer[i] = 0;
2703 }
2704
2705 /// (div0) build the full response only if possible; better a getinfo response than no response at all if getstatus won't fit
2706 static qbool NetConn_BuildStatusResponse(const char* challenge, char* out_msg, size_t out_size, qbool fullstatus)
2707 {
2708         prvm_prog_t *prog = SVVM_prog;
2709         char qcstatus[256];
2710         unsigned int nb_clients = 0, nb_bots = 0, i;
2711         int length;
2712         char teambuf[3];
2713         const char *crypto_idstring;
2714         const char *worldstatusstr;
2715
2716         // How many clients are there?
2717         for (i = 0;i < (unsigned int)svs.maxclients;i++)
2718         {
2719                 if (svs.clients[i].active)
2720                 {
2721                         nb_clients++;
2722                         if (!svs.clients[i].netconnection)
2723                                 nb_bots++;
2724                 }
2725         }
2726
2727         *qcstatus = 0;
2728         worldstatusstr = PRVM_GetString(prog, PRVM_serverglobalstring(worldstatus));
2729         if(worldstatusstr && *worldstatusstr)
2730         {
2731                 char *p;
2732                 const char *q;
2733                 p = qcstatus;
2734                 for(q = worldstatusstr; *q && (size_t)(p - qcstatus) < (sizeof(qcstatus) - 1); ++q)
2735                         if(*q != '\\' && *q != '\n')
2736                                 *p++ = *q;
2737                 *p = 0;
2738         }
2739
2740         /// \TODO: we should add more information for the full status string
2741         crypto_idstring = Crypto_GetInfoResponseDataString();
2742         length = dpsnprintf(out_msg, out_size,
2743                                                 "\377\377\377\377%s\x0A"
2744                                                 "\\gamename\\%s\\modname\\%s\\gameversion\\%d\\sv_maxclients\\%d"
2745                                                 "\\clients\\%d\\bots\\%d\\mapname\\%s\\hostname\\%s\\protocol\\%d"
2746                                                 "%s%s"
2747                                                 "%s%s"
2748                                                 "%s%s"
2749                                                 "%s",
2750                                                 fullstatus ? "statusResponse" : "infoResponse",
2751                                                 gamenetworkfiltername, com_modname, gameversion.integer, svs.maxclients,
2752                                                 nb_clients, nb_bots, sv.worldbasename, hostname.string, NET_PROTOCOL_VERSION,
2753                                                 *qcstatus ? "\\qcstatus\\" : "", qcstatus,
2754                                                 challenge ? "\\challenge\\" : "", challenge ? challenge : "",
2755                                                 crypto_idstring ? "\\d0_blind_id\\" : "", crypto_idstring ? crypto_idstring : "",
2756                                                 fullstatus ? "\n" : "");
2757
2758         // Make sure it fits in the buffer
2759         if (length < 0)
2760                 goto bad;
2761
2762         if (fullstatus)
2763         {
2764                 char *ptr;
2765                 int left;
2766                 int savelength;
2767
2768                 savelength = length;
2769
2770                 ptr = out_msg + length;
2771                 left = (int)out_size - length;
2772
2773                 for (i = 0;i < (unsigned int)svs.maxclients;i++)
2774                 {
2775                         client_t *client = &svs.clients[i];
2776                         if (client->active)
2777                         {
2778                                 int nameind, cleanind, pingvalue;
2779                                 char curchar;
2780                                 char cleanname [sizeof(client->name)];
2781                                 const char *statusstr;
2782                                 prvm_edict_t *ed;
2783
2784                                 // Remove all characters '"' and '\' in the player name
2785                                 nameind = 0;
2786                                 cleanind = 0;
2787                                 do
2788                                 {
2789                                         curchar = client->name[nameind++];
2790                                         if (curchar != '"' && curchar != '\\')
2791                                         {
2792                                                 cleanname[cleanind++] = curchar;
2793                                                 if (cleanind == sizeof(cleanname) - 1)
2794                                                         break;
2795                                         }
2796                                 } while (curchar != '\0');
2797                                 cleanname[cleanind] = 0; // cleanind is always a valid index even at this point
2798
2799                                 pingvalue = (int)(client->ping * 1000.0f);
2800                                 if(client->netconnection)
2801                                         pingvalue = bound(1, pingvalue, 9999);
2802                                 else
2803                                         pingvalue = 0;
2804
2805                                 *qcstatus = 0;
2806                                 ed = PRVM_EDICT_NUM(i + 1);
2807                                 statusstr = PRVM_GetString(prog, PRVM_serveredictstring(ed, clientstatus));
2808                                 if(statusstr && *statusstr)
2809                                 {
2810                                         char *p;
2811                                         const char *q;
2812                                         p = qcstatus;
2813                                         for(q = statusstr; *q && p != qcstatus + sizeof(qcstatus) - 1; ++q)
2814                                                 if(*q != '\\' && *q != '"' && !ISWHITESPACE(*q))
2815                                                         *p++ = *q;
2816                                         *p = 0;
2817                                 }
2818
2819                                 if (IS_NEXUIZ_DERIVED(gamemode) && (teamplay.integer > 0))
2820                                 {
2821                                         if(client->frags == -666) // spectator
2822                                                 dp_strlcpy(teambuf, " 0", sizeof(teambuf));
2823                                         else if(client->colors == 0x44) // red team
2824                                                 dp_strlcpy(teambuf, " 1", sizeof(teambuf));
2825                                         else if(client->colors == 0xDD) // blue team
2826                                                 dp_strlcpy(teambuf, " 2", sizeof(teambuf));
2827                                         else if(client->colors == 0xCC) // yellow team
2828                                                 dp_strlcpy(teambuf, " 3", sizeof(teambuf));
2829                                         else if(client->colors == 0x99) // pink team
2830                                                 dp_strlcpy(teambuf, " 4", sizeof(teambuf));
2831                                         else
2832                                                 dp_strlcpy(teambuf, " 0", sizeof(teambuf));
2833                                 }
2834                                 else
2835                                         *teambuf = 0;
2836
2837                                 // note: team number is inserted according to SoF2 protocol
2838                                 if(*qcstatus)
2839                                         length = dpsnprintf(ptr, left, "%s %d%s \"%s\"\n",
2840                                                                                 qcstatus,
2841                                                                                 pingvalue,
2842                                                                                 teambuf,
2843                                                                                 cleanname);
2844                                 else
2845                                         length = dpsnprintf(ptr, left, "%d %d%s \"%s\"\n",
2846                                                                                 client->frags,
2847                                                                                 pingvalue,
2848                                                                                 teambuf,
2849                                                                                 cleanname);
2850
2851                                 if(length < 0)
2852                                 {
2853                                         // out of space?
2854                                         // turn it into an infoResponse!
2855                                         out_msg[savelength] = 0;
2856                                         memcpy(out_msg + 4, "infoResponse\x0A", 13);
2857                                         memmove(out_msg + 17, out_msg + 19, savelength - 19);
2858                                         break;
2859                                 }
2860                                 left -= length;
2861                                 ptr += length;
2862                         }
2863                 }
2864         }
2865
2866         return true;
2867
2868 bad:
2869         return false;
2870 }
2871
2872 static qbool NetConn_PreventFlood(lhnetaddress_t *peeraddress, server_floodaddress_t *floodlist, size_t floodlength, double floodtime, qbool renew)
2873 {
2874         size_t floodslotnum, bestfloodslotnum;
2875         double bestfloodtime;
2876         lhnetaddress_t noportpeeraddress;
2877         // see if this is a connect flood
2878         noportpeeraddress = *peeraddress;
2879         LHNETADDRESS_SetPort(&noportpeeraddress, 0);
2880         bestfloodslotnum = 0;
2881         bestfloodtime = floodlist[bestfloodslotnum].lasttime;
2882         for (floodslotnum = 0;floodslotnum < floodlength;floodslotnum++)
2883         {
2884                 if (bestfloodtime >= floodlist[floodslotnum].lasttime)
2885                 {
2886                         bestfloodtime = floodlist[floodslotnum].lasttime;
2887                         bestfloodslotnum = floodslotnum;
2888                 }
2889                 if (floodlist[floodslotnum].lasttime && LHNETADDRESS_Compare(&noportpeeraddress, &floodlist[floodslotnum].address) == 0)
2890                 {
2891                         // this address matches an ongoing flood address
2892                         if (host.realtime < floodlist[floodslotnum].lasttime + floodtime)
2893                         {
2894                                 if(renew)
2895                                 {
2896                                         // renew the ban on this address so it does not expire
2897                                         // until the flood has subsided
2898                                         floodlist[floodslotnum].lasttime = host.realtime;
2899                                 }
2900                                 //Con_Printf("Flood detected!\n");
2901                                 return true;
2902                         }
2903                         // the flood appears to have subsided, so allow this
2904                         bestfloodslotnum = floodslotnum; // reuse the same slot
2905                         break;
2906                 }
2907         }
2908         // begin a new timeout on this address
2909         floodlist[bestfloodslotnum].address = noportpeeraddress;
2910         floodlist[bestfloodslotnum].lasttime = host.realtime;
2911         //Con_Printf("Flood detection initiated!\n");
2912         return false;
2913 }
2914
2915 void NetConn_ClearFlood(lhnetaddress_t *peeraddress, server_floodaddress_t *floodlist, size_t floodlength)
2916 {
2917         size_t floodslotnum;
2918         lhnetaddress_t noportpeeraddress;
2919         // see if this is a connect flood
2920         noportpeeraddress = *peeraddress;
2921         LHNETADDRESS_SetPort(&noportpeeraddress, 0);
2922         for (floodslotnum = 0;floodslotnum < floodlength;floodslotnum++)
2923         {
2924                 if (floodlist[floodslotnum].lasttime && LHNETADDRESS_Compare(&noportpeeraddress, &floodlist[floodslotnum].address) == 0)
2925                 {
2926                         // this address matches an ongoing flood address
2927                         // remove the ban
2928                         floodlist[floodslotnum].address.addresstype = LHNETADDRESSTYPE_NONE;
2929                         floodlist[floodslotnum].lasttime = 0;
2930                         //Con_Printf("Flood cleared!\n");
2931                 }
2932         }
2933 }
2934
2935 typedef qbool (*rcon_matchfunc_t) (lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen);
2936
2937 static qbool hmac_mdfour_time_matching(lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
2938 {
2939         char mdfourbuf[16];
2940         long t1, t2;
2941
2942         if (!password[0]) {
2943                 Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
2944                 return false;
2945         }
2946
2947         t1 = (long) time(NULL);
2948         t2 = strtol(s, NULL, 0);
2949         if(labs(t1 - t2) > rcon_secure_maxdiff.integer)
2950                 return false;
2951
2952         if(!HMAC_MDFOUR_16BYTES((unsigned char *) mdfourbuf, (unsigned char *) s, slen, (unsigned char *) password, (int)strlen(password)))
2953                 return false;
2954
2955         return !memcmp(mdfourbuf, hash, 16);
2956 }
2957
2958 static qbool hmac_mdfour_challenge_matching(lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
2959 {
2960         char mdfourbuf[16];
2961         int i;
2962
2963         if (!password[0]) {
2964                 Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
2965                 return false;
2966         }
2967
2968         if(slen < (int)(sizeof(challenges[0].string)) - 1)
2969                 return false;
2970
2971         // validate the challenge
2972         for (i = 0;i < MAX_CHALLENGES;i++)
2973                 if(challenges[i].time > 0)
2974                         if (!LHNETADDRESS_Compare(peeraddress, &challenges[i].address) && !strncmp(challenges[i].string, s, sizeof(challenges[0].string) - 1))
2975                                 break;
2976         // if the challenge is not recognized, drop the packet
2977         if (i == MAX_CHALLENGES)
2978                 return false;
2979
2980         if(!HMAC_MDFOUR_16BYTES((unsigned char *) mdfourbuf, (unsigned char *) s, slen, (unsigned char *) password, (int)strlen(password)))
2981                 return false;
2982
2983         if(memcmp(mdfourbuf, hash, 16))
2984                 return false;
2985
2986         // unmark challenge to prevent replay attacks
2987         challenges[i].time = 0;
2988
2989         return true;
2990 }
2991
2992 static qbool plaintext_matching(lhnetaddress_t *peeraddress, const char *password, const char *hash, const char *s, int slen)
2993 {
2994         if (!password[0]) {
2995                 Con_Print(CON_ERROR "LOGIC ERROR: RCon_Authenticate should never call the comparator with an empty password. Please report.\n");
2996                 return false;
2997         }
2998
2999         return !strcmp(password, hash);
3000 }
3001
3002 /// returns a string describing the user level, or NULL for auth failure
3003 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)
3004 {
3005         const char *text, *userpass_start, *userpass_end, *userpass_startpass;
3006         static char buf[MAX_INPUTLINE];
3007         qbool hasquotes;
3008         qbool restricted = false;
3009         qbool have_usernames = false;
3010         static char vabuf[1024];
3011
3012         userpass_start = rcon_password.string;
3013         while((userpass_end = strchr(userpass_start, ' ')))
3014         {
3015                 have_usernames = true;
3016                 dp_ustr2stp(buf, sizeof(buf), userpass_start, userpass_end - userpass_start);
3017                 if(buf[0])  // Ignore empty entries due to leading/duplicate space.
3018                         if(comparator(peeraddress, buf, password, cs, cslen))
3019                                 goto allow;
3020                 userpass_start = userpass_end + 1;
3021         }
3022         if(userpass_start[0])  // Ignore empty trailing entry due to trailing space or password not set.
3023         {
3024                 userpass_end = userpass_start + strlen(userpass_start);
3025                 if(comparator(peeraddress, userpass_start, password, cs, cslen))
3026                         goto allow;
3027         }
3028
3029         restricted = true;
3030         have_usernames = false;
3031         userpass_start = rcon_restricted_password.string;
3032         while((userpass_end = strchr(userpass_start, ' ')))
3033         {
3034                 have_usernames = true;
3035                 dp_ustr2stp(buf, sizeof(buf), userpass_start, userpass_end - userpass_start);
3036                 if(buf[0])  // Ignore empty entries due to leading/duplicate space.
3037                         if(comparator(peeraddress, buf, password, cs, cslen))
3038                                 goto check;
3039                 userpass_start = userpass_end + 1;
3040         }
3041         if(userpass_start[0])  // Ignore empty trailing entry due to trailing space or password not set.
3042         {
3043                 userpass_end = userpass_start + strlen(userpass_start);
3044                 if(comparator(peeraddress, userpass_start, password, cs, cslen))
3045                         goto check;
3046         }
3047
3048         return NULL; // DENIED
3049
3050 check:
3051         for(text = s; text != endpos; ++text)
3052                 if((signed char) *text > 0 && ((signed char) *text < (signed char) ' ' || *text == ';'))
3053                         return NULL; // block possible exploits against the parser/alias expansion
3054
3055         while(s != endpos)
3056         {
3057                 size_t l = strlen(s);
3058                 if(l)
3059                 {
3060                         hasquotes = (strchr(s, '"') != NULL);
3061                         // sorry, we can't allow these substrings in wildcard expressions,
3062                         // as they can mess with the argument counts
3063                         text = rcon_restricted_commands.string;
3064                         while(COM_ParseToken_Console(&text))
3065                         {
3066                                 // com_token now contains a pattern to check for...
3067                                 if(strchr(com_token, '*') || strchr(com_token, '?')) // wildcard expression, * can only match a SINGLE argument
3068                                 {
3069                                         if(!hasquotes)
3070                                                 if(matchpattern_with_separator(s, com_token, true, " ", true)) // note how we excluded tab, newline etc. above
3071                                                         goto match;
3072                                 }
3073                                 else if(strchr(com_token, ' ')) // multi-arg expression? must match in whole
3074                                 {
3075                                         if(!strcmp(com_token, s))
3076                                                 goto match;
3077                                 }
3078                                 else // single-arg expression? must match the beginning of the command
3079                                 {
3080                                         if(!strcmp(com_token, s))
3081                                                 goto match;
3082                                         if(!memcmp(va(vabuf, sizeof(vabuf), "%s ", com_token), s, strlen(com_token) + 1))
3083                                                 goto match;
3084                                 }
3085                         }
3086                         // if we got here, nothing matched!
3087                         return NULL;
3088                 }
3089 match:
3090                 s += l + 1;
3091         }
3092
3093 allow:
3094         userpass_startpass = strchr(userpass_start, ':');
3095         if(have_usernames && userpass_startpass && userpass_startpass < userpass_end)
3096                 return va(vabuf, sizeof(vabuf), "%srcon (username %.*s)", restricted ? "restricted " : "", (int)(userpass_startpass-userpass_start), userpass_start);
3097
3098         return va(vabuf, sizeof(vabuf), "%srcon", restricted ? "restricted " : "");
3099 }
3100
3101 static void RCon_Execute(lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress, const char *addressstring2, const char *userlevel, const char *s, const char *endpos, qbool proquakeprotocol)
3102 {
3103         if(userlevel)
3104         {
3105                 // looks like a legitimate rcon command with the correct password
3106                 const char *s_ptr = s;
3107                 Con_Printf("server received %s command from %s: ", userlevel, host_client ? host_client->name : addressstring2);
3108                 while(s_ptr != endpos)
3109                 {
3110                         size_t l = strlen(s_ptr);
3111                         if(l)
3112                                 Con_Printf(" %s;", s_ptr);
3113                         s_ptr += l + 1;
3114                 }
3115                 Con_Printf("\n");
3116
3117                 if (!host_client || !host_client->netconnection || LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
3118                         Con_Rcon_Redirect_Init(mysocket, peeraddress, proquakeprotocol);
3119                 while(s != endpos)
3120                 {
3121                         size_t l = strlen(s);
3122                         if(l)
3123                         {
3124                                 client_t *host_client_save = host_client;
3125                                 Cmd_PreprocessAndExecuteString(cmd_local, s, l, src_local, true);
3126                                 host_client = host_client_save;
3127                                 // in case it is a command that changes host_client (like restart)
3128                         }
3129                         s += l + 1;
3130                 }
3131                 Con_Rcon_Redirect_End();
3132         }
3133         else
3134         {
3135                 if (!host_client || !host_client->netconnection || LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
3136                         Con_Rcon_Redirect_Init(mysocket, peeraddress, proquakeprotocol);
3137                 Con_Printf(CON_ERROR "server denied rcon access to %s\n", host_client ? host_client->name : addressstring2);
3138                 Con_Rcon_Redirect_End();
3139         }
3140 }
3141
3142 static int NetConn_ServerParsePacket(lhnetsocket_t *mysocket, unsigned char *data, int length, lhnetaddress_t *peeraddress)
3143 {
3144         int i, ret, clientnum, best;
3145         double besttime;
3146         char *string, response[2800], addressstring2[128];
3147         static char stringbuf[16384]; // server only
3148         qbool islocal = (LHNETADDRESS_GetAddressType(peeraddress) == LHNETADDRESSTYPE_LOOP);
3149         char senddata[NET_HEADERSIZE+NET_MAXMESSAGE+CRYPTO_HEADERSIZE];
3150         size_t sendlength, response_len;
3151         char infostringvalue[MAX_INPUTLINE];
3152
3153         if (!sv.active)
3154                 return false;
3155
3156         // convert the address to a string incase we need it
3157         LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
3158
3159         // see if we can identify the sender as a local player
3160         // (this is necessary for rcon to send a reliable reply if the client is
3161         //  actually on the server, not sending remotely)
3162         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
3163                 if (host_client->netconnection && host_client->netconnection->mysocket == mysocket && !LHNETADDRESS_Compare(&host_client->netconnection->peeraddress, peeraddress))
3164                         break;
3165         if (i == svs.maxclients)
3166                 host_client = NULL;
3167
3168         if (length >= 5 && data[0] == 255 && data[1] == 255 && data[2] == 255 && data[3] == 255)
3169         {
3170                 // received a command string - strip off the packaging and put it
3171                 // into our string buffer with NULL termination
3172                 data += 4;
3173                 length -= 4;
3174                 length = min(length, (int)sizeof(stringbuf) - 1);
3175                 memcpy(stringbuf, data, length);
3176                 stringbuf[length] = 0;
3177                 string = stringbuf;
3178
3179                 if (developer_extra.integer)
3180                 {
3181                         Con_Printf("NetConn_ServerParsePacket: %s sent us a command:\n", addressstring2);
3182                         Com_HexDumpToConsole(data, length);
3183                 }
3184
3185                 sendlength = sizeof(senddata) - 4;
3186                 switch(Crypto_ServerParsePacket(string, length, senddata+4, &sendlength, peeraddress))
3187                 {
3188                         case CRYPTO_NOMATCH:
3189                                 // nothing to do
3190                                 break;
3191                         case CRYPTO_MATCH:
3192                                 if(sendlength)
3193                                 {
3194                                         memcpy(senddata, "\377\377\377\377", 4);
3195                                         NetConn_Write(mysocket, senddata, (int)sendlength+4, peeraddress);
3196                                 }
3197                                 break;
3198                         case CRYPTO_DISCARD:
3199                                 if(sendlength)
3200                                 {
3201                                         memcpy(senddata, "\377\377\377\377", 4);
3202                                         NetConn_Write(mysocket, senddata, (int)sendlength+4, peeraddress);
3203                                 }
3204                                 return true;
3205                                 break;
3206                         case CRYPTO_REPLACE:
3207                                 string = senddata+4;
3208                                 length = (int)sendlength;
3209                                 break;
3210                 }
3211
3212                 if (length >= 12 && !memcmp(string, "getchallenge", 12) && (islocal || sv_public.integer > -3))
3213                 {
3214                         for (i = 0, best = 0, besttime = host.realtime;i < MAX_CHALLENGES;i++)
3215                         {
3216                                 if(challenges[i].time > 0)
3217                                         if (!LHNETADDRESS_Compare(peeraddress, &challenges[i].address))
3218                                                 break;
3219                                 if (besttime > challenges[i].time)
3220                                         besttime = challenges[best = i].time;
3221                         }
3222                         // if we did not find an exact match, choose the oldest and
3223                         // update address and string
3224                         if (i == MAX_CHALLENGES)
3225                         {
3226                                 i = best;
3227                                 challenges[i].address = *peeraddress;
3228                                 NetConn_BuildChallengeString(challenges[i].string, sizeof(challenges[i].string));
3229                         }
3230                         else
3231                         {
3232                                 // flood control: drop if requesting challenge too often
3233                                 if(challenges[i].time > host.realtime - net_challengefloodblockingtimeout.value)
3234                                         return true;
3235                         }
3236                         challenges[i].time = host.realtime;
3237                         // send the challenge
3238                         memcpy(response, "\377\377\377\377", 4);
3239                         dpsnprintf(response+4, sizeof(response)-4, "challenge %s", challenges[i].string);
3240                         response_len = strlen(response) + 1;
3241                         Crypto_ServerAppendToChallenge(string, length, response, &response_len, sizeof(response));
3242                         NetConn_Write(mysocket, response, (int)response_len, peeraddress);
3243                         return true;
3244                 }
3245                 if (length > 8 && !memcmp(string, "connect\\", 8))
3246                 {
3247                         client_t *client;
3248                         crypto_t *crypto = Crypto_ServerGetInstance(peeraddress);
3249                         string += 7;
3250                         length -= 7;
3251
3252                         if(crypto && crypto->authenticated)
3253                         {
3254                                 // no need to check challenge
3255                                 if(crypto_developer.integer)
3256                                 {
3257                                         Con_Printf("%s connection to %s is being established: client is %s@%s%.*s, I am %.*s@%s%.*s\n",
3258                                                         crypto->use_aes ? "Encrypted" : "Authenticated",
3259                                                         addressstring2,
3260                                                         crypto->client_idfp[0] ? crypto->client_idfp : "-",
3261                                                         (crypto->client_issigned || !crypto->client_keyfp[0]) ? "" : "~",
3262                                                         crypto_keyfp_recommended_length, crypto->client_keyfp[0] ? crypto->client_keyfp : "-",
3263                                                         crypto_keyfp_recommended_length, crypto->server_idfp[0] ? crypto->server_idfp : "-",
3264                                                         (crypto->server_issigned || !crypto->server_keyfp[0]) ? "" : "~",
3265                                                         crypto_keyfp_recommended_length, crypto->server_keyfp[0] ? crypto->server_keyfp : "-"
3266                                                   );
3267                                 }
3268                         }
3269                         else
3270                         {
3271                                 if (InfoString_GetValue(string, "challenge", infostringvalue, sizeof(infostringvalue)))
3272                                 {
3273                                         // validate the challenge
3274                                         for (i = 0;i < MAX_CHALLENGES;i++)
3275                                                 if(challenges[i].time > 0)
3276                                                         if (!LHNETADDRESS_Compare(peeraddress, &challenges[i].address) && !strcmp(challenges[i].string, infostringvalue))
3277                                                                 break;
3278                                         // if the challenge is not recognized, drop the packet
3279                                         if (i == MAX_CHALLENGES)
3280                                                 return true;
3281                                 }
3282                         }
3283
3284                         if(InfoString_GetValue(string, "message", infostringvalue, sizeof(infostringvalue)))
3285                                 Con_DPrintf("Connecting client %s sent us the message: %s\n", addressstring2, infostringvalue);
3286
3287                         if(!(islocal || sv_public.integer > -2))
3288                         {
3289                                 if (developer_extra.integer)
3290                                         Con_Printf("Datagram_ParseConnectionless: sending \"reject %s\" to %s.\n", sv_public_rejectreason.string, addressstring2);
3291                                 memcpy(response, "\377\377\377\377", 4);
3292                                 dpsnprintf(response+4, sizeof(response)-4, "reject %s", sv_public_rejectreason.string);
3293                                 NetConn_WriteString(mysocket, response, peeraddress);
3294                                 return true;
3295                         }
3296
3297                         // check engine protocol
3298                         if(!InfoString_GetValue(string, "protocol", infostringvalue, sizeof(infostringvalue)) || strcmp(infostringvalue, "darkplaces 3"))
3299                         {
3300                                 if (developer_extra.integer)
3301                                         Con_Printf("Datagram_ParseConnectionless: sending \"reject Wrong game protocol.\" to %s.\n", addressstring2);
3302                                 NetConn_WriteString(mysocket, "\377\377\377\377reject Wrong game protocol.", peeraddress);
3303                                 return true;
3304                         }
3305
3306                         // see if this is a duplicate connection request or a disconnected
3307                         // client who is rejoining to the same client slot
3308                         for (clientnum = 0, client = svs.clients;clientnum < svs.maxclients;clientnum++, client++)
3309                         {
3310                                 if (client->netconnection && LHNETADDRESS_Compare(peeraddress, &client->netconnection->peeraddress) == 0)
3311                                 {
3312                                         // this is a known client...
3313                                         if(crypto && crypto->authenticated)
3314                                         {
3315                                                 // reject if changing key!
3316                                                 if(client->netconnection->crypto.authenticated)
3317                                                 {
3318                                                         if(
3319                                                                         strcmp(client->netconnection->crypto.client_idfp, crypto->client_idfp)
3320                                                                         ||
3321                                                                         strcmp(client->netconnection->crypto.server_idfp, crypto->server_idfp)
3322                                                                         ||
3323                                                                         strcmp(client->netconnection->crypto.client_keyfp, crypto->client_keyfp)
3324                                                                         ||
3325                                                                         strcmp(client->netconnection->crypto.server_keyfp, crypto->server_keyfp)
3326                                                           )
3327                                                         {
3328                                                                 if (developer_extra.integer)
3329                                                                         Con_Printf("Datagram_ParseConnectionless: sending \"reject Attempt to change key of crypto.\" to %s.\n", addressstring2);
3330                                                                 NetConn_WriteString(mysocket, "\377\377\377\377reject Attempt to change key of crypto.", peeraddress);
3331                                                                 return true;
3332                                                         }
3333                                                 }
3334                                         }
3335                                         else
3336                                         {
3337                                                 // reject if downgrading!
3338                                                 if(client->netconnection->crypto.authenticated)
3339                                                 {
3340                                                         if (developer_extra.integer)
3341                                                                 Con_Printf("Datagram_ParseConnectionless: sending \"reject Attempt to downgrade crypto.\" to %s.\n", addressstring2);
3342                                                         NetConn_WriteString(mysocket, "\377\377\377\377reject Attempt to downgrade crypto.", peeraddress);
3343                                                         return true;
3344                                                 }
3345                                         }
3346                                         if (client->begun)
3347                                         {
3348                                                 // client crashed and is coming back,
3349                                                 // keep their stuff intact
3350                                                 if (developer_extra.integer)
3351                                                         Con_Printf("Datagram_ParseConnectionless: sending \"accept\" to %s.\n", addressstring2);
3352                                                 NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
3353                                                 if(crypto && crypto->authenticated)
3354                                                         Crypto_FinishInstance(&client->netconnection->crypto, crypto);
3355                                                 SV_SendServerinfo(client);
3356                                         }
3357                                         else
3358                                         {
3359                                                 // client is still trying to connect,
3360                                                 // so we send a duplicate reply
3361                                                 if (developer_extra.integer)
3362                                                         Con_Printf("Datagram_ParseConnectionless: sending duplicate accept to %s.\n", addressstring2);
3363                                                 if(crypto && crypto->authenticated)
3364                                                         Crypto_FinishInstance(&client->netconnection->crypto, crypto);
3365                                                 NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
3366                                         }
3367                                         return true;
3368                                 }
3369                         }
3370
3371                         if (NetConn_PreventFlood(peeraddress, sv.connectfloodaddresses, sizeof(sv.connectfloodaddresses) / sizeof(sv.connectfloodaddresses[0]), net_connectfloodblockingtimeout.value, true))
3372                                 return true;
3373
3374                         // find an empty client slot for this new client
3375                         for (clientnum = 0, client = svs.clients;clientnum < svs.maxclients;clientnum++, client++)
3376                         {
3377                                 netconn_t *conn;
3378                                 if (!client->active && (conn = NetConn_Open(mysocket, peeraddress)))
3379                                 {
3380                                         // allocated connection
3381                                         if (developer_extra.integer)
3382                                                 Con_Printf("Datagram_ParseConnectionless: sending \"accept\" to %s.\n", conn->address);
3383                                         NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
3384                                         // now set up the client
3385                                         if(crypto && crypto->authenticated)
3386                                                 Crypto_FinishInstance(&conn->crypto, crypto);
3387                                         SV_ConnectClient(clientnum, conn);
3388                                         NetConn_Heartbeat(1);
3389                                         return true;
3390                                 }
3391                         }
3392
3393                         // no empty slots found - server is full
3394                         if (developer_extra.integer)
3395                                 Con_Printf("Datagram_ParseConnectionless: sending \"reject Server is full.\" to %s.\n", addressstring2);
3396                         NetConn_WriteString(mysocket, "\377\377\377\377reject Server is full.", peeraddress);
3397
3398                         return true;
3399                 }
3400                 if (length >= 7 && !memcmp(string, "getinfo", 7) && (islocal || sv_public.integer > -1))
3401                 {
3402                         const char *challenge = NULL;
3403
3404                         if (NetConn_PreventFlood(peeraddress, sv.getstatusfloodaddresses, sizeof(sv.getstatusfloodaddresses) / sizeof(sv.getstatusfloodaddresses[0]), net_getstatusfloodblockingtimeout.value, false))
3405                                 return true;
3406
3407                         // If there was a challenge in the getinfo message
3408                         if (length > 8 && string[7] == ' ')
3409                                 challenge = string + 8;
3410
3411                         if (NetConn_BuildStatusResponse(challenge, response, sizeof(response), false))
3412                         {
3413                                 if (developer_extra.integer)
3414                                         Con_DPrintf("Sending reply to master %s - %s\n", addressstring2, response);
3415                                 NetConn_WriteString(mysocket, response, peeraddress);
3416                         }
3417                         return true;
3418                 }
3419                 if (length >= 9 && !memcmp(string, "getstatus", 9) && (islocal || sv_public.integer > -1))
3420                 {
3421                         const char *challenge = NULL;
3422
3423                         if (NetConn_PreventFlood(peeraddress, sv.getstatusfloodaddresses, sizeof(sv.getstatusfloodaddresses) / sizeof(sv.getstatusfloodaddresses[0]), net_getstatusfloodblockingtimeout.value, false))
3424                                 return true;
3425
3426                         // If there was a challenge in the getinfo message
3427                         if (length > 10 && string[9] == ' ')
3428                                 challenge = string + 10;
3429
3430                         if (NetConn_BuildStatusResponse(challenge, response, sizeof(response), true))
3431                         {
3432                                 if (developer_extra.integer)
3433                                         Con_DPrintf("Sending reply to client %s - %s\n", addressstring2, response);
3434                                 NetConn_WriteString(mysocket, response, peeraddress);
3435                         }
3436                         return true;
3437                 }
3438                 if (length >= 37 && !memcmp(string, "srcon HMAC-MD4 TIME ", 20))
3439                 {
3440                         char *password = string + 20;
3441                         char *timeval = string + 37;
3442                         char *s = strchr(timeval, ' ');
3443                         char *endpos = string + length + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
3444                         const char *userlevel;
3445
3446                         if(rcon_secure.integer > 1)
3447                                 return true;
3448
3449                         if(!s)
3450                                 return true; // invalid packet
3451                         ++s;
3452
3453                         userlevel = RCon_Authenticate(peeraddress, password, s, endpos, hmac_mdfour_time_matching, timeval, endpos - timeval - 1); // not including the appended \0 into the HMAC
3454                         RCon_Execute(mysocket, peeraddress, addressstring2, userlevel, s, endpos, false);
3455                         return true;
3456                 }
3457                 if (length >= 42 && !memcmp(string, "srcon HMAC-MD4 CHALLENGE ", 25))
3458                 {
3459                         char *password = string + 25;
3460                         char *challenge = string + 42;
3461                         char *s = strchr(challenge, ' ');
3462                         char *endpos = string + length + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
3463                         const char *userlevel;
3464                         if(!s)
3465                                 return true; // invalid packet
3466                         ++s;
3467
3468                         userlevel = RCon_Authenticate(peeraddress, password, s, endpos, hmac_mdfour_challenge_matching, challenge, endpos - challenge - 1); // not including the appended \0 into the HMAC
3469                         RCon_Execute(mysocket, peeraddress, addressstring2, userlevel, s, endpos, false);
3470                         return true;
3471                 }
3472                 if (length >= 5 && !memcmp(string, "rcon ", 5))
3473                 {
3474                         int j;
3475                         char *s = string + 5;
3476                         char *endpos = string + length + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
3477                         char password[64];
3478
3479                         if(rcon_secure.integer > 0)
3480                                 return true;
3481
3482                         for (j = 0;!ISWHITESPACE(*s);s++)
3483                                 if (j < (int)sizeof(password) - 1)
3484                                         password[j++] = *s;
3485                         if(ISWHITESPACE(*s) && s != endpos) // skip leading ugly space
3486                                 ++s;
3487                         password[j] = 0;
3488                         if (!ISWHITESPACE(password[0]))
3489                         {
3490                                 const char *userlevel = RCon_Authenticate(peeraddress, password, s, endpos, plaintext_matching, NULL, 0);
3491                                 RCon_Execute(mysocket, peeraddress, addressstring2, userlevel, s, endpos, false);
3492                         }
3493                         return true;
3494                 }
3495                 if (!strncmp(string, "extResponse ", 12))
3496                 {
3497                         ++sv_net_extresponse_count;
3498                         if(sv_net_extresponse_count > NET_EXTRESPONSE_MAX)
3499                                 sv_net_extresponse_count = NET_EXTRESPONSE_MAX;
3500                         sv_net_extresponse_last = (sv_net_extresponse_last + 1) % NET_EXTRESPONSE_MAX;
3501                         dpsnprintf(sv_net_extresponse[sv_net_extresponse_last], sizeof(sv_net_extresponse[sv_net_extresponse_last]), "'%s' %s", addressstring2, string + 12);
3502                         return true;
3503                 }
3504                 if (!strncmp(string, "ping", 4))
3505                 {
3506                         if (developer_extra.integer)
3507                                 Con_DPrintf("Received ping from %s, sending ack\n", addressstring2);
3508                         NetConn_WriteString(mysocket, "\377\377\377\377ack", peeraddress);
3509                         return true;
3510                 }
3511                 if (!strncmp(string, "ack", 3))
3512                         return true;
3513                 // we may not have liked the packet, but it was a command packet, so
3514                 // we're done processing this packet now
3515                 return true;
3516         }
3517         // netquake control packets, supported for compatibility only, and only
3518         // when running game protocols that are normally served via this connection
3519         // protocol
3520         // (this protects more modern protocols against being used for
3521         //  Quake packet flood Denial Of Service attacks)
3522         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)
3523         {
3524                 int c;
3525                 int protocolnumber;
3526                 const char *protocolname;
3527                 client_t *knownclient;
3528                 client_t *newclient;
3529                 data += 4;
3530                 length -= 4;
3531                 SZ_Clear(&sv_message);
3532                 SZ_Write(&sv_message, data, length);
3533                 MSG_BeginReading(&sv_message);
3534                 c = MSG_ReadByte(&sv_message);
3535                 switch (c)
3536                 {
3537                 case CCREQ_CONNECT:
3538                         if (developer_extra.integer)
3539                                 Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_CONNECT from %s.\n", addressstring2);
3540                         if(!(islocal || sv_public.integer > -2))
3541                         {
3542                                 if (developer_extra.integer)
3543                                         Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_REJECT \"%s\" to %s.\n", sv_public_rejectreason.string, addressstring2);
3544                                 SZ_Clear(&sv_message);
3545                                 // save space for the header, filled in later
3546                                 MSG_WriteLong(&sv_message, 0);
3547                                 MSG_WriteByte(&sv_message, CCREP_REJECT);
3548                                 MSG_WriteUnterminatedString(&sv_message, sv_public_rejectreason.string);
3549                                 MSG_WriteString(&sv_message, "\n");
3550                                 StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3551                                 NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3552                                 SZ_Clear(&sv_message);
3553                                 break;
3554                         }
3555
3556                         protocolname = MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring));
3557                         protocolnumber = MSG_ReadByte(&sv_message);
3558                         if (strcmp(protocolname, "QUAKE") || protocolnumber != NET_PROTOCOL_VERSION)
3559                         {
3560                                 if (developer_extra.integer)
3561                                         Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_REJECT \"Incompatible version.\" to %s.\n", addressstring2);
3562                                 SZ_Clear(&sv_message);
3563                                 // save space for the header, filled in later
3564                                 MSG_WriteLong(&sv_message, 0);
3565                                 MSG_WriteByte(&sv_message, CCREP_REJECT);
3566                                 MSG_WriteString(&sv_message, "Incompatible version.\n");
3567                                 StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3568                                 NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3569                                 SZ_Clear(&sv_message);
3570                                 break;
3571                         }
3572
3573                         // see if this connect request comes from a known client
3574                         for (clientnum = 0, knownclient = svs.clients;clientnum < svs.maxclients;clientnum++, knownclient++)
3575                         {
3576                                 if (knownclient->netconnection && LHNETADDRESS_Compare(peeraddress, &knownclient->netconnection->peeraddress) == 0)
3577                                 {
3578                                         // this is either a duplicate connection request
3579                                         // or coming back from a timeout
3580                                         // (if so, keep their stuff intact)
3581
3582                                         crypto_t *crypto = Crypto_ServerGetInstance(peeraddress);
3583                                         if((crypto && crypto->authenticated) || knownclient->netconnection->crypto.authenticated)
3584                                         {
3585                                                 if (developer_extra.integer)
3586                                                         Con_Printf("Datagram_ParseConnectionless: sending CCREP_REJECT \"Attempt to downgrade crypto.\" to %s.\n", addressstring2);
3587                                                 SZ_Clear(&sv_message);
3588                                                 // save space for the header, filled in later
3589                                                 MSG_WriteLong(&sv_message, 0);
3590                                                 MSG_WriteByte(&sv_message, CCREP_REJECT);
3591                                                 MSG_WriteString(&sv_message, "Attempt to downgrade crypto.\n");
3592                                                 StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3593                                                 NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3594                                                 SZ_Clear(&sv_message);
3595                                                 return true;
3596                                         }
3597
3598                                         // send a reply
3599                                         if (developer_extra.integer)
3600                                                 Con_DPrintf("Datagram_ParseConnectionless: sending duplicate CCREP_ACCEPT to %s.\n", addressstring2);
3601                                         SZ_Clear(&sv_message);
3602                                         // save space for the header, filled in later
3603                                         MSG_WriteLong(&sv_message, 0);
3604                                         MSG_WriteByte(&sv_message, CCREP_ACCEPT);
3605                                         MSG_WriteLong(&sv_message, LHNETADDRESS_GetPort(LHNET_AddressFromSocket(knownclient->netconnection->mysocket)));
3606                                         StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3607                                         NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3608                                         SZ_Clear(&sv_message);
3609
3610                                         // if client is already spawned, re-send the
3611                                         // serverinfo message as they'll need it to play
3612                                         if (knownclient->begun)
3613                                                 SV_SendServerinfo(knownclient);
3614                                         return true;
3615                                 }
3616                         }
3617
3618                         // this is a new client, check for connection flood
3619                         if (NetConn_PreventFlood(peeraddress, sv.connectfloodaddresses, sizeof(sv.connectfloodaddresses) / sizeof(sv.connectfloodaddresses[0]), net_connectfloodblockingtimeout.value, true))
3620                                 break;
3621
3622                         // find a slot for the new client
3623                         for (clientnum = 0, newclient = svs.clients;clientnum < svs.maxclients;clientnum++, newclient++)
3624                         {
3625                                 netconn_t *conn;
3626                                 if (!newclient->active && (newclient->netconnection = conn = NetConn_Open(mysocket, peeraddress)) != NULL)
3627                                 {
3628                                         // connect to the client
3629                                         // everything is allocated, just fill in the details
3630                                         dp_strlcpy (conn->address, addressstring2, sizeof (conn->address));
3631                                         if (developer_extra.integer)
3632                                                 Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_ACCEPT to %s.\n", addressstring2);
3633                                         // send back the info about the server connection
3634                                         SZ_Clear(&sv_message);
3635                                         // save space for the header, filled in later
3636                                         MSG_WriteLong(&sv_message, 0);
3637                                         MSG_WriteByte(&sv_message, CCREP_ACCEPT);
3638                                         MSG_WriteLong(&sv_message, LHNETADDRESS_GetPort(LHNET_AddressFromSocket(conn->mysocket)));
3639                                         StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3640                                         NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3641                                         SZ_Clear(&sv_message);
3642                                         // now set up the client struct
3643                                         SV_ConnectClient(clientnum, conn);
3644                                         NetConn_Heartbeat(1);
3645                                         return true;
3646                                 }
3647                         }
3648
3649                         if (developer_extra.integer)
3650                                 Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_REJECT \"Server is full.\" to %s.\n", addressstring2);
3651                         // no room; try to let player know
3652                         SZ_Clear(&sv_message);
3653                         // save space for the header, filled in later
3654                         MSG_WriteLong(&sv_message, 0);
3655                         MSG_WriteByte(&sv_message, CCREP_REJECT);
3656                         MSG_WriteString(&sv_message, "Server is full.\n");
3657                         StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3658                         NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3659                         SZ_Clear(&sv_message);
3660                         break;
3661                 case CCREQ_SERVER_INFO:
3662                         if (developer_extra.integer)
3663                                 Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_SERVER_INFO from %s.\n", addressstring2);
3664                         if(!(islocal || sv_public.integer > -1))
3665                                 break;
3666
3667                         if (NetConn_PreventFlood(peeraddress, sv.getstatusfloodaddresses, sizeof(sv.getstatusfloodaddresses) / sizeof(sv.getstatusfloodaddresses[0]), net_getstatusfloodblockingtimeout.value, false))
3668                                 break;
3669
3670                         if (sv.active && !strcmp(MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring)), "QUAKE"))
3671                         {
3672                                 int numclients;
3673                                 char myaddressstring[128];
3674                                 if (developer_extra.integer)
3675                                         Con_DPrintf("Datagram_ParseConnectionless: sending CCREP_SERVER_INFO to %s.\n", addressstring2);
3676                                 SZ_Clear(&sv_message);
3677                                 // save space for the header, filled in later
3678                                 MSG_WriteLong(&sv_message, 0);
3679                                 MSG_WriteByte(&sv_message, CCREP_SERVER_INFO);
3680                                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), myaddressstring, sizeof(myaddressstring), true);
3681                                 MSG_WriteString(&sv_message, myaddressstring);
3682                                 MSG_WriteString(&sv_message, hostname.string);
3683                                 MSG_WriteString(&sv_message, sv.worldbasename);
3684                                 // How many clients are there?
3685                                 for (i = 0, numclients = 0;i < svs.maxclients;i++)
3686                                         if (svs.clients[i].active)
3687                                                 numclients++;
3688                                 MSG_WriteByte(&sv_message, numclients);
3689                                 MSG_WriteByte(&sv_message, svs.maxclients);
3690                                 MSG_WriteByte(&sv_message, NET_PROTOCOL_VERSION);
3691                                 StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3692                                 NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3693                                 SZ_Clear(&sv_message);
3694                         }
3695                         break;
3696                 case CCREQ_PLAYER_INFO:
3697                         if (developer_extra.integer)
3698                                 Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_PLAYER_INFO from %s.\n", addressstring2);
3699                         if(!(islocal || sv_public.integer > -1))
3700                                 break;
3701
3702                         if (NetConn_PreventFlood(peeraddress, sv.getstatusfloodaddresses, sizeof(sv.getstatusfloodaddresses) / sizeof(sv.getstatusfloodaddresses[0]), net_getstatusfloodblockingtimeout.value, false))
3703                                 break;
3704
3705                         if (sv.active)
3706                         {
3707                                 int playerNumber, activeNumber, clientNumber;
3708                                 client_t *client;
3709
3710                                 playerNumber = MSG_ReadByte(&sv_message);
3711                                 activeNumber = -1;
3712                                 for (clientNumber = 0, client = svs.clients; clientNumber < svs.maxclients; clientNumber++, client++)
3713                                         if (client->active && ++activeNumber == playerNumber)
3714                                                 break;
3715                                 if (clientNumber != svs.maxclients)
3716                                 {
3717                                         SZ_Clear(&sv_message);
3718                                         // save space for the header, filled in later
3719                                         MSG_WriteLong(&sv_message, 0);
3720                                         MSG_WriteByte(&sv_message, CCREP_PLAYER_INFO);
3721                                         MSG_WriteByte(&sv_message, playerNumber);
3722                                         MSG_WriteString(&sv_message, client->name);
3723                                         MSG_WriteLong(&sv_message, client->colors);
3724                                         MSG_WriteLong(&sv_message, client->frags);
3725                                         MSG_WriteLong(&sv_message, (int)(host.realtime - client->connecttime));
3726                                         if(sv_status_privacy.integer)
3727                                                 MSG_WriteString(&sv_message, client->netconnection ? "hidden" : "botclient");
3728                                         else
3729                                                 MSG_WriteString(&sv_message, client->netconnection ? client->netconnection->address : "botclient");
3730                                         StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3731                                         NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3732                                         SZ_Clear(&sv_message);
3733                                 }
3734                         }
3735                         break;
3736                 case CCREQ_RULE_INFO:
3737                         if (developer_extra.integer)
3738                                 Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_RULE_INFO from %s.\n", addressstring2);
3739                         if(!(islocal || sv_public.integer > -1))
3740                                 break;
3741
3742                         // no flood check here, as it only returns one cvar for one cvar and clients may iterate quickly
3743
3744                         if (sv.active)
3745                         {
3746                                 char *prevCvarName;
3747                                 cvar_t *var;
3748
3749                                 // find the search start location
3750                                 prevCvarName = MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring));
3751                                 var = Cvar_FindVarAfter(&cvars_all, prevCvarName, CF_NOTIFY);
3752
3753                                 // send the response
3754                                 SZ_Clear(&sv_message);
3755                                 // save space for the header, filled in later
3756                                 MSG_WriteLong(&sv_message, 0);
3757                                 MSG_WriteByte(&sv_message, CCREP_RULE_INFO);
3758                                 if (var)
3759                                 {
3760                                         MSG_WriteString(&sv_message, var->name);
3761                                         MSG_WriteString(&sv_message, var->string);
3762                                 }
3763                                 StoreBigLong(sv_message.data, NETFLAG_CTL | (sv_message.cursize & NETFLAG_LENGTH_MASK));
3764                                 NetConn_Write(mysocket, sv_message.data, sv_message.cursize, peeraddress);
3765                                 SZ_Clear(&sv_message);
3766                         }
3767                         break;
3768                 case CCREQ_RCON:
3769                         if (developer_extra.integer)
3770                                 Con_DPrintf("Datagram_ParseConnectionless: received CCREQ_RCON from %s.\n", addressstring2);
3771                         if (sv.active && !rcon_secure.integer)
3772                         {
3773                                 char password[2048];
3774                                 char cmd[2048];
3775                                 char *s;
3776                                 char *endpos;
3777                                 const char *userlevel;
3778                                 dp_strlcpy(password, MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring)), sizeof(password));
3779                                 dp_strlcpy(cmd, MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring)), sizeof(cmd));
3780                                 s = cmd;
3781                                 endpos = cmd + strlen(cmd) + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
3782                                 userlevel = RCon_Authenticate(peeraddress, password, s, endpos, plaintext_matching, NULL, 0);
3783                                 RCon_Execute(mysocket, peeraddress, addressstring2, userlevel, s, endpos, true);
3784                                 return true;
3785                         }
3786                         break;
3787                 default:
3788                         break;
3789                 }
3790                 SZ_Clear(&sv_message);
3791                 // we may not have liked the packet, but it was a valid control
3792                 // packet, so we're done processing this packet now
3793                 return true;
3794         }
3795         if (host_client)
3796         {
3797                 if ((ret = NetConn_ReceivedMessage(host_client->netconnection, data, length, sv.protocol, host_client->begun ? net_messagetimeout.value : net_connecttimeout.value)) == 2)
3798                 {
3799                         SV_ReadClientMessage();
3800                         return ret;
3801                 }
3802         }
3803         return 0;
3804 }
3805
3806 void NetConn_ServerFrame(void)
3807 {
3808         unsigned i;
3809         int length;
3810         lhnetaddress_t peeraddress;
3811         unsigned char readbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
3812
3813         for (i = 0;i < sv_numsockets;i++)
3814                 while (sv_sockets[i] && (length = NetConn_Read(sv_sockets[i], readbuffer, sizeof(readbuffer), &peeraddress)) > 0)
3815                         NetConn_ServerParsePacket(sv_sockets[i], readbuffer, length, &peeraddress);
3816 }
3817
3818 #ifdef CONFIG_MENU
3819 void NetConn_QueryMasters(qbool querydp, qbool queryqw)
3820 {
3821         unsigned i, j;
3822         unsigned masternum;
3823         lhnetaddress_t masteraddress;
3824         char request[256];
3825         char lookupstring[128];
3826
3827         if (serverlist_cachecount >= SERVERLIST_TOTALSIZE)
3828                 return;
3829
3830         memset(dpmasterstatus, 0, sizeof(*dpmasterstatus));
3831         memset(qwmasterstatus, 0, sizeof(*qwmasterstatus));
3832
3833         if (querydp)
3834         {
3835                 for (i = 0;i < cl_numsockets;i++)
3836                 {
3837                         if (cl_sockets[i])
3838                         {
3839                                 const char *cmdname, *extraoptions;
3840                                 lhnetaddresstype_t af = LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i]));
3841
3842                                 // build the getservers message to send to the dpmaster master servers
3843                                 if (LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i])) == LHNETADDRESSTYPE_INET6)
3844                                 {
3845                                         cmdname = "getserversExt";
3846                                         extraoptions = " ipv4 ipv6";  // ask for IPv4 and IPv6 servers
3847                                 }
3848                                 else
3849                                 {
3850                                         cmdname = "getservers";
3851                                         extraoptions = "";
3852                                 }
3853                                 memcpy(request, "\377\377\377\377", 4);
3854                                 dpsnprintf(request+4, sizeof(request)-4, "%s %s %u empty full%s", cmdname, gamenetworkfiltername, NET_PROTOCOL_VERSION, extraoptions);
3855
3856                                 // search internet
3857                                 for (masternum = 0; masternum < DPMASTER_COUNT; ++masternum)
3858                                 {
3859                                         if(sv_masters[masternum].string[0]
3860                                         && LHNETADDRESS_FromString(&masteraddress, sv_masters[masternum].string, DPMASTER_PORT)
3861                                         && LHNETADDRESS_GetAddressType(&masteraddress) == af)
3862                                         {
3863                                                 if (serverlist_consoleoutput || net_slist_debug.integer)
3864                                                 {
3865                                                         LHNETADDRESS_ToString(&masteraddress, lookupstring, sizeof(lookupstring), true);
3866                                                         Con_Printf("Querying DP master %s (resolved from %s)\n", lookupstring, sv_masters[masternum].string);
3867                                                 }
3868                                                 masterquerycount++;
3869                                                 NetConn_WriteString(cl_sockets[i], request, &masteraddress);
3870                                                 dpmasterstatus[masternum] = MASTER_TX_QUERY;
3871                                         }
3872                                 }
3873
3874                                 // search favorite servers
3875                                 for(j = 0; j < nFavorites; ++j)
3876                                         if(LHNETADDRESS_GetAddressType(&favorites[j]) == af
3877                                         && LHNETADDRESS_ToString(&favorites[j], lookupstring, sizeof(lookupstring), true))
3878                                                 NetConn_ClientParsePacket_ServerList_PrepareQuery(PROTOCOL_DARKPLACES7, lookupstring, true);
3879                         }
3880                 }
3881         }
3882
3883         // only query QuakeWorld servers when the user wants to
3884         if (queryqw)
3885         {
3886                 dpsnprintf(request, sizeof(request), "c\n");
3887
3888                 for (i = 0;i < cl_numsockets;i++)
3889                 {
3890                         if (cl_sockets[i])
3891                         {
3892                                 lhnetaddresstype_t af = LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i]));
3893
3894                                 // search internet
3895                                 for (masternum = 0; masternum < QWMASTER_COUNT; ++masternum)
3896                                 {
3897                                         if(sv_qwmasters[masternum].string[0]
3898                                         && LHNETADDRESS_FromString(&masteraddress, sv_qwmasters[masternum].string, QWMASTER_PORT)
3899                                         && LHNETADDRESS_GetAddressType(&masteraddress) == af)
3900                                         {
3901                                                 if (serverlist_consoleoutput || net_slist_debug.integer)
3902                                                 {
3903                                                         LHNETADDRESS_ToString(&masteraddress, lookupstring, sizeof(lookupstring), true);
3904                                                         Con_Printf("Querying QW master %s (resolved from %s)\n", lookupstring, sv_qwmasters[masternum].string);
3905                                                 }
3906                                                 masterquerycount++;
3907                                                 NetConn_Write(cl_sockets[i], request, (int)strlen(request) + 1, &masteraddress);
3908                                                 qwmasterstatus[masternum] = MASTER_TX_QUERY;
3909                                         }
3910                                 }
3911
3912                                 // search favorite servers
3913                                 for(j = 0; j < nFavorites; ++j)
3914                                         if(LHNETADDRESS_GetAddressType(&favorites[j]) == af
3915                                         && LHNETADDRESS_ToString(&favorites[j], lookupstring, sizeof(lookupstring), true))
3916                                                 NetConn_ClientParsePacket_ServerList_PrepareQuery(PROTOCOL_QUAKEWORLD, lookupstring, true);
3917                         }
3918                 }
3919         }
3920
3921         if (!masterquerycount)
3922         {
3923                 Con_Print(CON_ERROR "Unable to query master servers, no suitable network sockets active.\n");
3924                 dp_strlcpy(cl_connect_status, "No network", sizeof(cl_connect_status));
3925         }
3926 }
3927 #endif
3928
3929 void NetConn_Heartbeat(int priority)
3930 {
3931         lhnetaddress_t masteraddress;
3932         uint8_t masternum;
3933         lhnetsocket_t *mysocket;
3934
3935         // if it's a state change (client connected), limit next heartbeat to no
3936         // more than 30 sec in the future
3937         if (priority == 1 && nextheartbeattime > host.realtime + 30.0)
3938                 nextheartbeattime = host.realtime + 30.0;
3939
3940         // limit heartbeatperiod to 30 to 270 second range,
3941         // lower limit is to avoid abusing master servers with excess traffic,
3942         // upper limit is to avoid timing out on the master server (which uses
3943         // 300 sec timeout)
3944         if (sv_heartbeatperiod.value < 30)
3945                 Cvar_SetValueQuick(&sv_heartbeatperiod, 30);
3946         if (sv_heartbeatperiod.value > 270)
3947                 Cvar_SetValueQuick(&sv_heartbeatperiod, 270);
3948
3949         // make advertising optional and don't advertise singleplayer games, and
3950         // only send a heartbeat as often as the admin wants
3951         if (sv.active && sv_public.integer > 0 && svs.maxclients >= 2 && (priority > 1 || host.realtime > nextheartbeattime))
3952         {
3953                 nextheartbeattime = host.realtime + sv_heartbeatperiod.value;
3954                 for (masternum = 0; masternum < DPMASTER_COUNT; ++masternum)
3955                         if (sv_masters[masternum].string[0]
3956                         && LHNETADDRESS_FromString(&masteraddress, sv_masters[masternum].string, DPMASTER_PORT)
3957                         && (mysocket = NetConn_ChooseServerSocketForAddress(&masteraddress)))
3958                                 NetConn_WriteString(mysocket, "\377\377\377\377heartbeat DarkPlaces\x0A", &masteraddress);
3959         }
3960 }
3961
3962 static void Net_Heartbeat_f(cmd_state_t *cmd)
3963 {
3964         if (sv.active)
3965                 NetConn_Heartbeat(2);
3966         else
3967                 Con_Print("No server running, can not heartbeat to master server.\n");
3968 }
3969
3970 static void PrintStats(netconn_t *conn)
3971 {
3972         if ((cls.state == ca_connected && cls.protocol == PROTOCOL_QUAKEWORLD) || (sv.active && sv.protocol == PROTOCOL_QUAKEWORLD))
3973                 Con_Printf("address=%21s canSend=%u sendSeq=%6u recvSeq=%6u\n", conn->address, !conn->sendMessageLength, conn->outgoing_unreliable_sequence, conn->qw.incoming_sequence);
3974         else
3975                 Con_Printf("address=%21s canSend=%u sendSeq=%6u recvSeq=%6u\n", conn->address, !conn->sendMessageLength, conn->nq.sendSequence, conn->nq.receiveSequence);
3976         Con_Printf("unreliable messages sent   = %i\n", conn->unreliableMessagesSent);
3977         Con_Printf("unreliable messages recv   = %i\n", conn->unreliableMessagesReceived);
3978         Con_Printf("reliable messages sent     = %i\n", conn->reliableMessagesSent);
3979         Con_Printf("reliable messages received = %i\n", conn->reliableMessagesReceived);
3980         Con_Printf("packetsSent                = %i\n", conn->packetsSent);
3981         Con_Printf("packetsReSent              = %i\n", conn->packetsReSent);
3982         Con_Printf("packetsReceived            = %i\n", conn->packetsReceived);
3983         Con_Printf("receivedDuplicateCount     = %i\n", conn->receivedDuplicateCount);
3984         Con_Printf("droppedDatagrams           = %i\n", conn->droppedDatagrams);
3985 }
3986
3987 void Net_Stats_f(cmd_state_t *cmd)
3988 {
3989         netconn_t *conn;
3990         Con_Print("connections                =\n");
3991         for (conn = netconn_list;conn;conn = conn->next)
3992                 PrintStats(conn);
3993 }
3994
3995 #ifdef CONFIG_MENU
3996 void Net_Refresh_f(cmd_state_t *cmd)
3997 {
3998         if (m_state != m_slist)
3999         {
4000                 Con_Print("Sending new requests to DP master servers\n");
4001                 ServerList_QueryList(false, true, false, true);
4002                 Con_Print("Listening for replies...\n");
4003         }
4004         else
4005                 ServerList_QueryList(false, true, false, false);
4006 }
4007
4008 void Net_Slist_f(cmd_state_t *cmd)
4009 {
4010         ServerList_ResetMasks();
4011         serverlist_sortbyfield = SLIF_PING;
4012         serverlist_sortflags = 0;
4013         if (m_state != m_slist)
4014         {
4015                 Con_Print("Sending requests to DP master servers\n");
4016                 ServerList_QueryList(true, true, false, true);
4017                 Con_Print("Listening for replies...\n");
4018         }
4019         else
4020                 ServerList_QueryList(true, true, false, false);
4021 }
4022
4023 void Net_SlistQW_f(cmd_state_t *cmd)
4024 {
4025         ServerList_ResetMasks();
4026         serverlist_sortbyfield = SLIF_PING;
4027         serverlist_sortflags = 0;
4028         if (m_state != m_slist)
4029         {
4030                 Con_Print("Sending requests to QW master servers\n");
4031                 ServerList_QueryList(true, false, true, true);
4032                 Con_Print("Listening for replies...\n");
4033         }
4034         else
4035                 ServerList_QueryList(true, false, true, false);
4036 }
4037 #endif
4038
4039 void NetConn_Init(void)
4040 {
4041         int i;
4042         unsigned j;
4043         lhnetaddress_t tempaddress;
4044
4045         netconn_mempool = Mem_AllocPool("network connections", 0, NULL);
4046         Cmd_AddCommand(CF_SHARED, "net_stats", Net_Stats_f, "print network statistics");
4047 #ifdef CONFIG_MENU
4048         Cmd_AddCommand(CF_CLIENT, "net_slist", Net_Slist_f, "query dp master servers and print all server information");
4049         Cmd_AddCommand(CF_CLIENT, "net_slistqw", Net_SlistQW_f, "query qw master servers and print all server information");
4050         Cmd_AddCommand(CF_CLIENT, "net_refresh", Net_Refresh_f, "query dp master servers and refresh all server information");
4051 #endif
4052         Cmd_AddCommand(CF_SERVER, "heartbeat", Net_Heartbeat_f, "send a heartbeat to the master server (updates your server information)");
4053         Cvar_RegisterVariable(&net_test);
4054         Cvar_RegisterVariable(&net_usesizelimit);
4055         Cvar_RegisterVariable(&net_burstreserve);
4056         Cvar_RegisterVariable(&rcon_restricted_password);
4057         Cvar_RegisterVariable(&rcon_restricted_commands);
4058         Cvar_RegisterVariable(&rcon_secure_maxdiff);
4059
4060 #ifdef CONFIG_MENU
4061         Cvar_RegisterVariable(&net_slist_debug);
4062         Cvar_RegisterVariable(&net_slist_favorites);
4063         Cvar_RegisterCallback(&net_slist_favorites, NetConn_UpdateFavorites_c);
4064         Cvar_RegisterVariable(&net_slist_interval);
4065         Cvar_RegisterVariable(&net_slist_maxping);
4066         Cvar_RegisterVariable(&net_slist_maxtries);
4067         Cvar_RegisterVariable(&net_slist_pause);
4068         Cvar_RegisterCallback(&net_slist_pause, ServerList_RebuildViewList);
4069         Cvar_RegisterVariable(&net_slist_queriespersecond);
4070         Cvar_RegisterVariable(&net_slist_queriesperframe);
4071         Cvar_RegisterVariable(&net_slist_timeout);
4072 #endif
4073
4074 #ifdef IP_TOS // register cvar only if supported
4075         Cvar_RegisterVariable(&net_tos_dscp);
4076 #endif
4077         Cvar_RegisterVariable(&net_messagetimeout);
4078         Cvar_RegisterVariable(&net_connecttimeout);
4079         Cvar_RegisterVariable(&net_connectfloodblockingtimeout);
4080         Cvar_RegisterVariable(&net_challengefloodblockingtimeout);
4081         Cvar_RegisterVariable(&net_getstatusfloodblockingtimeout);
4082         Cvar_RegisterVariable(&net_sourceaddresscheck);
4083         Cvar_RegisterVariable(&net_fakelag);
4084         Cvar_RegisterVariable(&net_fakeloss_send);
4085         Cvar_RegisterVariable(&net_fakeloss_receive);
4086         Cvar_RegisterVirtual(&net_fakelag, "cl_netlocalping");
4087         Cvar_RegisterVirtual(&net_fakeloss_send, "cl_netpacketloss_send");
4088         Cvar_RegisterVirtual(&net_fakeloss_receive, "cl_netpacketloss_receive");
4089         Cvar_RegisterVariable(&hostname);
4090         Cvar_RegisterVariable(&developer_networking);
4091         Cvar_RegisterVariable(&cl_netport);
4092         Cvar_RegisterCallback(&cl_netport, NetConn_CL_UpdateSockets_Callback);
4093         Cvar_RegisterVariable(&sv_netport);
4094         Cvar_RegisterCallback(&sv_netport, NetConn_sv_netport_Callback);
4095         Cvar_RegisterVariable(&net_address);
4096         Cvar_RegisterVariable(&net_address_ipv6);
4097         Cvar_RegisterVariable(&sv_public);
4098         Cvar_RegisterVariable(&sv_public_rejectreason);
4099         Cvar_RegisterVariable(&sv_heartbeatperiod);
4100         for (j = 0; j < DPMASTER_COUNT; ++j)
4101                 Cvar_RegisterVariable(&sv_masters[j]);
4102 #ifdef CONFIG_MENU
4103         for (j = 0; j < QWMASTER_COUNT; ++j)
4104                 Cvar_RegisterVariable(&sv_qwmasters[j]);
4105 #endif
4106         Cvar_RegisterVariable(&gameversion);
4107         Cvar_RegisterVariable(&gameversion_min);
4108         Cvar_RegisterVariable(&gameversion_max);
4109 // 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.
4110         if ((i = Sys_CheckParm("-ip")) && i + 1 < sys.argc)
4111         {
4112                 if (LHNETADDRESS_FromString(&tempaddress, sys.argv[i + 1], 0) == 1)
4113                 {
4114                         Con_Printf("-ip option used, setting net_address to \"%s\"\n", sys.argv[i + 1]);
4115                         Cvar_SetQuick(&net_address, sys.argv[i + 1]);
4116                 }
4117                 else
4118                         Con_Printf(CON_ERROR "-ip option used, but unable to parse the address \"%s\"\n", sys.argv[i + 1]);
4119         }
4120 // 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
4121         if (((i = Sys_CheckParm("-port")) || (i = Sys_CheckParm("-ipport")) || (i = Sys_CheckParm("-udpport"))) && i + 1 < sys.argc)
4122         {
4123                 i = atoi(sys.argv[i + 1]);
4124                 if (i >= 0 && i < 65536)
4125                 {
4126                         Con_Printf("-port option used, setting port cvar to %i\n", i);
4127                         Cvar_SetValueQuick(&sv_netport, i);
4128                 }
4129                 else
4130                         Con_Printf(CON_ERROR "-port option used, but %i is not a valid port number\n", i);
4131         }
4132         cl_numsockets = 0;
4133         sv_numsockets = 0;
4134         cl_message.data = cl_message_buf;
4135         cl_message.maxsize = sizeof(cl_message_buf);
4136         cl_message.cursize = 0;
4137         sv_message.data = sv_message_buf;
4138         sv_message.maxsize = sizeof(sv_message_buf);
4139         sv_message.cursize = 0;
4140         LHNET_Init();
4141         if (Thread_HasThreads())
4142                 netconn_mutex = Thread_CreateMutex();
4143 }
4144
4145 void NetConn_Shutdown(void)
4146 {
4147         NetConn_CloseClientPorts();
4148         NetConn_CloseServerPorts();
4149         LHNET_Shutdown();
4150         if (netconn_mutex)
4151                 Thread_DestroyMutex(netconn_mutex);
4152         netconn_mutex = NULL;
4153 }
4154