FWGS
/
Xash3DArchive
Archived
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
This repository has been archived on 2022-06-27. You can view files and clone it, but cannot push or open issues or pull requests.
Xash3DArchive/launch/network.c

1024 lines
26 KiB
C
Raw Blame History

//=======================================================================
// Copyright XashXT Group 2007 ©
// network.c - network interface
//=======================================================================
#include <winsock.h>
#include <wsipx.h>
#include "launch.h"
#include "byteorder.h"
#define MAX_IPS 16
#define PORT_ANY -1
#define PORT_SERVER 27960
#define DO( src, dest ) \
copy[0] = s[src]; \
copy[1] = s[src + 1]; \
sscanf( copy, "%x", &val ); \
((struct sockaddr_ipx *)sadr)->dest = val
// wsock32.dll exports
static int (_stdcall *pWSACleanup)( void );
static word (_stdcall *pNtohs)( word netshort );
static int (_stdcall *pWSAGetLastError)( void );
static int (_stdcall *pCloseSocket)( SOCKET s );
static word (_stdcall *pHtons)( word hostshort );
static dword (_stdcall *pInet_Addr)( const char* cp );
static SOCKET (_stdcall *pSocket)( int af, int type, int protocol );
static struct hostent *(_stdcall *pGetHostByName)( const char* name );
static int (_stdcall *pIoctlSocket)( SOCKET s, long cmd, dword* argp );
static int (_stdcall *pWSAStartup)( word wVersionRequired, LPWSADATA lpWSAData );
static int (_stdcall *pBind)( SOCKET s, const struct sockaddr* addr, int namelen );
static int (_stdcall *pSetSockopt)( SOCKET s, int level, int optname, const char* optval, int optlen );
static int (_stdcall *pRecvFrom)( SOCKET s, char* buf, int len, int flags, struct sockaddr* from, int* fromlen );
static int (_stdcall *pSendTo)( SOCKET s, const char* buf, int len, int flags, const struct sockaddr* to, int tolen );
static int (_stdcall *pSelect)( int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, const struct timeval* timeout );
static int (_stdcall *pConnect)( SOCKET s, const struct sockaddr *name, int namelen );
static int (_stdcall *pSend)( SOCKET s, const char *buf, int len, int flags );
static int (_stdcall *pRecv)( SOCKET s, char *buf, int len, int flags );
static int (_stdcall *pGetHostName)( char *name, int namelen );
static dword (_stdcall *pNtohl)( dword netlong );
static dllfunc_t winsock_funcs[] =
{
{"bind", (void **) &pBind },
{"send", (void **) &pSend },
{"recv", (void **) &pRecv },
{"ntohs", (void **) &pNtohs },
{"htons", (void **) &pHtons },
{"ntohl", (void **) &pNtohl },
{"socket", (void **) &pSocket },
{"select", (void **) &pSelect },
{"sendto", (void **) &pSendTo },
{"connect", (void **) &pConnect },
{"recvfrom", (void **) &pRecvFrom },
{"inet_addr", (void **) &pInet_Addr },
{"WSAStartup", (void **) &pWSAStartup },
{"WSACleanup", (void **) &pWSACleanup },
{"setsockopt", (void **) &pSetSockopt },
{"ioctlsocket", (void **) &pIoctlSocket },
{"closesocket", (void **) &pCloseSocket },
{"gethostname", (void **) &pGetHostName },
{"gethostbyname", (void **) &pGetHostByName },
{"WSAGetLastError", (void **) &pWSAGetLastError },
{ NULL, NULL }
};
dll_info_t winsock_dll = { "wsock32.dll", winsock_funcs, NULL, NULL, NULL, true, 0 };
static WSADATA winsockdata;
static bool winsockInitialized = false;
static bool usingSocks = false;
static bool net_active = false;
static cvar_t *net_socks_enabled;
static cvar_t *net_socks_server;
static cvar_t *net_socks_port;
static cvar_t *net_socks_username;
static cvar_t *net_socks_password;
static struct sockaddr socksRelayAddr;
static SOCKET ip_socket;
static SOCKET socks_socket;
static SOCKET ipx_socket;
static char socksBuf[4096];
static byte localIP[MAX_IPS][4];
static int numIP;
void NET_OpenWinSock( void )
{
Sys_LoadLibrary( &winsock_dll );
}
void NET_FreeWinSock( void )
{
Sys_FreeLibrary( &winsock_dll );
}
/*
====================
NET_ErrorString
====================
*/
char *NET_ErrorString( void )
{
switch(pWSAGetLastError())
{
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 "NO ERROR";
}
}
void NetadrToSockadr( netadr_t *a, struct sockaddr *s )
{
Mem_Set( s, 0, sizeof(*s));
if( a->type == NA_BROADCAST )
{
((struct sockaddr_in *)s)->sin_family = AF_INET;
((struct sockaddr_in *)s)->sin_port = a->port;
((struct sockaddr_in *)s)->sin_addr.s_addr = INADDR_BROADCAST;
}
else if( a->type == NA_IP )
{
((struct sockaddr_in *)s)->sin_family = AF_INET;
((struct sockaddr_in *)s)->sin_addr.s_addr = *(int *)&a->ip;
((struct sockaddr_in *)s)->sin_port = a->port;
}
else if (a->type == NA_IPX)
{
((struct sockaddr_ipx *)s)->sa_family = AF_IPX;
Mem_Copy(((struct sockaddr_ipx *)s)->sa_netnum, &a->ipx[0], 4);
Mem_Copy(((struct sockaddr_ipx *)s)->sa_nodenum, &a->ipx[4], 6);
((struct sockaddr_ipx *)s)->sa_socket = a->port;
}
else if (a->type == NA_BROADCAST_IPX)
{
((struct sockaddr_ipx *)s)->sa_family = AF_IPX;
Mem_Set(((struct sockaddr_ipx *)s)->sa_netnum, 0, 4);
Mem_Set(((struct sockaddr_ipx *)s)->sa_nodenum, 0xff, 6);
((struct sockaddr_ipx *)s)->sa_socket = a->port;
}
}
void SockadrToNetadr( struct sockaddr *s, netadr_t *a )
{
if( s->sa_family == AF_INET )
{
a->type = NA_IP;
*(int *)&a->ip = ((struct sockaddr_in *)s)->sin_addr.s_addr;
a->port = ((struct sockaddr_in *)s)->sin_port;
}
else if (s->sa_family == AF_IPX)
{
a->type = NA_IPX;
Mem_Copy(&a->ipx[0], ((struct sockaddr_ipx *)s)->sa_netnum, 4);
Mem_Copy(&a->ipx[4], ((struct sockaddr_ipx *)s)->sa_nodenum, 6);
a->port = ((struct sockaddr_ipx *)s)->sa_socket;
}
}
/*
=============
NET_StringToAdr
idnewt
192.246.40.70
12121212.121212121212
=============
*/
bool NET_StringToSockaddr( const char *s, struct sockaddr *sadr )
{
struct hostent *h;
int val;
char copy[MAX_SYSPATH];
Mem_Set( sadr, 0, sizeof( *sadr ) );
// check for an IPX address
if(( com_strlen( s ) == 21 ) && ( s[8] == '.' ))
{
((struct sockaddr_ipx *)sadr)->sa_family = AF_IPX;
((struct sockaddr_ipx *)sadr)->sa_socket = 0;
copy[2] = 0;
DO(0, sa_netnum[0]);
DO(2, sa_netnum[1]);
DO(4, sa_netnum[2]);
DO(6, sa_netnum[3]);
DO(9, sa_nodenum[0]);
DO(11, sa_nodenum[1]);
DO(13, sa_nodenum[2]);
DO(15, sa_nodenum[3]);
DO(17, sa_nodenum[4]);
DO(19, sa_nodenum[5]);
}
else
{
((struct sockaddr_in *)sadr)->sin_family = AF_INET;
((struct sockaddr_in *)sadr)->sin_port = 0;
if( s[0] >= '0' && s[0] <= '9' )
{
*(int *)&((struct sockaddr_in *)sadr)->sin_addr = pInet_Addr(s);
}
else
{
if(( h = pGetHostByName(s)) == 0 )
return 0;
*(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0];
}
}
return true;
}
char *NET_AdrToString( netadr_t a )
{
static char s[64];
if( a.type == NA_LOOPBACK )
{
com_snprintf( s, sizeof(s), "loopback" );
}
else if( a.type == NA_IP )
{
com_snprintf( s, sizeof(s), "%i.%i.%i.%i:%hu", a.ip[0], a.ip[1], a.ip[2], a.ip[3], BigShort(a.port));
}
else
{
com_snprintf( s, sizeof(s), "%02x%02x%02x%02x.%02x%02x%02x%02x%02x%02x:%hu",
a.ipx[0], a.ipx[1], a.ipx[2], a.ipx[3], a.ipx[4], a.ipx[5], a.ipx[6], a.ipx[7], a.ipx[8], a.ipx[9],
BigShort(a.port));
}
return s;
}
/*
=============
NET_StringToAdr
idnewt
192.246.40.70
=============
*/
bool NET_StringToAdr( const char *s, netadr_t *a )
{
struct sockaddr sadr;
if( !NET_StringToSockaddr( s, &sadr ))
return false;
SockadrToNetadr( &sadr, a );
return true;
}
/*
==================
NET_GetPacket
Never called by the game logic, just the system event queing
==================
*/
bool NET_GetPacket( netadr_t *net_from, sizebuf_t *net_message )
{
int ret, err;
struct sockaddr from;
int fromlen;
int net_socket;
int protocol;
for( protocol = 0; protocol < 2; protocol++ )
{
if( protocol == 0 ) net_socket = ip_socket;
else net_socket = ipx_socket;
if( !net_socket ) continue;
fromlen = sizeof( from );
ret = pRecvFrom( net_socket, net_message->data, net_message->maxsize, 0, (struct sockaddr *)&from, &fromlen );
if (ret == SOCKET_ERROR)
{
err = pWSAGetLastError();
if( err == WSAEWOULDBLOCK || err == WSAECONNRESET )
continue;
MsgDev( D_ERROR, "NET_GetPacket: %s\n", NET_ErrorString());
continue;
}
if( net_socket == ip_socket )
{
Mem_Set(((struct sockaddr_in *)&from)->sin_zero, 0, 8 );
}
if( usingSocks && net_socket == ip_socket && memcmp( &from, &socksRelayAddr, fromlen ) == 0 )
{
if( ret < 10 || net_message->data[0] != 0 || net_message->data[1] != 0 || net_message->data[2] != 0 || net_message->data[3] != 1 )
continue;
net_from->type = NA_IP;
net_from->ip[0] = net_message->data[4];
net_from->ip[1] = net_message->data[5];
net_from->ip[2] = net_message->data[6];
net_from->ip[3] = net_message->data[7];
net_from->port = *(short *)&net_message->data[8];
net_message->readcount = 10;
}
else
{
SockadrToNetadr( &from, net_from );
net_message->readcount = 0;
}
if( ret == net_message->maxsize )
{
MsgDev( D_WARN, "oversize packet from %s\n", NET_AdrToString (*net_from) );
continue;
}
net_message->cursize = ret;
return true;
}
return false;
}
/*
==================
NET_SendPacket
==================
*/
void NET_SendPacket( int length, const void *data, netadr_t to )
{
int ret;
struct sockaddr addr;
SOCKET net_socket;
switch( to.type )
{
case NA_IP:
case NA_BROADCAST:
net_socket = ip_socket;
break;
case NA_IPX:
case NA_BROADCAST_IPX:
net_socket = ipx_socket;
break;
default:
MsgDev( D_ERROR, "NET_SendPacket: bad address type\n");
return;
}
if( !net_socket ) return;
NetadrToSockadr( &to, &addr );
if( usingSocks && to.type == NA_IP )
{
socksBuf[0] = 0; // reserved
socksBuf[1] = 0;
socksBuf[2] = 0; // fragment (not fragmented)
socksBuf[3] = 1; // address type: IPV4
*(int *)&socksBuf[4] = ((struct sockaddr_in *)&addr)->sin_addr.s_addr;
*(short *)&socksBuf[8] = ((struct sockaddr_in *)&addr)->sin_port;
Mem_Copy( &socksBuf[10], data, length );
ret = pSendTo( net_socket, socksBuf, length+10, 0, &socksRelayAddr, sizeof(socksRelayAddr) );
}
else ret = pSendTo( net_socket, data, length, 0, &addr, sizeof(addr) );
if( ret == SOCKET_ERROR )
{
int err = pWSAGetLastError();
// wouldblock is silent
if( err == WSAEWOULDBLOCK )
return;
// some PPP links do not allow broadcasts and return an error
if(( err == WSAEADDRNOTAVAIL ) && (( to.type == NA_BROADCAST ) || ( to.type == NA_BROADCAST_IPX )))
return;
MsgDev( D_ERROR, "NET_SendPacket: %s\n", NET_ErrorString() );
}
}
/*
==================
NET_IsLANAddress
LAN clients will have their rate var ignored
==================
*/
bool NET_IsLANAddress( netadr_t adr )
{
int i;
if( adr.type == NA_LOOPBACK )
return true;
if( adr.type == NA_IPX )
return true;
if( adr.type != NA_IP )
return false;
// choose which comparison to use based on the class of the address being tested
// any local adresses of a different class than the address being tested will fail based on the first byte
if( adr.ip[0] == 127 && adr.ip[1] == 0 && adr.ip[2] == 0 && adr.ip[3] == 1 )
return true;
// class A
if(( adr.ip[0] & 0x80) == 0x00 )
{
for( i = 0; i < numIP; i++ )
{
if( adr.ip[0] == localIP[i][0] )
return true;
}
// the RFC1918 class a block will pass the above test
return false;
}
// class B
if(( adr.ip[0] & 0xc0) == 0x80 )
{
for( i = 0; i < numIP; i++ )
{
if( adr.ip[0] == localIP[i][0] && adr.ip[1] == localIP[i][1] )
return true;
// also check against the RFC1918 class b blocks
if( adr.ip[0] == 172 && localIP[i][0] == 172 && (adr.ip[1] & 0xf0) == 16 && (localIP[i][1] & 0xf0) == 16 )
return true;
}
return false;
}
// class C
for( i = 0; i < numIP; i++ )
{
if( adr.ip[0] == localIP[i][0] && adr.ip[1] == localIP[i][1] && adr.ip[2] == localIP[i][2] )
return true;
// also check against the RFC1918 class c blocks
if( adr.ip[0] == 192 && localIP[i][0] == 192 && adr.ip[1] == 168 && localIP[i][1] == 168 )
return true;
}
return false;
}
/*
==================
NET_ShowIP
==================
*/
void NET_ShowIP( void )
{
int i;
for( i = 0; i < numIP; i++ )
{
Msg( "IP: %i.%i.%i.%i\n", localIP[i][0], localIP[i][1], localIP[i][2], localIP[i][3] );
}
}
/*
====================
NET_IPSocket
====================
*/
int NET_IPSocket( char *net_interface, int port )
{
SOCKET newsocket;
struct sockaddr_in address;
bool _true = true;
int i = 1;
int err;
if( net_interface ) MsgDev( D_INFO, "Opening IP socket: %s:%i\n", net_interface, port );
else MsgDev( D_INFO, "Opening IP socket: localhost:%i\n", port );
if(( newsocket = pSocket( AF_INET, SOCK_DGRAM, IPPROTO_UDP )) == INVALID_SOCKET )
{
err = pWSAGetLastError();
if( err != WSAEAFNOSUPPORT )
MsgDev( D_WARN, "NET_IPSocket: socket: %s\n", NET_ErrorString());
return 0;
}
// make it non-blocking
if( pIoctlSocket( newsocket, FIONBIO, &_true ) == SOCKET_ERROR )
{
MsgDev( D_WARN, "NET_IPSocket: ioctl FIONBIO: %s\n", NET_ErrorString());
return 0;
}
// make it broadcast capable
if( pSetSockopt( newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i) ) == SOCKET_ERROR )
{
MsgDev( D_WARN, "NET_IPSocket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString());
return 0;
}
if( !net_interface || !net_interface[0] || !com_stricmp( net_interface, "localhost"))
address.sin_addr.s_addr = INADDR_ANY;
else NET_StringToSockaddr( net_interface, (struct sockaddr *)&address );
if( port == PORT_ANY ) address.sin_port = 0;
else address.sin_port = pHtons((short)port);
address.sin_family = AF_INET;
if( pBind( newsocket, (void *)&address, sizeof(address) ) == SOCKET_ERROR )
{
MsgDev( D_WARN, "UDP_OpenSocket: bind: %s\n", NET_ErrorString());
pCloseSocket( newsocket );
return 0;
}
return newsocket;
}
/*
====================
NET_OpenSocks
====================
*/
void NET_OpenSocks( int port )
{
struct sockaddr_in address;
bool rfc1929 = false;
int err;
struct hostent *h;
int len;
byte buf[64];
usingSocks = false;
MsgDev( D_INFO, "Opening connection to SOCKS server.\n" );
if(( socks_socket = pSocket( AF_INET, SOCK_STREAM, IPPROTO_TCP )) == INVALID_SOCKET )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: socket: %s\n", NET_ErrorString());
return;
}
h = pGetHostByName( net_socks_server->string );
if( h == NULL )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: gethostbyname: %s\n", NET_ErrorString());
return;
}
if( h->h_addrtype != AF_INET )
{
MsgDev( D_WARN, "NET_OpenSocks: gethostbyname: address type was not AF_INET\n");
return;
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = *(int *)h->h_addr_list[0];
address.sin_port = pHtons( (short)net_socks_port->integer );
if( pConnect( socks_socket, (struct sockaddr *)&address, sizeof( address )) == SOCKET_ERROR )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: connect: %s\n", NET_ErrorString());
return;
}
// send socks authentication handshake
if( *net_socks_username->string || *net_socks_password->string )
rfc1929 = true;
buf[0] = 5; // SOCKS version
// method count
if( rfc1929 )
{
buf[1] = 2;
len = 4;
}
else
{
buf[1] = 1;
len = 3;
}
buf[2] = 0; // method #1 - method id #00: no authentication
if( rfc1929 ) buf[2] = 2; // method #2 - method id #02: username/password
if( pSend( socks_socket, buf, len, 0 ) == SOCKET_ERROR )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: send: %s\n", NET_ErrorString());
return;
}
// get the response
len = pRecv( socks_socket, buf, 64, 0 );
if( len == SOCKET_ERROR )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: recv: %s\n", NET_ErrorString());
return;
}
if( len != 2 || buf[0] != 5 )
{
MsgDev( D_WARN, "NET_OpenSocks: bad response\n" );
return;
}
switch( buf[1] )
{
case 0: // no authentication
case 2: // username/password authentication
break;
default:
MsgDev( D_WARN, "NET_OpenSocks: request denied\n" );
return;
}
// do username/password authentication if needed
if( buf[1] == 2 )
{
int ulen, plen;
// build the request
ulen = com_strlen( net_socks_username->string );
plen = com_strlen( net_socks_password->string );
buf[0] = 1; // username/password authentication version
buf[1] = ulen;
if( ulen ) Mem_Copy( &buf[2], net_socks_username->string, ulen );
buf[2 + ulen] = plen;
if( plen ) Mem_Copy( &buf[3 + ulen], net_socks_password->string, plen );
// send it
if( pSend( socks_socket, buf, 3 + ulen + plen, 0 ) == SOCKET_ERROR )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: send: %s\n", NET_ErrorString());
return;
}
// get the response
len = pRecv( socks_socket, buf, 64, 0 );
if( len == SOCKET_ERROR )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: recv: %s\n", NET_ErrorString());
return;
}
if( len != 2 || buf[0] != 1 )
{
MsgDev( D_WARN, "NET_OpenSocks: bad response\n" );
return;
}
if( buf[1] != 0 )
{
MsgDev( D_WARN, "NET_OpenSocks: authentication failed\n" );
return;
}
}
// send the UDP associate request
buf[0] = 5; // SOCKS version
buf[1] = 3; // command: UDP associate
buf[2] = 0; // reserved
buf[3] = 1; // address type: IPV4
*(int *)&buf[4] = INADDR_ANY;
*(short *)&buf[8] = pHtons((short)port); // port
if( pSend( socks_socket, buf, 10, 0 ) == SOCKET_ERROR )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: send: %s\n", NET_ErrorString());
return;
}
// get the response
len = pRecv( socks_socket, buf, 64, 0 );
if( len == SOCKET_ERROR )
{
err = pWSAGetLastError();
MsgDev( D_WARN, "NET_OpenSocks: recv: %s\n", NET_ErrorString());
return;
}
if( len < 2 || buf[0] != 5 )
{
MsgDev( D_WARN, "NET_OpenSocks: bad response\n" );
return;
}
// check completion code
if( buf[1] != 0 )
{
MsgDev( D_WARN, "NET_OpenSocks: request denied: %i\n", buf[1] );
return;
}
if( buf[3] != 1 )
{
MsgDev( D_WARN, "NET_OpenSocks: relay address is not IPV4: %i\n", buf[3] );
return;
}
((struct sockaddr_in *)&socksRelayAddr)->sin_family = AF_INET;
((struct sockaddr_in *)&socksRelayAddr)->sin_addr.s_addr = *(int *)&buf[4];
((struct sockaddr_in *)&socksRelayAddr)->sin_port = *(short *)&buf[8];
Mem_Set(((struct sockaddr_in *)&socksRelayAddr)->sin_zero, 0, 8 );
usingSocks = true;
}
/*
====================
NET_IPXSocket
====================
*/
int NET_IPXSocket( int port )
{
SOCKET newsocket;
struct sockaddr_ipx address;
int _true = 1;
int err;
if(( newsocket = pSocket( AF_IPX, SOCK_DGRAM, NSPROTO_IPX )) == INVALID_SOCKET )
{
err = pWSAGetLastError();
if( err != WSAEAFNOSUPPORT )
MsgDev( D_WARN, "IPX_Socket: socket: %s\n", NET_ErrorString());
return 0;
}
// make it non-blocking
if( pIoctlSocket( newsocket, FIONBIO, &_true ) == SOCKET_ERROR )
{
MsgDev( D_WARN, "IPX_Socket: ioctl FIONBIO: %s\n", NET_ErrorString());
return 0;
}
// make it broadcast capable
if( pSetSockopt( newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&_true, sizeof( _true ) ) == SOCKET_ERROR )
{
MsgDev( D_WARN, "IPX_Socket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString());
return 0;
}
address.sa_family = AF_IPX;
Mem_Set( address.sa_netnum, 0, 4 );
Mem_Set( address.sa_nodenum, 0, 6 );
if( port == PORT_ANY ) address.sa_socket = 0;
else address.sa_socket = pHtons( (short)port );
if( pBind( newsocket, (void *)&address, sizeof(address)) == SOCKET_ERROR )
{
MsgDev( D_WARN, "IPX_Socket: bind: %s\n", NET_ErrorString());
pCloseSocket( newsocket );
return 0;
}
return newsocket;
}
/*
====================
NET_OpenIPX
====================
*/
void NET_OpenIPX( void )
{
int port;
port = Cvar_Get( "net_port", va( "%i", PORT_SERVER ), CVAR_LATCH, "network ip address" )->integer;
ipx_socket = NET_IPXSocket( port );
}
/*
=====================
NET_GetLocalAddress
=====================
*/
void NET_GetLocalAddress( void )
{
string hostname;
int error, ip, i = 0;
struct hostent *hostInfo;
char *p;
if( pGetHostName( hostname, MAX_STRING ) == SOCKET_ERROR )
{
error = pWSAGetLastError();
return;
}
hostInfo = pGetHostByName( hostname );
if( !hostInfo )
{
error = pWSAGetLastError();
return;
}
MsgDev( D_INFO, "Hostname: %s\n", hostInfo->h_name );
while(( p = hostInfo->h_aliases[i++] ) != NULL )
MsgDev( D_INFO, "Alias: %s\n", p );
if( hostInfo->h_addrtype != AF_INET )
return;
numIP = 0;
while(( p = hostInfo->h_addr_list[numIP] ) != NULL && numIP < MAX_IPS )
{
ip = pNtohl( *(int *)p);
localIP[numIP][0] = p[0];
localIP[numIP][1] = p[1];
localIP[numIP][2] = p[2];
localIP[numIP][3] = p[3];
MsgDev( D_INFO, "IP: %i.%i.%i.%i\n", (ip>>24) & 0xff, (ip>>16) & 0xff, (ip>>8) & 0xff, ip & 0xff );
numIP++;
}
}
/*
====================
NET_OpenIP
====================
*/
void NET_OpenIP( void )
{
cvar_t *ip;
int i, port;
ip = Cvar_Get( "net_ip", "localhost", CVAR_LATCH, "network ip address" );
port = Cvar_Get( "net_port", va( "%i", PORT_SERVER ), CVAR_LATCH, "network default port" )->integer;
// automatically scan for a valid port, so multiple
// dedicated servers can be started without requiring
// a different net_port for each one
for( i = 0; i < 10; i++ )
{
ip_socket = NET_IPSocket( ip->string, port + i );
if( ip_socket )
{
Cvar_SetValue( "net_port", port + i );
if( net_socks_enabled->integer )
NET_OpenSocks( port + i );
NET_GetLocalAddress();
return;
}
}
MsgDev( D_WARN, "Couldn't allocate IP port\n" );
}
/*
====================
NET_GetCvars
====================
*/
static bool NET_GetCvars( void )
{
bool modified = false;
if( net_socks_enabled && net_socks_enabled->modified )
modified = true;
net_socks_enabled = Cvar_Get( "net_socksenabled", "0", CVAR_LATCH|CVAR_ARCHIVE, "network using socks" );
if( net_socks_server && net_socks_server->modified )
modified = true;
net_socks_server = Cvar_Get( "net_socksserver", "", CVAR_LATCH|CVAR_ARCHIVE, "network server socket" );
if( net_socks_port && net_socks_port->modified )
modified = true;
net_socks_port = Cvar_Get( "net_socksport", "1080", CVAR_LATCH|CVAR_ARCHIVE, "using socks port" );
if( net_socks_username && net_socks_username->modified )
modified = true;
net_socks_username = Cvar_Get( "net_socksusername", "", CVAR_LATCH|CVAR_ARCHIVE, "autorization login" );
if( net_socks_password && net_socks_password->modified )
modified = true;
net_socks_password = Cvar_Get( "net_sockspassword", "", CVAR_LATCH|CVAR_ARCHIVE, "autorization password" );
return modified;
}
/*
====================
NET_Config
====================
*/
void NET_Config( bool net_enable )
{
bool modified, start, stop;
// get any latched changes to cvars
modified = NET_GetCvars();
// if enable state is the same and no cvars were modified, we have nothing to do
if( net_enable == net_active && !modified )
return;
if( net_enable == net_active )
{
if( net_enable )
{
stop = true;
start = true;
}
else
{
stop = false;
start = false;
}
}
else
{
if( net_enable )
{
stop = false;
start = true;
}
else
{
stop = true;
start = false;
}
net_active = net_enable;
}
if( stop )
{
if( ip_socket && ip_socket != INVALID_SOCKET )
{
pCloseSocket( ip_socket );
ip_socket = 0;
}
if( socks_socket && socks_socket != INVALID_SOCKET )
{
pCloseSocket( socks_socket );
socks_socket = 0;
}
if( ipx_socket && ipx_socket != INVALID_SOCKET )
{
pCloseSocket( ipx_socket );
ipx_socket = 0;
}
}
if( start )
{
NET_OpenIP();
NET_OpenIPX();
}
}
/*
====================
NET_Init
====================
*/
void NET_Init( void )
{
int r;
NET_OpenWinSock(); // loading wsock32.dll
r = pWSAStartup(MAKEWORD( 1, 1 ), &winsockdata );
if( r )
{
MsgDev( D_WARN, "NET_Init: winsock initialization failed: %d\n", r );
return;
}
winsockInitialized = true;
MsgDev( D_NOTE, "NET_Init()\n" );
NET_GetCvars(); // register cvars
NET_Config( true ); // FIXME: testing!
}
/*
====================
NET_Shutdown
====================
*/
void NET_Shutdown( void )
{
if( !winsockInitialized )
return;
NET_Config( false );
pWSACleanup();
NET_FreeWinSock();
winsockInitialized = false;
}
Reference in New Issue View Git Blame Copy Permalink