diff options
Diffstat (limited to 'engine/net_ws.cpp')
| -rw-r--r-- | engine/net_ws.cpp | 3457 |
1 files changed, 3457 insertions, 0 deletions
diff --git a/engine/net_ws.cpp b/engine/net_ws.cpp new file mode 100644 index 0000000..3c49ab6 --- /dev/null +++ b/engine/net_ws.cpp @@ -0,0 +1,3457 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// net_ws.c +// Windows IP Support layer. + +#include "tier0/etwprof.h" +#include "tier0/vprof.h" +#include "net_ws_headers.h" +#include "net_ws_queued_packet_sender.h" +#include "fmtstr.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +#define NET_COMPRESSION_STACKBUF_SIZE 4096 + +static ConVar net_showudp_wire( "net_showudp_wire", "0", 0, "Show incoming packet information" ); + +#define UDP_SO_RCVBUF_SIZE 131072 + +static ConVar net_udp_rcvbuf( "net_udp_rcvbuf", NETSTRING( UDP_SO_RCVBUF_SIZE ), FCVAR_ALLOWED_IN_COMPETITIVE, "Default UDP receive buffer size", true, 8192, true, 128 * 1024 ); + +static ConVar net_showsplits( "net_showsplits", "0", 0, "Show info about packet splits" ); + +static ConVar net_splitrate( "net_splitrate", "1", 0, "Number of fragments for a splitpacket that can be sent per frame" ); + +static ConVar ipname ( "ip", "localhost", FCVAR_ALLOWED_IN_COMPETITIVE, "Overrides IP for multihomed hosts" ); +static ConVar hostport ( "hostport", NETSTRING( PORT_SERVER ) , FCVAR_ALLOWED_IN_COMPETITIVE, "Host game server port" ); +static ConVar hostip ( "hostip", "", FCVAR_ALLOWED_IN_COMPETITIVE, "Host game server ip" ); + +static ConVar clientport ( "clientport", NETSTRING( PORT_CLIENT ), FCVAR_ALLOWED_IN_COMPETITIVE, "Host game client port" ); +static ConVar hltvport ( "tv_port", NETSTRING( PORT_HLTV ), FCVAR_ALLOWED_IN_COMPETITIVE, "Host SourceTV port" ); +static ConVar matchmakingport( "matchmakingport", NETSTRING( PORT_MATCHMAKING ), FCVAR_ALLOWED_IN_COMPETITIVE, "Host Matchmaking port" ); +static ConVar systemlinkport( "systemlinkport", NETSTRING( PORT_SYSTEMLINK ), FCVAR_ALLOWED_IN_COMPETITIVE, "System Link port" ); + +static ConVar fakelag ( "net_fakelag", "0", FCVAR_CHEAT, "Lag all incoming network data (including loopback) by this many milliseconds." ); +static ConVar fakeloss ( "net_fakeloss", "0", FCVAR_CHEAT, "Simulate packet loss as a percentage (negative means drop 1/n packets)" ); +static ConVar droppackets ( "net_droppackets", "0", FCVAR_CHEAT, "Drops next n packets on client" ); +static ConVar fakejitter ( "net_fakejitter", "0", FCVAR_CHEAT, "Jitter fakelag packet time" ); + +static ConVar net_compressvoice( "net_compressvoice", "0", 0, "Attempt to compress out of band voice payloads (360 only)." ); +ConVar net_usesocketsforloopback( "net_usesocketsforloopback", "0", 0, "Use network sockets layer even for listen server local player's packets (multiplayer only)." ); + +#ifdef _DEBUG +static ConVar fakenoise ( "net_fakenoise", "0", FCVAR_CHEAT, "Simulate corrupt network packets (changes n bits per packet randomly)" ); +static ConVar fakeshuffle ( "net_fakeshuffle", "0", FCVAR_CHEAT, "Shuffles order of every nth packet (needs net_fakelag)" ); +static ConVar recvpackets ( "net_recvpackets", "-1", FCVAR_CHEAT, "Receive exactly next n packets if >= 0" ); +static ConVar net_savelargesplits( "net_savelargesplits", "-1", 0, "If not -1, then if a split has this many or more split parts, save the entire packet to disc for analysis." ); +#endif + +#ifdef _X360 +static void NET_LogServerCallback( IConVar *var, const char *pOldString, float flOldValue ); +static ConVar net_logserver( "net_logserver", "0", 0, "Dump server stats to a file", NET_LogServerCallback ); +static ConVar net_loginterval( "net_loginterval", "1", 0, "Time in seconds between server logs" ); +#endif + +//----------------------------------------------------------------------------- +// Toggle Xbox 360 network security to allow cross-platform testing +//----------------------------------------------------------------------------- +#if !defined( _X360 ) +#define X360SecureNetwork() false +#define IPPROTO_VDP IPPROTO_UDP +#elif defined( _RETAIL ) +#define X360SecureNetwork() true +#else +bool X360SecureNetwork( void ) +{ + if ( CommandLine()->FindParm( "-xnet_bypass_security" ) ) + { + return false; + } + return true; +} +#endif + +extern ConVar net_showudp; +extern ConVar net_showtcp; +extern ConVar net_blocksize; +extern ConVar host_timescale; +extern int host_framecount; + +void NET_ClearQueuedPacketsForChannel( INetChannel *chan ); + +#define DEF_LOOPBACK_SIZE 2048 + +typedef struct +{ + int nPort; // UDP/TCP use same port number + bool bListening; // true if TCP port is listening + int hUDP; // handle to UDP socket from socket() + int hTCP; // handle to TCP socket from socket() +} netsocket_t; + +typedef struct +{ + int newsock; // handle of new socket + int netsock; // handle of listen socket + float time; + netadr_t addr; +} pendingsocket_t; + + +#include "tier0/memdbgoff.h" + +struct loopback_t +{ + char *data; // loopback buffer + int datalen; // current data length + char defbuffer[ DEF_LOOPBACK_SIZE ]; + + DECLARE_FIXEDSIZE_ALLOCATOR( loopback_t ); +}; + +#include "tier0/memdbgon.h" + +DEFINE_FIXEDSIZE_ALLOCATOR( loopback_t, 2, CUtlMemoryPool::GROW_SLOW ); + +// Split long packets. Anything over 1460 is failing on some routers +typedef struct +{ + int currentSequence; + int splitCount; + int totalSize; + int nExpectedSplitSize; + char buffer[ NET_MAX_MESSAGE ]; // This has to be big enough to hold the largest message +} LONGPACKET; + +// Use this to pick apart the network stream, must be packed +#pragma pack(1) +typedef struct +{ + int netID; + int sequenceNumber; + int packetID : 16; + int nSplitSize : 16; +} SPLITPACKET; +#pragma pack() + +#define MIN_USER_MAXROUTABLE_SIZE 576 // ( X.25 Networks ) +#define MAX_USER_MAXROUTABLE_SIZE MAX_ROUTABLE_PAYLOAD + + +#define MAX_SPLIT_SIZE (MAX_USER_MAXROUTABLE_SIZE - sizeof( SPLITPACKET )) +#define MIN_SPLIT_SIZE (MIN_USER_MAXROUTABLE_SIZE - sizeof( SPLITPACKET )) + +// For metering out splitpackets, don't do them too fast as remote UDP socket will drop some payloads causing them to always fail to be reconstituted +// This problem is largely solved by increasing the buffer sizes for UDP sockets on Windows +#define SPLITPACKET_MAX_DATA_BYTES_PER_SECOND V_STRINGIFY(DEFAULT_RATE) + +static ConVar sv_maxroutable + ( + "sv_maxroutable", + "1260", + 0, + "Server upper bound on net_maxroutable that a client can use.", + true, MIN_USER_MAXROUTABLE_SIZE, + true, MAX_USER_MAXROUTABLE_SIZE + ); + +ConVar net_maxroutable + ( + "net_maxroutable", + "1260", + FCVAR_ARCHIVE | FCVAR_USERINFO, + "Requested max packet size before packets are 'split'.", + true, MIN_USER_MAXROUTABLE_SIZE, + true, MAX_USER_MAXROUTABLE_SIZE + ); + +netadr_t net_local_adr; +double net_time = 0.0f; // current time, updated each frame + +static CUtlVector<netsocket_t> net_sockets; // the 4 sockets, Server, Client, HLTV, Matchmaking +static CUtlVector<netpacket_t> net_packets; + +static bool net_multiplayer = false; // if true, configured for Multiplayer +static bool net_noip = false; // Disable IP support, can't switch to MP mode +static bool net_nodns = false; // Disable DNS request to avoid long timeouts +static bool net_notcp = true; // Disable TCP support +static bool net_nohltv = false; // disable HLTV support +static bool net_dedicated = false; // true is dedicated system +static int net_error = 0; // global error code updated with NET_GetLastError() + + +static CUtlVectorMT< CUtlVector< CNetChan* > > s_NetChannels; +static CUtlVectorMT< CUtlVector< pendingsocket_t > > s_PendingSockets; + +CTSQueue<loopback_t *> s_LoopBacks[LOOPBACK_SOCKETS]; +static netpacket_t* s_pLagData[MAX_SOCKETS]; // List of lag structures, if fakelag is set. + +unsigned short NET_HostToNetShort( unsigned short us_in ) +{ + return htons( us_in ); +} + +unsigned short NET_NetToHostShort( unsigned short us_in ) +{ + return ntohs( us_in ); +} + +// This macro is used to capture the return value of a function call while recording +// a VCR file. During playback, it will get the return value out of the VCR file +// instead of actually calling the function. +#if !defined( NO_VCR ) +#define VCR_NONPLAYBACKFN( call, resultVar, eventName ) \ + { \ + if ( VCRGetMode() != VCR_Playback ) \ + resultVar = call; \ + \ + VCRGenericValue( eventName, &resultVar, sizeof( resultVar ) ); \ + } +#else +#define VCR_NONPLAYBACKFN( call, resultVar, eventName ) \ + { \ + if ( VCRGetMode() != VCR_Playback ) \ + resultVar = call; \ + \ + } +#endif + +/* +==================== +NET_ErrorString +==================== +*/ +const char *NET_ErrorString (int code) +{ +#if defined( _WIN32 ) + switch (code) + { + case WSAEINTR: return "WSAEINTR"; + case WSAEBADF: return "WSAEBADF"; + case WSAEACCES: return "WSAEACCES"; + case WSAEDISCON: return "WSAEDISCON"; + case WSAEFAULT: return "WSAEFAULT"; + case WSAEINVAL: return "WSAEINVAL"; + case WSAEMFILE: return "WSAEMFILE"; + case WSAEWOULDBLOCK: return "WSAEWOULDBLOCK"; + case WSAEINPROGRESS: return "WSAEINPROGRESS"; + case WSAEALREADY: return "WSAEALREADY"; + case WSAENOTSOCK: return "WSAENOTSOCK"; + case WSAEDESTADDRREQ: return "WSAEDESTADDRREQ"; + case WSAEMSGSIZE: return "WSAEMSGSIZE"; + case WSAEPROTOTYPE: return "WSAEPROTOTYPE"; + case WSAENOPROTOOPT: return "WSAENOPROTOOPT"; + case WSAEPROTONOSUPPORT: return "WSAEPROTONOSUPPORT"; + case WSAESOCKTNOSUPPORT: return "WSAESOCKTNOSUPPORT"; + case WSAEOPNOTSUPP: return "WSAEOPNOTSUPP"; + case WSAEPFNOSUPPORT: return "WSAEPFNOSUPPORT"; + case WSAEAFNOSUPPORT: return "WSAEAFNOSUPPORT"; + case WSAEADDRINUSE: return "WSAEADDRINUSE"; + case WSAEADDRNOTAVAIL: return "WSAEADDRNOTAVAIL"; + case WSAENETDOWN: return "WSAENETDOWN"; + case WSAENETUNREACH: return "WSAENETUNREACH"; + case WSAENETRESET: return "WSAENETRESET"; + case WSAECONNABORTED: return "WSWSAECONNABORTEDAEINTR"; + case WSAECONNRESET: return "WSAECONNRESET"; + case WSAENOBUFS: return "WSAENOBUFS"; + case WSAEISCONN: return "WSAEISCONN"; + case WSAENOTCONN: return "WSAENOTCONN"; + case WSAESHUTDOWN: return "WSAESHUTDOWN"; + case WSAETOOMANYREFS: return "WSAETOOMANYREFS"; + case WSAETIMEDOUT: return "WSAETIMEDOUT"; + case WSAECONNREFUSED: return "WSAECONNREFUSED"; + case WSAELOOP: return "WSAELOOP"; + case WSAENAMETOOLONG: return "WSAENAMETOOLONG"; + case WSAEHOSTDOWN: return "WSAEHOSTDOWN"; + case WSASYSNOTREADY: return "WSASYSNOTREADY"; + case WSAVERNOTSUPPORTED: return "WSAVERNOTSUPPORTED"; + case WSANOTINITIALISED: return "WSANOTINITIALISED"; + case WSAHOST_NOT_FOUND: return "WSAHOST_NOT_FOUND"; + case WSATRY_AGAIN: return "WSATRY_AGAIN"; + case WSANO_RECOVERY: return "WSANO_RECOVERY"; + case WSANO_DATA: return "WSANO_DATA"; + default: return "UNKNOWN ERROR"; + } +#else + return strerror( code ); +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *s - +// *sadr - +// Output : bool NET_StringToSockaddr +//----------------------------------------------------------------------------- +bool NET_StringToSockaddr( const char *s, struct sockaddr *sadr ) +{ + char *colon; + char copy[128]; + + Q_memset (sadr, 0, sizeof(*sadr)); + ((struct sockaddr_in *)sadr)->sin_family = AF_INET; + ((struct sockaddr_in *)sadr)->sin_port = 0; + + Q_strncpy (copy, s, sizeof( copy ) ); + // strip off a trailing :port if present + for (colon = copy ; *colon ; colon++) + { + if (*colon == ':') + { + *colon = 0; + ((struct sockaddr_in *)sadr)->sin_port = NET_HostToNetShort((short)atoi(colon+1)); + } + } + + if (copy[0] >= '0' && copy[0] <= '9' && Q_strstr( copy, "." ) ) + { + *(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(copy); + } + else + { + if ( net_nodns ) + return false; // DNS names disabled + + struct hostent *h; + if ( (h = gethostbyname(copy)) == NULL ) + return false; + *(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0]; + } + + return true; +} + +void NET_ClearLastError( void ) +{ + net_error = 0; +} + +int NET_GetLastError( void ) +{ +#if defined( _WIN32 ) + net_error = WSAGetLastError(); +#else + net_error = errno; +#endif +#if !defined( NO_VCR ) + VCRGenericValue( "WSAGetLastError", &net_error, sizeof( net_error ) ); +#endif + return net_error; +} + +/* +================== +NET_ClearLaggedList + +================== +*/ +void NET_ClearLaggedList(netpacket_t **pList) +{ + netpacket_t * p = (*pList); + + while ( p ) + { + netpacket_t * n = p->pNext; + + if ( p->data ) + { + delete[] p->data; + p->data = NULL; + } + delete p; + p = n; + } + + (*pList) = NULL; +} + +void NET_ClearLagData( int sock ) +{ + if ( sock < MAX_SOCKETS && s_pLagData[sock] ) + { + NET_ClearLaggedList( &s_pLagData[sock] ); + } +} + +/* +============= +NET_StringToAdr + +localhost +idnewt +idnewt:28000 +192.246.40.70 +192.246.40.70:28000 +============= +*/ +bool NET_StringToAdr ( const char *s, netadr_t *a) +{ + struct sockaddr saddr; + + char address[128]; + + Q_strncpy( address, s, sizeof(address) ); + + if ( !Q_strncmp( address, "localhost", 10 ) || !Q_strncmp( address, "localhost:", 10 ) ) + { + // subsitute 'localhost' with '127.0.0.1", both have 9 chars + // this way we can resolve 'localhost' without DNS and still keep the port + Q_memcpy( address, "127.0.0.1", 9 ); + } + + + if ( !NET_StringToSockaddr (address, &saddr) ) + return false; + + a->SetFromSockadr( &saddr ); + + return true; +} + +CNetChan *NET_FindNetChannel(int socket, netadr_t &adr) +{ + AUTO_LOCK( s_NetChannels ); + + int numChannels = s_NetChannels.Count(); + + for ( int i = 0; i < numChannels; i++ ) + { + CNetChan * chan = s_NetChannels[i]; + + // sockets must match + if ( socket != chan->GetSocket() ) + continue; + + // and the IP:Port address + if ( adr.CompareAdr( chan->GetRemoteAddress() ) ) + { + return chan; // found it + } + } + + return NULL; // no channel found +} + +void NET_CloseSocket( int hSocket, int sock = -1) +{ + if ( !hSocket ) + return; + + // close socket handle + int ret; + VCR_NONPLAYBACKFN( closesocket( hSocket ), ret, "closesocket" ); + if ( ret == -1 ) + { + NET_GetLastError(); + ConMsg ("WARNING! NET_CloseSocket: %s\n", NET_ErrorString(net_error)); + } + + // if hSocket mapped to hTCP, clear hTCP + if ( sock >= 0 ) + { + if ( net_sockets[sock].hTCP == hSocket ) + { + net_sockets[sock].hTCP = 0; + net_sockets[sock].bListening = false; + } + } +} + +/* +==================== +NET_IPSocket +==================== +*/ +int NET_OpenSocket ( const char *net_interface, int& port, int protocol ) +{ + struct sockaddr_in address; + unsigned int opt; + int newsocket = -1; + + if ( protocol == IPPROTO_TCP ) + { + VCR_NONPLAYBACKFN( socket (PF_INET, SOCK_STREAM, IPPROTO_TCP), newsocket, "socket()" ); + } + else // as UDP or VDP + { + VCR_NONPLAYBACKFN( socket (PF_INET, SOCK_DGRAM, protocol), newsocket, "socket()" ); + } + + if ( newsocket == -1 ) + { + NET_GetLastError(); + if ( net_error != WSAEAFNOSUPPORT ) + Msg ("WARNING: NET_OpenSockett: socket failed: %s", NET_ErrorString(net_error)); + + return 0; + } + + + opt = 1; // make it non-blocking + int ret; + VCR_NONPLAYBACKFN( ioctlsocket (newsocket, FIONBIO, (unsigned long*)&opt), ret, "ioctlsocket" ); + if ( ret == -1 ) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: ioctl FIONBIO: %s\n", NET_ErrorString(net_error) ); + } + + if ( protocol == IPPROTO_TCP ) + { + if ( !IsX360() ) // SO_KEEPALIVE unsupported on the 360 + { + opt = 1; // set TCP options: keep TCP connection alive + VCR_NONPLAYBACKFN( setsockopt(newsocket, SOL_SOCKET, SO_KEEPALIVE, (char *)&opt, sizeof(opt)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt SO_KEEPALIVE: %s\n", NET_ErrorString(net_error)); + return 0; + } + } + + linger optlinger; // set TCP options: Does not block close waiting for unsent data to be sent + optlinger.l_linger = 0; + optlinger.l_onoff = 0; + VCR_NONPLAYBACKFN( setsockopt(newsocket, SOL_SOCKET, SO_LINGER, (char *)&optlinger, sizeof(optlinger)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt SO_LINGER: %s\n", NET_ErrorString(net_error)); + return 0; + } + + opt = 1; // set TCP options: Disables the Nagle algorithm for send coalescing. + VCR_NONPLAYBACKFN( setsockopt(newsocket, IPPROTO_TCP, TCP_NODELAY, (char *)&opt, sizeof(opt)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt TCP_NODELAY: %s\n", NET_ErrorString(net_error)); + return 0; + } + + opt = NET_MAX_MESSAGE; // set TCP options: set send buffer size + VCR_NONPLAYBACKFN( setsockopt(newsocket, SOL_SOCKET, SO_SNDBUF, (char *)&opt, sizeof(opt)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt SO_SNDBUF: %s\n", NET_ErrorString(net_error)); + return 0; + } + + opt = NET_MAX_MESSAGE; // set TCP options: set receive buffer size + VCR_NONPLAYBACKFN( setsockopt(newsocket, SOL_SOCKET, SO_RCVBUF, (char *)&opt, sizeof(opt)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt SO_RCVBUF: %s\n", NET_ErrorString(net_error)); + return 0; + } + + + return newsocket; // don't bind TCP sockets by default + } + + // rest is UDP only + + opt = 0; + socklen_t len = sizeof( opt ); + VCR_NONPLAYBACKFN( getsockopt( newsocket, SOL_SOCKET, SO_RCVBUF, (char *)&opt, &len ), ret, "getsockopt" ); + if ( ret == -1 ) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: getsockopt SO_RCVBUF: %s\n", NET_ErrorString(net_error)); + return 0; + } + + if ( net_showudp.GetBool() ) + { + static bool bFirst = true; + if ( bFirst ) + { + Msg( "UDP socket SO_RCVBUF size %d bytes, changing to %d\n", opt, net_udp_rcvbuf.GetInt() ); + } + bFirst = false; + } + + opt = net_udp_rcvbuf.GetInt(); // set UDP receive buffer size + VCR_NONPLAYBACKFN( setsockopt(newsocket, SOL_SOCKET, SO_RCVBUF, (char *)&opt, sizeof(opt)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt SO_RCVBUF: %s\n", NET_ErrorString(net_error)); + return 0; + } + + opt = net_udp_rcvbuf.GetInt(); // set UDP send buffer size + VCR_NONPLAYBACKFN( setsockopt(newsocket, SOL_SOCKET, SO_SNDBUF, (char *)&opt, sizeof(opt)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt SO_SNDBUF: %s\n", NET_ErrorString(net_error)); + return 0; + } + + + // VDP protocol (Xbox 360 secure network) doesn't support SO_BROADCAST + if ( !X360SecureNetwork() || protocol != IPPROTO_VDP ) + { + opt = 1; // set UDP options: make it broadcast capable + VCR_NONPLAYBACKFN( setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&opt, sizeof(opt)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString(net_error)); + return 0; + } + } + + if ( CommandLine()->FindParm( "-reuse" ) ) + { + opt = 1; // make it reusable + VCR_NONPLAYBACKFN( setsockopt(newsocket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)), ret, "setsockopt" ); + if (ret == -1) + { + NET_GetLastError(); + Msg ("WARNING: NET_OpenSocket: setsockopt SO_REUSEADDR: %s\n", NET_ErrorString(net_error)); + return 0; + } + } + + if (!net_interface || !net_interface[0] || !Q_strcmp(net_interface, "localhost")) + { + address.sin_addr.s_addr = INADDR_ANY; + } + else + { + NET_StringToSockaddr (net_interface, (struct sockaddr *)&address); + } + + address.sin_family = AF_INET; + + int port_offset; // try binding socket to port, try next 10 is port is already used + + for ( port_offset = 0; port_offset < PORT_TRY_MAX; port_offset++ ) + { + if ( port == PORT_ANY ) + { + address.sin_port = 0; // = INADDR_ANY + } + else + { + address.sin_port = NET_HostToNetShort((short)( port + port_offset )); + } + + VCR_NONPLAYBACKFN( bind (newsocket, (struct sockaddr *)&address, sizeof(address)), ret, "bind" ); + if ( ret != -1 ) + { + if ( port != PORT_ANY && port_offset != 0 ) + { + port += port_offset; // update port + ConDMsg( "Socket bound to non-default port %i because original port was already in use.\n", port ); + } + break; + } + + NET_GetLastError(); + + if ( port == PORT_ANY || net_error != WSAEADDRINUSE ) + { + Msg ("WARNING: NNET_OpenSocket: bind: %s\n", NET_ErrorString(net_error)); + NET_CloseSocket(newsocket,-1); + return 0; + } + + // Try next port + } + + const bool bStrictBind = CommandLine()->FindParm( "-strictportbind" ); + if ( port_offset == PORT_TRY_MAX && !bStrictBind ) + { + Msg( "WARNING: UDP_OpenSocket: unable to bind socket\n" ); + NET_CloseSocket( newsocket,-1 ); + return 0; + } + + if ( port_offset > 0 ) + { + if ( bStrictBind ) + { + // The server op wants to exit if the desired port was not avialable. + Sys_Exit( "ERROR: Port %i was unavailable - quitting due to \"-strictportbind\" command-line flag!\n", port - port_offset ); + } + else + { + Warning( "WARNING: Port %i was unavailable - bound to port %i instead\n", port - port_offset, port ); + } + } + + return newsocket; +} + +int NET_ConnectSocket( int sock, const netadr_t &addr ) +{ + Assert( (sock >= 0) && (sock < net_sockets.Count()) ); + + netsocket_t *netsock = &net_sockets[sock]; + + if ( netsock->hTCP ) + { + NET_CloseSocket( netsock->hTCP, sock ); + } + + if ( net_notcp ) + return 0; + + sockaddr saddr; + + addr.ToSockadr( &saddr ); + + int anyport = PORT_ANY; + + netsock->hTCP = NET_OpenSocket( ipname.GetString(), anyport, true ); + + if ( !netsock->hTCP ) + { + Msg( "Warning! NET_ConnectSocket failed opening socket %i, port %i.\n", sock, net_sockets[sock].nPort ); + return false; + } + + int ret; + VCR_NONPLAYBACKFN( connect( netsock->hTCP, &saddr, sizeof(saddr) ), ret, "connect" ); + if ( ret == -1 ) + { + NET_GetLastError(); + + if ( net_error != WSAEWOULDBLOCK ) + { + Msg ("NET_ConnectSocket: %s\n", NET_ErrorString( net_error ) ); + return 0; + } + } + + return net_sockets[sock].hTCP; +} + +int NET_SendStream( int nSock, const char * buf, int len, int flags ) +{ + //int ret = send( nSock, buf, len, flags ); + int ret = VCRHook_send( nSock, buf, len, flags ); + if ( ret == -1 ) + { + NET_GetLastError(); + + if ( net_error == WSAEWOULDBLOCK ) + { + return 0; // ignore EWOULDBLOCK + } + + Msg ("NET_SendStream: %s\n", NET_ErrorString( net_error ) ); + } + + return ret; +} + +int NET_ReceiveStream( int nSock, char * buf, int len, int flags ) +{ + int ret = VCRHook_recv( nSock, buf, len, flags ); + if ( ret == -1 ) + { + NET_GetLastError(); + + if ( net_error == WSAEWOULDBLOCK || + net_error == WSAENOTCONN ) + { + return 0; // ignore EWOULDBLOCK + } + + Msg ("NET_ReceiveStream: %s\n", NET_ErrorString( net_error ) ); + } + + return ret; +} + +INetChannel *NET_CreateNetChannel(int socket, netadr_t *adr, const char * name, INetChannelHandler * handler, bool bForceNewChannel/*=false*/, + int nProtocolVersion/*=PROTOCOL_VERSION*/) +{ + CNetChan *chan = NULL; + + if ( !bForceNewChannel && adr != NULL ) + { + // try to find real network channel if already existing + if ( ( chan = NET_FindNetChannel( socket, *adr ) ) != NULL ) + { + // channel already known, clear any old stuff before Setup wipes all + chan->Clear(); + } + } + + if ( !chan ) + { + // create new channel + chan = new CNetChan(); + + AUTO_LOCK( s_NetChannels ); + s_NetChannels.AddToTail( chan ); + } + + NET_ClearLagData( socket ); + + // just reset and return + chan->Setup( socket, adr, name, handler, nProtocolVersion ); + + return chan; +} + +void NET_RemoveNetChannel(INetChannel *netchan, bool bDeleteNetChan) +{ + if ( !netchan ) + { + return; + } + + AUTO_LOCK( s_NetChannels ); + if ( s_NetChannels.Find( static_cast<CNetChan*>(netchan) ) == s_NetChannels.InvalidIndex() ) + { + DevMsg(1, "NET_CloseNetChannel: unknown channel.\n"); + return; + } + + s_NetChannels.FindAndRemove( static_cast<CNetChan*>(netchan) ); + + NET_ClearQueuedPacketsForChannel( netchan ); + + if ( bDeleteNetChan ) + delete netchan; +} + + +/* +============================================================================= + +LOOPBACK BUFFERS FOR LOCAL PLAYER + +============================================================================= +*/ + + +void NET_SendLoopPacket (int sock, int length, const unsigned char *data, const netadr_t &to) +{ + loopback_t *loop; + + if ( length > NET_MAX_PAYLOAD ) + { + DevMsg( "NET_SendLoopPacket: packet too big (%i).\n", length ); + return; + } + + loop = new loopback_t; + + if ( length <= DEF_LOOPBACK_SIZE ) + { + loop->data = loop->defbuffer; + } + else + { + loop->data = new char[ length ]; + } + + Q_memcpy (loop->data, data, length); + loop->datalen = length; + + if ( sock == NS_SERVER ) + { + s_LoopBacks[NS_CLIENT].PushItem( loop ); + } + else if ( sock == NS_CLIENT ) + { + s_LoopBacks[NS_SERVER].PushItem( loop ); + } + else + { + DevMsg( "NET_SendLoopPacket: invalid socket (%i).\n", sock ); + return; + } +} + +//============================================================================= + +int NET_CountLaggedList( netpacket_t *pList ) +{ + int c = 0; + netpacket_t *p = pList; + + while ( p ) + { + c++; + p = p->pNext; + } + + return c; +} + +/* +=================== +NET_AddToLagged + +=================== +*/ +void NET_AddToLagged( netpacket_t **pList, netpacket_t *pPacket ) +{ + if ( pPacket->pNext ) + { + Msg("NET_AddToLagged::Packet already linked\n"); + return; + } + + // first copy packet + + netpacket_t *newPacket = new netpacket_t; + + (*newPacket) = (*pPacket); // copy packet infos + newPacket->data = new unsigned char[ pPacket->size ]; // create new data buffer + Q_memcpy( newPacket->data, pPacket->data, pPacket->size ); // copy packet data + newPacket->pNext = NULL; + + // if list is empty, this is our first element + if ( (*pList) == NULL ) + { + (*pList) = newPacket; // put packet in top of list + } + else + { + netpacket_t *last = (*pList); + + while ( last->pNext ) + { + // got to end of list + last = last->pNext; + } + + // add at end + last->pNext = newPacket; + } +} + +// Actual lag to use in msec +static float s_FakeLag = 0.0; + +float NET_GetFakeLag() +{ + return s_FakeLag; +} + +// How quickly we converge to a new value for fakelag +#define FAKELAG_CONVERGE 200 // ms per second + +/* +============================== +NET_AdjustLag + +============================== +*/ +void NET_AdjustLag( void ) +{ + static double s_LastTime = 0; + + // Bound time step + + float dt = net_time - s_LastTime; + dt = clamp( dt, 0.0f, 0.2f ); + + s_LastTime = net_time; + + // Already converged? + if ( fakelag.GetFloat() == s_FakeLag ) + return; + + // Figure out how far we have to go + float diff = fakelag.GetFloat() - s_FakeLag; + + // How much can we converge this frame + float converge = FAKELAG_CONVERGE * dt; + + // Last step, go the whole way + if ( converge > fabs( diff ) ) + { + converge = fabs( diff ); + } + + // Converge toward fakelag.GetFloat() + if ( diff < 0.0 ) + { + // Converge toward fakelag.GetFloat() + s_FakeLag -= converge; + } + else + { + s_FakeLag += converge; + } +} + + +bool NET_LagPacket (bool newdata, netpacket_t * packet) +{ + static int losscount[MAX_SOCKETS]; + + if ( packet->source >= MAX_SOCKETS ) + return newdata; // fake lag not supported for extra sockets + + if ( (droppackets.GetInt() > 0) && newdata && (packet->source == NS_CLIENT) ) + { + droppackets.SetValue( droppackets.GetInt() - 1 ); + return false; + } + + if ( fakeloss.GetFloat() && newdata ) + { + losscount[packet->source]++; + + if ( fakeloss.GetFloat() > 0.0f ) + { + // Act like we didn't hear anything if we are going to lose the packet. + // Depends on random # generator. + if (RandomInt(0,100) <= (int)fakeloss.GetFloat()) + return false; + } + else + { + int ninterval; + + ninterval = (int)(fabs( fakeloss.GetFloat() ) ); + ninterval = max( 2, ninterval ); + + if ( !( losscount[packet->source] % ninterval ) ) + { + return false; + } + } + } + + if (s_FakeLag <= 0.0) + { + // Never leave any old msgs around + for ( int i=0; i<MAX_SOCKETS; i++ ) + { + NET_ClearLagData( i ); + } + return newdata; + } + + // if new packet arrived in fakelag list + if ( newdata ) + { + NET_AddToLagged( &s_pLagData[packet->source], packet ); + } + + // Now check the correct list and feed any message that is old enough. + netpacket_t *p = s_pLagData[packet->source]; // current packet + + if ( !p ) + return false; // no packet in lag list + + float target = s_FakeLag; + float maxjitter = min( fakejitter.GetFloat(), target * 0.5f ); + target += RandomFloat( -maxjitter, maxjitter ); + + if ( (p->received + (target/1000.0f)) > net_time ) + return false; // not time yet for this packet + +#ifdef _DEBUG + if ( fakeshuffle.GetInt() && p->pNext ) + { + if ( !RandomInt( 0, fakeshuffle.GetInt() ) ) + { + // swap p and p->next + netpacket_t * t = p->pNext; + p->pNext = t->pNext; + t->pNext = p; + p = t; + } + } +#endif + + // remove packet p from list (is head) + s_pLagData[packet->source] = p->pNext; + + // copy & adjust content + packet->source = p->source; + packet->from = p->from; + packet->pNext = NULL; // no next + packet->received = net_time; // new time + packet->size = p->size; + packet->wiresize = p->wiresize; + packet->stream = p->stream; + + Q_memcpy( packet->data, p->data, p->size ); + + // free lag packet + + delete[] p->data; + delete p; + + return true; +} + +// Calculate MAX_SPLITPACKET_SPLITS according to the smallest split size +#define MAX_SPLITPACKET_SPLITS ( NET_MAX_MESSAGE / MIN_SPLIT_SIZE ) +#define SPLIT_PACKET_STALE_TIME 2.0f +#define SPLIT_PACKET_TRACKING_MAX 256 // most number of outstanding split packets to allow + +class CSplitPacketEntry +{ +public: + CSplitPacketEntry() + { + memset( &from, 0, sizeof( from ) ); + + int i; + for ( i = 0; i < MAX_SPLITPACKET_SPLITS; i++ ) + { + splitflags[ i ] = -1; + } + + memset( &netsplit, 0, sizeof( netsplit ) ); + lastactivetime = 0.0f; + } + +public: + netadr_t from; + int splitflags[ MAX_SPLITPACKET_SPLITS ]; + LONGPACKET netsplit; + // host_time the last time any entry was received for this entry + float lastactivetime; +}; + +typedef CUtlVector< CSplitPacketEntry > vecSplitPacketEntries_t; +static CUtlVector<vecSplitPacketEntries_t> net_splitpackets; + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void NET_DiscardStaleSplitpackets( const int sock ) +{ + vecSplitPacketEntries_t &splitPacketEntries = net_splitpackets[sock]; + int i; + for ( i = splitPacketEntries.Count() - 1; i >= 0; i-- ) + { + CSplitPacketEntry *entry = &splitPacketEntries[ i ]; + Assert( entry ); + + if ( net_time < ( entry->lastactivetime + SPLIT_PACKET_STALE_TIME ) ) + continue; + + splitPacketEntries.Remove( i ); + } + + if ( splitPacketEntries.Count() > SPLIT_PACKET_TRACKING_MAX ) + { + while ( splitPacketEntries.Count() > SPLIT_PACKET_TRACKING_MAX ) + { + CSplitPacketEntry *entry = &splitPacketEntries[ i ]; + if ( net_time != entry->lastactivetime ) + splitPacketEntries.Remove(0); // we add to tail each time, so head is the oldest entry, kill them first + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *from - +// Output : CSplitPacketEntry +//----------------------------------------------------------------------------- +CSplitPacketEntry *NET_FindOrCreateSplitPacketEntry( const int sock, netadr_t *from ) +{ + vecSplitPacketEntries_t &splitPacketEntries = net_splitpackets[sock]; + int i, count = splitPacketEntries.Count(); + CSplitPacketEntry *entry = NULL; + for ( i = 0; i < count; i++ ) + { + entry = &splitPacketEntries[ i ]; + Assert( entry ); + + if ( from->CompareAdr(entry->from) ) + break; + } + + if ( i >= count ) + { + CSplitPacketEntry newentry; + newentry.from = *from; + + splitPacketEntries.AddToTail( newentry ); + + entry = &splitPacketEntries[ splitPacketEntries.Count() - 1 ]; + } + + Assert( entry ); + return entry; +} + +static char const *DescribeSocket( int sock ) +{ + switch ( sock ) + { + default: + break; + case NS_CLIENT: + return "cl "; + case NS_SERVER: + return "sv "; + case NS_HLTV: + return "htv"; + case NS_MATCHMAKING: + return "mat"; + case NS_SYSTEMLINK: + return "lnk"; +#ifdef LINUX + case NS_SVLAN: + return "lan"; +#endif + } + + return "??"; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *pData - +// size - +// *outSize - +// Output : bool +//----------------------------------------------------------------------------- +bool NET_GetLong( const int sock, netpacket_t *packet ) +{ + int packetNumber, packetCount, sequenceNumber, offset; + short packetID; + SPLITPACKET *pHeader; + + if ( packet->size < sizeof(SPLITPACKET) ) + { + Msg( "Invalid split packet length %i\n", packet->size ); + return false; + } + + pHeader = ( SPLITPACKET * )packet->data; + // pHeader is network endian correct + sequenceNumber = LittleLong( pHeader->sequenceNumber ); + packetID = LittleShort( (short)pHeader->packetID ); + // High byte is packet number + packetNumber = ( packetID >> 8 ); + // Low byte is number of total packets + packetCount = ( packetID & 0xff ); + + int nSplitSizeMinusHeader = (int)LittleShort( (short)pHeader->nSplitSize ); + if ( nSplitSizeMinusHeader < MIN_SPLIT_SIZE || + nSplitSizeMinusHeader > MAX_SPLIT_SIZE ) + { + Msg( "NET_GetLong: Split packet from %s with invalid split size (number %i/ count %i) where size %i is out of valid range [%llu - %llu]\n", + packet->from.ToString(), + packetNumber, + packetCount, + nSplitSizeMinusHeader, + (uint64)MIN_SPLIT_SIZE, + (uint64)MAX_SPLIT_SIZE ); + return false; + } + + if ( packetNumber >= MAX_SPLITPACKET_SPLITS || + packetCount > MAX_SPLITPACKET_SPLITS ) + { + Msg( "NET_GetLong: Split packet from %s with too many split parts (number %i/ count %i) where %llu is max count allowed\n", + packet->from.ToString(), + packetNumber, + packetCount, + (uint64)MAX_SPLITPACKET_SPLITS ); + return false; + } + + CSplitPacketEntry *entry = NET_FindOrCreateSplitPacketEntry( sock, &packet->from ); + Assert( entry ); + if ( !entry ) + return false; + + entry->lastactivetime = net_time; + Assert( packet->from.CompareAdr( entry->from ) ); + + // First packet in split series? + if ( entry->netsplit.currentSequence == -1 || + sequenceNumber != entry->netsplit.currentSequence ) + { + entry->netsplit.currentSequence = sequenceNumber; + entry->netsplit.splitCount = packetCount; + entry->netsplit.nExpectedSplitSize = nSplitSizeMinusHeader; + } + + if ( entry->netsplit.nExpectedSplitSize != nSplitSizeMinusHeader ) + { + Msg( "NET_GetLong: Split packet from %s with inconsistent split size (number %i/ count %i) where size %i not equal to initial size of %i\n", + packet->from.ToString(), + packetNumber, + packetCount, + nSplitSizeMinusHeader, + entry->netsplit.nExpectedSplitSize + ); + entry->lastactivetime = net_time + SPLIT_PACKET_STALE_TIME; + return false; + } + + int size = packet->size - sizeof(SPLITPACKET); + + if ( entry->splitflags[ packetNumber ] != sequenceNumber ) + { + // Last packet in sequence? set size + if ( packetNumber == (packetCount-1) ) + { + entry->netsplit.totalSize = (packetCount-1) * nSplitSizeMinusHeader + size; + } + + entry->netsplit.splitCount--; // Count packet + entry->splitflags[ packetNumber ] = sequenceNumber; + + if ( net_showsplits.GetInt() && net_showsplits.GetInt() != 3 ) + { + Msg( "<-- [%s] Split packet %4i/%4i seq %5i size %4i mtu %4llu from %s\n", + DescribeSocket( sock ), + packetNumber + 1, + packetCount, + sequenceNumber, + size, + (uint64)(nSplitSizeMinusHeader + sizeof( SPLITPACKET )), + packet->from.ToString() ); + } + } + else + { + Msg( "NET_GetLong: Ignoring duplicated split packet %i of %i ( %i bytes ) from %s\n", packetNumber + 1, packetCount, size, packet->from.ToString() ); + } + + + // Copy the incoming data to the appropriate place in the buffer + offset = (packetNumber * nSplitSizeMinusHeader); + memcpy( entry->netsplit.buffer + offset, packet->data + sizeof(SPLITPACKET), size ); + + // Have we received all of the pieces to the packet? + if ( entry->netsplit.splitCount <= 0 ) + { + entry->netsplit.currentSequence = -1; // Clear packet + if ( entry->netsplit.totalSize > sizeof(entry->netsplit.buffer) ) + { + Msg("Split packet too large! %d bytes from %s\n", entry->netsplit.totalSize, packet->from.ToString() ); + return false; + } + + Q_memcpy( packet->data, entry->netsplit.buffer, entry->netsplit.totalSize ); + packet->size = entry->netsplit.totalSize; + packet->wiresize = entry->netsplit.totalSize; + return true; + } + + return false; +} + + +bool NET_GetLoopPacket ( netpacket_t * packet ) +{ + Assert ( packet ); + + loopback_t *loop; + + if ( packet->source > NS_SERVER ) + return false; + + if ( !s_LoopBacks[packet->source].PopItem( &loop ) ) + { + return false; + } + + if (loop->datalen == 0) + { + // no packet in loopback buffer + delete loop; + return ( NET_LagPacket( false, packet ) ); + } + + // copy data from loopback buffer to packet + packet->from.SetType( NA_LOOPBACK ); + packet->size = loop->datalen; + packet->wiresize = loop->datalen; + Q_memcpy ( packet->data, loop->data, packet->size ); + + loop->datalen = 0; // buffer is avalibale again + + if ( loop->data != loop->defbuffer ) + { + delete loop->data; + loop->data = loop->defbuffer; + } + + delete loop; + + // allow lag system to modify packet + return ( NET_LagPacket( true, packet ) ); +} + +bool NET_ReceiveDatagram ( const int sock, netpacket_t * packet ) +{ + VPROF_BUDGET( "NET_ReceiveDatagram", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + + Assert ( packet ); + Assert ( net_multiplayer ); + + struct sockaddr from; + int fromlen = sizeof(from); + int net_socket = net_sockets[packet->source].hUDP; + + int ret = 0; + { + VPROF_BUDGET( "recvfrom", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + ret = VCRHook_recvfrom(net_socket, (char *)packet->data, NET_MAX_MESSAGE, 0, (struct sockaddr *)&from, (int *)&fromlen ); + } + if ( ret >= NET_MIN_MESSAGE ) + { + packet->wiresize = ret; + packet->from.SetFromSockadr( &from ); + packet->size = ret; + + if ( net_showudp_wire.GetBool() ) + { + Msg( "WIRE: UDP sz=%d tm=%f rt %f from %s\n", ret, net_time, Plat_FloatTime(), packet->from.ToString() ); + } + + MEM_ALLOC_CREDIT(); + CUtlMemoryFixedGrowable< byte, NET_COMPRESSION_STACKBUF_SIZE > bufVoice( NET_COMPRESSION_STACKBUF_SIZE ); + + unsigned int nVoiceBits = 0u; + + if ( X360SecureNetwork() ) + { + // X360TBD: Check for voice data and forward it to XAudio + // For now, just pull off the 2-byte VDP header and shift the data + unsigned short nDataBytes = ( *( unsigned short * )packet->data ); + + Assert( nDataBytes > 0 && nDataBytes <= ret ); + + int nVoiceBytes = ret - nDataBytes - 2; + if ( nVoiceBytes > 0 ) + { + char *pVoice = (char *)packet->data + 2 + nDataBytes; + + nVoiceBits = (unsigned int)LittleShort( *( unsigned short *)pVoice ); + unsigned int nExpectedVoiceBytes = Bits2Bytes( nVoiceBits ); + pVoice += sizeof( unsigned short ); + + int nCompressedSize = nVoiceBytes - sizeof( unsigned short ); + int nDecompressedVoice = COM_GetUncompressedSize( pVoice, nCompressedSize ); + if ( nDecompressedVoice >= 0 ) + { + if ( (unsigned)nDecompressedVoice != nExpectedVoiceBytes ) + { + return false; + } + + bufVoice.EnsureCapacity( nDecompressedVoice ); + + // Decompress it + unsigned unActualDecompressedSize = (unsigned)nDecompressedVoice; + if ( !COM_BufferToBufferDecompress( (char*)bufVoice.Base(), &unActualDecompressedSize, pVoice, nCompressedSize ) ) + return false; + Assert( unActualDecompressedSize == (unsigned)nDecompressedVoice ); + + nVoiceBytes = unActualDecompressedSize; + } + else + { + bufVoice.EnsureCapacity( nVoiceBytes ); + Q_memcpy( bufVoice.Base(), pVoice, nVoiceBytes ); + } + } + + Q_memmove( packet->data, &packet->data[2], nDataBytes ); + + ret = nDataBytes; + } + + + if ( ret < NET_MAX_MESSAGE ) + { + // Check for split message + if ( LittleLong( *(int *)packet->data ) == NET_HEADER_FLAG_SPLITPACKET ) + { + if ( !NET_GetLong( sock, packet ) ) + return false; + } + + // Next check for compressed message + if ( LittleLong( *(int *)packet->data) == NET_HEADER_FLAG_COMPRESSEDPACKET ) + { + char *pCompressedData = (char*)packet->data + sizeof( unsigned int ); + unsigned nCompressedDataSize = packet->wiresize - sizeof( unsigned int ); + + // Decompress + int actualSize = COM_GetUncompressedSize( pCompressedData, nCompressedDataSize ); + if ( actualSize <= 0 || actualSize > NET_MAX_PAYLOAD ) + return false; + + MEM_ALLOC_CREDIT(); + CUtlMemoryFixedGrowable< byte, NET_COMPRESSION_STACKBUF_SIZE > memDecompressed( NET_COMPRESSION_STACKBUF_SIZE ); + memDecompressed.EnsureCapacity( actualSize ); + + unsigned uDecompressedSize = (unsigned)actualSize; + COM_BufferToBufferDecompress( (char*)memDecompressed.Base(), &uDecompressedSize, pCompressedData, nCompressedDataSize ); + if ( uDecompressedSize == 0 || ((unsigned int)actualSize) != uDecompressedSize ) + { + if ( net_showudp.GetBool() ) + { + Msg( "UDP: discarding %d bytes from %s due to decompression error [%d decomp, actual %d] at tm=%f rt=%f\n", ret, packet->from.ToString(), uDecompressedSize, actualSize, + (float)net_time, (float)Plat_FloatTime() ); + } + return false; + } + + // packet->wiresize is already set + Q_memcpy( packet->data, memDecompressed.Base(), uDecompressedSize ); + + packet->size = uDecompressedSize; + } + + if ( nVoiceBits > 0 ) + { + // 9th byte is flag byte + byte flagByte = *( (byte *)packet->data + sizeof( unsigned int ) + sizeof( unsigned int ) ); + unsigned int unPacketBits = packet->size << 3; + int nPadBits = DECODE_PAD_BITS( flagByte ); + unPacketBits -= nPadBits; + + bf_write fixup; + fixup.SetDebugName( "X360 Fixup" ); + fixup.StartWriting( packet->data, NET_MAX_MESSAGE, unPacketBits ); + fixup.WriteBits( bufVoice.Base(), nVoiceBits ); + + // Make sure we have enough bits to read a final net_NOP opcode before compressing + int nRemainingBits = fixup.GetNumBitsWritten() % 8; + if ( nRemainingBits > 0 && nRemainingBits <= (8-NETMSG_TYPE_BITS) ) + { + fixup.WriteUBitLong( net_NOP, NETMSG_TYPE_BITS ); + } + + packet->size = fixup.GetNumBytesWritten(); + } + + return NET_LagPacket( true, packet ); + } + else + { + ConDMsg ( "NET_ReceiveDatagram: Oversize packet from %s\n", packet->from.ToString() ); + } + } + else if ( ret == -1 ) // error? + { + NET_GetLastError(); + + switch ( net_error ) + { + case WSAEWOULDBLOCK: + case WSAECONNRESET: + case WSAECONNREFUSED: + break; + case WSAEMSGSIZE: + ConDMsg ("NET_ReceivePacket: %s\n", NET_ErrorString(net_error)); + break; + default: + // Let's continue even after errors + ConDMsg ("NET_ReceivePacket: %s\n", NET_ErrorString(net_error)); + break; + } + } + + return false; +} + +bool NET_ReceiveValidDatagram ( const int sock, netpacket_t * packet ) +{ +#ifdef _DEBUG + if ( recvpackets.GetInt() >= 0 ) + { + unsigned long bytes = 0; + + ioctlsocket( net_sockets[ sock ].hUDP , FIONREAD, &bytes ); + + if ( bytes <= 0 ) + return false; + + if ( recvpackets.GetInt() == 0 ) + return false; + + recvpackets.SetValue( recvpackets.GetInt() - 1 ); + } +#endif + + // Failsafe: never call recvfrom more than a fixed number of times per frame. + // We don't like the potential for infinite loops. Yes this means that 66000 + // invalid packets per frame will effectively DOS the server, but at that point + // you're basically flooding the network and you need to solve this at a higher + // firewall or router level instead which is beyond the scope of our netcode. + // --henryg 10/12/2011 + for ( int i = 1000; i > 0; --i ) + { + // Attempt to receive a valid packet. + NET_ClearLastError(); + if ( NET_ReceiveDatagram ( sock, packet ) ) + { + // Received a valid packet. + return true; + } + // NET_ReceiveDatagram calls Net_GetLastError() in case of socket errors + // or a would-have-blocked-because-there-is-no-data-to-read condition. + if ( net_error ) + { + break; + } + } + return false; +} + + +netpacket_t *NET_GetPacket (int sock, byte *scratch ) +{ + VPROF_BUDGET( "NET_GetPacket", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + + // Each socket has its own netpacket to allow multithreading + netpacket_t &inpacket = net_packets[sock]; + + NET_AdjustLag(); + NET_DiscardStaleSplitpackets( sock ); + + // setup new packet + inpacket.from.SetType( NA_IP ); + inpacket.from.Clear(); + inpacket.received = net_time; + inpacket.source = sock; + inpacket.data = scratch; + inpacket.size = 0; + inpacket.wiresize = 0; + inpacket.pNext = NULL; + inpacket.message.SetDebugName("inpacket.message"); + + // Check loopback first + if ( !NET_GetLoopPacket( &inpacket ) ) + { + if ( !NET_IsMultiplayer() ) + { + return NULL; + } + + // then check UDP data + if ( !NET_ReceiveValidDatagram( sock, &inpacket ) ) + { + // at last check if the lag system has a packet for us + if ( !NET_LagPacket (false, &inpacket) ) + { + return NULL; // we don't have any new packet + } + } + } + + Assert ( inpacket.size ); + +#ifdef _DEBUG + if ( fakenoise.GetInt() > 0 ) + { + COM_AddNoise( inpacket.data, inpacket.size, fakenoise.GetInt() ); + } +#endif + + // prepare bitbuffer for reading packet with new size + inpacket.message.StartReading( inpacket.data, inpacket.size ); + + return &inpacket; +} + +void NET_ProcessPending( void ) +{ + AUTO_LOCK( s_PendingSockets ); + for ( int i=0; i<s_PendingSockets.Count();i++ ) + { + pendingsocket_t * psock = &s_PendingSockets[i]; + + ALIGN4 char headerBuf[5] ALIGN4_POST; + + if ( (net_time - psock->time) > TCP_CONNECT_TIMEOUT ) + { + NET_CloseSocket( psock->newsock ); + s_PendingSockets.Remove( i ); + continue; + } + + int ret = NET_ReceiveStream( psock->newsock, headerBuf, sizeof(headerBuf), 0 ); + + if ( ret == 0 ) + { + continue; // nothing received + } + else if ( ret == -1 ) + { + NET_CloseSocket( psock->newsock ); + s_PendingSockets.Remove( i ); + continue; // connection closed somehow + } + + bf_read header( headerBuf, sizeof(headerBuf) ); + + int cmd = header.ReadByte(); + unsigned long challengeNr = header.ReadLong(); + bool bOK = false; + + if ( cmd == STREAM_CMD_ACKN ) + { + AUTO_LOCK( s_NetChannels ); + for ( int j = 0; j < s_NetChannels.Count(); j++ ) + { + CNetChan * chan = s_NetChannels[j]; + + if ( chan->GetSocket() != psock->netsock ) + continue; + + if ( challengeNr == chan->GetChallengeNr() && !chan->m_StreamSocket ) + { + if ( psock->addr.CompareAdr( chan->remote_address, true ) ) + { + chan->m_StreamSocket = psock->newsock; + chan->m_StreamActive = true; + + chan->ResetStreaming(); + + bOK = true; + + if ( net_showtcp.GetInt() ) + { + Msg ("TCP <- %s: connection accepted\n", psock->addr.ToString() ); + } + + break; + } + else + { + Msg ("TCP <- %s: IP address mismatch.\n", psock->addr.ToString() ); + } + } + } + } + + if ( !bOK ) + { + Msg ("TCP <- %s: invalid connection request.\n", psock->addr.ToString() ); + NET_CloseSocket( psock->newsock ); + } + + s_PendingSockets.Remove( i ); + } +} + +void NET_ProcessListen(int sock) +{ + netsocket_t * netsock = &net_sockets[sock]; + + if ( !netsock->bListening ) + return; + + sockaddr sa; + int nLengthAddr = sizeof(sa); + + int newSocket; + + VCR_NONPLAYBACKFN( accept( netsock->hTCP, &sa, (socklen_t*)&nLengthAddr), newSocket, "accept" ); +#if !defined( NO_VCR ) + VCRGenericValue( "sockaddr", &sa, sizeof( sa ) ); +#endif + if ( newSocket == -1 ) + { + NET_GetLastError(); + + if ( net_error != WSAEWOULDBLOCK ) + { + ConDMsg ("NET_ThreadListen: %s\n", NET_ErrorString(net_error)); + } + return; + } + + // new connection TCP request, put in pending queue + + pendingsocket_t psock; + + psock.newsock = newSocket; + psock.netsock = sock; + psock.addr.SetFromSockadr( &sa ); + psock.time = net_time; + + AUTO_LOCK( s_PendingSockets ); + s_PendingSockets.AddToTail( psock ); + + // tell client to send challenge number to identify + + char authcmd = STREAM_CMD_AUTH; + + NET_SendStream( newSocket, &authcmd, 1 , 0 ); + + if ( net_showtcp.GetInt() ) + { + Msg ("TCP <- %s: connection request.\n", psock.addr.ToString() ); + } +} + +struct NetScratchBuffer_t : TSLNodeBase_t +{ + byte data[NET_MAX_MESSAGE]; +}; +CTSSimpleList<NetScratchBuffer_t> g_NetScratchBuffers; + +void NET_ProcessSocket( int sock, IConnectionlessPacketHandler *handler ) +{ + VPROF_BUDGET( "NET_ProcessSocket", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + + netpacket_t * packet; + + Assert ( (sock >= 0) && (sock<net_sockets.Count()) ); + + // Scope for the auto_lock + { + AUTO_LOCK( s_NetChannels ); + + // get streaming data from channel sockets + int numChannels = s_NetChannels.Count(); + + for ( int i = (numChannels-1); i >= 0 ; i-- ) + { + CNetChan *netchan = s_NetChannels[i]; + + // sockets must match + if ( sock != netchan->GetSocket() ) + continue; + + if ( !netchan->ProcessStream() ) + { + netchan->GetMsgHandler()->ConnectionCrashed("TCP connection failed."); + } + } + } + + // now get datagrams from sockets + NetScratchBuffer_t *scratch = g_NetScratchBuffers.Pop(); + if ( !scratch ) + { + scratch = new NetScratchBuffer_t; + } + while ( ( packet = NET_GetPacket ( sock, scratch->data ) ) != NULL ) + { + if ( Filter_ShouldDiscard ( packet->from ) ) // filtering is done by network layer + { + Filter_SendBan( packet->from ); // tell them we aren't listening... + continue; + } + + // check for connectionless packet (0xffffffff) first + if ( LittleLong( *(unsigned int *)packet->data ) == CONNECTIONLESS_HEADER ) + { + packet->message.ReadLong(); // read the -1 + + if ( net_showudp.GetInt() ) + { + Msg("UDP <- %s: sz=%i OOB '%c' wire=%i\n", packet->from.ToString(), packet->size, packet->data[4], packet->wiresize ); + } + + handler->ProcessConnectionlessPacket( packet ); + continue; + } + + // check for packets from connected clients + + CNetChan * netchan = NET_FindNetChannel( sock, packet->from ); + + if ( netchan ) + { + netchan->ProcessPacket( packet, true ); + } + /* else // Not an error that may happen during connect or disconnect + { + Msg ("Sequenced packet without connection from %s\n" , packet->from.ToString() ); + }*/ + } + g_NetScratchBuffers.Push( scratch ); +} + +void NET_LogBadPacket(netpacket_t * packet) +{ + FileHandle_t fp; + int i = 0; + char filename[ MAX_OSPATH ]; + bool done = false; + + while ( i < 1000 && !done ) + { + Q_snprintf( filename, sizeof( filename ), "badpacket%03i.dat", i ); + fp = g_pFileSystem->Open( filename, "rb" ); + if ( !fp ) + { + fp = g_pFileSystem->Open( filename, "wb" ); + g_pFileSystem->Write( packet->data, packet->size, fp ); + done = true; + } + if ( fp ) + { + g_pFileSystem->Close( fp ); + } + i++; + } + + if ( i < 1000 ) + { + Msg( "Error buffer for %s written to %s\n", packet->from.ToString(), filename ); + } + else + { + Msg( "Couldn't write error buffer, delete error###.dat files to make space\n" ); + } +} + +int NET_SendToImpl( SOCKET s, const char FAR * buf, int len, const struct sockaddr FAR * to, int tolen, int iGameDataLength ) +{ + int nSend = 0; +#if defined( _X360 ) + if ( X360SecureNetwork() ) + { + // 360 uses VDP protocol to piggyback voice data across the network. + // Two-byte VDP Header contains the number of game data bytes + + // NOTE: The header bytes *should* be swapped to network endian, however when communicating + // with XLSP servers (the only cross-platform communication possible with a secure network) + // the server's network stack swaps the header at the receiving end. + const int nVDPHeaderBytes = 2; + Assert( len < (unsigned short)-1 ); + + const unsigned short nDataBytes = iGameDataLength == -1 ? len : iGameDataLength; + + WSABUF buffers[2]; + buffers[0].len = nVDPHeaderBytes; + buffers[0].buf = (char*)&nDataBytes; + + buffers[1].len = len; + buffers[1].buf = const_cast<char*>( buf ); + + WSASendTo( s, buffers, 2, (DWORD*)&nSend, 0, to, tolen, NULL, NULL ); + } + else +#endif //defined( _X360 ) + { + nSend = sendto( s, buf, len, 0, to, tolen ); + } + + return nSend; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : sock - +// s - +// buf - +// len - +// flags - +// to - +// tolen - +// Output : int +//----------------------------------------------------------------------------- +bool CL_IsHL2Demo(); +bool CL_IsPortalDemo(); +int NET_SendTo( bool verbose, SOCKET s, const char FAR * buf, int len, const struct sockaddr FAR * to, int tolen, int iGameDataLength ) +{ + int nSend = 0; + + VPROF_BUDGET( "NET_SendTo", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + + // If it's 0.0.0.0:0, then it's a fake player + sv_stressbots and we've plumbed everything all + // the way through here, where we finally bail out. + sockaddr_in *pInternetAddr = (sockaddr_in*)to; +#ifdef _WIN32 + if ( pInternetAddr->sin_addr.S_un.S_addr == 0 +#else + if ( pInternetAddr->sin_addr.s_addr == 0 +#endif + && pInternetAddr->sin_port == 0 ) + { + return len; + } + + // Normally, we shouldn't need to write this data to the file, but it can help catch + // out-of-sync errors earlier. + if ( VCRGetMode() != VCR_Disabled && vcr_verbose.GetInt() ) + { +#if !defined( NO_VCR ) + VCRGenericValue( "senddata", &len, sizeof( len ) ); + VCRGenericValue( "senddata2", (char*)buf, len ); +#endif + } + + // Don't send anything out in VCR mode.. it just annoys other people testing in multiplayer. + if ( VCRGetMode() != VCR_Playback ) + { +#ifndef SWDS + if ( ( CL_IsHL2Demo() || CL_IsPortalDemo() ) && !net_dedicated ) + { + Error( " " ); + } +#endif // _WIN32 + + nSend = NET_SendToImpl + ( + s, + buf, + len, + to, + tolen, + iGameDataLength + ); + } + +#if defined( _DEBUG ) + if ( verbose && + ( nSend > 0 ) && + ( len > MAX_ROUTABLE_PAYLOAD ) ) + { + ConDMsg( "NET_SendTo: Packet length (%i) > (%i) bytes\n", len, MAX_ROUTABLE_PAYLOAD ); + } +#endif + return nSend; +} + +#if defined( _DEBUG ) + +#include "filesystem.h" +#include "filesystem_engine.h" + +//----------------------------------------------------------------------------- +// Purpose: +// Output : char const +//----------------------------------------------------------------------------- +char const *NET_GetDebugFilename( char const *prefix ) +{ + static char filename[ MAX_OSPATH ]; + + int i; + + for ( i = 0; i < 10000; i++ ) + { + Q_snprintf( filename, sizeof( filename ), "debug/%s%04i.dat", prefix, i ); + if ( g_pFileSystem->FileExists( filename ) ) + continue; + + return filename; + } + + return NULL; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *filename - +// *buf - +// len - +//----------------------------------------------------------------------------- +void NET_StorePacket( char const *filename, byte const *buf, int len ) +{ + FileHandle_t fh; + + g_pFileSystem->CreateDirHierarchy( "debug/", "DEFAULT_WRITE_PATH" ); + fh = g_pFileSystem->Open( filename, "wb" ); + if ( FILESYSTEM_INVALID_HANDLE != fh ) + { + g_pFileSystem->Write( buf, len, fh ); + g_pFileSystem->Close( fh ); + } +} + +#endif // _DEBUG + +struct SendQueueItem_t +{ + SendQueueItem_t() : + m_pChannel( NULL ), + m_Socket( (SOCKET)-1 ) + { + } + + CNetChan *m_pChannel; + SOCKET m_Socket; + CUtlBuffer m_Buffer; + CUtlBuffer m_To; +}; + +struct SendQueue_t +{ + SendQueue_t() : + m_nHostFrame( 0 ) + { + } + int m_nHostFrame; + CUtlLinkedList< SendQueueItem_t > m_SendQueue; +}; + +static SendQueue_t g_SendQueue; + +int NET_QueuePacketForSend( CNetChan *chan, bool verbose, SOCKET s, const char FAR *buf, int len, const struct sockaddr FAR * to, int tolen, uint32 msecDelay ) +{ + // If net_queued_packet_thread was -1 at startup, then we don't even have a thread. + if ( net_queued_packet_thread.GetInt() && g_pQueuedPackedSender->IsRunning() ) + { + g_pQueuedPackedSender->QueuePacket( chan, s, buf, len, to, tolen, msecDelay ); + } + else + { + Assert( chan ); + // Set up data structure + SendQueueItem_t *sq = &g_SendQueue.m_SendQueue[ g_SendQueue.m_SendQueue.AddToTail() ]; + sq->m_Socket = s; + sq->m_pChannel = chan; + sq->m_Buffer.Put( (const void *)buf, len ); + sq->m_To.Put( (const void *)to, tolen ); + sq->m_pChannel->IncrementQueuedPackets(); + } + + return len; +} + +void NET_SendQueuedPacket( SendQueueItem_t *sq ) +{ + // Msg( "Send queued packet %d\n", sq->m_Buffer.TellPut() ); + NET_SendTo + ( + false, + sq->m_Socket, + ( const char FAR * )sq->m_Buffer.Base(), + sq->m_Buffer.TellPut(), + ( const struct sockaddr FAR * )sq->m_To.Base(), + sq->m_To.TellPut() , -1 + ); + + sq->m_pChannel->DecrementQueuedPackets(); +} + +void NET_ClearQueuedPacketsForChannel( INetChannel *channel ) +{ + CUtlLinkedList< SendQueueItem_t >& list = g_SendQueue.m_SendQueue; + + for ( unsigned short i = list.Head(); i != list.InvalidIndex(); ) + { + unsigned short n = list.Next( i ); + SendQueueItem_t &e = list[ i ]; + if ( e.m_pChannel == channel ) + { + list.Remove( i ); + } + i = n; + } +} + +void NET_SendQueuedPackets() +{ + // Only do this once per frame + if ( host_framecount == g_SendQueue.m_nHostFrame ) + return; + g_SendQueue.m_nHostFrame = host_framecount; + + CUtlLinkedList< SendQueueItem_t >& list = g_SendQueue.m_SendQueue; + + int nRemaining = net_splitrate.GetInt(); + while ( nRemaining ) + { + if ( list.IsValidIndex( list.Head() ) ) + { + SendQueueItem_t *sq = &list[ list.Head() ]; + NET_SendQueuedPacket( sq ); + list.Remove( list.Head() ); + --nRemaining; + } + else + { + break; + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : sock - +// s - +// buf - +// len - +// flags - +// to - +// tolen - +// Output : int +//----------------------------------------------------------------------------- +static volatile int32 s_SplitPacketSequenceNumber[ MAX_SOCKETS ] = {1}; +static ConVar net_splitpacket_maxrate( "net_splitpacket_maxrate", SPLITPACKET_MAX_DATA_BYTES_PER_SECOND, 0, "Max bytes per second when queueing splitpacket chunks", true, MIN_RATE, true, MAX_RATE ); + +int NET_SendLong( INetChannel *chan, int sock, SOCKET s, const char FAR * buf, int len, const struct sockaddr FAR * to, int tolen, int nMaxRoutableSize ) +{ + VPROF_BUDGET( "NET_SendLong", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + + CNetChan *netchan = dynamic_cast< CNetChan * >( chan ); + + short nSplitSizeMinusHeader = nMaxRoutableSize - sizeof( SPLITPACKET ); + + int nSequenceNumber = -1; + if ( netchan ) + { + nSequenceNumber = netchan->IncrementSplitPacketSequence(); + } + else + { + nSequenceNumber = ThreadInterlockedIncrement( &s_SplitPacketSequenceNumber[ sock ] ); + } + + const char *sendbuf = buf; + int sendlen = len; + + char packet[ MAX_ROUTABLE_PAYLOAD ]; + SPLITPACKET *pPacket = (SPLITPACKET *)packet; + + // Make pPacket data network endian correct + pPacket->netID = LittleLong( NET_HEADER_FLAG_SPLITPACKET ); + pPacket->sequenceNumber = LittleLong( nSequenceNumber ); + pPacket->nSplitSize = LittleShort( nSplitSizeMinusHeader ); + + int nPacketCount = (sendlen + nSplitSizeMinusHeader - 1) / nSplitSizeMinusHeader; + +#if defined( _DEBUG ) + if ( net_savelargesplits.GetInt() != -1 && nPacketCount >= net_savelargesplits.GetInt() ) + { + char const *filename = NET_GetDebugFilename( "splitpacket" ); + if ( filename ) + { + Msg( "Saving split packet of %i bytes and %i packets to file %s\n", + sendlen, nPacketCount, filename ); + + NET_StorePacket( filename, (byte const *)sendbuf, sendlen ); + } + else + { + Msg( "Too many files in debug directory, clear out old data!\n" ); + } + } +#endif + + int nBytesLeft = sendlen; + int nPacketNumber = 0; + int nTotalBytesSent = 0; + int nFragmentsSent = 0; + + while ( nBytesLeft > 0 ) + { + int size = min( (int)nSplitSizeMinusHeader, nBytesLeft ); + + pPacket->packetID = LittleShort( (short)(( nPacketNumber << 8 ) + nPacketCount) ); + + Q_memcpy( packet + sizeof(SPLITPACKET), sendbuf + (nPacketNumber * nSplitSizeMinusHeader), size ); + + int ret = 0; + + // Setting net_queued_packet_thread to NET_QUEUED_PACKET_THREAD_DEBUG_VALUE goes into a mode where all packets are queued.. can be used to stress-test it. + // Linux threads aren't prioritized well enough for this to work well (i.e. the queued packet thread doesn't get enough + // attention to flush itself well). The behavior the queue fixes is that if you send too many DP packets + // without giving up your timeslice, it'll just discard the 7th and later packets until you Sleep() (issue might be on client recipient side, need to + // snif packets to double check) + + if ( netchan && (nFragmentsSent >= net_splitrate.GetInt() || net_queued_packet_thread.GetInt() == NET_QUEUED_PACKET_THREAD_DEBUG_VALUE) ) + { + // Don't let this rate get too high (SPLITPACKET_MAX_DATA_BYTES_PER_SECOND == 15000 bytes/sec) + // or user's won't be able to receive all of the parts since they'll be too close together. + /// XXX(JohnS): (float)cv.GetInt() is just preserving what this was doing before to avoid changing the + /// semantics of this convar + float flMaxSplitpacketDataRateBytesPerSecond = min( (float)netchan->GetDataRate(), (float)net_splitpacket_maxrate.GetInt() ); + + // Calculate the delay (measured from now) for when this packet should be sent. + uint32 delay = (int)( 1000.0f * ( (float)( nPacketNumber * ( nMaxRoutableSize + UDP_HEADER_SIZE ) ) / flMaxSplitpacketDataRateBytesPerSecond ) + 0.5f ); + + ret = NET_QueuePacketForSend( netchan, false, s, packet, size + sizeof(SPLITPACKET), to, tolen, delay ); + } + else + { + // Also, we send the first packet no matter what + // w/o a netchan, if there are too many splits, its possible the packet can't be delivered. However, this would only apply to out of band stuff like + // server query packets, which should never require splitting anyway. + ret = NET_SendTo( false, s, packet, size + sizeof(SPLITPACKET), to, tolen, -1 ); + } + + // First split send + ++nFragmentsSent; + + if ( ret < 0 ) + { + return ret; + } + + if ( ret >= size ) + { + nTotalBytesSent += size; + } + + nBytesLeft -= size; + ++nPacketNumber; + + // Always bitch about split packets in debug + if ( net_showsplits.GetInt() && net_showsplits.GetInt() != 2 ) + { + netadr_t adr; + + adr.SetFromSockadr( (struct sockaddr*)to ); + + Msg( "--> [%s] Split packet %4i/%4i seq %5i size %4i mtu %4i to %s [ total %4i ]\n", + DescribeSocket( sock ), + nPacketNumber, + nPacketCount, + nSequenceNumber, + size, + nMaxRoutableSize, + adr.ToString(), + sendlen ); + } + } + + return nTotalBytesSent; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : sock - +// length - +// *data - +// to - +// Output : void NET_SendPacket +//----------------------------------------------------------------------------- + +int NET_SendPacket ( INetChannel *chan, int sock, const netadr_t &to, const unsigned char *data, int length, bf_write *pVoicePayload /* = NULL */, bool bUseCompression /*=false*/ ) +{ + VPROF_BUDGET( "NET_SendPacket", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + ETWSendPacket( to.ToString() , length , 0 , 0 ); + + int ret; + struct sockaddr addr; + int net_socket; + + if ( net_showudp.GetInt() && (*(unsigned int*)data == CONNECTIONLESS_HEADER) ) + { + Assert( !bUseCompression ); + Msg("UDP -> %s: sz=%i OOB '%c'\n", to.ToString(), length, data[4] ); + } + + if ( !NET_IsMultiplayer() || to.type == NA_LOOPBACK || ( to.IsLocalhost() && !net_usesocketsforloopback.GetBool() ) ) + { + Assert( !pVoicePayload ); + + NET_SendLoopPacket (sock, length, data, to); + return length; + } + + if ( to.type == NA_BROADCAST ) + { + net_socket = net_sockets[sock].hUDP; + if (!net_socket) + return length; + } + else if ( to.type == NA_IP ) + { + net_socket = net_sockets[sock].hUDP; + if (!net_socket) + return length; + } + else + { + DevMsg("NET_SendPacket: bad address type (%i)\n", to.type ); + return length; + } + + if ( (droppackets.GetInt() < 0) && sock == NS_CLIENT ) + { + droppackets.SetValue( droppackets.GetInt() + 1 ); + return length; + } + + if ( fakeloss.GetFloat() > 0.0f ) + { + // simulate sending this packet + if (RandomInt(0,100) <= (int)fakeloss.GetFloat()) + return length; + } + + to.ToSockadr ( &addr ); + + MEM_ALLOC_CREDIT(); + CUtlMemoryFixedGrowable< byte, NET_COMPRESSION_STACKBUF_SIZE > memCompressed( NET_COMPRESSION_STACKBUF_SIZE ); + CUtlMemoryFixedGrowable< byte, NET_COMPRESSION_STACKBUF_SIZE > memCompressedVoice( NET_COMPRESSION_STACKBUF_SIZE ); + + int iGameDataLength = pVoicePayload ? length : -1; + + bool bWroteVoice = false; + unsigned int nVoiceBytes = 0; + + if ( pVoicePayload ) + { + VPROF_BUDGET( "NET_SendPacket_CompressVoice", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + unsigned int nCompressedLength = COM_GetIdealDestinationCompressionBufferSize_Snappy( pVoicePayload->GetNumBytesWritten() ); + memCompressedVoice.EnsureCapacity( nCompressedLength + sizeof( unsigned short ) ); + + byte *pVoice = (byte *)memCompressedVoice.Base(); + + unsigned short usVoiceBits = pVoicePayload->GetNumBitsWritten(); + *( unsigned short * )pVoice = LittleShort( usVoiceBits ); + pVoice += sizeof( unsigned short ); + + byte *pOutput = NULL; + if ( net_compressvoice.GetBool() ) + { + if ( COM_BufferToBufferCompress_Snappy( pVoice, &nCompressedLength, pVoicePayload->GetData(), pVoicePayload->GetNumBytesWritten() + && ( (int)nCompressedLength < pVoicePayload->GetNumBytesWritten() ) ) ) + { + pOutput = pVoice; + } + } + if ( !pOutput ) + { + Q_memcpy( pVoice, pVoicePayload->GetData(), pVoicePayload->GetNumBytesWritten() ); + } + + nVoiceBytes = nCompressedLength + sizeof( unsigned short ); + } + + if ( bUseCompression ) + { + VPROF_BUDGET( "NET_SendPacket_Compress", VPROF_BUDGETGROUP_OTHER_NETWORKING ); + unsigned int nCompressedLength = COM_GetIdealDestinationCompressionBufferSize_Snappy( length ); + + memCompressed.EnsureCapacity( nCompressedLength + nVoiceBytes + sizeof( unsigned int ) ); + + *(int *)memCompressed.Base() = LittleLong( NET_HEADER_FLAG_COMPRESSEDPACKET ); + + if ( COM_BufferToBufferCompress_Snappy( memCompressed.Base() + sizeof( unsigned int ), &nCompressedLength, data, length ) + && (int)nCompressedLength < length ) + { + data = memCompressed.Base(); + length = nCompressedLength + sizeof( unsigned int ); + + if ( pVoicePayload && pVoicePayload->GetNumBitsWritten() > 0 ) + { + byte *pVoice = (byte *)memCompressed.Base() + length; + Q_memcpy( pVoice, memCompressedVoice.Base(), nVoiceBytes ); + } + + iGameDataLength = length; + + length += nVoiceBytes; + + bWroteVoice = true; + } + } + + if ( !bWroteVoice && pVoicePayload && pVoicePayload->GetNumBitsWritten() > 0 ) + { + memCompressed.EnsureCapacity( length + nVoiceBytes ); + + byte *pVoice = (byte *)memCompressed.Base(); + Q_memcpy( pVoice, (const void *)data, length ); + pVoice += length; + Q_memcpy( pVoice, memCompressedVoice.Base(), nVoiceBytes ); + data = memCompressed.Base(); + + length += nVoiceBytes; + } + + // Do we need to break this packet up? + int nMaxRoutable = MAX_ROUTABLE_PAYLOAD; + if ( chan ) + { + nMaxRoutable = clamp( chan->GetMaxRoutablePayloadSize(), MIN_USER_MAXROUTABLE_SIZE, min( sv_maxroutable.GetInt(), MAX_USER_MAXROUTABLE_SIZE ) ); + } + + if ( length <= nMaxRoutable && + !(net_queued_packet_thread.GetInt() == NET_QUEUED_PACKET_THREAD_DEBUG_VALUE && chan ) ) + { + // simple case, small packet, just send it + ret = NET_SendTo( true, net_socket, (const char *)data, length, &addr, sizeof(addr), iGameDataLength ); + } + else + { + // split packet into smaller pieces + ret = NET_SendLong( chan, sock, net_socket, (const char *)data, length, &addr, sizeof(addr), nMaxRoutable ); + } + + if (ret == -1) + { + NET_GetLastError(); + + // wouldblock is silent + if ( net_error == WSAEWOULDBLOCK ) + return 0; + + if ( net_error == WSAECONNRESET ) + return 0; + + // some PPP links dont allow broadcasts + if ( ( net_error == WSAEADDRNOTAVAIL) && ( to.type == NA_BROADCAST ) ) + return 0; + + ConDMsg ("NET_SendPacket Warning: %s : %s\n", NET_ErrorString(net_error), to.ToString() ); + ret = length; + } + + + return ret; +} + +void NET_OutOfBandPrintf(int sock, const netadr_t &adr, const char *format, ...) +{ + va_list argptr; + char string[MAX_ROUTABLE_PAYLOAD]; + + *(unsigned int*)string = CONNECTIONLESS_HEADER; + + va_start (argptr, format); + Q_vsnprintf (string+4, sizeof( string ) - 4, format,argptr); + va_end (argptr); + + int length = Q_strlen(string+4) + 5; + + NET_SendPacket ( NULL, sock, adr, (byte *)string, length ); +} + +/* +==================== +NET_CloseAllSockets +==================== +*/ +void NET_CloseAllSockets (void) +{ + // shut down any existing and open sockets + for (int i=0 ; i<net_sockets.Count() ; i++) + { + if ( net_sockets[i].nPort ) + { + NET_CloseSocket( net_sockets[i].hUDP ); + NET_CloseSocket( net_sockets[i].hTCP ); + + net_sockets[i].nPort = 0; + net_sockets[i].bListening = false; + net_sockets[i].hUDP = 0; + net_sockets[i].hTCP = 0; + } + } + + // shut down all pending sockets + AUTO_LOCK( s_PendingSockets ); + for(int j=0; j<s_PendingSockets.Count();j++ ) + { + NET_CloseSocket( s_PendingSockets[j].newsock ); + } + + s_PendingSockets.RemoveAll(); +} + +/* +==================== +NET_FlushAllSockets +==================== +*/ +void NET_FlushAllSockets( void ) +{ + // drain any packets that my still lurk in our incoming queue + char data[2048]; + struct sockaddr from; + int fromlen = sizeof(from); + + for (int i=0 ; i<net_sockets.Count() ; i++) + { + if ( net_sockets[i].hUDP ) + { + int bytes = 1; + + // loop until no packets are pending anymore + while ( bytes > 0 ) + { + bytes = VCRHook_recvfrom( net_sockets[i].hUDP, data, sizeof(data), 0, (struct sockaddr *)&from, (int *)&fromlen ); + } + } + } +} + +enum +{ + OSOCKET_FLAG_USE_IPNAME = 0x00000001, // Use ipname convar for net_interface. + OSOCKET_FLAG_FAIL = 0x00000002, // Call Sys_exit on error. +}; + +static bool OpenSocketInternal( int nModule, int nSetPort, int nDefaultPort, const char *pName, int nProtocol, bool bTryAny, + int flags = ( OSOCKET_FLAG_USE_IPNAME | OSOCKET_FLAG_FAIL ) ) +{ + int port = nSetPort ? nSetPort : nDefaultPort; + int *handle = NULL; + + if( nProtocol == IPPROTO_TCP ) + { + handle = &net_sockets[nModule].hTCP; + } + else if ( nProtocol == IPPROTO_UDP || nProtocol == IPPROTO_VDP ) + { + handle = &net_sockets[nModule].hUDP; + } + else + { + Sys_Error( "Unrecognized protocol type %d", nProtocol ); + return false; + } + + if ( !net_sockets[nModule].nPort ) + { + const char *netinterface = ( flags & OSOCKET_FLAG_USE_IPNAME ) ? ipname.GetString() : NULL; + + *handle = NET_OpenSocket (netinterface, port, nProtocol ); + if ( !*handle && bTryAny ) + { + port = PORT_ANY; // try again with PORT_ANY + *handle = NET_OpenSocket ( netinterface, port, nProtocol ); + } + + if ( !*handle ) + { + if ( flags & OSOCKET_FLAG_FAIL ) + Sys_Exit( "Couldn't allocate any %s IP port", pName ); + return false; + } + + net_sockets[nModule].nPort = port; + } + else + { + Msg( "WARNING: NET_OpenSockets: %s port %i already open.\n", pName, net_sockets[nModule].nPort ); + return false; + } + + return ( net_sockets[nModule].nPort != 0 ); +} + +/* +==================== +NET_OpenSockets +==================== +*/ +void NET_OpenSockets (void) +{ + // Xbox 360 uses VDP protocol to combine encrypted game data with clear voice data + const int nProtocol = X360SecureNetwork() ? IPPROTO_VDP : IPPROTO_UDP; + + OpenSocketInternal( NS_SERVER, hostport.GetInt(), PORT_SERVER, "server", nProtocol, false ); + OpenSocketInternal( NS_CLIENT, clientport.GetInt(), PORT_SERVER, "client", nProtocol, true ); + + if ( !net_nohltv ) + { + OpenSocketInternal( NS_HLTV, hltvport.GetInt(), PORT_HLTV, "hltv", nProtocol, false ); + } + + if ( IsX360() ) + { + OpenSocketInternal( NS_MATCHMAKING, matchmakingport.GetInt(), PORT_MATCHMAKING, "matchmaking", nProtocol, false ); + OpenSocketInternal( NS_SYSTEMLINK, systemlinkport.GetInt(), PORT_SYSTEMLINK, "systemlink", IPPROTO_UDP, false ); + } + +#ifdef LINUX + // On Linux, if you bind to a specific address then you will NOT receive broadcast messages. + // This means that if you do a +ip X.X.X.X, your game will not show up on the LAN server browser page. + // To workaround this, if the user has specified sv_lan and an IP address, we open an INADDR_ANY port. + // See http://developerweb.net/viewtopic.php?id=5722 for more information. + extern ConVar sv_lan; + if ( sv_lan.GetBool() ) + { + const char *net_interface = ipname.GetString(); + // If net_interface was specified and it's not localhost... + if ( net_interface[ 0 ] && ( Q_strcmp( net_interface, "localhost" ) != 0 ) ) + { + // From clientdll/matchmaking/ServerList.cpp, the ports queried are: + // 27015 - 27020, 26900 - 26905 + // 4242: RDKF, 27215: Lost Planet + static int s_ports[] = + { + 26900, 26901, 26902, 26903, 26904, 26905, + 27015, 27016, 27017, 27018, 27019, 27020 + }; + + for ( size_t iport = 0; iport < ARRAYSIZE( s_ports ); iport++ ) + { + bool bPortUsed = false; + for ( int i = NS_CLIENT; i < NS_SVLAN; i++ ) + { + // Move along if this port is already used. + if ( net_sockets[ i ].nPort == s_ports[ iport ] ) + { + bPortUsed = true; + break; + } + } + + if ( !bPortUsed ) + { + // Try to open the socket and break if we succeeded. + if ( OpenSocketInternal( NS_SVLAN, s_ports[ iport ], PORT_SERVER, "lan", nProtocol, false, 0 ) ) + break; + } + } + + if ( net_sockets[ NS_SVLAN ].nPort ) + Msg( "Opened sv_lan port %d\n", net_sockets[ NS_SVLAN ].nPort ); + else + Warning( "%s, Failed to open sv_lan port.\n", __FUNCTION__ ); + } + } +#endif // LINUX +} + +int NET_AddExtraSocket( int port ) +{ + int newSocket = net_sockets.AddToTail(); + + Q_memset( &net_sockets[newSocket], 0, sizeof(netsocket_t) ); + + OpenSocketInternal( newSocket, port, PORT_ANY, "extra", IPPROTO_UDP, true ); + + net_packets.EnsureCount( newSocket+1 ); + net_splitpackets.EnsureCount( newSocket+1 ); + + return newSocket; +} + +void NET_RemoveAllExtraSockets() +{ + for (int i=MAX_SOCKETS ; i<net_sockets.Count() ; i++) + { + if ( net_sockets[i].nPort ) + { + NET_CloseSocket( net_sockets[i].hUDP ); + NET_CloseSocket( net_sockets[i].hTCP ); + } + } + net_sockets.RemoveMultiple( MAX_SOCKETS, net_sockets.Count()-MAX_SOCKETS ); + + Assert( net_sockets.Count() == MAX_SOCKETS ); +} + +unsigned short NET_GetUDPPort(int socket) +{ + if ( socket < 0 || socket >= net_sockets.Count() ) + return 0; + + return net_sockets[socket].nPort; +} + + +/* +================ +NET_GetLocalAddress + +Returns the servers' ip address as a string. +================ +*/ +void NET_GetLocalAddress (void) +{ + net_local_adr.Clear(); + + if ( net_noip ) + { + Msg("TCP/UDP Disabled.\n"); + } + else + { + char buff[512]; + + // If we have changed the ip var from the command line, use that instead. + if ( Q_strcmp(ipname.GetString(), "localhost") ) + { + Q_strncpy(buff, ipname.GetString(), sizeof( buff ) ); // use IP set with ipname + } + else + { + gethostname( buff, sizeof(buff) ); // get own IP address + buff[sizeof(buff)-1] = 0; // Ensure that it doesn't overrun the buffer + } + + NET_StringToAdr (buff, &net_local_adr); + + int ipaddr = ( net_local_adr.ip[0] << 24 ) + + ( net_local_adr.ip[1] << 16 ) + + ( net_local_adr.ip[2] << 8 ) + + net_local_adr.ip[3]; + + hostip.SetValue( ipaddr ); + } +} + + +/* +==================== +NET_IsConfigured + +Is winsock ip initialized? +==================== +*/ +bool NET_IsMultiplayer( void ) +{ + return net_multiplayer; +} + +bool NET_IsDedicated( void ) +{ + return net_dedicated; +} + +#ifdef _X360 +#include "iengine.h" +static FileHandle_t g_fh; +void NET_LogServerStatus( void ) +{ + if ( !g_fh ) + return; + + static float fNextTime = 0.f; + float fCurrentTime = eng->GetCurTime(); + + if ( fCurrentTime >= fNextTime ) + { + fNextTime = fCurrentTime + net_loginterval.GetFloat(); + } + else + { + return; + } + + AUTO_LOCK( s_NetChannels ); + int numChannels = s_NetChannels.Count(); + + if ( numChannels == 0 ) + { + ConMsg( "No active net channels.\n" ); + return; + } + + enum + { + NET_LATENCY, + NET_LOSS, + NET_PACKETS_IN, + NET_PACKETS_OUT, + NET_CHOKE_IN, + NET_CHOKE_OUT, + NET_FLOW_IN, + NET_FLOW_OUT, + NET_TOTAL_IN, + NET_TOTAL_OUT, + NET_LAST, + }; + float fStats[NET_LAST] = {0.f}; + + for ( int i = 0; i < numChannels; ++i ) + { + INetChannel *chan = s_NetChannels[i]; + fStats[NET_LATENCY] += chan->GetAvgLatency(FLOW_OUTGOING); + fStats[NET_LOSS] += chan->GetAvgLoss(FLOW_INCOMING); + fStats[NET_PACKETS_IN] += chan->GetAvgPackets(FLOW_INCOMING); + fStats[NET_PACKETS_OUT] += chan->GetAvgPackets(FLOW_OUTGOING); + fStats[NET_CHOKE_IN] += chan->GetAvgChoke(FLOW_INCOMING); + fStats[NET_CHOKE_OUT] += chan->GetAvgChoke(FLOW_OUTGOING); + fStats[NET_FLOW_IN] += chan->GetAvgData(FLOW_INCOMING); + fStats[NET_FLOW_OUT] += chan->GetAvgData(FLOW_OUTGOING); + fStats[NET_TOTAL_IN] += chan->GetTotalData(FLOW_INCOMING); + fStats[NET_TOTAL_OUT] += chan->GetTotalData(FLOW_OUTGOING); + } + + for ( int i = 0; i < NET_LAST; ++i ) + { + fStats[i] /= numChannels; + } + + const unsigned int size = 128; + char msg[size]; + Q_snprintf( msg, size, "%.0f,%d,%.0f,%.0f,%.0f,%.1f,%.1f,%.1f,%.1f,%.1f\n", + fCurrentTime, + numChannels, + fStats[NET_LATENCY], + fStats[NET_LOSS], + fStats[NET_PACKETS_IN], + fStats[NET_PACKETS_OUT], + fStats[NET_FLOW_IN]/1024.0f, + fStats[NET_FLOW_OUT]/1024.0f, + fStats[NET_CHOKE_IN], + fStats[NET_CHOKE_OUT] + ); + + g_pFileSystem->Write( msg, Q_strlen( msg ), g_fh ); +} + +void NET_LogServerCallback( IConVar *pConVar, const char *pOldString, float flOldValue ) +{ + ConVarRef var( pConVar ); + + if ( var.GetBool() ) + { + if ( g_fh ) + { + g_pFileSystem->Close( g_fh ); + g_fh = 0; + } + + g_fh = g_pFileSystem->Open( "dump.csv", "wt" ); + if ( !g_fh ) + { + Msg( "Failed to open log file\n" ); + pConVar->SetValue( 0 ); + return; + } + + char msg[128]; + Q_snprintf( msg, 128, "Time,Channels,Latency,Loss,Packets In,Packets Out,Flow In(kB/s),Flow Out(kB/s),Choke In,Choke Out\n" ); + g_pFileSystem->Write( msg, Q_strlen( msg ), g_fh ); + } + else + { + if ( g_fh ) + { + g_pFileSystem->Close( g_fh ); + g_fh = 0; + } + } +} +#endif + +/* +==================== +NET_SetTime + +Updates net_time +==================== +*/ +void NET_SetTime( double flRealtime ) +{ + static double s_last_realtime = 0; + + double frametime = flRealtime - s_last_realtime; + s_last_realtime = flRealtime; + + if ( frametime > 1.0f ) + { + // if we have very long frame times because of loading stuff + // don't apply that to net time to avoid unwanted timeouts + frametime = 1.0f; + } + else if ( frametime < 0.0f ) + { + frametime = 0.0f; + } + + // adjust network time so fakelag works with host_timescale + net_time += frametime * host_timescale.GetFloat(); +} + +/* +==================== +NET_RunFrame + +RunFrame must be called each system frame before reading/sending on any socket +==================== +*/ +void NET_RunFrame( double flRealtime ) +{ + NET_SetTime( flRealtime ); + + RCONServer().RunFrame(); + +#ifdef ENABLE_RPT + RPTServer().RunFrame(); +#endif // ENABLE_RPT + +#ifndef SWDS + RCONClient().RunFrame(); +#ifdef ENABLE_RPT + RPTClient().RunFrame(); +#endif // ENABLE_RPT + +#endif // SWDS + +#ifdef _X360 + if ( net_logserver.GetInt() ) + { + NET_LogServerStatus(); + } + g_pMatchmaking->RunFrame(); +#endif + if ( !NET_IsMultiplayer() || net_notcp ) + return; + + // process TCP sockets: + for ( int i=0; i< net_sockets.Count(); i++ ) + { + if ( net_sockets[i].hTCP && net_sockets[i].bListening ) + { + NET_ProcessListen( i ); + } + } + + NET_ProcessPending(); +} + +void NET_ClearLoopbackBuffers() +{ + for (int i = 0; i < LOOPBACK_SOCKETS; i++) + { + loopback_t *loop; + + while ( s_LoopBacks[i].PopItem( &loop ) ) + { + if ( loop->data && loop->data != loop->defbuffer ) + { + delete [] loop->data; + } + delete loop; + } + } +} + +void NET_ConfigLoopbackBuffers( bool bAlloc ) +{ + NET_ClearLoopbackBuffers(); +} + +/* +==================== +NET_Config + +A single player game will only use the loopback code +==================== +*/ + +void NET_Config ( void ) +{ + // free anything + NET_CloseAllSockets(); // close all UDP/TCP sockets + + net_time = 0.0f; + + // now reconfiguare + + if ( net_multiplayer ) + { + // don't allocate loopback buffers + NET_ConfigLoopbackBuffers( false ); + + // get localhost IP address + NET_GetLocalAddress(); + + // reopen sockets if in MP mode + NET_OpenSockets(); + + // setup the rcon server sockets + if ( net_dedicated || CommandLine()->FindParm( "-usercon" ) ) + { + netadr_t rconAddr = net_local_adr; + rconAddr.SetPort( net_sockets[NS_SERVER].nPort ); + RCONServer().SetAddress( rconAddr.ToString() ); + RCONServer().CreateSocket(); + } + } + else + { + // allocate loopback buffers + NET_ConfigLoopbackBuffers( true ); + } + + Msg( "Network: IP %s, mode %s, dedicated %s, ports %i SV / %i CL\n", + net_local_adr.ToString(true), net_multiplayer?"MP":"SP", net_dedicated?"Yes":"No", + net_sockets[NS_SERVER].nPort, net_sockets[NS_CLIENT].nPort ); +} + +/* +==================== +NET_SetDedicated + +A single player game will only use the loopback code +==================== +*/ + +void NET_SetDedicated () +{ + if ( net_noip ) + { + Msg( "Warning! Dedicated not possible with -noip parameter.\n"); + return; + } + + net_dedicated = true; +} + +void NET_ListenSocket( int sock, bool bListen ) +{ + Assert( (sock >= 0) && (sock < net_sockets.Count()) ); + + netsocket_t * netsock = &net_sockets[sock]; + + if ( netsock->hTCP ) + { + NET_CloseSocket( netsock->hTCP, sock ); + } + + if ( !NET_IsMultiplayer() || net_notcp ) + return; + + if ( bListen ) + { + const char * net_interface = ipname.GetString(); + + netsock->hTCP = NET_OpenSocket( net_interface, netsock->nPort, true ); + + if ( !netsock->hTCP ) + { + Msg( "Warning! NET_ListenSocket failed opening socket %i, port %i.\n", sock, net_sockets[sock].nPort ); + return; + } + + struct sockaddr_in address; + + if (!net_interface || !net_interface[0] || !Q_strcmp(net_interface, "localhost")) + { + address.sin_addr.s_addr = INADDR_ANY; + } + else + { + NET_StringToSockaddr (net_interface, (struct sockaddr *)&address); + } + + address.sin_family = AF_INET; + address.sin_port = NET_HostToNetShort((short)( netsock->nPort )); + + int ret; + VCR_NONPLAYBACKFN( bind( netsock->hTCP, (struct sockaddr *)&address, sizeof(address)), ret, "bind" ); + if ( ret == -1 ) + { + NET_GetLastError(); + Msg ("WARNING: NET_ListenSocket bind failed on socket %i, port %i.\n", netsock->hTCP, netsock->nPort ); + return; + } + + VCR_NONPLAYBACKFN( listen( netsock->hTCP, TCP_MAX_ACCEPTS), ret, "listen" ); + if ( ret == -1 ) + { + NET_GetLastError(); + Msg ("WARNING: NET_ListenSocket listen failed on socket %i, port %i.\n", netsock->hTCP, netsock->nPort ); + return; + } + + netsock->bListening = true; + } +} + +void NET_SetMutiplayer(bool multiplayer) +{ + if ( net_noip && multiplayer ) + { + Msg( "Warning! Multiplayer mode not available with -noip parameter.\n"); + return; + } + + if ( net_dedicated && !multiplayer ) + { + Msg( "Warning! Singleplayer mode not available on dedicated server.\n"); + return; + } + + // reconfigure if changed + if ( net_multiplayer != multiplayer ) + { + net_multiplayer = multiplayer; + NET_Config(); + } + + // clear loopback buffer in single player mode + if ( !multiplayer ) + { + NET_ClearLoopbackBuffers(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : bIsDedicated - +//----------------------------------------------------------------------------- +void NET_Init( bool bIsDedicated ) +{ + + if ( CommandLine()->FindParm( "-NoQueuedPacketThread" ) ) + Warning( "Found -NoQueuedPacketThread, so no queued packet thread will be created.\n" ); + else + g_pQueuedPackedSender->Setup(); + + + if (CommandLine()->FindParm("-nodns")) + { + net_nodns = true; + } + + if (CommandLine()->FindParm("-usetcp")) + { + net_notcp = false; + } + + if (CommandLine()->FindParm("-nohltv")) + { + net_nohltv = true; + } + + if (CommandLine()->FindParm("-noip")) + { + net_noip = true; + } + else + { +#if defined(_WIN32) + +#if defined(_X360) + XNetStartupParams xnsp; + memset( &xnsp, 0, sizeof( xnsp ) ); + xnsp.cfgSizeOfStruct = sizeof( XNetStartupParams ); + if ( X360SecureNetwork() ) + { + Msg( "Xbox 360 network is Secure\n" ); + } + else + { + // Allow cross-platform communication + xnsp.cfgFlags = XNET_STARTUP_BYPASS_SECURITY; + Msg( "Xbox 360 network is Unsecure\n" ); + } + + INT err = XNetStartup( &xnsp ); + if ( err ) + { + ConMsg( "Error! Failed to set XNET Security Bypass.\n"); + } + err = XOnlineStartup(); + if ( err != ERROR_SUCCESS ) + { + ConMsg( "Error! XOnlineStartup failed.\n"); + } +#else + // initialize winsock 2.0 + WSAData wsaData; + if ( WSAStartup( MAKEWORD(2,0), &wsaData ) != 0 ) + { + ConMsg( "Error! Failed to load network socket library.\n"); + net_noip = true; + } +#endif // _X360 +#endif // _WIN32 + } + + COMPILE_TIME_ASSERT( SVC_LASTMSG < (1<<NETMSG_TYPE_BITS) ); + COMPILE_TIME_ASSERT( MAX_FILE_SIZE < (1<<MAX_FILE_SIZE_BITS) ); + + net_time = 0.0f; + + + int hPort = CommandLine()->ParmValue( "-port", -1 ); + if ( hPort == -1 ) + { + hPort = CommandLine()->ParmValue( "+port", -1 ); // check if they used +port by mistake + } + + if ( hPort != -1 ) + { + hostport.SetValue( hPort ); + } + + // clear static stuff + net_sockets.EnsureCount( MAX_SOCKETS ); + net_packets.EnsureCount( MAX_SOCKETS ); + net_splitpackets.EnsureCount( MAX_SOCKETS ); + + for ( int i = 0; i < MAX_SOCKETS; ++i ) + { + s_pLagData[i] = NULL; + Q_memset( &net_sockets[i], 0, sizeof(netsocket_t) ); + } + + const char *ip = CommandLine()->ParmValue( "-ip" ); + + if ( ip ) // if they had a command line option for IP + { + ipname.SetValue( ip ); // update the cvar right now, this will get overwritten by "stuffcmds" later + } + + if ( bIsDedicated ) + { + // set dedicated MP mode + NET_SetDedicated(); + } + else + { + // set SP mode + NET_ConfigLoopbackBuffers( true ); + } +} + +/* +==================== +NET_Shutdown + +==================== +*/ +void NET_Shutdown (void) +{ + int nError = 0; + + for (int i = 0; i < MAX_SOCKETS; i++) + { + NET_ClearLaggedList( &s_pLagData[i] ); + } + + g_pQueuedPackedSender->Shutdown(); + + net_multiplayer = false; + net_dedicated = false; + + NET_CloseAllSockets(); + NET_ConfigLoopbackBuffers( false ); + +#if defined(_WIN32) + if ( !net_noip ) + { + nError = WSACleanup(); + if ( nError ) + { + Msg("Failed to complete WSACleanup = 0x%x.\n", nError ); + } +#if defined(_X360) + nError = XOnlineCleanup(); + if ( nError != ERROR_SUCCESS ) + { + Msg( "Warning! Failed to complete XOnlineCleanup = 0x%x.\n", nError ); + } +#endif // _X360 + } +#endif // _WIN32 + + Assert( s_NetChannels.Count() == 0 ); + Assert( s_PendingSockets.Count() == 0); +} + +void NET_PrintChannelStatus( INetChannel * chan ) +{ + Msg( "NetChannel '%s':\n", chan->GetName() ); + Msg( "- remote IP: %s %s\n", chan->GetAddress(), chan->IsPlayback()?"(Demo)":"" ); + Msg( "- online: %s\n", COM_FormatSeconds( chan->GetTimeConnected() ) ); + Msg( "- reliable: %s\n", chan->HasPendingReliableData()?"pending data":"available" ); + Msg( "- latency: %.1f, loss %.2f\n", chan->GetAvgLatency(FLOW_OUTGOING), chan->GetAvgLoss(FLOW_INCOMING) ); + Msg( "- packets: in %.1f/s, out %.1f/s\n", chan->GetAvgPackets(FLOW_INCOMING), chan->GetAvgPackets(FLOW_OUTGOING) ); + Msg( "- choke: in %.2f, out %.2f\n", chan->GetAvgChoke(FLOW_INCOMING), chan->GetAvgChoke(FLOW_OUTGOING) ); + Msg( "- flow: in %.1f, out %.1f kB/s\n", chan->GetAvgData(FLOW_INCOMING)/1024.0f, chan->GetAvgData(FLOW_OUTGOING)/1024.0f ); + Msg( "- total: in %.1f, out %.1f MB\n\n", (float)chan->GetTotalData(FLOW_INCOMING)/(1024*1024), (float)chan->GetTotalData(FLOW_OUTGOING)/(1024*1024) ); +} + +CON_COMMAND( net_channels, "Shows net channel info" ) +{ + int numChannels = s_NetChannels.Count(); + + if ( numChannels == 0 ) + { + ConMsg( "No active net channels.\n" ); + return; + } + + AUTO_LOCK( s_NetChannels ); + for ( int i = 0; i < numChannels; i++ ) + { + NET_PrintChannelStatus( s_NetChannels[i] ); + } +} + +CON_COMMAND( net_start, "Inits multiplayer network sockets" ) +{ + net_multiplayer = true; + NET_Config(); +} + +CON_COMMAND( net_status, "Shows current network status" ) +{ + AUTO_LOCK( s_NetChannels ); + int numChannels = s_NetChannels.Count(); + + ConMsg("Net status for host %s:\n", + net_local_adr.ToString(true) ); + + ConMsg("- Config: %s, %s, %i connections\n", + net_multiplayer?"Multiplayer":"Singleplayer", + net_dedicated?"dedicated":"listen", + numChannels ); + + CFmtStrN<128> lan_str; +#ifdef LINUX + lan_str.sprintf( ", Lan %u", net_sockets[NS_SVLAN].nPort ); +#endif + + ConMsg("- Ports: Client %u, Server %u, HLTV %u, Matchmaking %u, Systemlink %u%s\n", + net_sockets[NS_CLIENT].nPort, + net_sockets[NS_SERVER].nPort, + net_sockets[NS_HLTV].nPort, + net_sockets[NS_MATCHMAKING].nPort, + net_sockets[NS_SYSTEMLINK].nPort, + lan_str.Get() ); + + if ( numChannels <= 0 ) + { + return; + } + + // gather statistics: + + float avgLatencyOut = 0; + float avgLatencyIn = 0; + float avgPacketsOut = 0; + float avgPacketsIn = 0; + float avgLossOut = 0; + float avgLossIn = 0; + float avgDataOut = 0; + float avgDataIn = 0; + + for ( int i = 0; i < numChannels; i++ ) + { + CNetChan *chan = s_NetChannels[i]; + + avgLatencyOut += chan->GetAvgLatency(FLOW_OUTGOING); + avgLatencyIn += chan->GetAvgLatency(FLOW_INCOMING); + + avgLossIn += chan->GetAvgLoss(FLOW_INCOMING); + avgLossOut += chan->GetAvgLoss(FLOW_OUTGOING); + + avgPacketsIn += chan->GetAvgPackets(FLOW_INCOMING); + avgPacketsOut += chan->GetAvgPackets(FLOW_OUTGOING); + + avgDataIn += chan->GetAvgData(FLOW_INCOMING); + avgDataOut += chan->GetAvgData(FLOW_OUTGOING); + } + + ConMsg( "- Latency: avg out %.2fs, in %.2fs\n", avgLatencyOut/numChannels, avgLatencyIn/numChannels ); + ConMsg( "- Loss: avg out %.1f, in %.1f\n", avgLossOut/numChannels, avgLossIn/numChannels ); + ConMsg( "- Packets: net total out %.1f/s, in %.1f/s\n", avgPacketsOut, avgPacketsIn ); + ConMsg( " per client out %.1f/s, in %.1f/s\n", avgPacketsOut/numChannels, avgPacketsIn/numChannels ); + ConMsg( "- Data: net total out %.1f, in %.1f kB/s\n", avgDataOut/1024.0f, avgDataIn/1024.0f ); + ConMsg( " per client out %.1f, in %.1f kB/s\n", (avgDataOut/numChannels)/1024.0f, (avgDataIn/numChannels)/1024.0f ); +} |