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