File: netconn.h

package info (click to toggle)
darkplaces 0~20180412~beta1-2
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 18,200 kB
  • sloc: ansic: 176,886; makefile: 485; pascal: 455; perl: 372; objc: 245; sh: 102
file content (488 lines) | stat: -rwxr-xr-x 13,428 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
/*
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 2003 Forest Hale

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef NET_H
#define NET_H

#include "lhnet.h"

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

// NetHeader flags
#define NETFLAG_LENGTH_MASK 0x0000ffff
#define NETFLAG_DATA        0x00010000
#define NETFLAG_ACK         0x00020000
#define NETFLAG_NAK         0x00040000
#define NETFLAG_EOM         0x00080000
#define NETFLAG_UNRELIABLE  0x00100000
#define NETFLAG_CRYPTO0     0x10000000
#define NETFLAG_CRYPTO1     0x20000000
#define NETFLAG_CRYPTO2     0x40000000
#define NETFLAG_CTL         0x80000000


#define NET_PROTOCOL_VERSION	3
#define NET_EXTRESPONSE_MAX 16

/// \page netconn The network info/connection protocol.
/// It is used to find Quake
/// servers, get info about them, and connect to them.  Once connected, the
/// Quake game protocol (documented elsewhere) is used.
///
///
/// General notes:\code
///	game_name is currently always "QUAKE", but is there so this same protocol
///		can be used for future games as well; can you say Quake2?
///
/// CCREQ_CONNECT
///		string	game_name				"QUAKE"
///		byte	net_protocol_version	NET_PROTOCOL_VERSION
///
/// CCREQ_SERVER_INFO
///		string	game_name				"QUAKE"
///		byte	net_protocol_version	NET_PROTOCOL_VERSION
///
/// CCREQ_PLAYER_INFO
///		byte	player_number
///
/// CCREQ_RULE_INFO
///		string	rule
///
/// CCREQ_RCON
///		string	password
///		string	command
///
///
///
/// CCREP_ACCEPT
///		long	port
///
/// CCREP_REJECT
///		string	reason
///
/// CCREP_SERVER_INFO
///		string	server_address
///		string	host_name
///		string	level_name
///		byte	current_players
///		byte	max_players
///		byte	protocol_version	NET_PROTOCOL_VERSION
///
/// CCREP_PLAYER_INFO
///		byte	player_number
///		string	name
///		long	colors
///		long	frags
///		long	connect_time
///		string	address
///
/// CCREP_RULE_INFO
///		string	rule
///		string	value
///
/// CCREP_RCON
///		string	reply
/// \endcode
///	\note
///		There are two address forms used above.  The short form is just a
///		port number.  The address that goes along with the port is defined as
///		"whatever address you receive this reponse from".  This lets us use
///		the host OS to solve the problem of multiple host addresses (possibly
///		with no routing between them); the host will use the right address
///		when we reply to the inbound connection request.  The long from is
///		a full address and port in a string.  It is used for returning the
///		address of a server that is not running locally.

#define CCREQ_CONNECT		0x01
#define CCREQ_SERVER_INFO	0x02
#define CCREQ_PLAYER_INFO	0x03
#define CCREQ_RULE_INFO		0x04
#define CCREQ_RCON		0x05 // RocketGuy: ProQuake rcon support

#define CCREP_ACCEPT		0x81
#define CCREP_REJECT		0x82
#define CCREP_SERVER_INFO	0x83
#define CCREP_PLAYER_INFO	0x84
#define CCREP_RULE_INFO		0x85
#define CCREP_RCON		0x86 // RocketGuy: ProQuake rcon support

typedef struct netgraphitem_s
{
	double time;
	int reliablebytes;
	int unreliablebytes;
	int ackbytes;
	double cleartime;
}
netgraphitem_t;

typedef struct netconn_s
{
	struct netconn_s *next;

	lhnetsocket_t *mysocket;
	lhnetaddress_t peeraddress;

	// this is mostly identical to qsocket_t from quake

	/// if this time is reached, kick off peer
	double connecttime;
	double timeout;
	double lastMessageTime;
	double lastSendTime;

	/// writing buffer to send to peer as the next reliable message
	/// can be added to at any time, copied into sendMessage buffer when it is
	/// possible to send a reliable message and then cleared
	/// @{
	sizebuf_t message;
	unsigned char messagedata[NET_MAXMESSAGE];
	/// @}

	/// reliable message that is currently sending
	/// (for building fragments)
	int sendMessageLength;
	unsigned char sendMessage[NET_MAXMESSAGE];

	/// reliable message that is currently being received
	/// (for putting together fragments)
	int receiveMessageLength;
	unsigned char receiveMessage[NET_MAXMESSAGE];

	/// used by both NQ and QW protocols
	unsigned int outgoing_unreliable_sequence;

	struct netconn_nq_s
	{
		unsigned int ackSequence;
		unsigned int sendSequence;

		unsigned int receiveSequence;
		unsigned int unreliableReceiveSequence;
	}
	nq;
	struct netconn_qw_s
	{
		// QW protocol
		qboolean	fatal_error;

		float		last_received;		// for timeouts

	// the statistics are cleared at each client begin, because
	// the server connecting process gives a bogus picture of the data
		float		frame_latency;		// rolling average
		float		frame_rate;

		int			drop_count;			///< dropped packets, cleared each level
		int			good_count;			///< cleared each level

		int			qport;

	// sequencing variables
		unsigned int		incoming_sequence;
		unsigned int		incoming_acknowledged;
		qboolean		incoming_reliable_acknowledged;	///< single bit

		qboolean		incoming_reliable_sequence;		///< single bit, maintained local

		qboolean		reliable_sequence;			///< single bit
		unsigned int		last_reliable_sequence;		///< sequence number of last send
	}
	qw;

	// bandwidth estimator
	double		cleartime;			// if realtime > nc->cleartime, free to go
	double		incoming_cleartime;		// if realtime > nc->cleartime, free to go (netgraph cleartime simulation only)

	// this tracks packet loss and packet sizes on the most recent packets
	// used by shownetgraph feature
#define NETGRAPH_PACKETS 256
#define NETGRAPH_NOPACKET 0
#define NETGRAPH_LOSTPACKET -1
#define NETGRAPH_CHOKEDPACKET -2
	int incoming_packetcounter;
	netgraphitem_t incoming_netgraph[NETGRAPH_PACKETS];
	int outgoing_packetcounter;
	netgraphitem_t outgoing_netgraph[NETGRAPH_PACKETS];

	char address[128];
	crypto_t crypto;

	// statistic counters
	int packetsSent;
	int packetsReSent;
	int packetsReceived;
	int receivedDuplicateCount;
	int droppedDatagrams;
	int unreliableMessagesSent;
	int unreliableMessagesReceived;
	int reliableMessagesSent;
	int reliableMessagesReceived;
} netconn_t;

extern netconn_t *netconn_list;
extern mempool_t *netconn_mempool;

extern cvar_t hostname;
extern cvar_t developer_networking;

#ifdef CONFIG_MENU
#define SERVERLIST_VIEWLISTSIZE		SERVERLIST_TOTALSIZE

typedef enum serverlist_maskop_e
{
	// SLMO_CONTAINS is the default for strings
	// SLMO_GREATEREQUAL is the default for numbers (also used when OP == CONTAINS or NOTCONTAINS
	SLMO_CONTAINS,
	SLMO_NOTCONTAIN,

	SLMO_LESSEQUAL,
	SLMO_LESS,
	SLMO_EQUAL,
	SLMO_GREATER,
	SLMO_GREATEREQUAL,
	SLMO_NOTEQUAL,
	SLMO_STARTSWITH,
	SLMO_NOTSTARTSWITH
} serverlist_maskop_t;

/// struct with all fields that you can search for or sort by
typedef struct serverlist_info_s
{
	/// address for connecting
	char cname[128];
	/// ping time for sorting servers
	int ping;
	/// name of the game
	char game[32];
	/// name of the mod
	char mod[32];
	/// name of the map
	char map[32];
	/// name of the session
	char name[128];
	/// qc-defined short status string
	char qcstatus[128];
	/// frags/ping/name list (if they fit in the packet)
	char players[1400];
	/// max client number
	int maxplayers;
	/// number of currently connected players (including bots)
	int numplayers;
	/// number of currently connected players that are bots
	int numbots;
	/// number of currently connected players that are not bots
	int numhumans;
	/// number of free slots
	int freeslots;
	/// protocol version
	int protocol;
	/// game data version
	/// (an integer that is used for filtering incompatible servers,
	///  not filterable by QC)
	int gameversion;

	// categorized sorting
	int category;
	/// favorite server flag
	qboolean isfavorite;
} serverlist_info_t;

typedef enum
{
	SLIF_CNAME,
	SLIF_PING,
	SLIF_GAME,
	SLIF_MOD,
	SLIF_MAP,
	SLIF_NAME,
	SLIF_MAXPLAYERS,
	SLIF_NUMPLAYERS,
	SLIF_PROTOCOL,
	SLIF_NUMBOTS,
	SLIF_NUMHUMANS,
	SLIF_FREESLOTS,
	SLIF_QCSTATUS,
	SLIF_PLAYERS,
	SLIF_CATEGORY,
	SLIF_ISFAVORITE,
	SLIF_COUNT
} serverlist_infofield_t;

typedef enum
{
	SLSF_DESCENDING = 1,
	SLSF_FAVORITES = 2,
	SLSF_CATEGORIES = 4
} serverlist_sortflags_t;

typedef enum
{
	SQS_NONE = 0,
	SQS_QUERYING,
	SQS_QUERIED,
	SQS_TIMEDOUT,
	SQS_REFRESHING
} serverlist_query_state;

typedef struct serverlist_entry_s
{
	/// used to determine whether this entry should be included into the final view
	serverlist_query_state query;
	/// used to count the number of times the host has tried to query this server already
	unsigned querycounter;
	/// used to calculate ping when update comes in
	double querytime;
	/// query protocol to use on this server, may be PROTOCOL_QUAKEWORLD or PROTOCOL_DARKPLACES7
	int protocol;

	serverlist_info_t info;

	// legacy stuff
	char line1[128];
	char line2[128];
} serverlist_entry_t;

typedef struct serverlist_mask_s
{
	qboolean			active;
	serverlist_maskop_t  tests[SLIF_COUNT];
	serverlist_info_t info;
} serverlist_mask_t;

#define ServerList_GetCacheEntry(x) (&serverlist_cache[(x)])
#define ServerList_GetViewEntry(x) (ServerList_GetCacheEntry(serverlist_viewlist[(x)]))

extern serverlist_mask_t serverlist_andmasks[SERVERLIST_ANDMASKCOUNT];
extern serverlist_mask_t serverlist_ormasks[SERVERLIST_ORMASKCOUNT];

extern serverlist_infofield_t serverlist_sortbyfield;
extern int serverlist_sortflags; // not using the enum, as it is a bitmask

#if SERVERLIST_TOTALSIZE > 65536
#error too many servers, change type of index array
#endif
extern int serverlist_viewcount;
extern unsigned short serverlist_viewlist[SERVERLIST_VIEWLISTSIZE];

extern int serverlist_cachecount;
extern serverlist_entry_t *serverlist_cache;
extern const serverlist_entry_t *serverlist_callbackentry;

extern qboolean serverlist_consoleoutput;

void ServerList_GetPlayerStatistics(int *numplayerspointer, int *maxplayerspointer);
#endif

//============================================================================
//
// public network functions
//
//============================================================================

extern char cl_net_extresponse[NET_EXTRESPONSE_MAX][1400];
extern int cl_net_extresponse_count;
extern int cl_net_extresponse_last;

extern char sv_net_extresponse[NET_EXTRESPONSE_MAX][1400];
extern int sv_net_extresponse_count;
extern int sv_net_extresponse_last;

#ifdef CONFIG_MENU
extern double masterquerytime;
extern int masterquerycount;
extern int masterreplycount;
extern int serverquerycount;
extern int serverreplycount;
#endif

extern sizebuf_t cl_message;
extern sizebuf_t sv_message;
extern char cl_readstring[MAX_INPUTLINE];
extern char sv_readstring[MAX_INPUTLINE];

extern cvar_t sv_public;

extern cvar_t cl_netlocalping;

extern cvar_t cl_netport;
extern cvar_t sv_netport;
extern cvar_t net_address;
extern cvar_t net_address_ipv6;
extern cvar_t net_usesizelimit;
extern cvar_t net_burstreserve;

qboolean NetConn_CanSend(netconn_t *conn);
int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate, int burstsize, qboolean quakesignon_suppressreliables);
qboolean NetConn_HaveClientPorts(void);
qboolean NetConn_HaveServerPorts(void);
void NetConn_CloseClientPorts(void);
void NetConn_OpenClientPorts(void);
void NetConn_CloseServerPorts(void);
void NetConn_OpenServerPorts(int opennetports);
void NetConn_UpdateSockets(void);
lhnetsocket_t *NetConn_ChooseClientSocketForAddress(lhnetaddress_t *address);
lhnetsocket_t *NetConn_ChooseServerSocketForAddress(lhnetaddress_t *address);
void NetConn_Init(void);
void NetConn_Shutdown(void);
netconn_t *NetConn_Open(lhnetsocket_t *mysocket, lhnetaddress_t *peeraddress);
void NetConn_Close(netconn_t *conn);
void NetConn_Listen(qboolean state);
int NetConn_Read(lhnetsocket_t *mysocket, void *data, int maxlength, lhnetaddress_t *peeraddress);
int NetConn_Write(lhnetsocket_t *mysocket, const void *data, int length, const lhnetaddress_t *peeraddress);
int NetConn_WriteString(lhnetsocket_t *mysocket, const char *string, const lhnetaddress_t *peeraddress);
int NetConn_IsLocalGame(void);
void NetConn_ClientFrame(void);
void NetConn_ServerFrame(void);
void NetConn_SleepMicroseconds(int microseconds);
void NetConn_Heartbeat(int priority);
void Net_Stats_f(void);

#ifdef CONFIG_MENU
void NetConn_QueryMasters(qboolean querydp, qboolean queryqw);
void NetConn_QueryQueueFrame(void);
void Net_Slist_f(void);
void Net_SlistQW_f(void);
void Net_Refresh_f(void);

/// ServerList interface (public)
/// manually refresh the view set, do this after having changed the mask or any other flag
void ServerList_RebuildViewList(void);
void ServerList_ResetMasks(void);
void ServerList_QueryList(qboolean resetcache, qboolean querydp, qboolean queryqw, qboolean consoleoutput);

/// called whenever net_slist_favorites changes
void NetConn_UpdateFavorites(void);
#endif

#define MAX_CHALLENGES 128
typedef struct challenge_s
{
	lhnetaddress_t address;
	double time;
	char string[12];
}
challenge_t;

extern challenge_t challenges[MAX_CHALLENGES];

#endif