lhnet.h File Reference

#include <stddef.h>
#include "com_list.h"

Include dependency graph for lhnet.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	lhnetaddress_t
struct	lhnetsocket_t

Enumerations
enum	lhnetaddresstype_t { LHNETADDRESSTYPE_NONE , LHNETADDRESSTYPE_LOOP , LHNETADDRESSTYPE_INET4 , LHNETADDRESSTYPE_INET6 }

Functions
lhnetaddress_t *	LHNET_AddressFromSocket (lhnetsocket_t *sock)
void	LHNET_CloseSocket (lhnetsocket_t *lhnetsocket)
int	LHNET_DefaultDSCP (int dscp)
void	LHNET_Init (void)
lhnetsocket_t *	LHNET_OpenSocket_Connectionless (lhnetaddress_t *address)
int	LHNET_Read (lhnetsocket_t *lhnetsocket, void *content, int maxcontentlength, lhnetaddress_t *address)
void	LHNET_Shutdown (void)
void	LHNET_SleepUntilPacket_Microseconds (int microseconds)
int	LHNET_Write (lhnetsocket_t *lhnetsocket, const void *content, int contentlength, const lhnetaddress_t *address)
int	LHNETADDRESS_Compare (const lhnetaddress_t *address1, const lhnetaddress_t *address2)
int	LHNETADDRESS_FromPort (lhnetaddress_t *address, lhnetaddresstype_t addresstype, int port)
int	LHNETADDRESS_FromString (lhnetaddress_t *address, const char *string, int defaultport)
static lhnetaddresstype_t	LHNETADDRESS_GetAddressType (const lhnetaddress_t *address)
const char *	LHNETADDRESS_GetInterfaceName (const lhnetaddress_t *address, char *ifname, size_t ifnamelength)
int	LHNETADDRESS_GetPort (const lhnetaddress_t *address)
int	LHNETADDRESS_SetPort (lhnetaddress_t *address, int port)
int	LHNETADDRESS_ToString (const lhnetaddress_t *address, char *string, int stringbuffersize, int includeport)
	Returns the number of bytes written to *string excluding the \0 terminator.

Variables
lhnetsocket_t	lhnet_socketlist

Enumeration Type Documentation

lhnetaddresstype_t

enum lhnetaddresstype_t

Enumerator
LHNETADDRESSTYPE_NONE
LHNETADDRESSTYPE_LOOP
LHNETADDRESSTYPE_INET4
LHNETADDRESSTYPE_INET6

Definition at line 10 of file lhnet.h.

{
    LHNETADDRESSTYPE_NONE,
    LHNETADDRESSTYPE_LOOP,
    LHNETADDRESSTYPE_INET4,
    LHNETADDRESSTYPE_INET6
}

Function Documentation

LHNET_AddressFromSocket()

lhnetaddress_t * LHNET_AddressFromSocket

(

lhnetsocket_t *

sock

)

Definition at line 1026 of file lhnet.c.

{
    if (sock)
        return &sock->address;
    else
        return NULL;
}

References lhnetsocket_t::address, and NULL.

Referenced by NetConn_ChooseClientSocketForAddress(), NetConn_ChooseServerSocketForAddress(), NetConn_OpenClientPort(), NetConn_OpenServerPort(), NetConn_Read(), NetConn_ServerParsePacket(), and NetConn_Write().

LHNET_CloseSocket()

void LHNET_CloseSocket

(

lhnetsocket_t *

lhnetsocket

)

Definition at line 1012 of file lhnet.c.

{
    if (lhnetsocket)
    {
        List_Delete(&lhnetsocket->list);
        // no special close code for loopback, just inet
        if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET4 || lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET6)
        {
            closesocket(lhnetsocket->inetsocket);
        }
        Z_Free(lhnetsocket);
    }
}

References lhnetsocket_t::address, lhnetaddress_t::addresstype, closesocket, lhnetsocket_t::inetsocket, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, lhnetsocket_t::list, List_Delete(), and Z_Free.

Referenced by LHNET_Shutdown(), NetConn_CloseClientPorts(), and NetConn_CloseServerPorts().

LHNET_DefaultDSCP()

int LHNET_DefaultDSCP

(

int

dscp

)

Definition at line 739 of file lhnet.c.

{
#ifdef IP_TOS
    int prev = lhnet_default_dscp;
    if(dscp >= 0)
        lhnet_default_dscp = dscp;
    return prev;
#else
    return -1;
#endif
}

References lhnet_default_dscp.

Referenced by NetConn_UpdateSockets().

LHNET_Init()

void LHNET_Init

(

void

)

Definition at line 725 of file lhnet.c.

{
    if (lhnet_active)
        return;
    List_Create(&lhnet_socketlist.list);
    List_Create(&lhnet_packetlist.list);
    lhnet_active = 1;
#ifdef WIN32
    lhnet_didWSAStartup = !WSAStartup(MAKEWORD(1, 1), &lhnet_winsockdata);
    if (!lhnet_didWSAStartup)
        Con_Print("LHNET_Init: WSAStartup failed, networking disabled\n");
#endif
}

References Con_Print(), lhnet_active, lhnet_packetlist, lhnet_socketlist, lhnetpacket_t::list, lhnetsocket_t::list, and List_Create().

Referenced by NetConn_Init().

LHNET_OpenSocket_Connectionless()

lhnetsocket_t * LHNET_OpenSocket_Connectionless

(

lhnetaddress_t *

address

)

Definition at line 832 of file lhnet.c.

{
    lhnetsocket_t *lhnetsocket, *s;
    if (!address)
        return NULL;
    lhnetsocket = (lhnetsocket_t *)Z_Malloc(sizeof(*lhnetsocket));
    if (lhnetsocket)
    {
        memset(lhnetsocket, 0, sizeof(*lhnetsocket));
        lhnetsocket->address = *address;
        switch(lhnetsocket->address.addresstype)
        {
        case LHNETADDRESSTYPE_LOOP:
            if (lhnetsocket->address.port == 0)
            {
                // allocate a port dynamically
                // this search will always terminate because there is never
                // an allocated socket with port 0, so if the number wraps it
                // will find the port is unused, and then refuse to use port
                // 0, causing an intentional failure condition
                lhnetsocket->address.port = 1024;
                for (;;)
                {
                    List_For_Each_Entry(s, &lhnet_socketlist.list, lhnetsocket_t, list)
                        if (s->address.addresstype == lhnetsocket->address.addresstype && s->address.port == lhnetsocket->address.port)
                            break;
                    if (s == &lhnet_socketlist)
                        break;
                    lhnetsocket->address.port++;
                }
            }
            // check if the port is available
            List_For_Each_Entry(s, &lhnet_socketlist.list, lhnetsocket_t, list)
                if (s->address.addresstype == lhnetsocket->address.addresstype && s->address.port == lhnetsocket->address.port)
                    break;
            if (s == &lhnet_socketlist && lhnetsocket->address.port != 0)
            {
                List_Add_Tail(&lhnetsocket->list, &lhnet_socketlist.list);
                return lhnetsocket;
            }
            break;
        case LHNETADDRESSTYPE_INET4:
#ifndef NOSUPPORTIPV6
        case LHNETADDRESSTYPE_INET6:
#endif
#ifdef WIN32
            if (lhnet_didWSAStartup)
            {
#endif
#ifndef NOSUPPORTIPV6
                if ((lhnetsocket->inetsocket = socket(address->addresstype == LHNETADDRESSTYPE_INET6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP)) != -1)
#else
                if ((lhnetsocket->inetsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) != -1)
#endif
                {
#ifdef WIN32
                    u_long _false = 0;
#endif
#ifdef MSG_DONTWAIT
                    if (1)
#else
#ifdef WIN32
                    u_long _true = 1;
#else
                    char _true = 1;
#endif
                    if (ioctlsocket(lhnetsocket->inetsocket, FIONBIO, &_true) != -1)
#endif
                    {
#ifdef IPV6_V6ONLY
                        // We need to set this flag to tell the OS that we only listen on IPv6. If we don't
                        // most OSes will create a dual-protocol socket that also listens on IPv4. In this case
                        // if an IPv4 socket is already bound to the port we want, our bind() call will fail.
                        int ipv6_only = 1;
                        if (address->addresstype != LHNETADDRESSTYPE_INET6
                            || setsockopt (lhnetsocket->inetsocket, IPPROTO_IPV6, IPV6_V6ONLY,
                                           (const char *)&ipv6_only, sizeof(ipv6_only)) == 0
#ifdef WIN32
                            // The Win32 API only supports IPV6_V6ONLY since Windows Vista, but fortunately
                            // the default value is what we want on Win32 anyway (IPV6_V6ONLY = true)
                            || SOCKETERRNO == WSAENOPROTOOPT
#endif
                            )
#endif
                        {
                            lhnetaddressnative_t *localaddress = (lhnetaddressnative_t *)&lhnetsocket->address;
                            SOCKLEN_T namelen;
                            int bindresult;
 
#if defined(SOL_RFC1149) && defined(RFC1149_1149ONLY)
                            // we got reports of massive lags when this protocol was chosen as transport
                            // so better turn it off
                            {
                                int rfc1149only = 0;
                                int rfc1149enabled = 0;
                                if(setsockopt(lhnetsocket->inetsocket, SOL_RFC1149, RFC1149_1149ONLY, &rfc1149only))
                                    Con_Printf(CON_ERROR "LHNET_OpenSocket_Connectionless: warning: setsockopt(RFC1149_1149ONLY) returned error: %s\n", LHNETPRIVATE_StrError());
                                if(setsockopt(lhnetsocket->inetsocket, SOL_RFC1149, RFC1149_ENABLED, &rfc1149enabled))
                                    Con_Printf(CON_ERROR "LHNET_OpenSocket_Connectionless: warning: setsockopt(RFC1149_ENABLED) returned error: %s\n", LHNETPRIVATE_StrError());
                            }
#endif
 
#ifndef NOSUPPORTIPV6
                            if (address->addresstype == LHNETADDRESSTYPE_INET6)
                            {
                                namelen = sizeof(localaddress->addr.in6);
                                bindresult = bind(lhnetsocket->inetsocket, &localaddress->addr.sock, namelen);
                                if (bindresult != -1)
                                {
                                    if (getsockname(lhnetsocket->inetsocket, &localaddress->addr.sock, &namelen))
                                    {
                                        // If getsockname failed, we can assume the bound socket is useless.
                                        bindresult = -1;
                                    }
                                }
                            }
                            else
#endif
                            {
                                namelen = sizeof(localaddress->addr.in);
                                bindresult = bind(lhnetsocket->inetsocket, &localaddress->addr.sock, namelen);
                                if (bindresult != -1)
                                {
                                    if (getsockname(lhnetsocket->inetsocket, &localaddress->addr.sock, &namelen))
                                    {
                                        // If getsockname failed, we can assume the bound socket is useless.
                                        bindresult = -1;
                                    }
                                }
                            }
                            if (bindresult != -1)
                            {
                                int i = 1;
                                // enable broadcast on this socket
                                setsockopt(lhnetsocket->inetsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i));
#ifdef IP_TOS
                                {
                                    // enable DSCP for ToS support
                                    int tos = lhnet_default_dscp << 2;
                                    if (setsockopt(lhnetsocket->inetsocket, IPPROTO_IP, IP_TOS, (char *) &tos, sizeof(tos)))
                                    {
                                        // Error in setsockopt - fine, we'll simply set no TOS then.
                                    }
                                }
#endif
                                List_Add_Tail(&lhnetsocket->list, &lhnet_socketlist.list);
#ifdef WIN32
                                if (ioctlsocket(lhnetsocket->inetsocket, SIO_UDP_CONNRESET, &_false) == -1)
                                    Con_DPrintf("LHNET_OpenSocket_Connectionless: ioctlsocket SIO_UDP_CONNRESET returned error: %s\n", LHNETPRIVATE_StrError());
#endif
                                return lhnetsocket;
                            }
                            else
                                Con_Printf("LHNET_OpenSocket_Connectionless: bind returned error: %s\n", LHNETPRIVATE_StrError());
                        }
#ifdef IPV6_V6ONLY
                        else
                            Con_Printf("LHNET_OpenSocket_Connectionless: setsockopt(IPV6_V6ONLY) returned error: %s\n", LHNETPRIVATE_StrError());
#endif
                    }
                    else
                        Con_Printf("LHNET_OpenSocket_Connectionless: ioctlsocket returned error: %s\n", LHNETPRIVATE_StrError());
                    closesocket(lhnetsocket->inetsocket);
                }
                else
                    Con_Printf("LHNET_OpenSocket_Connectionless: socket returned error: %s\n", LHNETPRIVATE_StrError());
#ifdef WIN32
            }
            else
                Con_Print("LHNET_OpenSocket_Connectionless: can't open a socket (WSAStartup failed during LHNET_Init)\n");
#endif
            break;
        default:
            break;
        }
        Z_Free(lhnetsocket);
    }
    return NULL;
}

References lhnetaddressnative_t::addr, lhnetsocket_t::address, lhnetaddress_t::addresstype, closesocket, Con_DPrintf(), CON_ERROR, Con_Print(), Con_Printf(), i, lhnetaddressnative_t::in, lhnetaddressnative_t::in6, lhnetsocket_t::inetsocket, ioctlsocket, lhnet_default_dscp, lhnet_socketlist, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, LHNETPRIVATE_StrError(), lhnetsocket_t::list, List_Add_Tail(), List_For_Each_Entry, NULL, lhnetaddress_t::port, lhnetaddressnative_t::sock, SOCKETERRNO, SOCKLEN_T, Z_Free, and Z_Malloc.

Referenced by NetConn_OpenClientPort(), and NetConn_OpenServerPort().

LHNET_Read()

int LHNET_Read	(	lhnetsocket_t *	lhnetsocket,
		void *	content,
		int	maxcontentlength,
		lhnetaddress_t *	address )

Definition at line 1034 of file lhnet.c.

{
    lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
    int value = 0;
    if (!lhnetsocket || !address || !content || maxcontentlength < 1)
        return -1;
    if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_LOOP)
    {
        time_t currenttime;
        lhnetpacket_t *p, *pnext;
        // scan for any old packets to timeout while searching for a packet
        // that is waiting to be delivered to this socket
        currenttime = time(NULL);
        List_For_Each_Entry_Safe(p, pnext, &lhnet_packetlist.list, lhnetpacket_t, list)
        {
            if (p->timeout < currenttime)
            {
                // unlink and free
                List_Delete(&p->list);
                Z_Free(p);
                continue;
            }
#ifndef STANDALONETEST
            if (net_fakelag.value && (host.realtime - net_fakelag.value * (1.0 / 2000.0)) < p->sentdoubletime)
                continue;
#endif
            if (value == 0 && p->destinationport == lhnetsocket->address.port)
            {
                if (p->length <= maxcontentlength)
                {
                    lhnetaddressnative_t *localaddress = (lhnetaddressnative_t *)&lhnetsocket->address;
                    *address = *localaddress;
                    address->port = p->sourceport;
                    memcpy(content, p->data, p->length);
                    value = p->length;
                }
                else
                    value = -1;
                // unlink and free
                List_Delete(&p->list);
                Z_Free(p);
            }
        }
    }
    else if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET4)
    {
        SOCKLEN_T inetaddresslength;
        address->addresstype = LHNETADDRESSTYPE_NONE;
        inetaddresslength = sizeof(address->addr.in);
        value = recvfrom(lhnetsocket->inetsocket, (char *)content, maxcontentlength, LHNET_RECVFROM_FLAGS, &address->addr.sock, &inetaddresslength);
        if (value > 0)
        {
            address->addresstype = LHNETADDRESSTYPE_INET4;
            address->port = ntohs(address->addr.in.sin_port);
            return value;
        }
        else if (value < 0)
        {
            int e = SOCKETERRNO;
            if (e == EWOULDBLOCK)
                return 0;
            switch (e)
            {
                case ECONNREFUSED:
                    Con_Print("Connection refused\n");
                    return 0;
            }
            Con_DPrintf("LHNET_Read: recvfrom returned error: %s\n", LHNETPRIVATE_StrError());
        }
    }
#ifndef NOSUPPORTIPV6
    else if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET6)
    {
        SOCKLEN_T inetaddresslength;
        address->addresstype = LHNETADDRESSTYPE_NONE;
        inetaddresslength = sizeof(address->addr.in6);
        value = recvfrom(lhnetsocket->inetsocket, (char *)content, maxcontentlength, LHNET_RECVFROM_FLAGS, &address->addr.sock, &inetaddresslength);
        if (value > 0)
        {
            address->addresstype = LHNETADDRESSTYPE_INET6;
            address->port = ntohs(address->addr.in6.sin6_port);
            return value;
        }
        else if (value == -1)
        {
            int e = SOCKETERRNO;
            if (e == EWOULDBLOCK)
                return 0;
            switch (e)
            {
                case ECONNREFUSED:
                    Con_Print("Connection refused\n");
                    return 0;
            }
            Con_DPrintf("LHNET_Read: recvfrom returned error: %s\n", LHNETPRIVATE_StrError());
        }
    }
#endif
    return value;
}

References lhnetaddressnative_t::addr, lhnetsocket_t::address, lhnetaddress_t::addresstype, lhnetaddressnative_t::addresstype, Con_DPrintf(), Con_Print(), lhnetpacket_t::data, lhnetpacket_t::destinationport, host, lhnetaddressnative_t::in, lhnetaddressnative_t::in6, lhnetsocket_t::inetsocket, lhnetpacket_t::length, lhnet_packetlist, LHNET_RECVFROM_FLAGS, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, LHNETADDRESSTYPE_NONE, LHNETPRIVATE_StrError(), lhnetpacket_t::list, List_Delete(), List_For_Each_Entry_Safe, net_fakelag, NULL, lhnetaddress_t::port, lhnetaddressnative_t::port, host_static_t::realtime, lhnetpacket_t::sentdoubletime, lhnetaddressnative_t::sock, SOCKETERRNO, SOCKLEN_T, lhnetpacket_t::sourceport, time, lhnetpacket_t::timeout, cvar_t::value, value, and Z_Free.

Referenced by NetConn_Read().

LHNET_Shutdown()

void LHNET_Shutdown

(

void

)

Definition at line 751 of file lhnet.c.

{
    lhnetsocket_t *s, *snext;
    lhnetpacket_t *p, *pnext;
    if (!lhnet_active)
        return;
    List_For_Each_Entry_Safe(s, snext, &lhnet_socketlist.list, lhnetsocket_t, list)
        LHNET_CloseSocket(s);
    List_For_Each_Entry_Safe(p, pnext, &lhnet_packetlist.list, lhnetpacket_t, list)
    {
        List_Delete(&p->list);
        Z_Free(p);
    }
#ifdef WIN32
    if (lhnet_didWSAStartup)
    {
        lhnet_didWSAStartup = 0;
        WSACleanup();
    }
#endif
    lhnet_active = 0;
}

References lhnet_active, LHNET_CloseSocket(), lhnet_packetlist, lhnet_socketlist, lhnetpacket_t::list, lhnetsocket_t::list, List_Delete(), List_For_Each_Entry_Safe, and Z_Free.

Referenced by NetConn_Shutdown().

LHNET_SleepUntilPacket_Microseconds()

void LHNET_SleepUntilPacket_Microseconds

(

int

microseconds

)

LHNET_Write()

int LHNET_Write	(	lhnetsocket_t *	lhnetsocket,
		const void *	content,
		int	contentlength,
		const lhnetaddress_t *	address )

Definition at line 1135 of file lhnet.c.

{
    lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
    int value = -1;
    if (!lhnetsocket || !address || !content || contentlength < 1)
        return -1;
    if (lhnetsocket->address.addresstype != address->addresstype)
        return -1;
    if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_LOOP)
    {
        lhnetpacket_t *p;
        p = (lhnetpacket_t *)Z_Malloc(sizeof(*p) + contentlength);
        p->data = (void *)(p + 1);
        memcpy(p->data, content, contentlength);
        p->length = contentlength;
        p->sourceport = lhnetsocket->address.port;
        p->destinationport = address->port;
        p->timeout = time(NULL) + 10;
        List_Add_Tail(&p->list, &lhnet_packetlist.list);
 
#ifndef STANDALONETEST
        p->sentdoubletime = host.realtime;
#endif
        value = contentlength;
    }
    else if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET4)
    {
        value = sendto(lhnetsocket->inetsocket, (char *)content, contentlength, LHNET_SENDTO_FLAGS, (struct sockaddr *)&address->addr.in, sizeof(struct sockaddr_in));
        if (value == -1)
        {
            if (SOCKETERRNO == EWOULDBLOCK)
                return 0;
            Con_DPrintf("LHNET_Write: sendto returned error: %s\n", LHNETPRIVATE_StrError());
        }
    }
#ifndef NOSUPPORTIPV6
    else if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET6)
    {
        value = sendto(lhnetsocket->inetsocket, (char *)content, contentlength, 0, (struct sockaddr *)&address->addr.in6, sizeof(struct sockaddr_in6));
        if (value == -1)
        {
            if (SOCKETERRNO == EWOULDBLOCK)
                return 0;
            Con_DPrintf("LHNET_Write: sendto returned error: %s\n", LHNETPRIVATE_StrError());
        }
    }
#endif
    return value;
}

References lhnetaddressnative_t::addr, lhnetsocket_t::address, lhnetaddress_t::addresstype, lhnetaddressnative_t::addresstype, Con_DPrintf(), lhnetpacket_t::data, lhnetpacket_t::destinationport, host, lhnetaddressnative_t::in, lhnetaddressnative_t::in6, lhnetsocket_t::inetsocket, lhnetpacket_t::length, lhnet_packetlist, LHNET_SENDTO_FLAGS, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, LHNETPRIVATE_StrError(), lhnetpacket_t::list, List_Add_Tail(), NULL, lhnetaddress_t::port, lhnetaddressnative_t::port, host_static_t::realtime, lhnetpacket_t::sentdoubletime, SOCKETERRNO, lhnetpacket_t::sourceport, time, lhnetpacket_t::timeout, value, and Z_Malloc.

Referenced by NetConn_Write().

LHNETADDRESS_Compare()

int LHNETADDRESS_Compare	(	const lhnetaddress_t *	address1,
		const lhnetaddress_t *	address2 )

Definition at line 665 of file lhnet.c.

{
    lhnetaddressnative_t *address1 = (lhnetaddressnative_t *)vaddress1;
    lhnetaddressnative_t *address2 = (lhnetaddressnative_t *)vaddress2;
    if (!address1 || !address2)
        return 1;
    if (address1->addresstype != address2->addresstype)
        return 1;
    switch(address1->addresstype)
    {
    case LHNETADDRESSTYPE_LOOP:
        if (address1->port != address2->port)
            return -1;
        return 0;
    case LHNETADDRESSTYPE_INET4:
        if (address1->addr.in.sin_family != address2->addr.in.sin_family)
            return 1;
        if (memcmp(&address1->addr.in.sin_addr, &address2->addr.in.sin_addr, sizeof(address1->addr.in.sin_addr)))
            return 1;
        if (address1->port != address2->port)
            return -1;
        return 0;
#ifndef NOSUPPORTIPV6
    case LHNETADDRESSTYPE_INET6:
        if (address1->addr.in6.sin6_family != address2->addr.in6.sin6_family)
            return 1;
        if (memcmp(&address1->addr.in6.sin6_addr, &address2->addr.in6.sin6_addr, sizeof(address1->addr.in6.sin6_addr)))
            return 1;
        if (address1->port != address2->port)
            return -1;
        return 0;
#endif
    default:
        return 1;
    }
}

References lhnetaddressnative_t::addr, lhnetaddressnative_t::addresstype, lhnetaddressnative_t::in, lhnetaddressnative_t::in6, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, and lhnetaddressnative_t::port.

Referenced by CL_Rcon_f(), Crypto_ClearHostKey(), Crypto_ClientParsePacket(), Crypto_RetrieveHostKey(), Crypto_ServerFindInstance(), Crypto_ServerParsePacket_Internal(), Crypto_StoreHostKey(), hmac_mdfour_challenge_matching(), NetConn_ClearFlood(), NetConn_ClientParsePacket(), NetConn_PreventFlood(), and NetConn_ServerParsePacket().

LHNETADDRESS_FromPort()

int LHNETADDRESS_FromPort	(	lhnetaddress_t *	address,
		lhnetaddresstype_t	addresstype,
		int	port )

Definition at line 125 of file lhnet.c.

{
    lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
    if (!address)
        return 0;
    switch(addresstype)
    {
    default:
        break;
    case LHNETADDRESSTYPE_LOOP:
        // local:port  (loopback)
        memset(address, 0, sizeof(*address));
        address->addresstype = LHNETADDRESSTYPE_LOOP;
        address->port = port;
        return 1;
    case LHNETADDRESSTYPE_INET4:
        // 0.0.0.0:port  (INADDR_ANY, binds to all interfaces)
        memset(address, 0, sizeof(*address));
        address->addresstype = LHNETADDRESSTYPE_INET4;
        address->port = port;
        address->addr.in.sin_family = AF_INET;
        address->addr.in.sin_port = htons((unsigned short)port);
        return 1;
#ifndef NOSUPPORTIPV6
    case LHNETADDRESSTYPE_INET6:
        // [0:0:0:0:0:0:0:0]:port  (IN6ADDR_ANY, binds to all interfaces)
        memset(address, 0, sizeof(*address));
        address->addresstype = LHNETADDRESSTYPE_INET6;
        address->port = port;
        address->addr.in6.sin6_family = AF_INET6;
        address->addr.in6.sin6_port = htons((unsigned short)port);
        return 1;
#endif
    }
    return 0;
}

References lhnetaddressnative_t::addr, lhnetaddressnative_t::addresstype, lhnetaddressnative_t::in, lhnetaddressnative_t::in6, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, and lhnetaddressnative_t::port.

Referenced by NetConn_OpenClientPort(), and NetConn_OpenServerPort().

LHNETADDRESS_FromString()

int LHNETADDRESS_FromString	(	lhnetaddress_t *	address,
		const char *	string,
		int	defaultport )

Definition at line 204 of file lhnet.c.

{
    lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
    int i, port, d1, d2, d3, d4, resolved;
    size_t namelen;
    unsigned char *a;
    char name[128];
#ifdef STANDALONETEST
    char string2[128];
#endif
    const char* addr_start;
    const char* addr_end = NULL;
    const char* port_name = NULL;
    int addr_family = AF_UNSPEC;
 
    if (!address || !string || !*string)
        return 0;
    memset(address, 0, sizeof(*address));
    address->addresstype = LHNETADDRESSTYPE_NONE;
    port = 0;
 
    // If it's a bracketed IPv6 address
    if (string[0] == '[')
    {
        const char* end_bracket = strchr(string, ']');
 
        if (end_bracket == NULL)
            return 0;
 
        if (end_bracket[1] == ':')
            port_name = end_bracket + 2;
        else if (end_bracket[1] != '\0')
            return 0;
 
        addr_family = AF_INET6;
        addr_start = &string[1];
        addr_end = end_bracket;
    }
    else
    {
        const char* first_colon;
 
        addr_start = string;
 
        // If it's a numeric non-bracket IPv6 address (-> no port),
        // or it's a numeric IPv4 address, or a name, with a port
        first_colon = strchr(string, ':');
        if (first_colon != NULL)
        {
            const char* last_colon = strrchr(first_colon + 1, ':');
 
            // If it's an numeric IPv4 address, or a name, with a port
            if (last_colon == NULL)
            {
                addr_end = first_colon;
                port_name = first_colon + 1;
            }
            else
                addr_family = AF_INET6;
        }
    }
 
    if (addr_end != NULL)
        namelen = addr_end - addr_start;
    else
        namelen = strlen (addr_start);
 
    if (namelen >= sizeof(name))
        namelen = sizeof(name) - 1;
    memcpy (name, addr_start, namelen);
    name[namelen] = 0;
 
    if (port_name)
        port = atoi(port_name);
 
    if (port == 0)
        port = defaultport;
 
    // handle loopback
    if (!strcmp(name, "local"))
    {
        address->addresstype = LHNETADDRESSTYPE_LOOP;
        address->port = port;
        return 1;
    }
    // try to parse as dotted decimal ipv4 address first
    // note this supports partial ip addresses
    d1 = d2 = d3 = d4 = 0;
#if _MSC_VER >= 1400
#define sscanf sscanf_s
#endif
    if (addr_family != AF_INET6 &&
        sscanf(name, "%d.%d.%d.%d", &d1, &d2, &d3, &d4) >= 1 && (unsigned int)d1 < 256 && (unsigned int)d2 < 256 && (unsigned int)d3 < 256 && (unsigned int)d4 < 256)
    {
        // parsed a valid ipv4 address
        address->addresstype = LHNETADDRESSTYPE_INET4;
        address->port = port;
        address->addr.in.sin_family = AF_INET;
        address->addr.in.sin_port = htons((unsigned short)port);
        a = (unsigned char *)&address->addr.in.sin_addr;
        a[0] = d1;
        a[1] = d2;
        a[2] = d3;
        a[3] = d4;
#ifdef STANDALONETEST
        LHNETADDRESS_ToString(address, string2, sizeof(string2), 1);
        printf("manual parsing of ipv4 dotted decimal address \"%s\" successful: %s\n", string, string2);
#endif
        return 1;
    }
    for (i = 0;i < MAX_NAMECACHE;i++)
        if (!strcmp(namecache[i].name, name))
            break;
#ifdef STANDALONETEST
    if (i < MAX_NAMECACHE)
#else
    if (i < MAX_NAMECACHE && host.realtime < namecache[i].expirationtime)
#endif
    {
        *address = namecache[i].address;
        address->port = port;
        if (address->addresstype == LHNETADDRESSTYPE_INET6)
        {
            address->addr.in6.sin6_port = htons((unsigned short)port);
            return 1;
        }
        else if (address->addresstype == LHNETADDRESSTYPE_INET4)
        {
            address->addr.in.sin_port = htons((unsigned short)port);
            return 1;
        }
        return 0;
    }
 
    for (i = 0;i < (int)sizeof(namecache[namecacheposition].name)-1 && name[i];i++)
        namecache[namecacheposition].name[i] = name[i];
    namecache[namecacheposition].name[i] = 0;
#ifndef STANDALONETEST
    namecache[namecacheposition].expirationtime = host.realtime + 12 * 3600; // 12 hours
#endif
 
    // try resolving the address (handles dns and other ip formats)
    resolved = LHNETADDRESS_Resolve(address, name, port);
    if (resolved)
    {
#ifdef STANDALONETEST
        const char *protoname;
 
        switch (address->addresstype)
        {
            case LHNETADDRESSTYPE_INET6:
                protoname = "ipv6";
                break;
            case LHNETADDRESSTYPE_INET4:
                protoname = "ipv4";
                break;
            default:
                protoname = "UNKNOWN";
                break;
        }
        LHNETADDRESS_ToString(vaddress, string2, sizeof(string2), 1);
        Con_Printf("LHNETADDRESS_Resolve(\"%s\") returned %s address %s\n", string, protoname, string2);
#endif
        namecache[namecacheposition].address = *address;
    }
    else
    {
#ifdef STANDALONETEST
        printf("name resolution failed on address \"%s\"\n", name);
#endif
        namecache[namecacheposition].address.addresstype = LHNETADDRESSTYPE_NONE;
    }
    
    namecacheposition = (namecacheposition + 1) % MAX_NAMECACHE;
    return resolved;
}

References a, lhnetaddressnative_t::addr, namecache_s::address, lhnetaddressnative_t::addresstype, Con_Printf(), namecache_s::expirationtime, host, i, lhnetaddressnative_t::in, lhnetaddressnative_t::in6, int(), LHNETADDRESS_Resolve(), LHNETADDRESS_ToString(), LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, LHNETADDRESSTYPE_NONE, MAX_NAMECACHE, name, namecache_s::name, namecache, namecacheposition, NULL, lhnetaddressnative_t::port, host_static_t::realtime, string, and strlen().

Referenced by CL_EstablishConnection(), CL_Packet_f(), CL_PQRcon_f(), CL_Rcon_f(), Crypto_HostKey_Clear_f(), Log_DestBuffer_Flush_NoLock(), NetConn_Heartbeat(), NetConn_Init(), NetConn_OpenClientPort(), NetConn_OpenServerPort(), VM_M_crypto_getencryptlevel(), VM_M_crypto_getidfp(), VM_M_crypto_getidstatus(), VM_M_crypto_getkeyfp(), and VM_netaddress_resolve().

LHNETADDRESS_GetAddressType()

static lhnetaddresstype_t LHNETADDRESS_GetAddressType ( const lhnetaddress_t * address )

inlinestatic

Definition at line 31 of file lhnet.h.

{
    if (address)
        return address->addresstype;
    else
        return LHNETADDRESSTYPE_NONE;
}

References lhnetaddress_t::addresstype, and LHNETADDRESSTYPE_NONE.

Referenced by Crypto_ServerParsePacket_Internal(), NetConn_ChooseClientSocketForAddress(), NetConn_ChooseServerSocketForAddress(), NetConn_ServerParsePacket(), RCon_Execute(), SV_Pause_f(), SV_SendClientDatagram(), and SV_Status_f().

LHNETADDRESS_GetInterfaceName()

const char * LHNETADDRESS_GetInterfaceName	(	const lhnetaddress_t *	address,
		char *	ifname,
		size_t	ifnamelength )

Definition at line 608 of file lhnet.c.

{
#ifndef NOSUPPORTIPV6
    lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
 
    if (address && address->addresstype == LHNETADDRESSTYPE_INET6)
    {
#ifndef _WIN32
 
        if (if_indextoname(address->addr.in6.sin6_scope_id, ifname) == ifname)
            return ifname;
 
#else
 
        // The Win32 API doesn't have if_indextoname() until Windows Vista,
        // but luckily it just uses the interface ID as the interface name
 
        if (dpsnprintf(ifname, ifnamelength, "%lu", address->addr.in6.sin6_scope_id) > 0)
            return ifname;
 
#endif
    }
#endif
 
    return NULL;
}

References lhnetaddressnative_t::addr, lhnetaddressnative_t::addresstype, dpsnprintf(), lhnetaddressnative_t::in6, LHNETADDRESSTYPE_INET6, and NULL.

LHNETADDRESS_GetPort()

int LHNETADDRESS_GetPort

(

const lhnetaddress_t *

address

)

Definition at line 635 of file lhnet.c.

{
    if (!address)
        return -1;
    return address->port;
}

References lhnetaddress_t::port.

Referenced by NetConn_ServerParsePacket().

LHNETADDRESS_SetPort()

int LHNETADDRESS_SetPort	(	lhnetaddress_t *	address,
		int	port )

Definition at line 642 of file lhnet.c.

{
    lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
    if (!address)
        return 0;
    address->port = port;
    switch(address->addresstype)
    {
    case LHNETADDRESSTYPE_LOOP:
        return 1;
    case LHNETADDRESSTYPE_INET4:
        address->addr.in.sin_port = htons((unsigned short)port);
        return 1;
#ifndef NOSUPPORTIPV6
    case LHNETADDRESSTYPE_INET6:
        address->addr.in6.sin6_port = htons((unsigned short)port);
        return 1;
#endif
    default:
        return 0;
    }
}

References lhnetaddressnative_t::addr, lhnetaddressnative_t::addresstype, lhnetaddressnative_t::in, lhnetaddressnative_t::in6, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, and lhnetaddressnative_t::port.

Referenced by NetConn_ClearFlood(), NetConn_ClientParsePacket(), and NetConn_PreventFlood().

LHNETADDRESS_ToString()

int LHNETADDRESS_ToString	(	const lhnetaddress_t *	address,
		char *	string,
		int	stringbuffersize,
		int	includeport )

Returns the number of bytes written to *string excluding the \0 terminator.

Definition at line 540 of file lhnet.c.

{
    lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
    const unsigned char *a;
    if (!address || !string || stringbuffersize < 1)
        return 0;
    *string = 0;
    switch(address->addresstype)
    {
    default:
        break;
    case LHNETADDRESSTYPE_LOOP:
        if (includeport)
        {
            if (stringbuffersize >= 12)
            {
                return dpsnprintf(string, stringbuffersize, "local:%d", address->port);
            }
        }
        else
        {
            if (stringbuffersize >= 6)
            {
                memcpy(string, "local", 6);
                return 5;
            }
        }
        break;
    case LHNETADDRESSTYPE_INET4:
        a = (const unsigned char *)(&address->addr.in.sin_addr);
        if (includeport)
        {
            if (stringbuffersize >= 22)
            {
                return dpsnprintf(string, stringbuffersize, "%d.%d.%d.%d:%d", a[0], a[1], a[2], a[3], address->port);
            }
        }
        else
        {
            if (stringbuffersize >= 16)
            {
                return dpsnprintf(string, stringbuffersize, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
            }
        }
        break;
#ifndef NOSUPPORTIPV6
    case LHNETADDRESSTYPE_INET6:
        a = (const unsigned char *)(&address->addr.in6.sin6_addr);
        if (includeport)
        {
            if (stringbuffersize >= 88)
            {
                return dpsnprintf(string, stringbuffersize, "[%x:%x:%x:%x:%x:%x:%x:%x]:%d", a[0] * 256 + a[1], a[2] * 256 + a[3], a[4] * 256 + a[5], a[6] * 256 + a[7], a[8] * 256 + a[9], a[10] * 256 + a[11], a[12] * 256 + a[13], a[14] * 256 + a[15], address->port);
            }
        }
        else
        {
            if (stringbuffersize >= 80)
            {
                return dpsnprintf(string, stringbuffersize, "%x:%x:%x:%x:%x:%x:%x:%x", a[0] * 256 + a[1], a[2] * 256 + a[3], a[4] * 256 + a[5], a[6] * 256 + a[7], a[8] * 256 + a[9], a[10] * 256 + a[11], a[12] * 256 + a[13], a[14] * 256 + a[15]);
            }
        }
        break;
#endif
    }
    return 0;
}

References a, lhnetaddressnative_t::addr, lhnetaddressnative_t::addresstype, dpsnprintf(), lhnetaddressnative_t::in, lhnetaddressnative_t::in6, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, LHNETADDRESSTYPE_LOOP, and lhnetaddressnative_t::port.

Referenced by CL_Rcon_f(), Crypto_ClearHostKey(), Crypto_HostKeys_f(), Crypto_RetrieveHostKey(), Crypto_StoreHostKey(), LHNETADDRESS_FromString(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_Open(), NetConn_OpenClientPort(), NetConn_OpenServerPort(), NetConn_Read(), NetConn_ServerParsePacket(), NetConn_UpdateSockets(), NetConn_Write(), SV_SendServerinfo(), SVVM_init_edict(), and VM_netaddress_resolve().

Variable Documentation

lhnet_socketlist

lhnetsocket_t lhnet_socketlist

extern

Definition at line 717 of file lhnet.c.

Referenced by LHNET_Init(), LHNET_OpenSocket_Connectionless(), LHNET_Shutdown(), and Sys_Sleep().