net_ws port. Port non-blocking NS resolution also.

engine/common/net_ws.c

@@ -13,7 +13,24 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 */
 
+#ifdef _WIN32
+// Winsock
 #include <winsock.h>
+#include <wsipx.h>
+#define socklen_t int //#include <ws2tcpip.h>
+#else
+// BSD sockets
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+// Errors handling
+#include <errno.h>
+#include <fcntl.h>
+#endif
 #include "common.h"
 #include "netchan.h"
 #include "mathlib.h"
@@ -28,6 +45,11 @@ GNU General Public License for more details.
 #define SPLIT_SIZE			( MAX_ROUTEABLE_PACKET - sizeof( SPLITPACKET ))
 #define NET_MAX_FRAGMENTS		( NET_MAX_FRAGMENT / SPLIT_SIZE )
 
+#ifndef _WIN32 // it seems we need to use WS2 to support it
+#define HAVE_GETADDRINFO
+#endif
+
+#ifdef _WIN32
 // wsock32.dll exports
 static int (_stdcall *pWSACleanup)( void );
 static word (_stdcall *pNtohs)( word netshort );
@@ -81,6 +103,69 @@ static dllfunc_t winsock_funcs[] =
 
 dll_info_t winsock_dll = { "wsock32.dll", winsock_funcs, false };
 
+static dllfunc_t kernel32_funcs[] =
+{
+	{ "InitializeCriticalSection", (void **) &pInitializeCriticalSection },
+	{ "EnterCriticalSection", (void **) &pEnterCriticalSection },
+	{ "LeaveCriticalSection", (void **) &pLeaveCriticalSection },
+	{ "DeleteCriticalSection", (void **) &pDeleteCriticalSection },
+	{ NULL, NULL }
+};
+
+dll_info_t kernel32_dll = { "kernel32.dll", kernel32_funcs, false };
+
+
+static void NET_InitializeCriticalSections( void );
+
+qboolean NET_OpenWinSock( void )
+{
+	if( Sys_LoadLibrary( &kernel32_dll ) )
+		NET_InitializeCriticalSections();
+
+	// initialize the Winsock function vectors (we do this instead of statically linking
+	// so we can run on Win 3.1, where there isn't necessarily Winsock)
+	return Sys_LoadLibrary( &winsock_dll );
+}
+
+void NET_FreeWinSock( void )
+{
+	Sys_FreeLibrary( &winsock_dll );
+}
+#else
+#define pHtons htons
+#define pConnect connect
+#define pInet_Addr inet_addr
+#define pRecvFrom recvfrom
+#define pSendTo sendto
+#define pSocket socket
+#define pIoctlSocket ioctl
+#define pCloseSocket close
+#define pSetSockopt setsockopt
+#define pBind bind
+#define pGetHostName gethostname
+#define pGetSockName getsockname
+#define pGetHs
+#define pRecv recv
+#define pSend send
+#define pInet_Ntoa inet_ntoa
+#define pNtohs ntohs
+#define pGetHostByName gethostbyname
+#define pSelect select
+#define pGetAddrInfo getaddrinfo
+#define SOCKET int
+#define INVALID_SOCKET 0
+#endif
+
+#ifdef __EMSCRIPTEN__
+/* All socket operations are non-blocking already */
+static int ioctl_stub( int d, unsigned long r, ...)
+{
+	return 0;
+}
+#undef pIoctlSocket
+#define pIoctlSocket ioctl_stub
+#endif
+
 typedef struct
 {
 	byte		data[NET_MAX_MESSAGE];
@@ -132,10 +217,12 @@ typedef struct
 	int		split_flags[NET_MAX_FRAGMENTS];
 	long		sequence_number;
 	int		ip_sockets[NS_COUNT];
-	WSADATA		winsockdata;
 	qboolean		initialized;
 	qboolean		configured;
 	qboolean		allow_ip;
+#ifdef _WIN32
+	WSADATA		winsockdata;
+#endif
 } net_state_t;
 
 static net_state_t		net;
@@ -150,34 +237,6 @@ static convar_t		*net_address;
 convar_t			*net_clockwindow;
 netadr_t			net_local;
 
-/*
-====================
-NET_OpenWinSock
-
-load wsock32.dll
-====================
-*/
-qboolean NET_OpenWinSock( void )
-{
-	// initialize the Winsock function vectors (we do this instead of statically linking
-	// so we can run on Win 3.1, where there isn't necessarily Winsock)
-	if( Sys_LoadLibrary( &winsock_dll ))
-		return true;
-	return false;
-}
-
-/*
-====================
-NET_FreeWinSock
-
-unload wsock32.dll
-====================
-*/
-void NET_FreeWinSock( void )
-{
-	Sys_FreeLibrary( &winsock_dll );
-}
-
 /*
 ====================
 NET_ErrorString
@@ -185,6 +244,7 @@ NET_ErrorString
 */
 char *NET_ErrorString( void )
 {
+#ifdef _WIN32
 	int	err = WSANOTINITIALISED;
 
 	if( net.initialized )
@@ -238,6 +298,27 @@ char *NET_ErrorString( void )
 	case WSANO_DATA: return "WSANO_DATA";
 	default: return "NO ERROR";
 	}
+#else
+	return strerror( errno );
+#endif
+}
+
+_inline qboolean NET_IsSocketError( int retval )
+{
+#ifdef _WIN32
+	return retval == SOCKET_ERROR ? true : false;
+#else
+	return retval < 0 ? true : false;
+#endif
+}
+
+_inline qboolean NET_IsSocketValid( int socket )
+{
+#ifdef _WIN32
+	return socket != INVALID_SOCKET;
+#else
+	return socket;
+#endif
 }
 
 /*
@@ -278,6 +359,151 @@ static void NET_SockadrToNetadr( struct sockaddr *s, netadr_t *a )
 	}
 }
 
+#if !defined XASH_NO_ASYNC_NS_RESOLVE && ( defined _WIN32 || !defined __EMSCRIPTEN__ )
+#define CAN_ASYNC_NS_RESOLVE
+#endif
+
+#ifdef CAN_ASYNC_NS_RESOLVE
+static void NET_ResolveThread( void );
+#if !defined _WIN32
+#include <pthread.h>
+#define mutex_lock pthread_mutex_lock
+#define mutex_unlock pthread_mutex_unlock
+#define exit_thread( x ) pthread_exit(x)
+#define create_thread( pfn ) !pthread_create( &nsthread.thread, NULL, (pfn), NULL )
+#define detach_thread( x ) pthread_detach(x)
+#define mutex_t  pthread_mutex_t
+#define thread_t pthread_t
+
+void *NET_ThreadStart( void *unused )
+{
+	NET_ResolveThread();
+	return NULL;
+}
+
+#else // WIN32
+struct cs {
+	void* p1;
+	int   i1, i2;
+	void *p2, *p3;
+	uint  i4;
+};
+#define mutex_lock pEnterCriticalSection
+#define mutex_unlock pLeaveCriticalSection
+#define detach_thread( x ) CloseHandle(x)
+#define create_thread( pfn ) nsthread.thread = CreateThread( NULL, 0, pfn, NULL, 0, NULL )
+#define mutex_t  struct cs
+#define thread_t HANDLE
+DWORD WINAPI NET_ThreadStart( LPVOID unused )
+{
+	NET_ResolveThread();
+	ExitThread(0);
+	return 0;
+}
+#endif
+
+#ifdef DEBUG_RESOLVE
+#define RESOLVE_DBG(x) Sys_PrintLog(x)
+#else
+#define RESOLVE_DBG(x)
+#endif //  DEBUG_RESOLVE
+
+static struct nsthread_s
+{
+	mutex_t mutexns;
+	mutex_t mutexres;
+	thread_t thread;
+	int     result;
+	string  hostname;
+	qboolean busy;
+} nsthread
+#ifndef _WIN32
+= { PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER }
+#endif
+;
+
+#ifdef _WIN32
+static void NET_InitializeCriticalSections( void )
+{
+	pInitializeCriticalSection( &nsthread.mutexns );
+	pInitializeCriticalSection( &nsthread.mutexres );
+}
+#endif
+
+void NET_ResolveThread( void )
+{
+#ifdef HAVE_GETADDRINFO
+	struct addrinfo *ai = NULL, *cur;
+	struct addrinfo hints;
+	int sin_addr = 0;
+
+	RESOLVE_DBG( "[resolve thread] starting resolve for " );
+	RESOLVE_DBG( nsthread.hostname );
+	RESOLVE_DBG( " with getaddrinfo\n" );
+	memset( &hints, 0, sizeof( hints ) );
+	hints.ai_family = AF_INET;
+	if( !pGetAddrInfo( nsthread.hostname, NULL, &hints, &ai ) )
+	{
+		for( cur = ai; cur; cur = cur->ai_next ) {
+			if( cur->ai_family == AF_INET ) {
+				sin_addr = *((int*)&((struct sockaddr_in *)cur->ai_addr)->sin_addr);
+				freeaddrinfo( ai );
+				ai = NULL;
+				break;
+			}
+		}
+
+		if( ai )
+			freeaddrinfo( ai );
+	}
+
+	if( sin_addr )
+		RESOLVE_DBG( "[resolve thread] getaddrinfo success\n" );
+	else
+		RESOLVE_DBG( "[resolve thread] getaddrinfo failed\n" );
+	mutex_lock( &nsthread.mutexres );
+	nsthread.result = sin_addr;
+	nsthread.busy = false;
+	RESOLVE_DBG( "[resolve thread] returning result\n" );
+	mutex_unlock( &nsthread.mutexres );
+	RESOLVE_DBG( "[resolve thread] exiting thread\n" );
+#else
+	struct hostent *res;
+
+	RESOLVE_DBG( "[resolve thread] starting resolve for " );
+	RESOLVE_DBG( nsthread.hostname );
+	RESOLVE_DBG( " with gethostbyname\n" );
+
+	mutex_lock( &nsthread.mutexns );
+	RESOLVE_DBG( "[resolve thread] locked gethostbyname mutex\n" );
+	res = pGetHostByName( nsthread.hostname );
+	if(res)
+		RESOLVE_DBG( "[resolve thread] gethostbyname success\n" );
+	else
+		RESOLVE_DBG( "[resolve thread] gethostbyname failed\n" );
+
+	mutex_lock( &nsthread.mutexres );
+	RESOLVE_DBG( "[resolve thread] returning result\n" );
+	if( res )
+		nsthread.result = *(int *)res->h_addr_list[0];
+	else
+		nsthread.result = 0;
+
+	nsthread.busy = false;
+
+	mutex_unlock( &nsthread.mutexns );
+
+	RESOLVE_DBG( "[resolve thread] unlocked gethostbyname mutex\n" );
+
+	mutex_unlock( &nsthread.mutexres );
+
+	RESOLVE_DBG( "[resolve thread] exiting thread\n" );
+#endif
+}
+
+#endif // CAN_ASYNC_NS_RESOLVE
+
+
 /*
 =============
 NET_StringToAdr
@@ -289,8 +515,9 @@ idnewt:28000
 192.246.40.70:28000
 =============
 */
-static qboolean NET_StringToSockaddr( const char *s, struct sockaddr *sadr )
+static int NET_StringToSockaddr( const char *s, struct sockaddr *sadr, qboolean nonblocking )
 {
+	int ip = 0;
 	char	*colon;
 	char	copy[128];
 
@@ -309,22 +536,141 @@ static qboolean NET_StringToSockaddr( const char *s, struct sockaddr *sadr )
 		if( *colon == ':' )
 		{
 			*colon = 0;
-			((struct sockaddr_in *)sadr)->sin_port = pHtons((short)Q_atoi( colon + 1 ));	
+			((struct sockaddr_in *)sadr)->sin_port = pHtons((short)Q_atoi( colon + 1 ));
 		}
 	}
 
-	((struct sockaddr_in *)sadr)->sin_addr.s_addr = pInet_Addr( copy );
+	if( copy[0] >= '0' && copy[0] <= '9' )
-
-	if(((struct sockaddr_in *)sadr)->sin_addr.s_addr == INADDR_NONE )
 	{
-		struct hostent	*h = pGetHostByName( copy );
+		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = pInet_Addr( copy );
-
-		if( h == NULL || h->h_addr == NULL )
-			return false;
-
-		((struct sockaddr_in *)sadr)->sin_addr.s_addr = *(uint *)h->h_addr;	
 	}
-	return true;
+	else
+	{
+#ifdef CAN_ASYNC_NS_RESOLVE
+		qboolean asyncfailed = false;
+#ifdef _WIN32
+		if( pInitializeCriticalSection )
+#endif // _WIN32
+		{
+			if( !nonblocking )
+			{
+#ifdef HAVE_GETADDRINFO
+				struct addrinfo *ai = NULL, *cur;
+				struct addrinfo hints;
+
+				memset( &hints, 0, sizeof( hints ) );
+				hints.ai_family = AF_INET;
+				if( !pGetAddrInfo( copy, NULL, &hints, &ai ) )
+				{
+					for( cur = ai; cur; cur = cur->ai_next )
+					{
+						if( cur->ai_family == AF_INET )
+						{
+							ip = *((int*)&((struct sockaddr_in *)cur->ai_addr)->sin_addr);
+							freeaddrinfo(ai);
+							ai = NULL;
+							break;
+						}
+					}
+
+					if( ai )
+						freeaddrinfo(ai);
+				}
+#else
+				struct hostent *h;
+
+				mutex_lock( &nsthread.mutexns );
+				h = pGetHostByName( copy );
+				if( !h )
+				{
+					mutex_unlock( &nsthread.mutexns );
+					return 0;
+				}
+
+				ip = *(int *)h->h_addr_list[0];
+				mutex_unlock( &nsthread.mutexns );
+#endif
+			}
+			else
+			{
+				mutex_lock( &nsthread.mutexres );
+
+				if( nsthread.busy )
+				{
+					mutex_unlock( &nsthread.mutexres );
+					return 2;
+				}
+
+				if( !Q_strcmp( copy, nsthread.hostname ) )
+				{
+					ip = nsthread.result;
+					nsthread.hostname[0] = 0;
+					detach_thread( nsthread.thread );
+				}
+				else
+				{
+					Q_strncpy( nsthread.hostname, copy, MAX_STRING );
+					nsthread.busy = true;
+					mutex_unlock( &nsthread.mutexres );
+
+					if( create_thread( NET_ThreadStart ) )
+						return 2;
+					else // failed to create thread
+					{
+						MsgDev( D_ERROR, "NET_StringToSockaddr: failed to create thread!\n");
+						nsthread.busy = false;
+						asyncfailed = true;
+					}
+				}
+
+				mutex_unlock( &nsthread.mutexres );
+			}
+		}
+#ifdef _WIN32
+		else
+			asyncfailed = true;
+#else
+		if( asyncfailed )
+#endif // _WIN32
+#endif // CAN_ASYNC_NS_RESOLVE
+		{
+#ifdef HAVE_GETADDRINFO
+			struct addrinfo *ai = NULL, *cur;
+			struct addrinfo hints;
+
+			memset( &hints, 0, sizeof( hints ) );
+			hints.ai_family = AF_INET;
+			if( !pGetAddrInfo( copy, NULL, &hints, &ai ) )
+			{
+				for( cur = ai; cur; cur = cur->ai_next )
+				{
+					if( cur->ai_family == AF_INET )
+					{
+						ip = *((int*)&((struct sockaddr_in *)cur->ai_addr)->sin_addr);
+						freeaddrinfo(ai);
+						ai = NULL;
+						break;
+					}
+				}
+
+				if( ai )
+					freeaddrinfo(ai);
+			}
+#else
+			struct hostent *h;
+			if(!( h = pGetHostByName( copy )))
+				return 0;
+			ip = *(int *)h->h_addr_list[0];
+#endif
+		}
+
+		if( !ip )
+			return 0;
+
+		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = ip;
+	}
+
+	return 1;
 }
 
 /*
@@ -477,20 +823,43 @@ qboolean NET_StringToAdr( const char *string, netadr_t *adr )
 {
 	struct sockaddr s;
 
-	if( !Q_stricmp( string, "localhost" ))
+	memset( adr, 0, sizeof( netadr_t ));
+
+	if( !Q_stricmp( string, "localhost" ) || !Q_stricmp( string, "loopback" ) )
 	{
-		memset( adr, 0, sizeof( netadr_t ));
 		adr->type = NA_LOOPBACK;
 		return true;
 	}
 
-	if( !NET_StringToSockaddr( string, &s ))
+	if( !NET_StringToSockaddr( string, &s, false ))
 		return false;
 	NET_SockadrToNetadr( &s, adr );
 
 	return true;
 }
 
+int NET_StringToAdrNB( const char *string, netadr_t *adr )
+{
+	struct sockaddr s;
+	int res;
+
+	memset( adr, 0, sizeof( netadr_t ));
+	if( !Q_stricmp( string, "localhost" )  || !Q_stricmp( string, "loopback" ) )
+	{
+		adr->type = NA_LOOPBACK;
+		return true;
+	}
+
+	res = NET_StringToSockaddr( string, &s, true );
+
+	if( res == 0 || res == 2 )
+		return res;
+
+	NET_SockadrToNetadr( &s, adr );
+
+	return true;
+}
+
 /*
 =============================================================================
 
@@ -758,7 +1127,7 @@ static qboolean NET_LagPacket( qboolean newdata, netsrc_t sock, netadr_t *from,
 
 	Mem_Free( pPacket );
 
-	return TRUE;
+	return true;
 }
 
 /*
@@ -858,7 +1227,7 @@ queue normal and lagged packets
 qboolean NET_QueuePacket( netsrc_t sock, netadr_t *from, byte *data, size_t *length )
 {
 	byte		buf[NET_MAX_FRAGMENT];
-	int		ret = SOCKET_ERROR;
+	int		ret;
 	int		net_socket;
 	int		addr_len;
 	struct sockaddr	addr;
@@ -867,12 +1236,12 @@ qboolean NET_QueuePacket( netsrc_t sock, netadr_t *from, byte *data, size_t *len
 
 	net_socket = net.ip_sockets[sock];
 
-	if( net_socket != INVALID_SOCKET )
+	if( NET_IsSocketValid( net_socket ) )
 	{
 		addr_len = sizeof( addr );
 		ret = pRecvFrom( net_socket, buf, sizeof( buf ), 0, (struct sockaddr *)&addr, &addr_len );
 
-		if( ret != SOCKET_ERROR )
+		if( !NET_IsSocketError( ret ) )
 		{
 			NET_SockadrToNetadr( &addr, from );
 
@@ -898,6 +1267,7 @@ qboolean NET_QueuePacket( netsrc_t sock, netadr_t *from, byte *data, size_t *len
 		}
 		else
 		{
+#ifdef _WIN32
 			int	err = pWSAGetLastError();
 
 			switch( err )
@@ -911,6 +1281,19 @@ qboolean NET_QueuePacket( netsrc_t sock, netadr_t *from, byte *data, size_t *len
 				MsgDev( D_ERROR, "NET_QueuePacket: %s from %s\n", NET_ErrorString(), NET_AdrToString( *from ));
 				break;
 			}
+#else
+			switch( errno )
+			{
+			case EWOULDBLOCK:
+			case ECONNRESET:
+			case ECONNREFUSED:
+			case EMSGSIZE:
+				break;
+			default:	// let's continue even after errors
+				MsgDev( D_ERROR, "NET_QueuePacket: %s from %s\n", NET_ErrorString(), NET_AdrToString( *from ));
+				break;
+			}
+#endif
 		}
 	}
 
@@ -1026,13 +1409,13 @@ void NET_SendPacket( netsrc_t sock, size_t length, const void *data, netadr_t to
 	else if( to.type == NA_BROADCAST )
 	{
 		net_socket = net.ip_sockets[sock];
-		if( net_socket == INVALID_SOCKET )
+		if( !NET_IsSocketValid( net_socket ) )
 			return;
 	}
 	else if( to.type == NA_IP )
 	{
 		net_socket = net.ip_sockets[sock];
-		if( net_socket == INVALID_SOCKET )
+		if( !NET_IsSocketValid( net_socket ) )
 			return;
 	}
 	else
@@ -1044,24 +1427,38 @@ void NET_SendPacket( netsrc_t sock, size_t length, const void *data, netadr_t to
 
 	ret = NET_SendLong( sock, net_socket, data, length, 0, &addr, sizeof( addr ));
 
-	if( ret == SOCKET_ERROR )
+	if( NET_IsSocketError( err ))
 	{
-		err = pWSAGetLastError();
+		{
+#ifdef _WIN32
+			err = pWSAGetLastError();
 
-		// WSAEWOULDBLOCK is silent
+			// WSAEWOULDBLOCK is silent
-		if( err == WSAEWOULDBLOCK )
+			if( err == WSAEWOULDBLOCK )
-			return;
+				return;
 
-		// some PPP links don't allow broadcasts
+			// some PPP links don't allow broadcasts
-		if( err == WSAEADDRNOTAVAIL && to.type == NA_BROADCAST )
+			if( err == WSAEADDRNOTAVAIL && to.type == NA_BROADCAST )
-			return;
+				return;
+#else
+			// WSAEWOULDBLOCK is silent
+			if( errno == EWOULDBLOCK )
+				return;
 
-		// let dedicated servers continue after errors
+			// some PPP links don't allow broadcasts
+			if( errno == EADDRNOTAVAIL && to.type == NA_BROADCAST )
+				return;
+#endif
+		}
 		if( host.type == HOST_DEDICATED )
 		{
 			MsgDev( D_ERROR, "NET_SendPacket: %s to %s\n", NET_ErrorString(), NET_AdrToString( to ));
 		}
+#ifdef _WIN32
 		else if( err == WSAEADDRNOTAVAIL || err == WSAENOBUFS )
+#else
+		else if( err == EADDRNOTAVAIL || err == ENOBUFS )
+#endif
 		{
 			MsgDev( D_ERROR, "NET_SendPacket: %s to %s\n", NET_ErrorString(), NET_AdrToString( to ));
 		}
@@ -1070,6 +1467,7 @@ void NET_SendPacket( netsrc_t sock, size_t length, const void *data, netadr_t to
 			Host_Error( "NET_SendPacket: %s to %s\n", NET_ErrorString(), NET_AdrToString( to ));
 		}
 	}
+
 }
 
 /*
@@ -1141,36 +1539,41 @@ NET_IPSocket
 */
 static int NET_IPSocket( const char *net_interface, int port, qboolean multicast )
 {
+	struct sockaddr_in	addr;
 	int		err, net_socket;
 	uint		optval = 1;
-	struct sockaddr_in	addr;
+	dword		_true = 1;
 
-	if(( net_socket = pSocket( PF_INET, SOCK_DGRAM, IPPROTO_UDP )) == SOCKET_ERROR )
+	if( NET_IsSocketError(( net_socket = pSocket( PF_INET, SOCK_DGRAM, IPPROTO_UDP )) ) )
 	{
-		err = pWSAGetLastError();
+#ifdef _WIN32
+		int err = pWSAGetLastError();
 		if( err != WSAEAFNOSUPPORT )
-			MsgDev( D_WARN, "NET_UDPSocket: port: %d socket: %s\n", port, NET_ErrorString( ));
+#else
+		if( err != EAFNOSUPPORT )
+#endif
+			MsgDev( D_WARN, "NET_UDPSocket: socket = %s\n", NET_ErrorString( ));
 		return INVALID_SOCKET;
 	}
 
-	if( pIoctlSocket( net_socket, FIONBIO, &optval ) == SOCKET_ERROR )
+	if( NET_IsSocketError( pIoctlSocket( net_socket, FIONBIO, &_true ) ) )
 	{
-		MsgDev( D_WARN, "NET_UDPSocket: port: %d ioctl FIONBIO: %s\n", port, NET_ErrorString( ));
+		MsgDev( D_WARN, "NET_UDPSocket: ioctlsocket FIONBIO = %s\n", NET_ErrorString( ));
 		pCloseSocket( net_socket );
 		return INVALID_SOCKET;
 	}
 
 	// make it broadcast capable
-	if( pSetSockopt( net_socket, SOL_SOCKET, SO_BROADCAST, (const char *)&optval, sizeof( optval )) == SOCKET_ERROR )
+	if( NET_IsSocketError( pSetSockopt( net_socket, SOL_SOCKET, SO_BROADCAST, (char *)&_true, sizeof( _true ) ) ) )
 	{
-		MsgDev( D_WARN, "NET_UDPSocket: port: %d setsockopt SO_BROADCAST: %s\n", port, NET_ErrorString( ));
+		MsgDev( D_WARN, "NET_UDPSocket: setsockopt SO_BROADCAST = %s\n", NET_ErrorString( ));
 		pCloseSocket( net_socket );
 		return INVALID_SOCKET;
 	}
 
 	if( Sys_CheckParm( "-reuse" ) || multicast )
 	{
-		if( pSetSockopt( net_socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof( optval )) == SOCKET_ERROR )
+		if( NET_IsSocketError( pSetSockopt( net_socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof( optval )) ) )
 		{
 			MsgDev( D_WARN, "NET_UDPSocket: port: %d setsockopt SO_REUSEADDR: %s\n", port, NET_ErrorString( ));
 			pCloseSocket( net_socket );
@@ -1183,10 +1586,14 @@ static int NET_IPSocket( const char *net_interface, int port, qboolean multicast
 		optval = 16;
 		Con_Printf( "Enabling LOWDELAY TOS option\n" );
 
-		if( pSetSockopt( net_socket, IPPROTO_IP, IP_TOS, (const char *)&optval, sizeof( optval )) == SOCKET_ERROR )
+		if( NET_IsSocketError( pSetSockopt( net_socket, IPPROTO_IP, IP_TOS, (const char *)&optval, sizeof( optval )) ) )
 		{
+#ifdef _WIN32
 			err = pWSAGetLastError();
 			if( err != WSAENOPROTOOPT )
+#else
+			if( errno != ENOPROTOOPT )
+#endif
 				Con_Printf( S_WARN "NET_UDPSocket: port: %d  setsockopt IP_TOS: %s\n", port, NET_ErrorString( ));
 			pCloseSocket( net_socket );
 			return INVALID_SOCKET;
@@ -1195,14 +1602,14 @@ static int NET_IPSocket( const char *net_interface, int port, qboolean multicast
 
 	if( !net_interface[0] || !Q_stricmp( net_interface, "localhost" ))
 		addr.sin_addr.s_addr = INADDR_ANY;
-	else NET_StringToSockaddr( net_interface, (struct sockaddr *)&addr );
+	else NET_StringToSockaddr( net_interface, (struct sockaddr *)&addr, false );
 
 	if( port == PORT_ANY ) addr.sin_port = 0;
 	else addr.sin_port = pHtons((short)port);
 
 	addr.sin_family = AF_INET;
 
-	if( pBind( net_socket, (void *)&addr, sizeof( addr )) == SOCKET_ERROR )
+	if( NET_IsSocketError( pBind( net_socket, (void *)&addr, sizeof( addr )) ) )
 	{
 		MsgDev( D_WARN, "NET_UDPSocket: port: %d bind: %s\n", port, NET_ErrorString( ));
 		pCloseSocket( net_socket );
@@ -1212,7 +1619,7 @@ static int NET_IPSocket( const char *net_interface, int port, qboolean multicast
 	if( Sys_CheckParm( "-loopback" ))
 	{
 		optval = 1;
-		if( pSetSockopt( net_socket, IPPROTO_IP, IP_MULTICAST_LOOP, (const char *)&optval, sizeof( optval )) == SOCKET_ERROR )
+		if( NET_IsSocketError( pSetSockopt( net_socket, IPPROTO_IP, IP_MULTICAST_LOOP, (const char *)&optval, sizeof( optval )) ) )
 			MsgDev( D_WARN, "NET_UDPSocket: port %d setsockopt IP_MULTICAST_LOOP: %s\n", port, NET_ErrorString( ));
 	}
 
@@ -1228,14 +1635,14 @@ static void NET_OpenIP( void )
 {
 	int	port, sv_port = 0, cl_port = 0;
 
-	if( net.ip_sockets[NS_SERVER] == INVALID_SOCKET )
+	if( !NET_IsSocketValid( net.ip_sockets[NS_SERVER] ) )
 	{
 		port = net_iphostport->value;
 		if( !port ) port = net_hostport->value;
 		if( !port ) port = PORT_SERVER; // forcing to default
 		net.ip_sockets[NS_SERVER] = NET_IPSocket( net_ipname->string, port, false );
 
-		if( net.ip_sockets[NS_SERVER] == INVALID_SOCKET && host.type == HOST_DEDICATED )
+		if( !NET_IsSocketValid( net.ip_sockets[NS_SERVER] ) && host.type == HOST_DEDICATED )
 			Host_Error( "Couldn't allocate dedicated server IP port %d.\n", port );
 		sv_port = port;
 	}
@@ -1243,14 +1650,14 @@ static void NET_OpenIP( void )
 	// dedicated servers don't need client ports
 	if( host.type == HOST_DEDICATED ) return;
 
-	if( net.ip_sockets[NS_CLIENT] == INVALID_SOCKET )
+	if( !NET_IsSocketValid( net.ip_sockets[NS_CLIENT] ) )
 	{
 		port = net_ipclientport->value;
 		if( !port ) port = net_clientport->value;
 		if( !port ) port = PORT_ANY; // forcing to default
 		net.ip_sockets[NS_CLIENT] = NET_IPSocket( net_ipname->string, port, false );
 
-		if( net.ip_sockets[NS_CLIENT] == INVALID_SOCKET )
+		if( !NET_IsSocketValid( net.ip_sockets[NS_CLIENT] ) )
 			net.ip_sockets[NS_CLIENT] = NET_IPSocket( net_ipname->string, PORT_ANY, false );
 		cl_port = port;
 	}
@@ -1291,7 +1698,7 @@ void NET_GetLocalAddress( void )
 		{
 			namelen = sizeof( address );
 
-			if( pGetSockName( net.ip_sockets[NS_SERVER], (struct sockaddr *)&address, &namelen ) == SOCKET_ERROR )
+			if( NET_IsSocketError( pGetSockName( net.ip_sockets[NS_SERVER], (struct sockaddr *)&address, &namelen ) ) )
 			{
 				// this may happens if multiple clients running on single machine
 				MsgDev( D_ERROR, "Could not get TCP/IP address. Reason:  %s\n", NET_ErrorString( ));
@@ -1461,6 +1868,7 @@ void NET_Init( void )
 		net.ip_sockets[i] = INVALID_SOCKET;
 	}
 
+#ifdef _WIN32
 	if( !NET_OpenWinSock( ))	// loading wsock32.dll
 	{
 		MsgDev( D_ERROR, "network failed to load wsock32.dll.\n" );
@@ -1473,6 +1881,7 @@ void NET_Init( void )
 		NET_FreeWinSock();
 		return;
 	}
+#endif
 
 	if( Sys_CheckParm( "-noip" ))
 		net.allow_ip = false;
@@ -1505,7 +1914,9 @@ void NET_Shutdown( void )
 	NET_ClearLagData( true, true );
 
 	NET_Config( false );
+#ifdef _WIN32
 	pWSACleanup();
 	NET_FreeWinSock();
+#endif
 	net.initialized = false;
-}
+}