X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=netconn.h;h=7341359ed0127134e8d3fd700a74991719c9ad3b;hp=9586fdcd65ba0abc54d8a328d7202f2963b46e6e;hb=2075ae43356d724bae305ce8fd36ea570718b14a;hpb=8da4459b59336acc54dd028e44177756cbfa48cd diff --git a/netconn.h b/netconn.h index 9586fdcd..7341359e 100755 --- a/netconn.h +++ b/netconn.h @@ -24,95 +24,115 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "lhnet.h" -#define NET_NAMELEN 128 - -#define NET_MAXMESSAGE 65536 #define NET_HEADERSIZE (2 * sizeof(unsigned int)) -#define NET_DATAGRAMSIZE (MAX_DATAGRAM + NET_HEADERSIZE) // 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_CTL 0x80000000 +#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 - -// This is 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: -// 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 -// -// -// -// 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 - -// 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 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 { @@ -123,27 +143,99 @@ typedef struct netconn_s // this is mostly identical to qsocket_t from quake - // if this time is reached, kick off peer + /// if this time is reached, kick off peer double connecttime; double timeout; double lastMessageTime; double lastSendTime; - qboolean canSend; - qboolean sendNext; + /// 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]; + /// @} - unsigned int ackSequence; - unsigned int sendSequence; - unsigned int unreliableSendSequence; + /// reliable message that is currently sending + /// (for building fragments) int sendMessageLength; - qbyte sendMessage[NET_MAXMESSAGE]; + unsigned char sendMessage[NET_MAXMESSAGE]; - unsigned int receiveSequence; - unsigned int unreliableReceiveSequence; + /// reliable message that is currently being received + /// (for putting together fragments) int receiveMessageLength; - qbyte receiveMessage[NET_MAXMESSAGE]; - - char address[NET_NAMELEN]; + 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; @@ -151,38 +243,153 @@ extern mempool_t *netconn_mempool; extern cvar_t hostname; extern cvar_t developer_networking; -extern char playername[]; -extern int playercolor; -#define HOSTCACHESIZE 128 +#ifdef CONFIG_MENU +#define SERVERLIST_VIEWLISTSIZE SERVERLIST_TOTALSIZE -typedef struct +typedef enum serverlist_maskop_e { - // ping time for sorting servers - double ping; - // address for connecting + // 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]; - // description (seen by user) + /// 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]; -} hostcache_t; +} serverlist_entry_t; -extern int hostCacheCount; -extern hostcache_t hostcache[HOSTCACHESIZE]; +typedef struct serverlist_mask_s +{ + qboolean active; + serverlist_maskop_t tests[SLIF_COUNT]; + serverlist_info_t info; +} serverlist_mask_t; -#if !defined(_WIN32 ) && !defined (__linux__) && !defined (__sun__) -#ifndef htonl -extern unsigned long htonl (unsigned long hostlong); -#endif -#ifndef htons -extern unsigned short htons (unsigned short hostshort); -#endif -#ifndef ntohl -extern unsigned long ntohl (unsigned long netlong); -#endif -#ifndef ntohs -extern unsigned short ntohs (unsigned short netshort); +#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 //============================================================================ @@ -191,17 +398,47 @@ extern unsigned short ntohs (unsigned short netshort); // //============================================================================ -extern sizebuf_t net_message; +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; -int NetConn_SendReliableMessage(netconn_t *conn, sizebuf_t *data); -//void NetConn_SendMessageNext(netconn_t *conn); -//void NetConn_ReSendMessage(netconn_t *conn); -qboolean NetConn_CanSendMessage(netconn_t *conn); -int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data); +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); @@ -209,17 +446,43 @@ 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); -//int NetConn_ReceivedMessage(netconn_t *conn, qbyte *data, int length); -//int NetConn_ClientParsePacket(lhnetsocket_t *mysocket, qbyte *data, int length, lhnetaddress_t *peeraddress); -//int NetConn_ServerParsePacket(lhnetsocket_t *mysocket, qbyte *data, int length, lhnetaddress_t *peeraddress); void NetConn_ClientFrame(void); void NetConn_ServerFrame(void); -void NetConn_QueryMasters(void); +void NetConn_SleepMicroseconds(int microseconds); void NetConn_Heartbeat(int priority); -int NetConn_SendToAll(sizebuf_t *data, double blocktime); 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