int NET_TCPConnect (SOCKET sockfd, char *net_remote_address, int port)
{
struct sockaddr_in address; // Internet socket address
if (port < 1 || port > 32767)
{
Com_Printf("WARNING: TCP_Connect: Invalid Port: %i\n", port);
closesocket(sockfd);
return 0;
}
if (!net_remote_address || !net_remote_address[0])
{
Com_Printf("WARNING: TCP_Connect: No host specified\n");
closesocket(sockfd);
return 0;
}
else
{
NET_StringToSockaddr(net_remote_address, (struct sockaddr *)&address);
}
address.sin_family = AF_INET; // host byte order
address.sin_port = htons((short)port); // short, network byte order
memset(&(address.sin_zero), '\0', 8); // zero the rest of the struct
if (-1 == connect(sockfd, (struct sockaddr*)&address, sizeof(struct sockaddr)))
{
Com_Printf ("WARNING: TCP_Connect failed: connect(%s:%i): %s\n", net_remote_address,port,NET_ErrorString());
closesocket (sockfd);
return 0;
}
return 1;
}
void NET_GetLocalAddress (int socket, netadr_t *out)
{
char buff[512];
struct sockaddr_storage address;
size_t namelen;
netadr_t adr = {0};
qbool notvalid = false;
strlcpy (buff, "localhost", sizeof (buff));
gethostname (buff, sizeof (buff));
buff[sizeof(buff) - 1] = 0;
if (!NET_StringToAdr (buff, &adr)) //urm
NET_StringToAdr ("127.0.0.1", &adr);
namelen = sizeof(address);
if (getsockname (socket, (struct sockaddr *)&address, (socklen_t *)&namelen) == -1) {
notvalid = true;
NET_StringToSockaddr("0.0.0.0", (struct sockaddr_storage *)&address);
// Sys_Error ("NET_Init: getsockname:", strerror(qerrno));
}
SockadrToNetadr(&address, out);
if (!*(int*)out->ip) //socket was set to auto
*(int *)out->ip = *(int *)adr.ip; //change it to what the machine says it is, rather than the socket.
#ifndef SERVERONLY
if (notvalid)
Com_Printf_State (PRINT_FAIL, "Couldn't detect local ip\n");
else
Com_Printf_State (PRINT_OK, "IP address %s\n", NET_AdrToString (*out));
#endif
}
/*
====================
NET_Socket
====================
*/
int NET_IPSocket (char *net_interface, int port)
{
int newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (newsocket == -1)
{
Com_Printf ("UDP_OpenSocket: Couldn't make socket: %s\n", LOG_NET, NET_ErrorString());
return 0;
}
if (newsocket >= FD_SETSIZE)
Com_Error (ERR_FATAL, "NET_IPSocket: socket is higher than FD_SETSIZE");
// make it non-blocking
qboolean _true = true;
if (ioctl (newsocket, FIONBIO, &_true) == -1)
{
Com_Printf ("UDP_OpenSocket: Couldn't make non-blocking: %s\n", LOG_NET, NET_ErrorString());
return 0;
}
// make it broadcast capable
int i = 1;
if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1)
{
Com_Printf ("UDP_OpenSocket: Couldn't set SO_BROADCAST: %s\n", LOG_NET, NET_ErrorString());
return 0;
}
// r1: accept icmp unreachables for quick disconnects
if (!net_no_recverr->intvalue)
{
if (setsockopt (newsocket, IPPROTO_IP, IP_RECVERR, (char *)&i, sizeof(i)) == -1)
{
Com_Printf ("UDP_OpenSocket: Couldn't set IP_RECVERR: %s\n", LOG_NET, NET_ErrorString());
}
}
struct sockaddr_in address;
if (!net_interface || !net_interface[0] || !Q_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 = htons((uint16)port);
address.sin_family = AF_INET;
if( bind (newsocket, (struct sockaddr *) &address, sizeof(address)) == -1)
{
close (newsocket);
Com_Printf ("UDP_OpenSocket: Couldn't bind to UDP port %d: %s\n", LOG_NET, port, NET_ErrorString());
return 0;
}
return newsocket;
}
SOCKET NET_IPSocket( const char *net_interface, int port ) {
SOCKET newsocket;
struct sockaddr_in address;
u_long _true = 1;
int i = 1;
if( !net_interface || !net_interface[0] ) {
net_interface = "localhost";
}
Com_Printf( "Opening IP socket: %s:%i\n", net_interface, port );
if( ( newsocket = socket( PF_INET, SOCK_DGRAM, IPPROTO_UDP ) ) == INVALID_SOCKET ) {
#ifdef _WIN32
if( WSAGetLastError() != WSAEAFNOSUPPORT )
#endif
Com_Printf ("WARNING: UDP_OpenSocket: socket: %s", NET_ErrorString() );
return INVALID_SOCKET;
}
// make it non-blocking
if( ioctlsocket( newsocket, FIONBIO, &_true ) == SOCKET_ERROR ) {
Com_Printf ("WARNING: UDP_OpenSocket: ioctl FIONBIO: %s\n", NET_ErrorString() );
closesocket( newsocket );
return INVALID_SOCKET;
}
// make it broadcast capable
if( setsockopt( newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof( i ) ) == SOCKET_ERROR ) {
Com_Printf ("WARNING: UDP_OpenSocket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString() );
closesocket( newsocket );
return INVALID_SOCKET;
}
if( !Q_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 = htons( (u_short)port );
}
address.sin_family = AF_INET;
if( bind( newsocket, (void *)&address, sizeof( address ) ) == SOCKET_ERROR ) {
Com_Printf ("WARNING: UDP_OpenSocket: bind: %s\n", NET_ErrorString() );
closesocket( newsocket );
return INVALID_SOCKET;
}
return newsocket;
}
/*
====================
NET_Socket
====================
*/
int NET_IPSocket (char *net_interface, int port)
{
int newsocket;
struct sockaddr_in address;
u_long _true = true;
int i = 1;
int err;
if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
{
err = WSAGetLastError();
if (err != WSAEAFNOSUPPORT)
Com_Printf ("WARNING: UDP_OpenSocket: socket: %s", NET_ErrorString());
return 0;
}
// make it non-blocking
if (ioctlsocket (newsocket, FIONBIO, &_true) == -1)
{
Com_Printf ("WARNING: UDP_OpenSocket: ioctl FIONBIO: %s\n", NET_ErrorString());
return 0;
}
// make it broadcast capable
if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1)
{
Com_Printf ("WARNING: UDP_OpenSocket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString());
return 0;
}
if (!net_interface || !net_interface[0] || !_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 = htons((short)port);
address.sin_family = AF_INET;
if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
{
Com_Printf ("WARNING: UDP_OpenSocket: bind: %s\n", NET_ErrorString());
closesocket (newsocket);
return 0;
}
return newsocket;
}
/*
=============
NET_StringToAdr
localhost
idnewt
idnewt:28000
192.246.40.70
192.246.40.70:28000
=============
*/
qboolean NET_StringToAdr (const char *s, netadr_t *a)
{
struct sockaddr sadr;
if (!Q_stricmp(s, "localhost")) {
memset (a, 0, sizeof(*a));
a->type = NA_LOOPBACK;
return true;
}
if (!NET_StringToSockaddr (s, &sadr))
return false;
SockadrToNetadr (&sadr, a);
return true;
}
/* <d2eca> ../engine/net_ws.c:483 */
qboolean NET_StringToAdr(const char *s, netadr_t *a)
{
struct sockaddr sadr;
if (Q_strcmp(s, "localhost"))
{
if (!NET_StringToSockaddr(s, &sadr))
{
return FALSE;
}
SockadrToNetadr(&sadr, a);
}
else
{
Q_memset(a, 0, sizeof(netadr_t));
a->type = NA_LOOPBACK;
}
return TRUE;
}
qbool NET_StringToAdr (const char *s, netadr_t *a)
{
struct sockaddr_storage sadr;
#ifndef SERVERONLY
if (!strcmp(s, "local")) {
memset(a, 0, sizeof(*a));
a->type = NA_LOOPBACK;
return true;
}
#endif
if (!NET_StringToSockaddr (s, &sadr))
return false;
SockadrToNetadr (&sadr, a);
return true;
}
qboolean
NET_StringToAdr(char *s, netadr_t *a)
{
struct sockaddr_storage sadr;
memset(a, 0, sizeof(*a));
if (!strcmp(s, "localhost"))
{
a->type = NA_LOOPBACK;
return true;
}
if (!NET_StringToSockaddr(s, &sadr))
{
return false;
}
SockadrToNetadr(&sadr, a);
return true;
}
/*
=============
NET_StringToAdr
localhost
idnewt
idnewt:28000
192.246.40.70
192.246.40.70:28000
=============
*/
qboolean NET_StringToAdr (const char *s, netadr_t *a)
{
struct sockaddr sadr;
if (!strcmp (s, "localhost"))
{
memset (a, 0, sizeof(*a));
//r1: should need some kind of ip data to prevent comparisons with empty ips?
a->ip[0] = 127;
a->ip[3] = 1;
a->port = PORT_SERVER;
a->type = NA_LOOPBACK;
return true;
}
if (!NET_StringToSockaddr (s, &sadr))
return false;
SockadrToNetadr (&sadr, a);
return true;
}
qboolean SV_AntiCheat_Connect (void)
{
struct hostent *h;
struct sockaddr_in bindAddress;
const char *ip;
const unsigned long _true = 1;
if (acSocket)
return true;
h = gethostbyname (sv_anticheat_server_address->string);
if (!h)
{
Com_Printf ("ANTICHEAT: Unable to lookup anticheat server address '%s'. Retrying in %d seconds.\n", LOG_SERVER|LOG_ANTICHEAT, sv_anticheat_server_address->string, retryBackOff);
retryTime = time(NULL) + retryBackOff;
retryBackOff += 60;
return false;
}
acSocket = socket (AF_INET, SOCK_STREAM, 0);
if (acSocket == SOCKET_ERROR)
Com_Error (ERR_DROP, "SV_AntiCheat_Connect: socket");
if (!dedicated->intvalue)
{
Com_Printf ("ANTICHEAT: Anticheat is only supported on dedicated servers, disabling.\n", LOG_SERVER|LOG_ANTICHEAT);
SV_AntiCheat_Disconnect ();
return false;
}
if (ioctlsocket (acSocket, FIONBIO, (u_long *)&_true) == -1)
Com_Error (ERR_DROP, "SV_AntiCheat_Connect: ioctl");
setsockopt (acSocket, SOL_SOCKET, SO_KEEPALIVE, (const char *)&_true, sizeof(_true));
memset (&bindAddress.sin_zero, 0, sizeof(bindAddress.sin_zero));
bindAddress.sin_family = AF_INET;
bindAddress.sin_port = 0;
ip = Cvar_VariableString ("ip");
if (ip[0] && Q_stricmp (ip, "localhost"))
NET_StringToSockaddr (ip, (struct sockaddr *)&bindAddress);
else
bindAddress.sin_addr.s_addr = INADDR_ANY;
if (bind (acSocket, (const struct sockaddr *)&bindAddress, sizeof(bindAddress)) == SOCKET_ERROR)
Com_Error (ERR_DROP, "SV_AntiCheat_Connect: couldn't bind to %s", ip);
memset (&acServer.sin_zero, 0, sizeof(acServer.sin_zero));
acServer.sin_family = AF_INET;
acServer.sin_port = htons (27910);
memcpy (&acServer.sin_addr, h->h_addr_list[0], sizeof(acServer.sin_addr));
retryTime = 0;
connect_pending = true;
connect (acSocket, (const struct sockaddr *)&acServer, sizeof(acServer));
packetLen = 0;
expectedLength = 0;
anticheat_ready = false;
return true;
}
/* <d455d> ../engine/net_ws.c:1700 */
int NET_IPSocket(char *net_interface, int port, qboolean multicast)
{
int newsocket;
struct sockaddr_in address;
qboolean _true = TRUE;
int i = 1;
int err;
#ifdef _WIN32
if ((newsocket = CRehldsPlatformHolder::get()->socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET)
#else
if ((newsocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET)
#endif // _WIN32
{
#ifdef _WIN32
err = CRehldsPlatformHolder::get()->WSAGetLastError();
#else
err = errno;
#endif // _WIN32
if (err != WSAEAFNOSUPPORT)
Con_Printf("WARNING: UDP_OpenSocket: port: %d socket: %s", port, NET_ErrorString(err));
return 0;
}
#ifdef _WIN32
if (CRehldsPlatformHolder::get()->ioctlsocket(newsocket, FIONBIO, (u_long *)&_true) == SOCKET_ERROR)
#else
if (SOCKET_FIONBIO(newsocket, _true) == SOCKET_ERROR)
#endif // _WIN32
{
#ifdef _WIN32
err = CRehldsPlatformHolder::get()->WSAGetLastError();
#else
err = errno;
#endif // _WIN32
Con_Printf("WARNING: UDP_OpenSocket: port: %d ioctl FIONBIO: %s\n", port, NET_ErrorString(err));
return 0;
}
#ifdef _WIN32
if (CRehldsPlatformHolder::get()->setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == SOCKET_ERROR)
#else
if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == SOCKET_ERROR)
#endif
{
#ifdef _WIN32
err = CRehldsPlatformHolder::get()->WSAGetLastError();
#else
err = errno;
#endif // _WIN32
Con_Printf ("WARNING: UDP_OpenSocket: port: %d setsockopt SO_BROADCAST: %s\n", port, NET_ErrorString(err));
return 0;
}
if (COM_CheckParm("-reuse") || multicast)
{
#ifdef _WIN32
if (CRehldsPlatformHolder::get()->setsockopt(newsocket, SOL_SOCKET, SO_REUSEADDR, (char *)&_true, sizeof(qboolean)) == SOCKET_ERROR)
#else
if (setsockopt(newsocket, SOL_SOCKET, SO_REUSEADDR, (char *)&_true, sizeof(qboolean)) == SOCKET_ERROR)
#endif // _WIN32
{
#ifdef _WIN32
err = CRehldsPlatformHolder::get()->WSAGetLastError();
#else
err = errno;
#endif // _WIN32
Con_Printf ("WARNING: UDP_OpenSocket: port: %d setsockopt SO_REUSEADDR: %s\n", port, NET_ErrorString(err));
return 0;
}
}
#ifndef _WIN32
if (COM_CheckParm("-tos"))
{
i = 16;
Con_Printf("Enabling LOWDELAY TOS option\n");
if (setsockopt(newsocket, IPPROTO_IP, IP_TOS, (char *)&i, sizeof(i)) == SOCKET_ERROR)
{
err = errno;
if (err != WSAENOPROTOOPT)
Con_Printf("WARNING: UDP_OpenSocket: port: %d setsockopt IP_TOS: %s\n", port, NET_ErrorString(err));
return 0;
}
}
#endif // _WIN32
if (net_interface && *net_interface && Q_stricmp(net_interface, "localhost"))
NET_StringToSockaddr(net_interface, (sockaddr *)&address);
else
address.sin_addr.s_addr = INADDR_ANY;
if (port == -1)
address.sin_port = 0;
else address.sin_port = htons((u_short)port);
address.sin_family = AF_INET;
#ifdef _WIN32
if (CRehldsPlatformHolder::get()->bind(newsocket, (struct sockaddr *)&address, sizeof(address)) == SOCKET_ERROR)
#else
if (bind(newsocket, (struct sockaddr *)&address, sizeof(address)) == SOCKET_ERROR)
#endif // _WIN32
{
#ifdef _WIN32
err = CRehldsPlatformHolder::get()->WSAGetLastError();
#else
err = errno;
#endif // _WIN32
Con_Printf("WARNING: UDP_OpenSocket: port: %d bind: %s\n", port, NET_ErrorString(err));
#ifdef _WIN32
CRehldsPlatformHolder::get()->closesocket(newsocket);
#else
SOCKET_CLOSE(newsocket);
#endif // _WIN32
return 0;
}
i = COM_CheckParm("-loopback") != 0;
#ifdef _WIN32
if (CRehldsPlatformHolder::get()->setsockopt(newsocket, IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&i, sizeof(i)) == SOCKET_ERROR)
#else
if (setsockopt(newsocket, IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&i, sizeof(i)) == SOCKET_ERROR)
#endif // _WIN32
{
#ifdef _WIN32
err = CRehldsPlatformHolder::get()->WSAGetLastError();
#else
err = errno;
#endif // _WIN32
Con_DPrintf("WARNING: UDP_OpenSocket: port %d setsockopt IP_MULTICAST_LOOP: %s\n", port, NET_ErrorString(err));
}
return newsocket;
}
/*
====================
NET_Socket
====================
*/
int NET_IPSocket (char *net_interface, int port)
{
SOCKET newsocket;
struct sockaddr_in address;
int i;
int j;
int x = sizeof(i);
int err;
if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET)
{
err = WSAGetLastError();
if (err != WSAEAFNOSUPPORT)
Com_Printf ("WARNING: UDP_OpenSocket: socket: %s\n", LOG_NET, NET_ErrorString());
return 0;
}
i = net_rcvbuf->intvalue * 1024;
if (i)
{
setsockopt (newsocket, SOL_SOCKET, SO_RCVBUF, (char *)&i, sizeof(i));
getsockopt (newsocket, SOL_SOCKET, SO_RCVBUF, (char *)&j, &x);
if (i != j)
Com_Printf ("WARNING: Setting SO_RCVBUF: wanted %d, got %d\n", LOG_NET, i, j);
}
i = net_sndbuf->intvalue * 1024;
if (i)
{
setsockopt (newsocket, SOL_SOCKET, SO_SNDBUF, (char *)&i, sizeof(i));
getsockopt (newsocket, SOL_SOCKET, SO_SNDBUF, (char *)&j, &x);
if (i != j)
Com_Printf ("WARNING: Setting SO_SNDBUF: wanted %d, got %d\n", LOG_NET, i, j);
}
i = 1;
// make it non-blocking
if (ioctlsocket (newsocket, FIONBIO, (u_long *)&_true) == -1)
{
Com_Printf ("UDP_OpenSocket: Couldn't make non-blocking: %s\n", LOG_NET, NET_ErrorString());
return 0;
}
//setsockopt (sckRaw, IPPROTO_IP, IP_TTL, (char *)&stIPInfo.Ttl, sizeof(stIPInfo.Ttl));
// make it broadcast capable
if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1)
{
Com_Printf ("UDP_OpenSocket: setsockopt SO_BROADCAST: %s\n", LOG_NET, NET_ErrorString());
return 0;
}
//r1: set 'interactive' ToS
i = 0x10;
if (setsockopt(newsocket, IPPROTO_IP, IP_TOS, (char *)&i, sizeof(i)) == -1)
Com_Printf ("WARNING: UDP_OpenSocket: setsockopt IP_TOS: %s\n", LOG_NET, NET_ErrorString());
if (!net_interface || !net_interface[0] || !Q_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 = htons((uint16)port);
address.sin_family = AF_INET;
if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
{
Com_Printf ("UDP_OpenSocket: Couldn't bind to UDP port %d: %s\n", LOG_NET, port, NET_ErrorString());
closesocket (newsocket);
return 0;
}
return (int)newsocket;
}
/*
====================
NET_Socket
====================
*/
int NET_Socket (char *net_interface, int port)
{
int newsocket;
struct sockaddr_in address;
qboolean _true = true;
int i = 1;
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Switching to the equivalent function (and data structures) in the platform:
//if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
if ((newsocket = net_socket (PF_INET, SOCK_DGRAM, IPPROTO_IP)) < 0)
// <<< FIX
{
Com_Printf ("ERROR: UDP_OpenSocket: socket: %s\n", NET_ErrorString());
return 0;
}
// make it non-blocking
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Switching to the equivalent function in the platform:
//if (ioctl (newsocket, FIONBIO, &_true) == -1)
if (net_ioctl (newsocket, FIONBIO, &_true) < 0)
// <<< FIX
{
Com_Printf ("ERROR: UDP_OpenSocket: ioctl FIONBIO: %s\n", NET_ErrorString());
return 0;
}
// make it broadcast capable
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// SO_BROADCAST cannot be applied to sockets in this platform. Letting it pass:
//if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1)
//{
// Com_Printf ("ERROR: UDP_OpenSocket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString());
// return 0;
//}
// <<< FIX
if (!net_interface || !net_interface[0] || !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 = htons((short)port);
address.sin_family = AF_INET;
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Do not bind the socket if port == 0 (part 1):
if(address.sin_port > 0)
{
// <<< FIX
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Switching to the equivalent function in the platform:
//if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
if( net_bind (newsocket, (void *)&address, sizeof(address)) < 0)
// <<< FIX
{
Com_Printf ("ERROR: UDP_OpenSocket: bind: %s\n", NET_ErrorString());
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Switching to the equivalent function in the library:
//close (newsocket);
net_close (newsocket);
// <<< FIX
return 0;
}
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Do not bind the socket if port == 0 (part 2):
}
// <<< FIX
return newsocket;
}
