merged CL_MoveParticles, CL_MoveDecals, and R_MoveExplosions into their
[divverent/darkplaces.git] / netconn.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3 Copyright (C) 2002 Mathieu Olivier
4 Copyright (C) 2003 Forest Hale
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 "lhnet.h"
25
26 #define QWMASTER_PORT 27000
27 #define DPMASTER_PORT 27950
28
29 // note this defaults on for dedicated servers, off for listen servers
30 cvar_t sv_public = {0, "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"};
31 static cvar_t sv_heartbeatperiod = {CVAR_SAVE, "sv_heartbeatperiod", "120", "how often to send heartbeat in seconds (only used if sv_public is 1)"};
32
33 static cvar_t sv_masters [] =
34 {
35         {CVAR_SAVE, "sv_master1", "", "user-chosen master server 1"},
36         {CVAR_SAVE, "sv_master2", "", "user-chosen master server 2"},
37         {CVAR_SAVE, "sv_master3", "", "user-chosen master server 3"},
38         {CVAR_SAVE, "sv_master4", "", "user-chosen master server 4"},
39         {0, "sv_masterextra1", "ghdigital.com", "default master server 1 (admin: LordHavoc)"}, // admin: LordHavoc
40         {0, "sv_masterextra2", "dpmaster.deathmask.net", "default master server 2 (admin: Willis)"}, // admin: Willis
41         {0, "sv_masterextra3", "excalibur.nvg.ntnu.no", "default master server 3 (admin: tChr)"}, // admin: tChr
42         {0, NULL, NULL, NULL}
43 };
44
45 static cvar_t sv_qwmasters [] =
46 {
47         {CVAR_SAVE, "sv_qwmaster1", "", "user-chosen qwmaster server 1"},
48         {CVAR_SAVE, "sv_qwmaster2", "", "user-chosen qwmaster server 2"},
49         {CVAR_SAVE, "sv_qwmaster3", "", "user-chosen qwmaster server 3"},
50         {CVAR_SAVE, "sv_qwmaster4", "", "user-chosen qwmaster server 4"},
51         {0, "sv_qwmasterextra1", "master.quakeservers.net:27000", "Global master server. (admin: unknown)"},
52         {0, "sv_qwmasterextra2", "asgaard.morphos-team.net:27000", "Global master server. (admin: unknown)"},
53         {0, "sv_qwmasterextra3", "qwmaster.ocrana.de:27000", "German master server. (admin: unknown)"},
54         {0, "sv_qwmasterextra4", "masterserver.exhale.de:27000", "German master server. (admin: unknown)"},
55         {0, "sv_qwmasterextra5", "kubus.rulez.pl:27000", "Poland master server. (admin: unknown)"},
56         {0, NULL, NULL, NULL}
57 };
58
59 static double nextheartbeattime = 0;
60
61 sizebuf_t net_message;
62 static unsigned char net_message_buf[NET_MAXMESSAGE];
63
64 cvar_t net_messagetimeout = {0, "net_messagetimeout","300", "drops players who have not sent any packets for this many seconds"};
65 cvar_t net_connecttimeout = {0, "net_connecttimeout","10", "after requesting a connection, the client must reply within this many seconds or be dropped (cuts down on connect floods)"};
66 cvar_t net_connectfloodblockingtimeout = {0, "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)"};
67 cvar_t hostname = {CVAR_SAVE, "hostname", "UNNAMED", "server message to show in server browser"};
68 cvar_t developer_networking = {0, "developer_networking", "0", "prints all received and sent packets (recommended only for debugging)"};
69
70 cvar_t cl_netlocalping = {0, "cl_netlocalping","0", "lags local loopback connection by this much ping time (useful to play more fairly on your own server with people with higher pings)"};
71 static cvar_t cl_netpacketloss_send = {0, "cl_netpacketloss_send","0", "drops this percentage of outgoing packets, useful for testing network protocol robustness (jerky movement, prediction errors, etc)"};
72 static cvar_t cl_netpacketloss_receive = {0, "cl_netpacketloss_receive","0", "drops this percentage of incoming packets, useful for testing network protocol robustness (jerky movement, effects failing to start, sounds failing to play, etc)"};
73 static cvar_t net_slist_queriespersecond = {0, "net_slist_queriespersecond", "20", "how many server information requests to send per second"};
74 static cvar_t net_slist_queriesperframe = {0, "net_slist_queriesperframe", "4", "maximum number of server information requests to send each rendered frame (guards against low framerates causing problems)"};
75 static cvar_t net_slist_timeout = {0, "net_slist_timeout", "4", "how long to listen for a server information response before giving up"};
76 static cvar_t net_slist_pause = {0, "net_slist_pause", "0", "when set to 1, the server list won't update until it is set back to 0"};
77 static cvar_t net_slist_maxtries = {0, "net_slist_maxtries", "3", "how many times to ask the same server for information (more times gives better ping reports but takes longer)"};
78
79 static cvar_t gameversion = {0, "gameversion", "0", "version of game data (mod-specific), when client and server gameversion mismatch in the server browser the server is shown as incompatible"};
80 static cvar_t rcon_restricted_password = {CVAR_PRIVATE, "rcon_restricted_password", "", "password to authenticate rcon commands in restricted mode"};
81 static cvar_t rcon_restricted_commands = {0, "rcon_restricted_commands", "", "allowed commands for rcon when the restricted mode password was used"};
82
83 /* statistic counters */
84 static int packetsSent = 0;
85 static int packetsReSent = 0;
86 static int packetsReceived = 0;
87 static int receivedDuplicateCount = 0;
88 static int droppedDatagrams = 0;
89
90 static int unreliableMessagesSent = 0;
91 static int unreliableMessagesReceived = 0;
92 static int reliableMessagesSent = 0;
93 static int reliableMessagesReceived = 0;
94
95 double masterquerytime = -1000;
96 int masterquerycount = 0;
97 int masterreplycount = 0;
98 int serverquerycount = 0;
99 int serverreplycount = 0;
100
101 // this is only false if there are still servers left to query
102 static qboolean serverlist_querysleep = true;
103 static qboolean serverlist_paused = false;
104 // this is pushed a second or two ahead of realtime whenever a master server
105 // reply is received, to avoid issuing queries while master replies are still
106 // flooding in (which would make a mess of the ping times)
107 static double serverlist_querywaittime = 0;
108
109 static unsigned char sendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
110 static unsigned char readbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
111
112 static int cl_numsockets;
113 static lhnetsocket_t *cl_sockets[16];
114 static int sv_numsockets;
115 static lhnetsocket_t *sv_sockets[16];
116
117 netconn_t *netconn_list = NULL;
118 mempool_t *netconn_mempool = NULL;
119
120 cvar_t cl_netport = {0, "cl_port", "0", "forces client to use chosen port number if not 0"};
121 cvar_t sv_netport = {0, "port", "26000", "server port for players to connect to"};
122 cvar_t net_address = {0, "net_address", "0.0.0.0", "network address to open ports on"};
123 //cvar_t net_netaddress_ipv6 = {0, "net_address_ipv6", "[0:0:0:0:0:0:0:0]", "network address to open ipv6 ports on"};
124
125 char net_extresponse[NET_EXTRESPONSE_MAX][1400];
126 int net_extresponse_count = 0;
127 int net_extresponse_last = 0;
128
129 // ServerList interface
130 serverlist_mask_t serverlist_andmasks[SERVERLIST_ANDMASKCOUNT];
131 serverlist_mask_t serverlist_ormasks[SERVERLIST_ORMASKCOUNT];
132
133 serverlist_infofield_t serverlist_sortbyfield;
134 qboolean serverlist_sortdescending;
135
136 int serverlist_viewcount = 0;
137 serverlist_entry_t *serverlist_viewlist[SERVERLIST_VIEWLISTSIZE];
138
139 int serverlist_cachecount;
140 serverlist_entry_t serverlist_cache[SERVERLIST_TOTALSIZE];
141
142 qboolean serverlist_consoleoutput;
143
144 // helper function to insert a value into the viewset
145 // spare entries will be removed
146 static void _ServerList_ViewList_Helper_InsertBefore( int index, serverlist_entry_t *entry )
147 {
148     int i;
149         if( serverlist_viewcount < SERVERLIST_VIEWLISTSIZE ) {
150                 i = serverlist_viewcount++;
151         } else {
152                 i = SERVERLIST_VIEWLISTSIZE - 1;
153         }
154
155         for( ; i > index ; i-- )
156                 serverlist_viewlist[ i ] = serverlist_viewlist[ i - 1 ];
157
158         serverlist_viewlist[index] = entry;
159 }
160
161 // we suppose serverlist_viewcount to be valid, ie > 0
162 static void _ServerList_ViewList_Helper_Remove( int index )
163 {
164         serverlist_viewcount--;
165         for( ; index < serverlist_viewcount ; index++ )
166                 serverlist_viewlist[index] = serverlist_viewlist[index + 1];
167 }
168
169 // returns true if A should be inserted before B
170 static qboolean _ServerList_Entry_Compare( serverlist_entry_t *A, serverlist_entry_t *B )
171 {
172         int result = 0; // > 0 if for numbers A > B and for text if A < B
173
174         switch( serverlist_sortbyfield ) {
175                 case SLIF_PING:
176                         result = A->info.ping - B->info.ping;
177                         break;
178                 case SLIF_MAXPLAYERS:
179                         result = A->info.maxplayers - B->info.maxplayers;
180                         break;
181                 case SLIF_NUMPLAYERS:
182                         result = A->info.numplayers - B->info.numplayers;
183                         break;
184                 case SLIF_NUMBOTS:
185                         result = A->info.numbots - B->info.numbots;
186                         break;
187                 case SLIF_NUMHUMANS:
188                         result = A->info.numhumans - B->info.numhumans;
189                         break;
190                 case SLIF_FREESLOTS:
191                         result = A->info.freeslots - B->info.freeslots;
192                         break;
193                 case SLIF_PROTOCOL:
194                         result = A->info.protocol - B->info.protocol;
195                         break;
196                 case SLIF_CNAME:
197                         result = strcmp( B->info.cname, A->info.cname );
198                         break;
199                 case SLIF_GAME:
200                         result = strcasecmp( B->info.game, A->info.game );
201                         break;
202                 case SLIF_MAP:
203                         result = strcasecmp( B->info.map, A->info.map );
204                         break;
205                 case SLIF_MOD:
206                         result = strcasecmp( B->info.mod, A->info.mod );
207                         break;
208                 case SLIF_NAME:
209                         result = strcasecmp( B->info.name, A->info.name );
210                         break;
211                 default:
212                         Con_DPrint( "_ServerList_Entry_Compare: Bad serverlist_sortbyfield!\n" );
213                         break;
214         }
215
216         if( serverlist_sortdescending )
217                 return result > 0;
218         if (result != 0)
219                 return result < 0;
220         // if the chosen sort key is identical, sort by index
221         // (makes this a stable sort, so that later replies from servers won't
222         //  shuffle the servers around when they have the same ping)
223         return A < B;
224 }
225
226 static qboolean _ServerList_CompareInt( int A, serverlist_maskop_t op, int B )
227 {
228         // This should actually be done with some intermediate and end-of-function return
229         switch( op ) {
230                 case SLMO_LESS:
231                         return A < B;
232                 case SLMO_LESSEQUAL:
233                         return A <= B;
234                 case SLMO_EQUAL:
235                         return A == B;
236                 case SLMO_GREATER:
237                         return A > B;
238                 case SLMO_NOTEQUAL:
239                         return A != B;
240                 case SLMO_GREATEREQUAL:
241                 case SLMO_CONTAINS:
242                 case SLMO_NOTCONTAIN:
243                         return A >= B;
244                 default:
245                         Con_DPrint( "_ServerList_CompareInt: Bad op!\n" );
246                         return false;
247         }
248 }
249
250 static qboolean _ServerList_CompareStr( const char *A, serverlist_maskop_t op, const char *B )
251 {
252         int i;
253         char bufferA[ 256 ], bufferB[ 256 ]; // should be more than enough
254         for (i = 0;i < (int)sizeof(bufferA)-1 && A[i];i++)
255                 bufferA[i] = (A[i] >= 'A' && A[i] <= 'Z') ? (A[i] + 'a' - 'A') : A[i];
256         bufferA[i] = 0;
257         for (i = 0;i < (int)sizeof(bufferB)-1 && B[i];i++)
258                 bufferB[i] = (B[i] >= 'A' && B[i] <= 'Z') ? (B[i] + 'a' - 'A') : B[i];
259         bufferB[i] = 0;
260
261         // Same here, also using an intermediate & final return would be more appropriate
262         // A info B mask
263         switch( op ) {
264                 case SLMO_CONTAINS:
265                         return *bufferB && !!strstr( bufferA, bufferB ); // we want a real bool
266                 case SLMO_NOTCONTAIN:
267                         return !*bufferB || !strstr( bufferA, bufferB );
268                 case SLMO_LESS:
269                         return strcmp( bufferA, bufferB ) < 0;
270                 case SLMO_LESSEQUAL:
271                         return strcmp( bufferA, bufferB ) <= 0;
272                 case SLMO_EQUAL:
273                         return strcmp( bufferA, bufferB ) == 0;
274                 case SLMO_GREATER:
275                         return strcmp( bufferA, bufferB ) > 0;
276                 case SLMO_NOTEQUAL:
277                         return strcmp( bufferA, bufferB ) != 0;
278                 case SLMO_GREATEREQUAL:
279                         return strcmp( bufferA, bufferB ) >= 0;
280                 default:
281                         Con_DPrint( "_ServerList_CompareStr: Bad op!\n" );
282                         return false;
283         }
284 }
285
286 static qboolean _ServerList_Entry_Mask( serverlist_mask_t *mask, serverlist_info_t *info )
287 {
288         if( !_ServerList_CompareInt( info->ping, mask->tests[SLIF_PING], mask->info.ping ) )
289                 return false;
290         if( !_ServerList_CompareInt( info->maxplayers, mask->tests[SLIF_MAXPLAYERS], mask->info.maxplayers ) )
291                 return false;
292         if( !_ServerList_CompareInt( info->numplayers, mask->tests[SLIF_NUMPLAYERS], mask->info.numplayers ) )
293                 return false;
294         if( !_ServerList_CompareInt( info->numbots, mask->tests[SLIF_NUMBOTS], mask->info.numbots ) )
295                 return false;
296         if( !_ServerList_CompareInt( info->numhumans, mask->tests[SLIF_NUMHUMANS], mask->info.numhumans ) )
297                 return false;
298         if( !_ServerList_CompareInt( info->freeslots, mask->tests[SLIF_FREESLOTS], mask->info.freeslots ) )
299                 return false;
300         if( !_ServerList_CompareInt( info->protocol, mask->tests[SLIF_PROTOCOL], mask->info.protocol ))
301                 return false;
302         if( *mask->info.cname
303                 && !_ServerList_CompareStr( info->cname, mask->tests[SLIF_CNAME], mask->info.cname ) )
304                 return false;
305         if( *mask->info.game
306                 && !_ServerList_CompareStr( info->game, mask->tests[SLIF_GAME], mask->info.game ) )
307                 return false;
308         if( *mask->info.mod
309                 && !_ServerList_CompareStr( info->mod, mask->tests[SLIF_MOD], mask->info.mod ) )
310                 return false;
311         if( *mask->info.map
312                 && !_ServerList_CompareStr( info->map, mask->tests[SLIF_MAP], mask->info.map ) )
313                 return false;
314         if( *mask->info.name
315                 && !_ServerList_CompareStr( info->name, mask->tests[SLIF_NAME], mask->info.name ) )
316                 return false;
317         return true;
318 }
319
320 static void ServerList_ViewList_Insert( serverlist_entry_t *entry )
321 {
322         int start, end, mid;
323
324         // reject incompatible servers
325         if (entry->info.gameversion != gameversion.integer)
326                 return;
327
328         // FIXME: change this to be more readable (...)
329         // now check whether it passes through the masks
330         for( start = 0 ; serverlist_andmasks[start].active && start < SERVERLIST_ANDMASKCOUNT ; start++ )
331                 if( !_ServerList_Entry_Mask( &serverlist_andmasks[start], &entry->info ) )
332                         return;
333
334         for( start = 0 ; serverlist_ormasks[start].active && start < SERVERLIST_ORMASKCOUNT ; start++ )
335                 if( _ServerList_Entry_Mask( &serverlist_ormasks[start], &entry->info ) )
336                         break;
337         if( start == SERVERLIST_ORMASKCOUNT || (start > 0 && !serverlist_ormasks[start].active) )
338                 return;
339
340         if( !serverlist_viewcount ) {
341                 _ServerList_ViewList_Helper_InsertBefore( 0, entry );
342                 return;
343         }
344         // ok, insert it, we just need to find out where exactly:
345
346         // two special cases
347         // check whether to insert it as new first item
348         if( _ServerList_Entry_Compare( entry, serverlist_viewlist[0] ) ) {
349                 _ServerList_ViewList_Helper_InsertBefore( 0, entry );
350                 return;
351         } // check whether to insert it as new last item
352         else if( !_ServerList_Entry_Compare( entry, serverlist_viewlist[serverlist_viewcount - 1] ) ) {
353                 _ServerList_ViewList_Helper_InsertBefore( serverlist_viewcount, entry );
354                 return;
355         }
356         start = 0;
357         end = serverlist_viewcount - 1;
358         while( end > start + 1 )
359         {
360                 mid = (start + end) / 2;
361                 // test the item that lies in the middle between start and end
362                 if( _ServerList_Entry_Compare( entry, serverlist_viewlist[mid] ) )
363                         // the item has to be in the upper half
364                         end = mid;
365                 else
366                         // the item has to be in the lower half
367                         start = mid;
368         }
369         _ServerList_ViewList_Helper_InsertBefore( start + 1, entry );
370 }
371
372 static void ServerList_ViewList_Remove( serverlist_entry_t *entry )
373 {
374         int i;
375         for( i = 0; i < serverlist_viewcount; i++ )
376         {
377                 if (serverlist_viewlist[i] == entry)
378                 {
379                         _ServerList_ViewList_Helper_Remove(i);
380                         break;
381                 }
382         }
383 }
384
385 void ServerList_RebuildViewList(void)
386 {
387         int i;
388
389         serverlist_viewcount = 0;
390         for( i = 0 ; i < serverlist_cachecount ; i++ ) {
391                 serverlist_entry_t *entry = &serverlist_cache[i];
392                 // also display entries that are currently being refreshed [11/8/2007 Black]
393                 if( entry->query == SQS_QUERIED || entry->query == SQS_REFRESHING )
394                         ServerList_ViewList_Insert( entry );
395         }
396 }
397
398 void ServerList_ResetMasks(void)
399 {
400         int i;
401
402         memset( &serverlist_andmasks, 0, sizeof( serverlist_andmasks ) );
403         memset( &serverlist_ormasks, 0, sizeof( serverlist_ormasks ) );
404         // numbots needs to be compared to -1 to always succeed
405         for(i = 0; i < SERVERLIST_ANDMASKCOUNT; ++i)
406                 serverlist_andmasks[i].info.numbots = -1;
407         for(i = 0; i < SERVERLIST_ORMASKCOUNT; ++i)
408                 serverlist_ormasks[i].info.numbots = -1;
409 }
410
411 void ServerList_GetPlayerStatistics(int *numplayerspointer, int *maxplayerspointer)
412 {
413         int i;
414         int numplayers = 0, maxplayers = 0;
415         for (i = 0;i < serverlist_cachecount;i++)
416         {
417                 if (serverlist_cache[i].query == SQS_QUERIED)
418                 {
419                         numplayers += serverlist_cache[i].info.numhumans;
420                         maxplayers += serverlist_cache[i].info.maxplayers;
421                 }
422         }
423         *numplayerspointer = numplayers;
424         *maxplayerspointer = maxplayers;
425 }
426
427 #if 0
428 static void _ServerList_Test(void)
429 {
430         int i;
431         for( i = 0 ; i < 1024 ; i++ ) {
432                 memset( &serverlist_cache[serverlist_cachecount], 0, sizeof( serverlist_entry_t ) );
433                 serverlist_cache[serverlist_cachecount].info.ping = 1000 + 1024 - i;
434                 dpsnprintf( serverlist_cache[serverlist_cachecount].info.name, sizeof(serverlist_cache[serverlist_cachecount].info.name), "Black's ServerList Test %i", i );
435                 serverlist_cache[serverlist_cachecount].finished = true;
436                 sprintf( serverlist_cache[serverlist_cachecount].line1, "%i %s", serverlist_cache[serverlist_cachecount].info.ping, serverlist_cache[serverlist_cachecount].info.name );
437                 ServerList_ViewList_Insert( &serverlist_cache[serverlist_cachecount] );
438                 serverlist_cachecount++;
439         }
440 }
441 #endif
442
443 void ServerList_QueryList(qboolean resetcache, qboolean querydp, qboolean queryqw, qboolean consoleoutput)
444 {
445         masterquerytime = realtime;
446         masterquerycount = 0;
447         masterreplycount = 0;
448         if( resetcache ) {
449                 serverquerycount = 0;
450                 serverreplycount = 0;
451                 serverlist_cachecount = 0;
452                 serverlist_viewcount = 0;
453         } else {
454                 // refresh all entries
455                 int n;
456                 for( n = 0 ; n < serverlist_cachecount ; n++ ) {
457                         serverlist_entry_t *entry = &serverlist_cache[ n ];
458                         entry->query = SQS_REFRESHING;
459                         entry->querycounter = 0;
460                 }
461         }
462         serverlist_consoleoutput = consoleoutput;
463
464         //_ServerList_Test();
465
466         NetConn_QueryMasters(querydp, queryqw);
467 }
468
469 // rest
470
471 int NetConn_Read(lhnetsocket_t *mysocket, void *data, int maxlength, lhnetaddress_t *peeraddress)
472 {
473         int length = LHNET_Read(mysocket, data, maxlength, peeraddress);
474         int i;
475         if (length == 0)
476                 return 0;
477         if (cl_netpacketloss_receive.integer)
478                 for (i = 0;i < cl_numsockets;i++)
479                         if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss_receive.integer)
480                                 return 0;
481         if (developer_networking.integer)
482         {
483                 char addressstring[128], addressstring2[128];
484                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), addressstring, sizeof(addressstring), true);
485                 if (length > 0)
486                 {
487                         LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
488                         Con_Printf("LHNET_Read(%p (%s), %p, %i, %p) = %i from %s:\n", mysocket, addressstring, data, maxlength, peeraddress, length, addressstring2);
489                         Com_HexDumpToConsole((unsigned char *)data, length);
490                 }
491                 else
492                         Con_Printf("LHNET_Read(%p (%s), %p, %i, %p) = %i\n", mysocket, addressstring, data, maxlength, peeraddress, length);
493         }
494         return length;
495 }
496
497 int NetConn_Write(lhnetsocket_t *mysocket, const void *data, int length, const lhnetaddress_t *peeraddress)
498 {
499         int ret;
500         int i;
501         if (cl_netpacketloss_send.integer)
502                 for (i = 0;i < cl_numsockets;i++)
503                         if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss_send.integer)
504                                 return length;
505         ret = LHNET_Write(mysocket, data, length, peeraddress);
506         if (developer_networking.integer)
507         {
508                 char addressstring[128], addressstring2[128];
509                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), addressstring, sizeof(addressstring), true);
510                 LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
511                 Con_Printf("LHNET_Write(%p (%s), %p, %i, %p (%s)) = %i%s\n", mysocket, addressstring, data, length, peeraddress, addressstring2, length, ret == length ? "" : " (ERROR)");
512                 Com_HexDumpToConsole((unsigned char *)data, length);
513         }
514         return ret;
515 }
516
517 int NetConn_WriteString(lhnetsocket_t *mysocket, const char *string, const lhnetaddress_t *peeraddress)
518 {
519         // note this does not include the trailing NULL because we add that in the parser
520         return NetConn_Write(mysocket, string, (int)strlen(string), peeraddress);
521 }
522
523 qboolean NetConn_CanSend(netconn_t *conn)
524 {
525         conn->outgoing_packetcounter = (conn->outgoing_packetcounter + 1) % NETGRAPH_PACKETS;
526         conn->outgoing_unreliablesize[conn->outgoing_packetcounter] = NETGRAPH_NOPACKET;
527         conn->outgoing_reliablesize[conn->outgoing_packetcounter] = NETGRAPH_NOPACKET;
528         conn->outgoing_acksize[conn->outgoing_packetcounter] = NETGRAPH_NOPACKET;
529         if (realtime > conn->cleartime)
530                 return true;
531         else
532         {
533                 conn->outgoing_unreliablesize[conn->outgoing_packetcounter] = NETGRAPH_CHOKEDPACKET;
534                 return false;
535         }
536 }
537
538 int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate, qboolean quakesignon_suppressreliables)
539 {
540         int totallen = 0;
541
542         // if this packet was supposedly choked, but we find ourselves sending one
543         // anyway, make sure the size counting starts at zero
544         // (this mostly happens on level changes and disconnects and such)
545         if (conn->outgoing_unreliablesize[conn->outgoing_packetcounter] == NETGRAPH_CHOKEDPACKET)
546                 conn->outgoing_unreliablesize[conn->outgoing_packetcounter] = NETGRAPH_NOPACKET;
547
548         if (protocol == PROTOCOL_QUAKEWORLD)
549         {
550                 int packetLen;
551                 qboolean sendreliable;
552
553                 // note that it is ok to send empty messages to the qw server,
554                 // otherwise it won't respond to us at all
555
556                 sendreliable = false;
557                 // if the remote side dropped the last reliable message, resend it
558                 if (conn->qw.incoming_acknowledged > conn->qw.last_reliable_sequence && conn->qw.incoming_reliable_acknowledged != conn->qw.reliable_sequence)
559                         sendreliable = true;
560                 // if the reliable transmit buffer is empty, copy the current message out
561                 if (!conn->sendMessageLength && conn->message.cursize)
562                 {
563                         memcpy (conn->sendMessage, conn->message.data, conn->message.cursize);
564                         conn->sendMessageLength = conn->message.cursize;
565                         SZ_Clear(&conn->message); // clear the message buffer
566                         conn->qw.reliable_sequence ^= 1;
567                         sendreliable = true;
568                 }
569                 // outgoing unreliable packet number, and outgoing reliable packet number (0 or 1)
570                 *((int *)(sendbuffer + 0)) = LittleLong((unsigned int)conn->outgoing_unreliable_sequence | ((unsigned int)sendreliable<<31));
571                 // last received unreliable packet number, and last received reliable packet number (0 or 1)
572                 *((int *)(sendbuffer + 4)) = LittleLong((unsigned int)conn->qw.incoming_sequence | ((unsigned int)conn->qw.incoming_reliable_sequence<<31));
573                 packetLen = 8;
574                 conn->outgoing_unreliable_sequence++;
575                 // client sends qport in every packet
576                 if (conn == cls.netcon)
577                 {
578                         *((short *)(sendbuffer + 8)) = LittleShort(cls.qw_qport);
579                         packetLen += 2;
580                         // also update cls.qw_outgoing_sequence
581                         cls.qw_outgoing_sequence = conn->outgoing_unreliable_sequence;
582                 }
583                 if (packetLen + (sendreliable ? conn->sendMessageLength : 0) > 1400)
584                 {
585                         Con_Printf ("NetConn_SendUnreliableMessage: reliable message too big %u\n", data->cursize);
586                         return -1;
587                 }
588
589                 conn->outgoing_unreliablesize[conn->outgoing_packetcounter] += packetLen;
590
591                 // add the reliable message if there is one
592                 if (sendreliable)
593                 {
594                         conn->outgoing_reliablesize[conn->outgoing_packetcounter] += conn->sendMessageLength;
595                         memcpy(sendbuffer + packetLen, conn->sendMessage, conn->sendMessageLength);
596                         packetLen += conn->sendMessageLength;
597                         conn->qw.last_reliable_sequence = conn->outgoing_unreliable_sequence;
598                 }
599
600                 // add the unreliable message if possible
601                 if (packetLen + data->cursize <= 1400)
602                 {
603                         conn->outgoing_unreliablesize[conn->outgoing_packetcounter] += data->cursize;
604                         memcpy(sendbuffer + packetLen, data->data, data->cursize);
605                         packetLen += data->cursize;
606                 }
607
608                 NetConn_Write(conn->mysocket, (void *)&sendbuffer, packetLen, &conn->peeraddress);
609
610                 packetsSent++;
611                 unreliableMessagesSent++;
612
613                 totallen += packetLen + 28;
614         }
615         else
616         {
617                 unsigned int packetLen;
618                 unsigned int dataLen;
619                 unsigned int eom;
620                 unsigned int *header;
621
622                 // if a reliable message fragment has been lost, send it again
623                 if (conn->sendMessageLength && (realtime - conn->lastSendTime) > 1.0)
624                 {
625                         if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
626                         {
627                                 dataLen = conn->sendMessageLength;
628                                 eom = NETFLAG_EOM;
629                         }
630                         else
631                         {
632                                 dataLen = MAX_PACKETFRAGMENT;
633                                 eom = 0;
634                         }
635
636                         packetLen = NET_HEADERSIZE + dataLen;
637
638                         header = (unsigned int *)sendbuffer;
639                         header[0] = BigLong(packetLen | (NETFLAG_DATA | eom));
640                         header[1] = BigLong(conn->nq.sendSequence - 1);
641                         memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
642
643                         conn->outgoing_reliablesize[conn->outgoing_packetcounter] += packetLen;
644
645                         if (NetConn_Write(conn->mysocket, (void *)&sendbuffer, packetLen, &conn->peeraddress) == (int)packetLen)
646                         {
647                                 conn->lastSendTime = realtime;
648                                 packetsReSent++;
649                         }
650
651                         totallen += packetLen + 28;
652                 }
653
654                 // if we have a new reliable message to send, do so
655                 if (!conn->sendMessageLength && conn->message.cursize && !quakesignon_suppressreliables)
656                 {
657                         if (conn->message.cursize > (int)sizeof(conn->sendMessage))
658                         {
659                                 Con_Printf("NetConn_SendUnreliableMessage: reliable message too big (%u > %u)\n", conn->message.cursize, (int)sizeof(conn->sendMessage));
660                                 conn->message.overflowed = true;
661                                 return -1;
662                         }
663
664                         if (developer_networking.integer && conn == cls.netcon)
665                         {
666                                 Con_Print("client sending reliable message to server:\n");
667                                 SZ_HexDumpToConsole(&conn->message);
668                         }
669
670                         memcpy(conn->sendMessage, conn->message.data, conn->message.cursize);
671                         conn->sendMessageLength = conn->message.cursize;
672                         SZ_Clear(&conn->message);
673
674                         if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
675                         {
676                                 dataLen = conn->sendMessageLength;
677                                 eom = NETFLAG_EOM;
678                         }
679                         else
680                         {
681                                 dataLen = MAX_PACKETFRAGMENT;
682                                 eom = 0;
683                         }
684
685                         packetLen = NET_HEADERSIZE + dataLen;
686
687                         header = (unsigned int *)sendbuffer;
688                         header[0] = BigLong(packetLen | (NETFLAG_DATA | eom));
689                         header[1] = BigLong(conn->nq.sendSequence);
690                         memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
691
692                         conn->nq.sendSequence++;
693
694                         conn->outgoing_reliablesize[conn->outgoing_packetcounter] += packetLen;
695
696                         NetConn_Write(conn->mysocket, (void *)&sendbuffer, packetLen, &conn->peeraddress);
697
698                         conn->lastSendTime = realtime;
699                         packetsSent++;
700                         reliableMessagesSent++;
701
702                         totallen += packetLen + 28;
703                 }
704
705                 // if we have an unreliable message to send, do so
706                 if (data->cursize)
707                 {
708                         packetLen = NET_HEADERSIZE + data->cursize;
709
710                         if (packetLen > (int)sizeof(sendbuffer))
711                         {
712                                 Con_Printf("NetConn_SendUnreliableMessage: message too big %u\n", data->cursize);
713                                 return -1;
714                         }
715
716                         header = (unsigned int *)sendbuffer;
717                         header[0] = BigLong(packetLen | NETFLAG_UNRELIABLE);
718                         header[1] = BigLong(conn->outgoing_unreliable_sequence);
719                         memcpy(sendbuffer + NET_HEADERSIZE, data->data, data->cursize);
720
721                         conn->outgoing_unreliable_sequence++;
722
723                         conn->outgoing_unreliablesize[conn->outgoing_packetcounter] += packetLen;
724
725                         NetConn_Write(conn->mysocket, (void *)&sendbuffer, packetLen, &conn->peeraddress);
726
727                         packetsSent++;
728                         unreliableMessagesSent++;
729
730                         totallen += packetLen + 28;
731                 }
732         }
733
734         // delay later packets to obey rate limit
735         if (conn->cleartime < realtime - 0.1)
736                 conn->cleartime = realtime - 0.1;
737         conn->cleartime = conn->cleartime + (double)totallen / (double)rate;
738         if (conn->cleartime < realtime)
739                 conn->cleartime = realtime;
740
741         return 0;
742 }
743
744 qboolean NetConn_HaveClientPorts(void)
745 {
746         return !!cl_numsockets;
747 }
748
749 qboolean NetConn_HaveServerPorts(void)
750 {
751         return !!sv_numsockets;
752 }
753
754 void NetConn_CloseClientPorts(void)
755 {
756         for (;cl_numsockets > 0;cl_numsockets--)
757                 if (cl_sockets[cl_numsockets - 1])
758                         LHNET_CloseSocket(cl_sockets[cl_numsockets - 1]);
759 }
760
761 void NetConn_OpenClientPort(const char *addressstring, int defaultport)
762 {
763         lhnetaddress_t address;
764         lhnetsocket_t *s;
765         char addressstring2[1024];
766         if (LHNETADDRESS_FromString(&address, addressstring, defaultport))
767         {
768                 if ((s = LHNET_OpenSocket_Connectionless(&address)))
769                 {
770                         cl_sockets[cl_numsockets++] = s;
771                         LHNETADDRESS_ToString(LHNET_AddressFromSocket(s), addressstring2, sizeof(addressstring2), true);
772                         Con_Printf("Client opened a socket on address %s\n", addressstring2);
773                 }
774                 else
775                 {
776                         LHNETADDRESS_ToString(&address, addressstring2, sizeof(addressstring2), true);
777                         Con_Printf("Client failed to open a socket on address %s\n", addressstring2);
778                 }
779         }
780         else
781                 Con_Printf("Client unable to parse address %s\n", addressstring);
782 }
783
784 void NetConn_OpenClientPorts(void)
785 {
786         int port;
787         NetConn_CloseClientPorts();
788         port = bound(0, cl_netport.integer, 65535);
789         if (cl_netport.integer != port)
790                 Cvar_SetValueQuick(&cl_netport, port);
791         if(port == 0)
792                 Con_Printf("Client using an automatically assigned port\n");
793         else
794                 Con_Printf("Client using port %i\n", port);
795         NetConn_OpenClientPort("local:2", 0);
796         NetConn_OpenClientPort(net_address.string, port);
797         //NetConn_OpenClientPort(net_address_ipv6.string, port);
798 }
799
800 void NetConn_CloseServerPorts(void)
801 {
802         for (;sv_numsockets > 0;sv_numsockets--)
803                 if (sv_sockets[sv_numsockets - 1])
804                         LHNET_CloseSocket(sv_sockets[sv_numsockets - 1]);
805 }
806
807 void NetConn_OpenServerPort(const char *addressstring, int defaultport)
808 {
809         lhnetaddress_t address;
810         lhnetsocket_t *s;
811         int port;
812         char addressstring2[1024];
813
814         for (port = defaultport; port <= defaultport + 100; port++)
815         {
816                 if (LHNETADDRESS_FromString(&address, addressstring, port))
817                 {
818                         if ((s = LHNET_OpenSocket_Connectionless(&address)))
819                         {
820                                 sv_sockets[sv_numsockets++] = s;
821                                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(s), addressstring2, sizeof(addressstring2), true);
822                                 Con_Printf("Server listening on address %s\n", addressstring2);
823                                 break;
824                         }
825                         else
826                         {
827                                 LHNETADDRESS_ToString(&address, addressstring2, sizeof(addressstring2), true);
828                                 Con_Printf("Server failed to open socket on address %s\n", addressstring2);
829                         }
830                 }
831                 else
832                 {
833                         Con_Printf("Server unable to parse address %s\n", addressstring);
834                         // if it cant parse one address, it wont be able to parse another for sure
835                         break;
836                 }
837         }
838 }
839
840 void NetConn_OpenServerPorts(int opennetports)
841 {
842         int port;
843         NetConn_CloseServerPorts();
844         NetConn_UpdateSockets();
845         port = bound(0, sv_netport.integer, 65535);
846         if (port == 0)
847                 port = 26000;
848         Con_Printf("Server using port %i\n", port);
849         if (sv_netport.integer != port)
850                 Cvar_SetValueQuick(&sv_netport, port);
851         if (cls.state != ca_dedicated)
852                 NetConn_OpenServerPort("local:1", 0);
853         if (opennetports)
854         {
855                 NetConn_OpenServerPort(net_address.string, port);
856                 //NetConn_OpenServerPort(net_address_ipv6.string, port);
857         }
858         if (sv_numsockets == 0)
859                 Host_Error("NetConn_OpenServerPorts: unable to open any ports!");
860 }
861
862 lhnetsocket_t *NetConn_ChooseClientSocketForAddress(lhnetaddress_t *address)
863 {
864         int i, a = LHNETADDRESS_GetAddressType(address);
865         for (i = 0;i < cl_numsockets;i++)
866                 if (cl_sockets[i] && LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i])) == a)
867                         return cl_sockets[i];
868         return NULL;
869 }
870
871 lhnetsocket_t *NetConn_ChooseServerSocketForAddress(lhnetaddress_t *address)
872 {
873         int i, a = LHNETADDRESS_GetAddressType(address);
874         for (i = 0;i < sv_numsockets;i++)
875                 if (sv_sockets[i] && LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(sv_sockets[i])) == a)
876                         return sv_sockets[i];
877         return NULL;
878 }
879
880 netconn_t *NetConn_Open(lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress)
881 {
882         netconn_t *conn;
883         conn = (netconn_t *)Mem_Alloc(netconn_mempool, sizeof(*conn));
884         conn->mysocket = mysocket;
885         conn->peeraddress = *peeraddress;
886         conn->lastMessageTime = realtime;
887         conn->message.data = conn->messagedata;
888         conn->message.maxsize = sizeof(conn->messagedata);
889         conn->message.cursize = 0;
890         // LordHavoc: (inspired by ProQuake) use a short connect timeout to
891         // reduce effectiveness of connection request floods
892         conn->timeout = realtime + net_connecttimeout.value;
893         LHNETADDRESS_ToString(&conn->peeraddress, conn->address, sizeof(conn->address), true);
894         conn->next = netconn_list;
895         netconn_list = conn;
896         return conn;
897 }
898
899 void NetConn_ClearConnectFlood(lhnetaddress_t *peeraddress);
900 void NetConn_Close(netconn_t *conn)
901 {
902         netconn_t *c;
903         // remove connection from list
904
905         // allow the client to reconnect immediately
906         NetConn_ClearConnectFlood(&(conn->peeraddress));
907
908         if (conn == netconn_list)
909                 netconn_list = conn->next;
910         else
911         {
912                 for (c = netconn_list;c;c = c->next)
913                 {
914                         if (c->next == conn)
915                         {
916                                 c->next = conn->next;
917                                 break;
918                         }
919                 }
920                 // not found in list, we'll avoid crashing here...
921                 if (!c)
922                         return;
923         }
924         // free connection
925         Mem_Free(conn);
926 }
927
928 static int clientport = -1;
929 static int clientport2 = -1;
930 static int hostport = -1;
931 void NetConn_UpdateSockets(void)
932 {
933         if (cls.state != ca_dedicated)
934         {
935                 if (clientport2 != cl_netport.integer)
936                 {
937                         clientport2 = cl_netport.integer;
938                         if (cls.state == ca_connected)
939                                 Con_Print("Changing \"cl_port\" will not take effect until you reconnect.\n");
940                 }
941                 if (cls.state == ca_disconnected && clientport != clientport2)
942                 {
943                         clientport = clientport2;
944                         NetConn_CloseClientPorts();
945                 }
946                 if (cl_numsockets == 0)
947                         NetConn_OpenClientPorts();
948         }
949
950         if (hostport != sv_netport.integer)
951         {
952                 hostport = sv_netport.integer;
953                 if (sv.active)
954                         Con_Print("Changing \"port\" will not take effect until \"map\" command is executed.\n");
955         }
956 }
957
958 static int NetConn_ReceivedMessage(netconn_t *conn, unsigned char *data, int length, protocolversion_t protocol, double newtimeout)
959 {
960         int originallength = length;
961         if (length < 8)
962                 return 0;
963
964         if (protocol == PROTOCOL_QUAKEWORLD)
965         {
966                 int sequence, sequence_ack;
967                 int reliable_ack, reliable_message;
968                 int count;
969                 int qport;
970
971                 sequence = LittleLong(*((int *)(data + 0)));
972                 sequence_ack = LittleLong(*((int *)(data + 4)));
973                 data += 8;
974                 length -= 8;
975
976                 if (conn != cls.netcon)
977                 {
978                         // server only
979                         if (length < 2)
980                                 return 0;
981                         // 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?)
982                         qport = LittleShort(*((int *)(data + 8)));
983                         data += 2;
984                         length -= 2;
985                 }
986
987                 packetsReceived++;
988                 reliable_message = (sequence >> 31) & 1;
989                 reliable_ack = (sequence_ack >> 31) & 1;
990                 sequence &= ~(1<<31);
991                 sequence_ack &= ~(1<<31);
992                 if (sequence <= conn->qw.incoming_sequence)
993                 {
994                         //Con_DPrint("Got a stale datagram\n");
995                         return 0;
996                 }
997                 count = sequence - (conn->qw.incoming_sequence + 1);
998                 if (count > 0)
999                 {
1000                         droppedDatagrams += count;
1001                         //Con_DPrintf("Dropped %u datagram(s)\n", count);
1002                         while (count--)
1003                         {
1004                                 conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
1005                                 conn->incoming_unreliablesize[conn->incoming_packetcounter] = NETGRAPH_LOSTPACKET;
1006                                 conn->incoming_reliablesize[conn->incoming_packetcounter] = NETGRAPH_NOPACKET;
1007                                 conn->incoming_acksize[conn->incoming_packetcounter] = NETGRAPH_NOPACKET;
1008                         }
1009                 }
1010                 conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
1011                 conn->incoming_unreliablesize[conn->incoming_packetcounter] = originallength;
1012                 conn->incoming_reliablesize[conn->incoming_packetcounter] = NETGRAPH_NOPACKET;
1013                 conn->incoming_acksize[conn->incoming_packetcounter] = NETGRAPH_NOPACKET;
1014                 if (reliable_ack == conn->qw.reliable_sequence)
1015                 {
1016                         // received, now we will be able to send another reliable message
1017                         conn->sendMessageLength = 0;
1018                         reliableMessagesReceived++;
1019                 }
1020                 conn->qw.incoming_sequence = sequence;
1021                 if (conn == cls.netcon)
1022                         cls.qw_incoming_sequence = conn->qw.incoming_sequence;
1023                 conn->qw.incoming_acknowledged = sequence_ack;
1024                 conn->qw.incoming_reliable_acknowledged = reliable_ack;
1025                 if (reliable_message)
1026                         conn->qw.incoming_reliable_sequence ^= 1;
1027                 conn->lastMessageTime = realtime;
1028                 conn->timeout = realtime + newtimeout;
1029                 unreliableMessagesReceived++;
1030                 SZ_Clear(&net_message);
1031                 SZ_Write(&net_message, data, length);
1032                 MSG_BeginReading();
1033                 return 2;
1034         }
1035         else
1036         {
1037                 unsigned int count;
1038                 unsigned int flags;
1039                 unsigned int sequence;
1040                 int qlength;
1041
1042                 qlength = (unsigned int)BigLong(((int *)data)[0]);
1043                 flags = qlength & ~NETFLAG_LENGTH_MASK;
1044                 qlength &= NETFLAG_LENGTH_MASK;
1045                 // control packets were already handled
1046                 if (!(flags & NETFLAG_CTL) && qlength == length)
1047                 {
1048                         sequence = BigLong(((int *)data)[1]);
1049                         packetsReceived++;
1050                         data += 8;
1051                         length -= 8;
1052                         if (flags & NETFLAG_UNRELIABLE)
1053                         {
1054                                 if (sequence >= conn->nq.unreliableReceiveSequence)
1055                                 {
1056                                         if (sequence > conn->nq.unreliableReceiveSequence)
1057                                         {
1058                                                 count = sequence - conn->nq.unreliableReceiveSequence;
1059                                                 droppedDatagrams += count;
1060                                                 //Con_DPrintf("Dropped %u datagram(s)\n", count);
1061                                                 while (count--)
1062                                                 {
1063                                                         conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
1064                                                         conn->incoming_unreliablesize[conn->incoming_packetcounter] = NETGRAPH_LOSTPACKET;
1065                                                         conn->incoming_reliablesize[conn->incoming_packetcounter] = NETGRAPH_NOPACKET;
1066                                                         conn->incoming_acksize[conn->incoming_packetcounter] = NETGRAPH_NOPACKET;
1067                                                 }
1068                                         }
1069                                         conn->incoming_packetcounter = (conn->incoming_packetcounter + 1) % NETGRAPH_PACKETS;
1070                                         conn->incoming_unreliablesize[conn->incoming_packetcounter] = originallength;
1071                                         conn->incoming_reliablesize[conn->incoming_packetcounter] = NETGRAPH_NOPACKET;
1072                                         conn->incoming_acksize[conn->incoming_packetcounter] = NETGRAPH_NOPACKET;
1073                                         conn->nq.unreliableReceiveSequence = sequence + 1;
1074                                         conn->lastMessageTime = realtime;
1075                                         conn->timeout = realtime + newtimeout;
1076                                         unreliableMessagesReceived++;
1077                                         if (length > 0)
1078                                         {
1079                                                 SZ_Clear(&net_message);
1080                                                 SZ_Write(&net_message, data, length);
1081                                                 MSG_BeginReading();
1082                                                 return 2;
1083                                         }
1084                                 }
1085                                 //else
1086                                 //      Con_DPrint("Got a stale datagram\n");
1087                                 return 1;
1088                         }
1089                         else if (flags & NETFLAG_ACK)
1090                         {
1091                                 conn->incoming_acksize[conn->incoming_packetcounter] += originallength;
1092                                 if (sequence == (conn->nq.sendSequence - 1))
1093                                 {
1094                                         if (sequence == conn->nq.ackSequence)
1095                                         {
1096                                                 conn->nq.ackSequence++;
1097                                                 if (conn->nq.ackSequence != conn->nq.sendSequence)
1098                                                         Con_DPrint("ack sequencing error\n");
1099                                                 conn->lastMessageTime = realtime;
1100                                                 conn->timeout = realtime + newtimeout;
1101                                                 if (conn->sendMessageLength > MAX_PACKETFRAGMENT)
1102                                                 {
1103                                                         unsigned int packetLen;
1104                                                         unsigned int dataLen;
1105                                                         unsigned int eom;
1106                                                         unsigned int *header;
1107
1108                                                         conn->sendMessageLength -= MAX_PACKETFRAGMENT;
1109                                                         memmove(conn->sendMessage, conn->sendMessage+MAX_PACKETFRAGMENT, conn->sendMessageLength);
1110
1111                                                         if (conn->sendMessageLength <= MAX_PACKETFRAGMENT)
1112                                                         {
1113                                                                 dataLen = conn->sendMessageLength;
1114                                                                 eom = NETFLAG_EOM;
1115                                                         }
1116                                                         else
1117                                                         {
1118                                                                 dataLen = MAX_PACKETFRAGMENT;
1119                                                                 eom = 0;
1120                                                         }
1121
1122                                                         packetLen = NET_HEADERSIZE + dataLen;
1123
1124                                                         header = (unsigned int *)sendbuffer;
1125                                                         header[0] = BigLong(packetLen | (NETFLAG_DATA | eom));
1126                                                         header[1] = BigLong(conn->nq.sendSequence);
1127                                                         memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
1128
1129                                                         conn->nq.sendSequence++;
1130
1131                                                         if (NetConn_Write(conn->mysocket, (void *)&sendbuffer, packetLen, &conn->peeraddress) == (int)packetLen)
1132                                                         {
1133                                                                 conn->lastSendTime = realtime;
1134                                                                 packetsSent++;
1135                                                         }
1136                                                 }
1137                                                 else
1138                                                         conn->sendMessageLength = 0;
1139                                         }
1140                                         //else
1141                                         //      Con_DPrint("Duplicate ACK received\n");
1142                                 }
1143                                 //else
1144                                 //      Con_DPrint("Stale ACK received\n");
1145                                 return 1;
1146                         }
1147                         else if (flags & NETFLAG_DATA)
1148                         {
1149                                 unsigned int temppacket[2];
1150                                 conn->incoming_reliablesize[conn->incoming_packetcounter] += originallength;
1151                                 conn->outgoing_acksize[conn->outgoing_packetcounter] += 8;
1152                                 temppacket[0] = BigLong(8 | NETFLAG_ACK);
1153                                 temppacket[1] = BigLong(sequence);
1154                                 NetConn_Write(conn->mysocket, (unsigned char *)temppacket, 8, &conn->peeraddress);
1155                                 if (sequence == conn->nq.receiveSequence)
1156                                 {
1157                                         conn->lastMessageTime = realtime;
1158                                         conn->timeout = realtime + newtimeout;
1159                                         conn->nq.receiveSequence++;
1160                                         if( conn->receiveMessageLength + length <= (int)sizeof( conn->receiveMessage ) ) {
1161                                                 memcpy(conn->receiveMessage + conn->receiveMessageLength, data, length);
1162                                                 conn->receiveMessageLength += length;
1163                                         } else {
1164                                                 Con_Printf( "Reliable message (seq: %i) too big for message buffer!\n"
1165                                                                         "Dropping the message!\n", sequence );
1166                                                 conn->receiveMessageLength = 0;
1167                                                 return 1;
1168                                         }
1169                                         if (flags & NETFLAG_EOM)
1170                                         {
1171                                                 reliableMessagesReceived++;
1172                                                 length = conn->receiveMessageLength;
1173                                                 conn->receiveMessageLength = 0;
1174                                                 if (length > 0)
1175                                                 {
1176                                                         SZ_Clear(&net_message);
1177                                                         SZ_Write(&net_message, conn->receiveMessage, length);
1178                                                         MSG_BeginReading();
1179                                                         return 2;
1180                                                 }
1181                                         }
1182                                 }
1183                                 else
1184                                         receivedDuplicateCount++;
1185                                 return 1;
1186                         }
1187                 }
1188         }
1189         return 0;
1190 }
1191
1192 void NetConn_ConnectionEstablished(lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress, protocolversion_t initialprotocol)
1193 {
1194         cls.connect_trying = false;
1195         M_Update_Return_Reason("");
1196         // the connection request succeeded, stop current connection and set up a new connection
1197         CL_Disconnect();
1198         // if we're connecting to a remote server, shut down any local server
1199         if (LHNETADDRESS_GetAddressType(peeraddress) != LHNETADDRESSTYPE_LOOP && sv.active)
1200                 Host_ShutdownServer ();
1201         // allocate a net connection to keep track of things
1202         cls.netcon = NetConn_Open(mysocket, peeraddress);
1203         Con_Printf("Connection accepted to %s\n", cls.netcon->address);
1204         key_dest = key_game;
1205         m_state = m_none;
1206         cls.demonum = -1;                       // not in the demo loop now
1207         cls.state = ca_connected;
1208         cls.signon = 0;                         // need all the signon messages before playing
1209         cls.protocol = initialprotocol;
1210         // reset move sequence numbering on this new connection
1211         cls.servermovesequence = 0;
1212         if (cls.protocol == PROTOCOL_QUAKEWORLD)
1213                 Cmd_ForwardStringToServer("new");
1214         if (cls.protocol == PROTOCOL_QUAKE)
1215         {
1216                 // write a keepalive (clc_nop) as it seems to greatly improve the
1217                 // chances of connecting to a netquake server
1218                 sizebuf_t msg;
1219                 unsigned char buf[4];
1220                 memset(&msg, 0, sizeof(msg));
1221                 msg.data = buf;
1222                 msg.maxsize = sizeof(buf);
1223                 MSG_WriteChar(&msg, clc_nop);
1224                 NetConn_SendUnreliableMessage(cls.netcon, &msg, cls.protocol, 10000, false);
1225         }
1226 }
1227
1228 int NetConn_IsLocalGame(void)
1229 {
1230         if (cls.state == ca_connected && sv.active && cl.maxclients == 1)
1231                 return true;
1232         return false;
1233 }
1234
1235 static int NetConn_ClientParsePacket_ServerList_ProcessReply(const char *addressstring)
1236 {
1237         int n;
1238         int pingtime;
1239         serverlist_entry_t *entry = NULL;
1240
1241         // search the cache for this server and update it
1242         for (n = 0;n < serverlist_cachecount;n++) {
1243                 entry = &serverlist_cache[ n ];
1244                 if (!strcmp(addressstring, entry->info.cname))
1245                         break;
1246         }
1247
1248         if (n == serverlist_cachecount)
1249         {
1250                 // LAN search doesnt require an answer from the master server so we wont
1251                 // know the ping nor will it be initialized already...
1252
1253                 // find a slot
1254                 if (serverlist_cachecount == SERVERLIST_TOTALSIZE)
1255                         return -1;
1256
1257                 entry = &serverlist_cache[n];
1258
1259                 memset(entry, 0, sizeof(*entry));
1260                 // store the data the engine cares about (address and ping)
1261                 strlcpy(entry->info.cname, addressstring, sizeof(entry->info.cname));
1262                 entry->info.ping = 100000;
1263                 entry->querytime = realtime;
1264                 // if not in the slist menu we should print the server to console
1265                 if (serverlist_consoleoutput)
1266                         Con_Printf("querying %s\n", addressstring);
1267                 ++serverlist_cachecount;
1268         }
1269         // if this is the first reply from this server, count it as having replied
1270         pingtime = (int)((realtime - entry->querytime) * 1000.0 + 0.5);
1271         pingtime = bound(0, pingtime, 9999);
1272         if (entry->query == SQS_REFRESHING) {
1273                 entry->info.ping = pingtime;
1274                 entry->query = SQS_QUERIED;
1275         } else {
1276                 // convert to unsigned to catch the -1
1277                 // I still dont like this but its better than the old 10000 magic ping number - as in easier to type and read :( [11/8/2007 Black]
1278                 entry->info.ping = min((unsigned) entry->info.ping, (unsigned) pingtime);
1279                 serverreplycount++;
1280         }
1281         
1282         // other server info is updated by the caller
1283         return n;
1284 }
1285
1286 static void NetConn_ClientParsePacket_ServerList_UpdateCache(int n)
1287 {
1288         serverlist_entry_t *entry = &serverlist_cache[n];
1289         serverlist_info_t *info = &entry->info;
1290         // update description strings for engine menu and console output
1291         dpsnprintf(entry->line1, sizeof(serverlist_cache[n].line1), "^%c%5d^7 ^%c%3u^7/%3u %-65.65s", info->ping >= 300 ? '1' : (info->ping >= 200 ? '3' : '7'), (int)info->ping, ((info->numhumans > 0 && info->numhumans < info->maxplayers) ? (info->numhumans >= 4 ? '7' : '3') : '1'), info->numplayers, info->maxplayers, info->name);
1292         dpsnprintf(entry->line2, sizeof(serverlist_cache[n].line2), "^4%-21.21s %-19.19s ^%c%-17.17s^4 %-20.20s", info->cname, info->game, (info->gameversion != gameversion.integer) ? '1' : '4', info->mod, info->map);
1293         if (entry->query == SQS_QUERIED)
1294         {
1295                 if(!serverlist_paused)
1296                         ServerList_ViewList_Remove(entry);
1297         }
1298         // if not in the slist menu we should print the server to console (if wanted)
1299         else if( serverlist_consoleoutput )
1300                 Con_Printf("%s\n%s\n", serverlist_cache[n].line1, serverlist_cache[n].line2);
1301         // and finally, update the view set
1302         if(!serverlist_paused)
1303                 ServerList_ViewList_Insert( entry );
1304         //      update the entry's state
1305         serverlist_cache[n].query = SQS_QUERIED;
1306 }
1307
1308 // returns true, if it's sensible to continue the processing
1309 static qboolean NetConn_ClientParsePacket_ServerList_PrepareQuery( int protocol, const char *ipstring ) {
1310         int n;
1311         serverlist_entry_t *entry;
1312
1313         //      ignore the rest of the message if the serverlist is full
1314         if( serverlist_cachecount == SERVERLIST_TOTALSIZE )
1315                 return false;
1316         //      also ignore     it      if      we      have already queried    it      (other master server    response)
1317         for( n =        0 ; n   < serverlist_cachecount ; n++   )
1318                 if( !strcmp( ipstring, serverlist_cache[ n ].info.cname ) )
1319                         break;
1320
1321         entry = &serverlist_cache[n];
1322
1323         if( n < serverlist_cachecount ) {
1324                 // the entry has already been queried once or 
1325                 return true;
1326         }
1327
1328         memset(entry, 0, sizeof(entry));
1329         entry->protocol =       protocol;
1330         //      store   the data        the engine cares about (address and     ping)
1331         strlcpy (entry->info.cname, ipstring, sizeof(entry->info.cname));
1332         
1333         // no, then reset the ping right away
1334         entry->info.ping = -1;
1335         // we also want to increase the serverlist_cachecount then
1336         serverlist_cachecount++;
1337         serverquerycount++;
1338
1339         entry->query =  SQS_QUERYING;
1340
1341         return true;
1342 }
1343
1344 static int NetConn_ClientParsePacket(lhnetsocket_t *mysocket, unsigned char *data, int length, lhnetaddress_t *peeraddress)
1345 {
1346         qboolean fromserver;
1347         int ret, c, control;
1348         const char *s;
1349         char *string, addressstring2[128], ipstring[32];
1350         char stringbuf[16384];
1351
1352         // quakeworld ingame packet
1353         fromserver = cls.netcon && mysocket == cls.netcon->mysocket && !LHNETADDRESS_Compare(&cls.netcon->peeraddress, peeraddress);
1354
1355         // convert the address to a string incase we need it
1356         LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
1357
1358         if (length >= 5 && data[0] == 255 && data[1] == 255 && data[2] == 255 && data[3] == 255)
1359         {
1360                 // received a command string - strip off the packaging and put it
1361                 // into our string buffer with NULL termination
1362                 data += 4;
1363                 length -= 4;
1364                 length = min(length, (int)sizeof(stringbuf) - 1);
1365                 memcpy(stringbuf, data, length);
1366                 stringbuf[length] = 0;
1367                 string = stringbuf;
1368
1369                 if (developer_networking.integer)
1370                 {
1371                         Con_Printf("NetConn_ClientParsePacket: %s sent us a command:\n", addressstring2);
1372                         Com_HexDumpToConsole(data, length);
1373                 }
1374
1375                 if (length > 10 && !memcmp(string, "challenge ", 10) && cls.connect_trying)
1376                 {
1377                         // darkplaces or quake3
1378                         char protocolnames[1400];
1379                         Protocol_Names(protocolnames, sizeof(protocolnames));
1380                         Con_Printf("\"%s\" received, sending connect request back to %s\n", string, addressstring2);
1381                         M_Update_Return_Reason("Got challenge response");
1382                         // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
1383                         InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
1384                         // TODO: add userinfo stuff here instead of using NQ commands?
1385                         NetConn_WriteString(mysocket, va("\377\377\377\377connect\\protocol\\darkplaces 3\\protocols\\%s\\challenge\\%s", protocolnames, string + 10), peeraddress);
1386                         return true;
1387                 }
1388                 if (length == 6 && !memcmp(string, "accept", 6) && cls.connect_trying)
1389                 {
1390                         // darkplaces or quake3
1391                         M_Update_Return_Reason("Accepted");
1392                         NetConn_ConnectionEstablished(mysocket, peeraddress, PROTOCOL_DARKPLACES3);
1393                         return true;
1394                 }
1395                 if (length > 7 && !memcmp(string, "reject ", 7) && cls.connect_trying)
1396                 {
1397                         char rejectreason[32];
1398                         cls.connect_trying = false;
1399                         string += 7;
1400                         length = max(length - 7, (int)sizeof(rejectreason) - 1);
1401                         memcpy(rejectreason, string, length);
1402                         rejectreason[length] = 0;
1403                         M_Update_Return_Reason(rejectreason);
1404                         return true;
1405                 }
1406                 if (length >= 13 && !memcmp(string, "infoResponse\x0A", 13))
1407                 {
1408                         serverlist_info_t *info;
1409                         int n;
1410
1411                         string += 13;
1412                         // search the cache for this server and update it
1413                         n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2);
1414                         if (n < 0)
1415                                 return true;
1416
1417                         info = &serverlist_cache[n].info;
1418                         info->game[0] = 0;
1419                         info->mod[0]  = 0;
1420                         info->map[0]  = 0;
1421                         info->name[0] = 0;
1422                         info->protocol = -1;
1423                         info->numplayers = 0;
1424                         info->numbots = -1;
1425                         info->maxplayers  = 0;
1426                         info->gameversion = 0;
1427                         if ((s = SearchInfostring(string, "gamename"     )) != NULL) strlcpy(info->game, s, sizeof (info->game));
1428                         if ((s = SearchInfostring(string, "modname"      )) != NULL) strlcpy(info->mod , s, sizeof (info->mod ));
1429                         if ((s = SearchInfostring(string, "mapname"      )) != NULL) strlcpy(info->map , s, sizeof (info->map ));
1430                         if ((s = SearchInfostring(string, "hostname"     )) != NULL) strlcpy(info->name, s, sizeof (info->name));
1431                         if ((s = SearchInfostring(string, "protocol"     )) != NULL) info->protocol = atoi(s);
1432                         if ((s = SearchInfostring(string, "clients"      )) != NULL) info->numplayers = atoi(s);
1433                         if ((s = SearchInfostring(string, "bots"         )) != NULL) info->numbots = atoi(s);
1434                         if ((s = SearchInfostring(string, "sv_maxclients")) != NULL) info->maxplayers = atoi(s);
1435                         if ((s = SearchInfostring(string, "gameversion"  )) != NULL) info->gameversion = atoi(s);
1436                         info->numhumans = info->numplayers - max(0, info->numbots);
1437                         info->freeslots = info->maxplayers - info->numplayers;
1438
1439                         NetConn_ClientParsePacket_ServerList_UpdateCache(n);
1440
1441                         return true;
1442                 }
1443                 if (!strncmp(string, "getserversResponse\\", 19) && serverlist_cachecount < SERVERLIST_TOTALSIZE)
1444                 {
1445                         // Extract the IP addresses
1446                         data += 18;
1447                         length -= 18;
1448                         masterreplycount++;
1449                         if (serverlist_consoleoutput)
1450                                 Con_Print("received DarkPlaces server list...\n");
1451                         while (length >= 7 && data[0] == '\\' && (data[1] != 0xFF || data[2] != 0xFF || data[3] != 0xFF || data[4] != 0xFF) && data[5] * 256 + data[6] != 0)
1452                         {
1453                                 dpsnprintf (ipstring, sizeof (ipstring), "%u.%u.%u.%u:%u", data[1], data[2], data[3], data[4], data[5] * 256 + data[6]);
1454                                 if (serverlist_consoleoutput && developer_networking.integer)
1455                                         Con_Printf("Requesting info from DarkPlaces server %s\n", ipstring);
1456                                 
1457                                 if( !NetConn_ClientParsePacket_ServerList_PrepareQuery( PROTOCOL_DARKPLACES7, ipstring ) ) {
1458                                         break;
1459                                 }
1460
1461                                 // move on to next address in packet
1462                                 data += 7;
1463                                 length -= 7;
1464                         }
1465                         // begin or resume serverlist queries
1466                         serverlist_querysleep = false;
1467                         serverlist_querywaittime = realtime + 3;
1468                         return true;
1469                 }
1470                 if (!memcmp(string, "d\n", 2) && serverlist_cachecount < SERVERLIST_TOTALSIZE)
1471                 {
1472                         // Extract the IP addresses
1473                         data += 2;
1474                         length -= 2;
1475                         masterreplycount++;
1476                         if (serverlist_consoleoutput)
1477                                 Con_Printf("received QuakeWorld server list from %s...\n", addressstring2);
1478                         while (length >= 6 && (data[0] != 0xFF || data[1] != 0xFF || data[2] != 0xFF || data[3] != 0xFF) && data[4] * 256 + data[5] != 0)
1479                         {
1480                                 dpsnprintf (ipstring, sizeof (ipstring), "%u.%u.%u.%u:%u", data[0], data[1], data[2], data[3], data[4] * 256 + data[5]);
1481                                 if (serverlist_consoleoutput && developer_networking.integer)
1482                                         Con_Printf("Requesting info from QuakeWorld server %s\n", ipstring);
1483                                 
1484                                 if( !NetConn_ClientParsePacket_ServerList_PrepareQuery( PROTOCOL_QUAKEWORLD, ipstring ) ) {
1485                                         break;
1486                                 }
1487
1488                                 // move on to next address in packet
1489                                 data += 6;
1490                                 length -= 6;
1491                         }
1492                         // begin or resume serverlist queries
1493                         serverlist_querysleep = false;
1494                         serverlist_querywaittime = realtime + 3;
1495                         return true;
1496                 }
1497                 if (!strncmp(string, "extResponse ", 12))
1498                 {
1499                         ++net_extresponse_count;
1500                         if(net_extresponse_count > NET_EXTRESPONSE_MAX)
1501                                 net_extresponse_count = NET_EXTRESPONSE_MAX;
1502                         net_extresponse_last = (net_extresponse_last + 1) % NET_EXTRESPONSE_MAX;
1503                         dpsnprintf(net_extresponse[net_extresponse_last], sizeof(net_extresponse[net_extresponse_last]), "'%s' %s", addressstring2, string + 12);
1504                         return true;
1505                 }
1506                 if (!strncmp(string, "ping", 4))
1507                 {
1508                         if (developer.integer >= 10)
1509                                 Con_Printf("Received ping from %s, sending ack\n", addressstring2);
1510                         NetConn_WriteString(mysocket, "\377\377\377\377ack", peeraddress);
1511                         return true;
1512                 }
1513                 if (!strncmp(string, "ack", 3))
1514                         return true;
1515                 // QuakeWorld compatibility
1516                 if (length > 1 && string[0] == 'c' && (string[1] == '-' || (string[1] >= '0' && string[1] <= '9')) && cls.connect_trying)
1517                 {
1518                         // challenge message
1519                         Con_Printf("challenge %s received, sending QuakeWorld connect request back to %s\n", string + 1, addressstring2);
1520                         M_Update_Return_Reason("Got QuakeWorld challenge response");
1521                         cls.qw_qport = qport.integer;
1522                         // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
1523                         InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
1524                         NetConn_WriteString(mysocket, va("\377\377\377\377connect %i %i %i \"%s\"\n", 28, cls.qw_qport, atoi(string + 1), cls.userinfo), peeraddress);
1525                         return true;
1526                 }
1527                 if (length >= 1 && string[0] == 'j' && cls.connect_trying)
1528                 {
1529                         // accept message
1530                         M_Update_Return_Reason("QuakeWorld Accepted");
1531                         NetConn_ConnectionEstablished(mysocket, peeraddress, PROTOCOL_QUAKEWORLD);
1532                         return true;
1533                 }
1534                 if (length > 2 && !memcmp(string, "n\\", 2))
1535                 {
1536                         serverlist_info_t *info;
1537                         int n;
1538
1539                         // qw server status
1540                         if (serverlist_consoleoutput && developer_networking.integer >= 2)
1541                                 Con_Printf("QW server status from server at %s:\n%s\n", addressstring2, string + 1);
1542
1543                         string += 1;
1544                         // search the cache for this server and update it
1545                         n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2);
1546                         if (n < 0)
1547                                 return true;
1548
1549                         info = &serverlist_cache[n].info;
1550                         strlcpy(info->game, "QuakeWorld", sizeof(info->game));;
1551                         if ((s = SearchInfostring(string, "*gamedir"     )) != NULL) strlcpy(info->mod , s, sizeof (info->mod ));else info->mod[0]  = 0;
1552                         if ((s = SearchInfostring(string, "map"          )) != NULL) strlcpy(info->map , s, sizeof (info->map ));else info->map[0]  = 0;
1553                         if ((s = SearchInfostring(string, "hostname"     )) != NULL) strlcpy(info->name, s, sizeof (info->name));else info->name[0] = 0;
1554                         info->protocol = 0;
1555                         info->numplayers = 0; // updated below
1556                         info->numhumans = 0; // updated below
1557                         if ((s = SearchInfostring(string, "maxclients"   )) != NULL) info->maxplayers = atoi(s);else info->maxplayers  = 0;
1558                         if ((s = SearchInfostring(string, "gameversion"  )) != NULL) info->gameversion = atoi(s);else info->gameversion = 0;
1559
1560                         // count active players on server
1561                         // (we could gather more info, but we're just after the number)
1562                         s = strchr(string, '\n');
1563                         if (s)
1564                         {
1565                                 s++;
1566                                 while (s < string + length)
1567                                 {
1568                                         for (;s < string + length && *s != '\n';s++)
1569                                                 ;
1570                                         if (s >= string + length)
1571                                                 break;
1572                                         info->numplayers++;
1573                                         info->numhumans++;
1574                                         s++;
1575                                 }
1576                         }
1577
1578                         NetConn_ClientParsePacket_ServerList_UpdateCache(n);
1579
1580                         return true;
1581                 }
1582                 if (string[0] == 'n')
1583                 {
1584                         // qw print command
1585                         Con_Printf("QW print command from server at %s:\n%s\n", addressstring2, string + 1);
1586                 }
1587                 // we may not have liked the packet, but it was a command packet, so
1588                 // we're done processing this packet now
1589                 return true;
1590         }
1591         // quakeworld ingame packet
1592         if (fromserver && cls.protocol == PROTOCOL_QUAKEWORLD && length >= 8 && (ret = NetConn_ReceivedMessage(cls.netcon, data, length, cls.protocol, net_messagetimeout.value)) == 2)
1593         {
1594                 ret = 0;
1595                 CL_ParseServerMessage();
1596                 return ret;
1597         }
1598         // netquake control packets, supported for compatibility only
1599         if (length >= 5 && (control = BigLong(*((int *)data))) && (control & (~NETFLAG_LENGTH_MASK)) == (int)NETFLAG_CTL && (control & NETFLAG_LENGTH_MASK) == length)
1600         {
1601                 int n;
1602                 serverlist_info_t *info;
1603
1604                 data += 4;
1605                 length -= 4;
1606                 SZ_Clear(&net_message);
1607                 SZ_Write(&net_message, data, length);
1608                 MSG_BeginReading();
1609                 c = MSG_ReadByte();
1610                 switch (c)
1611                 {
1612                 case CCREP_ACCEPT:
1613                         if (developer.integer >= 10)
1614                                 Con_Printf("Datagram_ParseConnectionless: received CCREP_ACCEPT from %s.\n", addressstring2);
1615                         if (cls.connect_trying)
1616                         {
1617                                 lhnetaddress_t clientportaddress;
1618                                 clientportaddress = *peeraddress;
1619                                 LHNETADDRESS_SetPort(&clientportaddress, MSG_ReadLong());
1620                                 // update the server IP in the userinfo (QW servers expect this, and it is used by the reconnect command)
1621                                 InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), "*ip", addressstring2);
1622                                 M_Update_Return_Reason("Accepted");
1623                                 NetConn_ConnectionEstablished(mysocket, &clientportaddress, PROTOCOL_QUAKE);
1624                         }
1625                         break;
1626                 case CCREP_REJECT:
1627                         if (developer.integer >= 10)
1628                                 Con_Printf("Datagram_ParseConnectionless: received CCREP_REJECT from %s.\n", addressstring2);
1629                         cls.connect_trying = false;
1630                         M_Update_Return_Reason((char *)MSG_ReadString());
1631                         break;
1632                 case CCREP_SERVER_INFO:
1633                         if (developer.integer >= 10)
1634                                 Con_Printf("Datagram_ParseConnectionless: received CCREP_SERVER_INFO from %s.\n", addressstring2);
1635                         // LordHavoc: because the quake server may report weird addresses
1636                         // we just ignore it and keep the real address
1637                         MSG_ReadString();
1638                         // search the cache for this server and update it
1639                         n = NetConn_ClientParsePacket_ServerList_ProcessReply(addressstring2);
1640                         if (n < 0)
1641                                 break;
1642
1643                         info = &serverlist_cache[n].info;
1644                         strlcpy(info->game, "Quake", sizeof(info->game));
1645                         strlcpy(info->mod , "", sizeof(info->mod)); // mod name is not specified
1646                         strlcpy(info->name, MSG_ReadString(), sizeof(info->name));
1647                         strlcpy(info->map , MSG_ReadString(), sizeof(info->map));
1648                         info->numplayers = MSG_ReadByte();
1649                         info->maxplayers = MSG_ReadByte();
1650                         info->protocol = MSG_ReadByte();
1651
1652                         NetConn_ClientParsePacket_ServerList_UpdateCache(n);
1653
1654                         break;
1655                 case CCREP_PLAYER_INFO:
1656                         // we got a CCREP_PLAYER_INFO??
1657                         //if (developer.integer >= 10)
1658                                 Con_Printf("Datagram_ParseConnectionless: received CCREP_PLAYER_INFO from %s.\n", addressstring2);
1659                         break;
1660                 case CCREP_RULE_INFO:
1661                         // we got a CCREP_RULE_INFO??
1662                         //if (developer.integer >= 10)
1663                                 Con_Printf("Datagram_ParseConnectionless: received CCREP_RULE_INFO from %s.\n", addressstring2);
1664                         break;
1665                 default:
1666                         break;
1667                 }
1668                 SZ_Clear(&net_message);
1669                 // we may not have liked the packet, but it was a valid control
1670                 // packet, so we're done processing this packet now
1671                 return true;
1672         }
1673         ret = 0;
1674         if (fromserver && length >= (int)NET_HEADERSIZE && (ret = NetConn_ReceivedMessage(cls.netcon, data, length, cls.protocol, net_messagetimeout.value)) == 2)
1675                 CL_ParseServerMessage();
1676         return ret;
1677 }
1678
1679 void NetConn_QueryQueueFrame(void)
1680 {
1681         int index;
1682         int queries;
1683         int maxqueries;
1684         double timeouttime;
1685         static double querycounter = 0;
1686
1687         if(!net_slist_pause.integer && serverlist_paused)
1688                 ServerList_RebuildViewList();
1689         serverlist_paused = net_slist_pause.integer;
1690
1691         if (serverlist_querysleep)
1692                 return;
1693
1694         // apply a cool down time after master server replies,
1695         // to avoid messing up the ping times on the servers
1696         if (serverlist_querywaittime > realtime)
1697                 return;
1698
1699         // each time querycounter reaches 1.0 issue a query
1700         querycounter += cl.realframetime * net_slist_queriespersecond.value;
1701         maxqueries = (int)querycounter;
1702         maxqueries = bound(0, maxqueries, net_slist_queriesperframe.integer);
1703         querycounter -= maxqueries;
1704
1705         if( maxqueries == 0 ) {
1706                 return;
1707         }
1708
1709         //      scan serverlist and issue queries as needed
1710         serverlist_querysleep = true;
1711
1712         timeouttime     = realtime - net_slist_timeout.value;
1713         for( index = 0, queries = 0 ;   index   < serverlist_cachecount &&      queries < maxqueries    ; index++ )
1714         {
1715                 serverlist_entry_t *entry = &serverlist_cache[ index ];
1716                 if( entry->query != SQS_QUERYING && entry->query != SQS_REFRESHING )
1717                 {
1718                         continue;
1719                 }
1720
1721                 serverlist_querysleep   = false;
1722                 if( entry->querycounter !=      0 && entry->querytime > timeouttime     )
1723                 {
1724                         continue;
1725                 }
1726
1727                 if( entry->querycounter !=      (unsigned) net_slist_maxtries.integer )
1728                 {
1729                         lhnetaddress_t  address;
1730                         int socket;
1731
1732                         LHNETADDRESS_FromString(&address, entry->info.cname, 0);
1733                         if      (entry->protocol == PROTOCOL_QUAKEWORLD)
1734                         {
1735                                 for (socket     = 0; socket     < cl_numsockets ;       socket++)
1736                                         NetConn_WriteString(cl_sockets[socket], "\377\377\377\377status\n", &address);
1737                         }
1738                         else
1739                         {
1740                                 for (socket     = 0; socket     < cl_numsockets ;       socket++)
1741                                         NetConn_WriteString(cl_sockets[socket], "\377\377\377\377getinfo", &address);
1742                         }
1743
1744                         //      update the entry fields
1745                         entry->querytime = realtime;
1746                         entry->querycounter++;
1747
1748                         // if not in the slist menu we should print the server to console
1749                         if (serverlist_consoleoutput)
1750                                 Con_Printf("querying %25s (%i. try)\n", entry->info.cname, entry->querycounter);
1751
1752                         queries++;
1753                 }
1754                 else
1755                 {
1756                         // have we tried to refresh this server?
1757                         if( entry->query == SQS_REFRESHING ) {
1758                                 // yes, so update the reply count (since its not responding anymore)
1759                                 serverreplycount--;
1760                                 if(!serverlist_paused)
1761                                         ServerList_ViewList_Remove(entry);
1762                         }
1763                         entry->query = SQS_TIMEDOUT;
1764                 }
1765         }
1766 }
1767
1768 void NetConn_ClientFrame(void)
1769 {
1770         int i, length;
1771         lhnetaddress_t peeraddress;
1772         NetConn_UpdateSockets();
1773         if (cls.connect_trying && cls.connect_nextsendtime < realtime)
1774         {
1775                 if (cls.connect_remainingtries == 0)
1776                         M_Update_Return_Reason("Connect: Waiting 10 seconds for reply");
1777                 cls.connect_nextsendtime = realtime + 1;
1778                 cls.connect_remainingtries--;
1779                 if (cls.connect_remainingtries <= -10)
1780                 {
1781                         cls.connect_trying = false;
1782                         M_Update_Return_Reason("Connect: Failed");
1783                         return;
1784                 }
1785                 // try challenge first (newer DP server or QW)
1786                 NetConn_WriteString(cls.connect_mysocket, "\377\377\377\377getchallenge", &cls.connect_address);
1787                 // then try netquake as a fallback (old server, or netquake)
1788                 SZ_Clear(&net_message);
1789                 // save space for the header, filled in later
1790                 MSG_WriteLong(&net_message, 0);
1791                 MSG_WriteByte(&net_message, CCREQ_CONNECT);
1792                 MSG_WriteString(&net_message, "QUAKE");
1793                 MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
1794                 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
1795                 NetConn_Write(cls.connect_mysocket, net_message.data, net_message.cursize, &cls.connect_address);
1796                 SZ_Clear(&net_message);
1797         }
1798         for (i = 0;i < cl_numsockets;i++)
1799                 while (cl_sockets[i] && (length = NetConn_Read(cl_sockets[i], readbuffer, sizeof(readbuffer), &peeraddress)) > 0)
1800                         NetConn_ClientParsePacket(cl_sockets[i], readbuffer, length, &peeraddress);
1801         NetConn_QueryQueueFrame();
1802         if (cls.netcon && realtime > cls.netcon->timeout && !sv.active)
1803         {
1804                 Con_Print("Connection timed out\n");
1805                 CL_Disconnect();
1806                 Host_ShutdownServer ();
1807         }
1808 }
1809
1810 #define MAX_CHALLENGES 128
1811 struct challenge_s
1812 {
1813         lhnetaddress_t address;
1814         double time;
1815         char string[12];
1816 }
1817 challenge[MAX_CHALLENGES];
1818
1819 static void NetConn_BuildChallengeString(char *buffer, int bufferlength)
1820 {
1821         int i;
1822         char c;
1823         for (i = 0;i < bufferlength - 1;i++)
1824         {
1825                 do
1826                 {
1827                         c = rand () % (127 - 33) + 33;
1828                 } while (c == '\\' || c == ';' || c == '"' || c == '%' || c == '/');
1829                 buffer[i] = c;
1830         }
1831         buffer[i] = 0;
1832 }
1833
1834 static qboolean NetConn_BuildStatusResponse(const char* challenge, char* out_msg, size_t out_size, qboolean fullstatus)
1835 {
1836         unsigned int nb_clients = 0, nb_bots = 0, i;
1837         int length;
1838
1839         // How many clients are there?
1840         for (i = 0;i < (unsigned int)svs.maxclients;i++)
1841         {
1842                 if (svs.clients[i].active)
1843                 {
1844                         nb_clients++;
1845                         if (!svs.clients[i].netconnection)
1846                                 nb_bots++;
1847                 }
1848         }
1849
1850         // TODO: we should add more information for the full status string
1851         length = dpsnprintf(out_msg, out_size,
1852                                                 "\377\377\377\377%s\x0A"
1853                                                 "\\gamename\\%s\\modname\\%s\\gameversion\\%d\\sv_maxclients\\%d"
1854                                                 "\\clients\\%d\\bots\\%d\\mapname\\%s\\hostname\\%s\\protocol\\%d"
1855                                                 "%s%s"
1856                                                 "%s",
1857                                                 fullstatus ? "statusResponse" : "infoResponse",
1858                                                 gamename, com_modname, gameversion.integer, svs.maxclients,
1859                                                 nb_clients, nb_bots, sv.name, hostname.string, NET_PROTOCOL_VERSION,
1860                                                 challenge ? "\\challenge\\" : "", challenge ? challenge : "",
1861                                                 fullstatus ? "\n" : "");
1862
1863         // Make sure it fits in the buffer
1864         if (length < 0)
1865                 return false;
1866
1867         if (fullstatus)
1868         {
1869                 char *ptr;
1870                 int left;
1871
1872                 ptr = out_msg + length;
1873                 left = (int)out_size - length;
1874
1875                 for (i = 0;i < (unsigned int)svs.maxclients;i++)
1876                 {
1877                         client_t *cl = &svs.clients[i];
1878                         if (cl->active)
1879                         {
1880                                 int nameind, cleanind, pingvalue;
1881                                 char curchar;
1882                                 char cleanname [sizeof(cl->name)];
1883
1884                                 // Remove all characters '"' and '\' in the player name
1885                                 nameind = 0;
1886                                 cleanind = 0;
1887                                 do
1888                                 {
1889                                         curchar = cl->name[nameind++];
1890                                         if (curchar != '"' && curchar != '\\')
1891                                         {
1892                                                 cleanname[cleanind++] = curchar;
1893                                                 if (cleanind == sizeof(cleanname) - 1)
1894                                                         break;
1895                                         }
1896                                 } while (curchar != '\0');
1897
1898                                 pingvalue = (int)(cl->ping * 1000.0f);
1899                                 if(cl->netconnection)
1900                                         pingvalue = bound(1, pingvalue, 9999);
1901                                 else
1902                                         pingvalue = 0;
1903                                 length = dpsnprintf(ptr, left, "%d %d \"%s\"\n",
1904                                                                         cl->frags,
1905                                                                         pingvalue,
1906                                                                         cleanname);
1907                                 if(length < 0)
1908                                         return false;
1909                                 left -= length;
1910                                 ptr += length;
1911                         }
1912                 }
1913         }
1914
1915         return true;
1916 }
1917
1918 static qboolean NetConn_PreventConnectFlood(lhnetaddress_t *peeraddress)
1919 {
1920         int floodslotnum, bestfloodslotnum;
1921         double bestfloodtime;
1922         lhnetaddress_t noportpeeraddress;
1923         // see if this is a connect flood
1924         noportpeeraddress = *peeraddress;
1925         LHNETADDRESS_SetPort(&noportpeeraddress, 0);
1926         bestfloodslotnum = 0;
1927         bestfloodtime = sv.connectfloodaddresses[bestfloodslotnum].lasttime;
1928         for (floodslotnum = 0;floodslotnum < MAX_CONNECTFLOODADDRESSES;floodslotnum++)
1929         {
1930                 if (bestfloodtime >= sv.connectfloodaddresses[floodslotnum].lasttime)
1931                 {
1932                         bestfloodtime = sv.connectfloodaddresses[floodslotnum].lasttime;
1933                         bestfloodslotnum = floodslotnum;
1934                 }
1935                 if (sv.connectfloodaddresses[floodslotnum].lasttime && LHNETADDRESS_Compare(&noportpeeraddress, &sv.connectfloodaddresses[floodslotnum].address) == 0)
1936                 {
1937                         // this address matches an ongoing flood address
1938                         if (realtime < sv.connectfloodaddresses[floodslotnum].lasttime + net_connectfloodblockingtimeout.value)
1939                         {
1940                                 // renew the ban on this address so it does not expire
1941                                 // until the flood has subsided
1942                                 sv.connectfloodaddresses[floodslotnum].lasttime = realtime;
1943                                 //Con_Printf("Flood detected!\n");
1944                                 return true;
1945                         }
1946                         // the flood appears to have subsided, so allow this
1947                         bestfloodslotnum = floodslotnum; // reuse the same slot
1948                         break;
1949                 }
1950         }
1951         // begin a new timeout on this address
1952         sv.connectfloodaddresses[bestfloodslotnum].address = noportpeeraddress;
1953         sv.connectfloodaddresses[bestfloodslotnum].lasttime = realtime;
1954         //Con_Printf("Flood detection initiated!\n");
1955         return false;
1956 }
1957
1958 void NetConn_ClearConnectFlood(lhnetaddress_t *peeraddress)
1959 {
1960         int floodslotnum;
1961         lhnetaddress_t noportpeeraddress;
1962         // see if this is a connect flood
1963         noportpeeraddress = *peeraddress;
1964         LHNETADDRESS_SetPort(&noportpeeraddress, 0);
1965         for (floodslotnum = 0;floodslotnum < MAX_CONNECTFLOODADDRESSES;floodslotnum++)
1966         {
1967                 if (sv.connectfloodaddresses[floodslotnum].lasttime && LHNETADDRESS_Compare(&noportpeeraddress, &sv.connectfloodaddresses[floodslotnum].address) == 0)
1968                 {
1969                         // this address matches an ongoing flood address
1970                         // remove the ban
1971                         sv.connectfloodaddresses[floodslotnum].address.addresstype = LHNETADDRESSTYPE_NONE;
1972                         sv.connectfloodaddresses[floodslotnum].lasttime = 0;
1973                         //Con_Printf("Flood cleared!\n");
1974                 }
1975         }
1976 }
1977
1978 qboolean RCon_Authenticate(const char *password, const char *s, const char *endpos)
1979 {
1980         const char *text;
1981
1982         if(!strcmp(rcon_password.string, password))
1983                 return true;
1984         
1985         if(strcmp(rcon_restricted_password.string, password))
1986                 return false;
1987
1988         for(text = s; text != endpos; ++text)
1989                 if(*text > 0 && (*text < ' ' || *text == ';'))
1990                         return false; // block possible exploits against the parser/alias expansion
1991
1992         while(s != endpos)
1993         {
1994                 size_t l = strlen(s);
1995                 if(l)
1996                 {
1997                         text = s;
1998
1999                         if (!COM_ParseToken_Console(&text))
2000                                 return false;
2001
2002                         // com_token now contains the command
2003                         if(!strstr(va(" %s ", rcon_restricted_commands.string), va(" %s ", com_token)))
2004                                 return false;
2005                 }
2006                 s += l + 1;
2007         }
2008
2009         return true;
2010 }
2011
2012 extern void SV_SendServerinfo (client_t *client);
2013 static int NetConn_ServerParsePacket(lhnetsocket_t *mysocket, unsigned char *data, int length, lhnetaddress_t *peeraddress)
2014 {
2015         int i, ret, clientnum, best;
2016         double besttime;
2017         client_t *client;
2018         char *s, *string, response[1400], addressstring2[128], stringbuf[16384];
2019         qboolean islocal = (LHNETADDRESS_GetAddressType(peeraddress) == LHNETADDRESSTYPE_LOOP);
2020
2021         if (!sv.active)
2022                 return false;
2023
2024         // convert the address to a string incase we need it
2025         LHNETADDRESS_ToString(peeraddress, addressstring2, sizeof(addressstring2), true);
2026
2027         // see if we can identify the sender as a local player
2028         // (this is necessary for rcon to send a reliable reply if the client is
2029         //  actually on the server, not sending remotely)
2030         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2031                 if (host_client->netconnection && host_client->netconnection->mysocket == mysocket && !LHNETADDRESS_Compare(&host_client->netconnection->peeraddress, peeraddress))
2032                         break;
2033         if (i == svs.maxclients)
2034                 host_client = NULL;
2035
2036         if (length >= 5 && data[0] == 255 && data[1] == 255 && data[2] == 255 && data[3] == 255)
2037         {
2038                 // received a command string - strip off the packaging and put it
2039                 // into our string buffer with NULL termination
2040                 data += 4;
2041                 length -= 4;
2042                 length = min(length, (int)sizeof(stringbuf) - 1);
2043                 memcpy(stringbuf, data, length);
2044                 stringbuf[length] = 0;
2045                 string = stringbuf;
2046
2047                 if (developer.integer >= 10)
2048                 {
2049                         Con_Printf("NetConn_ServerParsePacket: %s sent us a command:\n", addressstring2);
2050                         Com_HexDumpToConsole(data, length);
2051                 }
2052
2053                 if (length >= 12 && !memcmp(string, "getchallenge", 12) && (islocal || sv_public.integer > -2))
2054                 {
2055                         for (i = 0, best = 0, besttime = realtime;i < MAX_CHALLENGES;i++)
2056                         {
2057                                 if (!LHNETADDRESS_Compare(peeraddress, &challenge[i].address))
2058                                         break;
2059                                 if (besttime > challenge[i].time)
2060                                         besttime = challenge[best = i].time;
2061                         }
2062                         // if we did not find an exact match, choose the oldest and
2063                         // update address and string
2064                         if (i == MAX_CHALLENGES)
2065                         {
2066                                 i = best;
2067                                 challenge[i].address = *peeraddress;
2068                                 NetConn_BuildChallengeString(challenge[i].string, sizeof(challenge[i].string));
2069                         }
2070                         challenge[i].time = realtime;
2071                         // send the challenge
2072                         NetConn_WriteString(mysocket, va("\377\377\377\377challenge %s", challenge[i].string), peeraddress);
2073                         return true;
2074                 }
2075                 if (length > 8 && !memcmp(string, "connect\\", 8) && (islocal || sv_public.integer > -2))
2076                 {
2077                         string += 7;
2078                         length -= 7;
2079
2080                         if (!(s = SearchInfostring(string, "challenge")))
2081                                 return true;
2082                         // validate the challenge
2083                         for (i = 0;i < MAX_CHALLENGES;i++)
2084                                 if (!LHNETADDRESS_Compare(peeraddress, &challenge[i].address) && !strcmp(challenge[i].string, s))
2085                                         break;
2086                         // if the challenge is not recognized, drop the packet
2087                         if (i == MAX_CHALLENGES)
2088                                 return true;
2089
2090                         // check engine protocol
2091                         if (strcmp(SearchInfostring(string, "protocol"), "darkplaces 3"))
2092                         {
2093                                 if (developer.integer >= 10)
2094                                         Con_Printf("Datagram_ParseConnectionless: sending \"reject Wrong game protocol.\" to %s.\n", addressstring2);
2095                                 NetConn_WriteString(mysocket, "\377\377\377\377reject Wrong game protocol.", peeraddress);
2096                                 return true;
2097                         }
2098
2099                         // see if this is a duplicate connection request or a disconnected
2100                         // client who is rejoining to the same client slot
2101                         for (clientnum = 0, client = svs.clients;clientnum < svs.maxclients;clientnum++, client++)
2102                         {
2103                                 if (client->netconnection && LHNETADDRESS_Compare(peeraddress, &client->netconnection->peeraddress) == 0)
2104                                 {
2105                                         // this is a known client...
2106                                         if (client->spawned)
2107                                         {
2108                                                 // client crashed and is coming back,
2109                                                 // keep their stuff intact
2110                                                 if (developer.integer >= 10)
2111                                                         Con_Printf("Datagram_ParseConnectionless: sending \"accept\" to %s.\n", addressstring2);
2112                                                 NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
2113                                                 SV_VM_Begin();
2114                                                 SV_SendServerinfo(client);
2115                                                 SV_VM_End();
2116                                         }
2117                                         else
2118                                         {
2119                                                 // client is still trying to connect,
2120                                                 // so we send a duplicate reply
2121                                                 if (developer.integer >= 10)
2122                                                         Con_Printf("Datagram_ParseConnectionless: sending duplicate accept to %s.\n", addressstring2);
2123                                                 NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
2124                                         }
2125                                         return true;
2126                                 }
2127                         }
2128
2129                         if (NetConn_PreventConnectFlood(peeraddress))
2130                                 return true;
2131
2132                         // find an empty client slot for this new client
2133                         for (clientnum = 0, client = svs.clients;clientnum < svs.maxclients;clientnum++, client++)
2134                         {
2135                                 netconn_t *conn;
2136                                 if (!client->active && (conn = NetConn_Open(mysocket, peeraddress)))
2137                                 {
2138                                         // allocated connection
2139                                         if (developer.integer >= 10)
2140                                                 Con_Printf("Datagram_ParseConnectionless: sending \"accept\" to %s.\n", conn->address);
2141                                         NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
2142                                         // now set up the client
2143                                         SV_VM_Begin();
2144                                         SV_ConnectClient(clientnum, conn);
2145                                         SV_VM_End();
2146                                         NetConn_Heartbeat(1);
2147                                         return true;
2148                                 }
2149                         }
2150
2151                         // no empty slots found - server is full
2152                         if (developer.integer >= 10)
2153                                 Con_Printf("Datagram_ParseConnectionless: sending \"reject Server is full.\" to %s.\n", addressstring2);
2154                         NetConn_WriteString(mysocket, "\377\377\377\377reject Server is full.", peeraddress);
2155
2156                         return true;
2157                 }
2158                 if (length >= 7 && !memcmp(string, "getinfo", 7) && (islocal || sv_public.integer > -1))
2159                 {
2160                         const char *challenge = NULL;
2161
2162                         // If there was a challenge in the getinfo message
2163                         if (length > 8 && string[7] == ' ')
2164                                 challenge = string + 8;
2165
2166                         if (NetConn_BuildStatusResponse(challenge, response, sizeof(response), false))
2167                         {
2168                                 if (developer.integer >= 10)
2169                                         Con_Printf("Sending reply to master %s - %s\n", addressstring2, response);
2170                                 NetConn_WriteString(mysocket, response, peeraddress);
2171                         }
2172                         return true;
2173                 }
2174                 if (length >= 9 && !memcmp(string, "getstatus", 9) && (islocal || sv_public.integer > -1))
2175                 {
2176                         const char *challenge = NULL;
2177
2178                         // If there was a challenge in the getinfo message
2179                         if (length > 10 && string[9] == ' ')
2180                                 challenge = string + 10;
2181
2182                         if (NetConn_BuildStatusResponse(challenge, response, sizeof(response), true))
2183                         {
2184                                 if (developer.integer >= 10)
2185                                         Con_Printf("Sending reply to client %s - %s\n", addressstring2, response);
2186                                 NetConn_WriteString(mysocket, response, peeraddress);
2187                         }
2188                         return true;
2189                 }
2190                 if (length >= 5 && !memcmp(string, "rcon ", 5))
2191                 {
2192                         int i;
2193                         char *s = string + 5;
2194                         char *endpos = string + length + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
2195                         char password[64];
2196                         for (i = 0;*s > ' ';s++)
2197                                 if (i < (int)sizeof(password) - 1)
2198                                         password[i++] = *s;
2199                         if(*s <= ' ' && s != endpos) // skip leading ugly space
2200                                 ++s;
2201                         password[i] = 0;
2202                         if (password[0] > ' ')
2203                         {
2204                                 if (RCon_Authenticate(password, s, endpos))
2205                                 {
2206                                         // looks like a legitimate rcon command with the correct password
2207                                         char *s_ptr = s;
2208                                         Con_Printf("server received rcon command from %s:\n", host_client ? host_client->name : addressstring2);
2209                                         while(s_ptr != endpos)
2210                                         {
2211                                                 size_t l = strlen(s_ptr);
2212                                                 if(l)
2213                                                         Con_Printf(" %s;", s_ptr);
2214                                                 s_ptr += l + 1;
2215                                         }
2216                                         Con_Printf("\n");
2217                                         rcon_redirect = true;
2218                                         rcon_redirect_bufferpos = 0;
2219                                         while(s != endpos)
2220                                         {
2221                                                 size_t l = strlen(s);
2222                                                 if(l)
2223                                                         Cmd_ExecuteString(s, src_command);
2224                                                 s += l + 1;
2225                                         }
2226                                         rcon_redirect_buffer[rcon_redirect_bufferpos] = 0;
2227                                         rcon_redirect = false;
2228                                         // print resulting text to client
2229                                         // if client is playing, send a reliable reply instead of
2230                                         // a command packet
2231                                         if (host_client)
2232                                         {
2233                                                 // if the netconnection is loop, then this is the
2234                                                 // local player on a listen mode server, and it would
2235                                                 // result in duplicate printing to the console
2236                                                 // (not that the local player should be using rcon
2237                                                 //  when they have the console)
2238                                                 if (host_client->netconnection && LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
2239                                                         SV_ClientPrintf("%s", rcon_redirect_buffer);
2240                                         }
2241                                         else
2242                                         {
2243                                                 // qw print command
2244                                                 dpsnprintf(response, sizeof(response), "\377\377\377\377n%s", rcon_redirect_buffer);
2245                                                 NetConn_WriteString(mysocket, response, peeraddress);
2246                                         }
2247                                 }
2248                                 else
2249                                 {
2250                                         Con_Printf("server denied rcon access to %s\n", host_client ? host_client->name : addressstring2);
2251                                 }
2252                         }
2253                         return true;
2254                 }
2255                 if (!strncmp(string, "ping", 4))
2256                 {
2257                         if (developer.integer >= 10)
2258                                 Con_Printf("Received ping from %s, sending ack\n", addressstring2);
2259                         NetConn_WriteString(mysocket, "\377\377\377\377ack", peeraddress);
2260                         return true;
2261                 }
2262                 if (!strncmp(string, "ack", 3))
2263                         return true;
2264                 // we may not have liked the packet, but it was a command packet, so
2265                 // we're done processing this packet now
2266                 return true;
2267         }
2268         // netquake control packets, supported for compatibility only, and only
2269         // when running game protocols that are normally served via this connection
2270         // protocol
2271         // (this protects more modern protocols against being used for
2272         //  Quake packet flood Denial Of Service attacks)
2273         if (length >= 5 && (i = BigLong(*((int *)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))
2274         {
2275                 int c;
2276                 int protocolnumber;
2277                 const char *protocolname;
2278                 data += 4;
2279                 length -= 4;
2280                 SZ_Clear(&net_message);
2281                 SZ_Write(&net_message, data, length);
2282                 MSG_BeginReading();
2283                 c = MSG_ReadByte();
2284                 switch (c)
2285                 {
2286                 case CCREQ_CONNECT:
2287                         if (developer.integer >= 10)
2288                                 Con_Printf("Datagram_ParseConnectionless: received CCREQ_CONNECT from %s.\n", addressstring2);
2289                         if(!islocal && sv_public.integer <= -2)
2290                                 break;
2291
2292                         protocolname = MSG_ReadString();
2293                         protocolnumber = MSG_ReadByte();
2294                         if (strcmp(protocolname, "QUAKE") || protocolnumber != NET_PROTOCOL_VERSION)
2295                         {
2296                                 if (developer.integer >= 10)
2297                                         Con_Printf("Datagram_ParseConnectionless: sending CCREP_REJECT \"Incompatible version.\" to %s.\n", addressstring2);
2298                                 SZ_Clear(&net_message);
2299                                 // save space for the header, filled in later
2300                                 MSG_WriteLong(&net_message, 0);
2301                                 MSG_WriteByte(&net_message, CCREP_REJECT);
2302                                 MSG_WriteString(&net_message, "Incompatible version.\n");
2303                                 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
2304                                 NetConn_Write(mysocket, net_message.data, net_message.cursize, peeraddress);
2305                                 SZ_Clear(&net_message);
2306                                 break;
2307                         }
2308
2309                         // see if this connect request comes from a known client
2310                         for (clientnum = 0, client = svs.clients;clientnum < svs.maxclients;clientnum++, client++)
2311                         {
2312                                 if (client->netconnection && LHNETADDRESS_Compare(peeraddress, &client->netconnection->peeraddress) == 0)
2313                                 {
2314                                         // this is either a duplicate connection request
2315                                         // or coming back from a timeout
2316                                         // (if so, keep their stuff intact)
2317
2318                                         // send a reply
2319                                         if (developer.integer >= 10)
2320                                                 Con_Printf("Datagram_ParseConnectionless: sending duplicate CCREP_ACCEPT to %s.\n", addressstring2);
2321                                         SZ_Clear(&net_message);
2322                                         // save space for the header, filled in later
2323                                         MSG_WriteLong(&net_message, 0);
2324                                         MSG_WriteByte(&net_message, CCREP_ACCEPT);
2325                                         MSG_WriteLong(&net_message, LHNETADDRESS_GetPort(LHNET_AddressFromSocket(client->netconnection->mysocket)));
2326                                         *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
2327                                         NetConn_Write(mysocket, net_message.data, net_message.cursize, peeraddress);
2328                                         SZ_Clear(&net_message);
2329
2330                                         // if client is already spawned, re-send the
2331                                         // serverinfo message as they'll need it to play
2332                                         if (client->spawned)
2333                                         {
2334                                                 SV_VM_Begin();
2335                                                 SV_SendServerinfo(client);
2336                                                 SV_VM_End();
2337                                         }
2338                                         return true;
2339                                 }
2340                         }
2341
2342                         // this is a new client, check for connection flood
2343                         if (NetConn_PreventConnectFlood(peeraddress))
2344                                 break;
2345
2346                         // find a slot for the new client
2347                         for (clientnum = 0, client = svs.clients;clientnum < svs.maxclients;clientnum++, client++)
2348                         {
2349                                 netconn_t *conn;
2350                                 if (!client->active && (client->netconnection = conn = NetConn_Open(mysocket, peeraddress)) != NULL)
2351                                 {
2352                                         // connect to the client
2353                                         // everything is allocated, just fill in the details
2354                                         strlcpy (conn->address, addressstring2, sizeof (conn->address));
2355                                         if (developer.integer >= 10)
2356                                                 Con_Printf("Datagram_ParseConnectionless: sending CCREP_ACCEPT to %s.\n", addressstring2);
2357                                         // send back the info about the server connection
2358                                         SZ_Clear(&net_message);
2359                                         // save space for the header, filled in later
2360                                         MSG_WriteLong(&net_message, 0);
2361                                         MSG_WriteByte(&net_message, CCREP_ACCEPT);
2362                                         MSG_WriteLong(&net_message, LHNETADDRESS_GetPort(LHNET_AddressFromSocket(conn->mysocket)));
2363                                         *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
2364                                         NetConn_Write(mysocket, net_message.data, net_message.cursize, peeraddress);
2365                                         SZ_Clear(&net_message);
2366                                         // now set up the client struct
2367                                         SV_VM_Begin();
2368                                         SV_ConnectClient(clientnum, conn);
2369                                         SV_VM_End();
2370                                         NetConn_Heartbeat(1);
2371                                         return true;
2372                                 }
2373                         }
2374
2375                         if (developer.integer >= 10)
2376                                 Con_Printf("Datagram_ParseConnectionless: sending CCREP_REJECT \"Server is full.\" to %s.\n", addressstring2);
2377                         // no room; try to let player know
2378                         SZ_Clear(&net_message);
2379                         // save space for the header, filled in later
2380                         MSG_WriteLong(&net_message, 0);
2381                         MSG_WriteByte(&net_message, CCREP_REJECT);
2382                         MSG_WriteString(&net_message, "Server is full.\n");
2383                         *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
2384                         NetConn_Write(mysocket, net_message.data, net_message.cursize, peeraddress);
2385                         SZ_Clear(&net_message);
2386                         break;
2387                 case CCREQ_SERVER_INFO:
2388                         if (developer.integer >= 10)
2389                                 Con_Printf("Datagram_ParseConnectionless: received CCREQ_SERVER_INFO from %s.\n", addressstring2);
2390                         if(!islocal && sv_public.integer <= -1)
2391                                 break;
2392                         if (sv.active && !strcmp(MSG_ReadString(), "QUAKE"))
2393                         {
2394                                 int numclients;
2395                                 char myaddressstring[128];
2396                                 if (developer.integer >= 10)
2397                                         Con_Printf("Datagram_ParseConnectionless: sending CCREP_SERVER_INFO to %s.\n", addressstring2);
2398                                 SZ_Clear(&net_message);
2399                                 // save space for the header, filled in later
2400                                 MSG_WriteLong(&net_message, 0);
2401                                 MSG_WriteByte(&net_message, CCREP_SERVER_INFO);
2402                                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(mysocket), myaddressstring, sizeof(myaddressstring), true);
2403                                 MSG_WriteString(&net_message, myaddressstring);
2404                                 MSG_WriteString(&net_message, hostname.string);
2405                                 MSG_WriteString(&net_message, sv.name);
2406                                 // How many clients are there?
2407                                 for (i = 0, numclients = 0;i < svs.maxclients;i++)
2408                                         if (svs.clients[i].active)
2409                                                 numclients++;
2410                                 MSG_WriteByte(&net_message, numclients);
2411                                 MSG_WriteByte(&net_message, svs.maxclients);
2412                                 MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
2413                                 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
2414                                 NetConn_Write(mysocket, net_message.data, net_message.cursize, peeraddress);
2415                                 SZ_Clear(&net_message);
2416                         }
2417                         break;
2418                 case CCREQ_PLAYER_INFO:
2419                         if (developer.integer >= 10)
2420                                 Con_Printf("Datagram_ParseConnectionless: received CCREQ_PLAYER_INFO from %s.\n", addressstring2);
2421                         if(!islocal && sv_public.integer <= -1)
2422                                 break;
2423                         if (sv.active)
2424                         {
2425                                 int playerNumber, activeNumber, clientNumber;
2426                                 client_t *client;
2427
2428                                 playerNumber = MSG_ReadByte();
2429                                 activeNumber = -1;
2430                                 for (clientNumber = 0, client = svs.clients; clientNumber < svs.maxclients; clientNumber++, client++)
2431                                         if (client->active && ++activeNumber == playerNumber)
2432                                                 break;
2433                                 if (clientNumber != svs.maxclients)
2434                                 {
2435                                         SZ_Clear(&net_message);
2436                                         // save space for the header, filled in later
2437                                         MSG_WriteLong(&net_message, 0);
2438                                         MSG_WriteByte(&net_message, CCREP_PLAYER_INFO);
2439                                         MSG_WriteByte(&net_message, playerNumber);
2440                                         MSG_WriteString(&net_message, client->name);
2441                                         MSG_WriteLong(&net_message, client->colors);
2442                                         MSG_WriteLong(&net_message, client->frags);
2443                                         MSG_WriteLong(&net_message, (int)(realtime - client->connecttime));
2444                                         MSG_WriteString(&net_message, client->netconnection ? client->netconnection->address : "botclient");
2445                                         *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
2446                                         NetConn_Write(mysocket, net_message.data, net_message.cursize, peeraddress);
2447                                         SZ_Clear(&net_message);
2448                                 }
2449                         }
2450                         break;
2451                 case CCREQ_RULE_INFO:
2452                         if (developer.integer >= 10)
2453                                 Con_Printf("Datagram_ParseConnectionless: received CCREQ_RULE_INFO from %s.\n", addressstring2);
2454                         if(!islocal && sv_public.integer <= -1)
2455                                 break;
2456                         if (sv.active)
2457                         {
2458                                 char *prevCvarName;
2459                                 cvar_t *var;
2460
2461                                 // find the search start location
2462                                 prevCvarName = MSG_ReadString();
2463                                 var = Cvar_FindVarAfter(prevCvarName, CVAR_NOTIFY);
2464
2465                                 // send the response
2466                                 SZ_Clear(&net_message);
2467                                 // save space for the header, filled in later
2468                                 MSG_WriteLong(&net_message, 0);
2469                                 MSG_WriteByte(&net_message, CCREP_RULE_INFO);
2470                                 if (var)
2471                                 {
2472                                         MSG_WriteString(&net_message, var->name);
2473                                         MSG_WriteString(&net_message, var->string);
2474                                 }
2475                                 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
2476                                 NetConn_Write(mysocket, net_message.data, net_message.cursize, peeraddress);
2477                                 SZ_Clear(&net_message);
2478                         }
2479                         break;
2480                 default:
2481                         break;
2482                 }
2483                 SZ_Clear(&net_message);
2484                 // we may not have liked the packet, but it was a valid control
2485                 // packet, so we're done processing this packet now
2486                 return true;
2487         }
2488         if (host_client)
2489         {
2490                 if ((ret = NetConn_ReceivedMessage(host_client->netconnection, data, length, sv.protocol, host_client->spawned ? net_messagetimeout.value : net_connecttimeout.value)) == 2)
2491                 {
2492                         SV_VM_Begin();
2493                         SV_ReadClientMessage();
2494                         SV_VM_End();
2495                         return ret;
2496                 }
2497         }
2498         return 0;
2499 }
2500
2501 void NetConn_ServerFrame(void)
2502 {
2503         int i, length;
2504         lhnetaddress_t peeraddress;
2505         for (i = 0;i < sv_numsockets;i++)
2506                 while (sv_sockets[i] && (length = NetConn_Read(sv_sockets[i], readbuffer, sizeof(readbuffer), &peeraddress)) > 0)
2507                         NetConn_ServerParsePacket(sv_sockets[i], readbuffer, length, &peeraddress);
2508         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2509         {
2510                 // never timeout loopback connections
2511                 if (host_client->netconnection && realtime > host_client->netconnection->timeout && LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
2512                 {
2513                         Con_Printf("Client \"%s\" connection timed out\n", host_client->name);
2514                         SV_VM_Begin();
2515                         SV_DropClient(false);
2516                         SV_VM_End();
2517                 }
2518         }
2519 }
2520
2521 void NetConn_SleepMicroseconds(int microseconds)
2522 {
2523         LHNET_SleepUntilPacket_Microseconds(microseconds);
2524 }
2525
2526 void NetConn_QueryMasters(qboolean querydp, qboolean queryqw)
2527 {
2528         int i;
2529         int masternum;
2530         lhnetaddress_t masteraddress;
2531         lhnetaddress_t broadcastaddress;
2532         char request[256];
2533
2534         if (serverlist_cachecount >= SERVERLIST_TOTALSIZE)
2535                 return;
2536
2537         // 26000 is the default quake server port, servers on other ports will not
2538         // be found
2539         // note this is IPv4-only, I doubt there are IPv6-only LANs out there
2540         LHNETADDRESS_FromString(&broadcastaddress, "255.255.255.255", 26000);
2541
2542         if (querydp)
2543         {
2544                 for (i = 0;i < cl_numsockets;i++)
2545                 {
2546                         if (cl_sockets[i])
2547                         {
2548                                 // search LAN for Quake servers
2549                                 SZ_Clear(&net_message);
2550                                 // save space for the header, filled in later
2551                                 MSG_WriteLong(&net_message, 0);
2552                                 MSG_WriteByte(&net_message, CCREQ_SERVER_INFO);
2553                                 MSG_WriteString(&net_message, "QUAKE");
2554                                 MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
2555                                 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
2556                                 NetConn_Write(cl_sockets[i], net_message.data, net_message.cursize, &broadcastaddress);
2557                                 SZ_Clear(&net_message);
2558
2559                                 // search LAN for DarkPlaces servers
2560                                 NetConn_WriteString(cl_sockets[i], "\377\377\377\377getinfo", &broadcastaddress);
2561
2562                                 // build the getservers message to send to the dpmaster master servers
2563                                 dpsnprintf(request, sizeof(request), "\377\377\377\377getservers %s %u empty full\x0A", gamename, NET_PROTOCOL_VERSION);
2564
2565                                 // search internet
2566                                 for (masternum = 0;sv_masters[masternum].name;masternum++)
2567                                 {
2568                                         if (sv_masters[masternum].string && sv_masters[masternum].string[0] && LHNETADDRESS_FromString(&masteraddress, sv_masters[masternum].string, DPMASTER_PORT) && LHNETADDRESS_GetAddressType(&masteraddress) == LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i])))
2569                                         {
2570                                                 masterquerycount++;
2571                                                 NetConn_WriteString(cl_sockets[i], request, &masteraddress);
2572                                         }
2573                                 }
2574                         }
2575                 }
2576         }
2577
2578         // only query QuakeWorld servers when the user wants to
2579         if (queryqw)
2580         {
2581                 for (i = 0;i < cl_numsockets;i++)
2582                 {
2583                         if (cl_sockets[i])
2584                         {
2585                                 // search LAN for QuakeWorld servers
2586                                 NetConn_WriteString(cl_sockets[i], "\377\377\377\377status\n", &broadcastaddress);
2587
2588                                 // build the getservers message to send to the qwmaster master servers
2589                                 // note this has no -1 prefix, and the trailing nul byte is sent
2590                                 dpsnprintf(request, sizeof(request), "c\n");
2591
2592                                 // search internet
2593                                 for (masternum = 0;sv_qwmasters[masternum].name;masternum++)
2594                                 {
2595                                         if (sv_qwmasters[masternum].string && LHNETADDRESS_FromString(&masteraddress, sv_qwmasters[masternum].string, QWMASTER_PORT) && LHNETADDRESS_GetAddressType(&masteraddress) == LHNETADDRESS_GetAddressType(LHNET_AddressFromSocket(cl_sockets[i])))
2596                                         {
2597                                                 if (m_state != m_slist)
2598                                                 {
2599                                                         char lookupstring[128];
2600                                                         LHNETADDRESS_ToString(&masteraddress, lookupstring, sizeof(lookupstring), true);
2601                                                         Con_Printf("Querying master %s (resolved from %s)\n", lookupstring, sv_qwmasters[masternum].string);
2602                                                 }
2603                                                 masterquerycount++;
2604                                                 NetConn_Write(cl_sockets[i], request, (int)strlen(request) + 1, &masteraddress);
2605                                         }
2606                                 }
2607                         }
2608                 }
2609         }
2610         if (!masterquerycount)
2611         {
2612                 Con_Print("Unable to query master servers, no suitable network sockets active.\n");
2613                 M_Update_Return_Reason("No network");
2614         }
2615 }
2616
2617 void NetConn_Heartbeat(int priority)
2618 {
2619         lhnetaddress_t masteraddress;
2620         int masternum;
2621         lhnetsocket_t *mysocket;
2622
2623         // if it's a state change (client connected), limit next heartbeat to no
2624         // more than 30 sec in the future
2625         if (priority == 1 && nextheartbeattime > realtime + 30.0)
2626                 nextheartbeattime = realtime + 30.0;
2627
2628         // limit heartbeatperiod to 30 to 270 second range,
2629         // lower limit is to avoid abusing master servers with excess traffic,
2630         // upper limit is to avoid timing out on the master server (which uses
2631         // 300 sec timeout)
2632         if (sv_heartbeatperiod.value < 30)
2633                 Cvar_SetValueQuick(&sv_heartbeatperiod, 30);
2634         if (sv_heartbeatperiod.value > 270)
2635                 Cvar_SetValueQuick(&sv_heartbeatperiod, 270);
2636
2637         // make advertising optional and don't advertise singleplayer games, and
2638         // only send a heartbeat as often as the admin wants
2639         if (sv.active && sv_public.integer > 0 && svs.maxclients >= 2 && (priority > 1 || realtime > nextheartbeattime))
2640         {
2641                 nextheartbeattime = realtime + sv_heartbeatperiod.value;
2642                 for (masternum = 0;sv_masters[masternum].name;masternum++)
2643                         if (sv_masters[masternum].string && sv_masters[masternum].string[0] && LHNETADDRESS_FromString(&masteraddress, sv_masters[masternum].string, DPMASTER_PORT) && (mysocket = NetConn_ChooseServerSocketForAddress(&masteraddress)))
2644                                 NetConn_WriteString(mysocket, "\377\377\377\377heartbeat DarkPlaces\x0A", &masteraddress);
2645         }
2646 }
2647
2648 static void Net_Heartbeat_f(void)
2649 {
2650         if (sv.active)
2651                 NetConn_Heartbeat(2);
2652         else
2653                 Con_Print("No server running, can not heartbeat to master server.\n");
2654 }
2655
2656 void PrintStats(netconn_t *conn)
2657 {
2658         if ((cls.state == ca_connected && cls.protocol == PROTOCOL_QUAKEWORLD) || (sv.active && sv.protocol == PROTOCOL_QUAKEWORLD))
2659                 Con_Printf("address=%21s canSend=%u sendSeq=%6u recvSeq=%6u\n", conn->address, !conn->sendMessageLength, conn->outgoing_unreliable_sequence, conn->qw.incoming_sequence);
2660         else
2661                 Con_Printf("address=%21s canSend=%u sendSeq=%6u recvSeq=%6u\n", conn->address, !conn->sendMessageLength, conn->nq.sendSequence, conn->nq.receiveSequence);
2662 }
2663
2664 void Net_Stats_f(void)
2665 {
2666         netconn_t *conn;
2667         Con_Printf("unreliable messages sent   = %i\n", unreliableMessagesSent);
2668         Con_Printf("unreliable messages recv   = %i\n", unreliableMessagesReceived);
2669         Con_Printf("reliable messages sent     = %i\n", reliableMessagesSent);
2670         Con_Printf("reliable messages received = %i\n", reliableMessagesReceived);
2671         Con_Printf("packetsSent                = %i\n", packetsSent);
2672         Con_Printf("packetsReSent              = %i\n", packetsReSent);
2673         Con_Printf("packetsReceived            = %i\n", packetsReceived);
2674         Con_Printf("receivedDuplicateCount     = %i\n", receivedDuplicateCount);
2675         Con_Printf("droppedDatagrams           = %i\n", droppedDatagrams);
2676         Con_Print("connections                =\n");
2677         for (conn = netconn_list;conn;conn = conn->next)
2678                 PrintStats(conn);
2679 }
2680
2681 void Net_Refresh_f(void)
2682 {
2683         if (m_state != m_slist) {
2684                 Con_Print("Sending new requests to master servers\n");
2685                 ServerList_QueryList(false, true, false, true);
2686                 Con_Print("Listening for replies...\n");
2687         } else
2688                 ServerList_QueryList(false, true, false, false);
2689 }
2690
2691 void Net_Slist_f(void)
2692 {
2693         ServerList_ResetMasks();
2694         serverlist_sortbyfield = SLIF_PING;
2695         serverlist_sortdescending = false;
2696     if (m_state != m_slist) {
2697                 Con_Print("Sending requests to master servers\n");
2698                 ServerList_QueryList(true, true, false, true);
2699                 Con_Print("Listening for replies...\n");
2700         } else
2701                 ServerList_QueryList(true, true, false, false);
2702 }
2703
2704 void Net_SlistQW_f(void)
2705 {
2706         ServerList_ResetMasks();
2707         serverlist_sortbyfield = SLIF_PING;
2708         serverlist_sortdescending = false;
2709     if (m_state != m_slist) {
2710                 Con_Print("Sending requests to master servers\n");
2711                 ServerList_QueryList(true, false, true, true);
2712                 serverlist_consoleoutput = true;
2713                 Con_Print("Listening for replies...\n");
2714         } else
2715                 ServerList_QueryList(true, false, true, false);
2716 }
2717
2718 void NetConn_Init(void)
2719 {
2720         int i;
2721         lhnetaddress_t tempaddress;
2722         netconn_mempool = Mem_AllocPool("network connections", 0, NULL);
2723         Cmd_AddCommand("net_stats", Net_Stats_f, "print network statistics");
2724         Cmd_AddCommand("net_slist", Net_Slist_f, "query dp master servers and print all server information");
2725         Cmd_AddCommand("net_slistqw", Net_SlistQW_f, "query qw master servers and print all server information");
2726         Cmd_AddCommand("net_refresh", Net_Refresh_f, "query dp master servers and refresh all server information");
2727         Cmd_AddCommand("heartbeat", Net_Heartbeat_f, "send a heartbeat to the master server (updates your server information)");
2728         Cvar_RegisterVariable(&rcon_restricted_password);
2729         Cvar_RegisterVariable(&rcon_restricted_commands);
2730         Cvar_RegisterVariable(&net_slist_queriespersecond);
2731         Cvar_RegisterVariable(&net_slist_queriesperframe);
2732         Cvar_RegisterVariable(&net_slist_timeout);
2733         Cvar_RegisterVariable(&net_slist_maxtries);
2734         Cvar_RegisterVariable(&net_slist_pause);
2735         Cvar_RegisterVariable(&net_messagetimeout);
2736         Cvar_RegisterVariable(&net_connecttimeout);
2737         Cvar_RegisterVariable(&net_connectfloodblockingtimeout);
2738         Cvar_RegisterVariable(&cl_netlocalping);
2739         Cvar_RegisterVariable(&cl_netpacketloss_send);
2740         Cvar_RegisterVariable(&cl_netpacketloss_receive);
2741         Cvar_RegisterVariable(&hostname);
2742         Cvar_RegisterVariable(&developer_networking);
2743         Cvar_RegisterVariable(&cl_netport);
2744         Cvar_RegisterVariable(&sv_netport);
2745         Cvar_RegisterVariable(&net_address);
2746         //Cvar_RegisterVariable(&net_address_ipv6);
2747         Cvar_RegisterVariable(&sv_public);
2748         Cvar_RegisterVariable(&sv_heartbeatperiod);
2749         for (i = 0;sv_masters[i].name;i++)
2750                 Cvar_RegisterVariable(&sv_masters[i]);
2751         Cvar_RegisterVariable(&gameversion);
2752 // 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.
2753         if ((i = COM_CheckParm("-ip")) && i + 1 < com_argc)
2754         {
2755                 if (LHNETADDRESS_FromString(&tempaddress, com_argv[i + 1], 0) == 1)
2756                 {
2757                         Con_Printf("-ip option used, setting net_address to \"%s\"\n", com_argv[i + 1]);
2758                         Cvar_SetQuick(&net_address, com_argv[i + 1]);
2759                 }
2760                 else
2761                         Con_Printf("-ip option used, but unable to parse the address \"%s\"\n", com_argv[i + 1]);
2762         }
2763 // 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
2764         if (((i = COM_CheckParm("-port")) || (i = COM_CheckParm("-ipport")) || (i = COM_CheckParm("-udpport"))) && i + 1 < com_argc)
2765         {
2766                 i = atoi(com_argv[i + 1]);
2767                 if (i >= 0 && i < 65536)
2768                 {
2769                         Con_Printf("-port option used, setting port cvar to %i\n", i);
2770                         Cvar_SetValueQuick(&sv_netport, i);
2771                 }
2772                 else
2773                         Con_Printf("-port option used, but %i is not a valid port number\n", i);
2774         }
2775         cl_numsockets = 0;
2776         sv_numsockets = 0;
2777         net_message.data = net_message_buf;
2778         net_message.maxsize = sizeof(net_message_buf);
2779         net_message.cursize = 0;
2780         LHNET_Init();
2781 }
2782
2783 void NetConn_Shutdown(void)
2784 {
2785         NetConn_CloseClientPorts();
2786         NetConn_CloseServerPorts();
2787         LHNET_Shutdown();
2788 }
2789