net.c File Reference

#include "shared/shared.h"
#include "common/common.h"
#include "common/cvar.h"
#include "common/fifo.h"
#include "common/msg.h"
#include "common/net/net.h"
#include "common/protocol.h"
#include "common/zone.h"
#include "client/client.h"
#include "server/server.h"
#include "system/system.h"
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include "inet_ntop.h"
#include "inet_pton.h"
#include "win.h"

Go to the source code of this file.

Macros
#define	WIN32_LEAN_AND_MEAN
#define	MAX_ERROR_RETRIES   64
#define	NS_INT16SZ   2
#define	NS_INADDRSZ   4
#define	NS_IN6ADDRSZ   16
#define	RATE_SECS   3

Functions
static size_t	NET_NetadrToSockadr (const netadr_t *a, struct sockaddr_storage *s)
static void	NET_SockadrToNetadr (const struct sockaddr_storage *s, netadr_t *a)
char *	NET_BaseAdrToString (const netadr_t *a)
char *	NET_AdrToString (const netadr_t *a)
static struct addrinfo *	NET_SearchAdrrInfo (struct addrinfo *rp, int family)
qboolean	NET_StringPairToAdr (const char *host, const char *port, netadr_t *a)
qboolean	NET_StringToAdr (const char *s, netadr_t *a, int default_port)
void	NET_UpdateStats (void)
static void	NET_Stats_f (void)
static size_t	NET_UpRate_m (char *buffer, size_t size)
static size_t	NET_DnRate_m (char *buffer, size_t size)
const char *	NET_ErrorString (void)
ioentry_t *	NET_AddFd (qsocket_t fd)
void	NET_RemoveFd (qsocket_t fd)
int	NET_Sleep (int msec)
static void	NET_GetUdpPackets (qsocket_t sock, void(*packet_cb)(void))
void	NET_GetPackets (netsrc_t sock, void(*packet_cb)(void))
qboolean	NET_SendPacket (netsrc_t sock, const void *data, size_t len, const netadr_t *to)
static qsocket_t	UDP_OpenSocket (const char *iface, int port, int family)
static qsocket_t	TCP_OpenSocket (const char *iface, int port, int family, netsrc_t who)
static void	NET_OpenServer (void)
static void	NET_OpenServer6 (void)
void	NET_Config (netflag_t flag)
qboolean	NET_GetAddress (netsrc_t sock, netadr_t *adr)
void	NET_CloseStream (netstream_t *s)
static neterr_t	NET_Listen4 (qboolean arg)
static neterr_t	NET_Listen6 (qboolean arg)
neterr_t	NET_Listen (qboolean arg)
static neterr_t	NET_AcceptSocket (netstream_t *s, qsocket_t sock)
neterr_t	NET_Accept (netstream_t *s)
neterr_t	NET_Connect (const netadr_t *peer, netstream_t *s)
neterr_t	NET_RunConnect (netstream_t *s)
void	NET_UpdateStream (netstream_t *s)
neterr_t	NET_RunStream (netstream_t *s)
static void	dump_addrinfo (struct addrinfo *ai)
static void	dump_socket (qsocket_t s, const char *s1, const char *s2)
static void	NET_ShowIP_f (void)
static void	NET_Dns_f (void)
static void	NET_Restart_f (void)
static void	net_udp_param_changed (cvar_t *self)
static const char *	NET_EnableIP6 (void)
void	NET_Init (void)
void	NET_Shutdown (void)

Variables
cvar_t *	net_ip
cvar_t *	net_ip6
cvar_t *	net_port
netadr_t	net_from
static cvar_t *	net_enable_ipv6
static netflag_t	net_active
static int	net_error
static qsocket_t	udp_sockets [NS_COUNT] = { -1, -1 }
static qsocket_t	tcp_socket = -1
static qsocket_t	udp6_sockets [NS_COUNT] = { -1, -1 }
static qsocket_t	tcp6_socket = -1
static ioentry_t	io_entries [FD_SETSIZE]
static int	io_numfds
static unsigned	net_rate_time
static size_t	net_rate_rcvd
static size_t	net_rate_sent
static size_t	net_rate_dn
static size_t	net_rate_up
static uint64_t	net_recv_errors
static uint64_t	net_send_errors
static uint64_t	net_bytes_rcvd
static uint64_t	net_bytes_sent
static uint64_t	net_packets_rcvd
static uint64_t	net_packets_sent

Macro Definition Documentation

MAX_ERROR_RETRIES

#define MAX_ERROR_RETRIES   64

Definition at line 65 of file net.c.

NS_IN6ADDRSZ

#define NS_IN6ADDRSZ   16

Definition at line 208 of file net.c.

NS_INADDRSZ

#define NS_INADDRSZ   4

Definition at line 207 of file net.c.

NS_INT16SZ

#define NS_INT16SZ   2

Definition at line 206 of file net.c.

RATE_SECS

#define RATE_SECS   3

Definition at line 470 of file net.c.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 39 of file net.c.

Function Documentation

dump_addrinfo()

static void dump_addrinfo ( struct addrinfo *  ai )

static

Definition at line 1747 of file net.c.

{
    char buf1[MAX_QPATH], buf2[MAX_STRING_CHARS];
    char *fa = (ai->ai_addr->sa_family == AF_INET6) ? "6" : "";
 
    getnameinfo(ai->ai_addr, ai->ai_addrlen,
                buf1, sizeof(buf1), NULL, 0, NI_NUMERICHOST);
    if (getnameinfo(ai->ai_addr, ai->ai_addrlen,
                    buf2, sizeof(buf2), NULL, 0, NI_NAMEREQD) == 0)
        Com_Printf("IP%1s     : %s (%s)\n", fa, buf1, buf2);
    else
        Com_Printf("IP%1s     : %s\n", fa, buf1);
}

Referenced by NET_Dns_f(), and NET_ShowIP_f().

dump_socket()

static void dump_socket ( qsocket_t  s, const char *  s1, const char *  s2  )

static

Definition at line 1761 of file net.c.

{
    netadr_t adr;
 
    if (s == -1)
        return;
 
    if (os_getsockname(s, &adr)) {
        Com_EPrintf("Couldn't get %s %s socket name: %s\n",
                    s1, s2, NET_ErrorString());
        return;
    }
 
    Com_Printf("%s %s socket bound to %s\n",
               s1, s2, NET_AdrToString(&adr));
}

Referenced by NET_ShowIP_f().

NET_Accept()

neterr_t NET_Accept

(

netstream_t *

s

)

Definition at line 1525 of file net.c.

{
    neterr_t ret;
 
    ret = NET_AcceptSocket(s, tcp_socket);
    if (ret == NET_AGAIN)
        ret = NET_AcceptSocket(s, tcp6_socket);
 
    return ret;
}

Referenced by CL_GTV_Run(), and SV_MvdRunClients().

NET_AcceptSocket()

static neterr_t NET_AcceptSocket ( netstream_t *  s, qsocket_t  sock  )

static

Definition at line 1482 of file net.c.

{
    ioentry_t *e;
    qsocket_t newsocket;
    neterr_t ret;
 
    if (sock == -1) {
        return NET_AGAIN;
    }
 
    e = os_get_io(sock);
    if (!e->canread) {
        return NET_AGAIN;
    }
 
    ret = os_accept(sock, &newsocket, &net_from);
    if (ret) {
        e->canread = qfalse;
        return ret;
    }
 
    // make it non-blocking
    ret = os_make_nonblock(newsocket, 1);
    if (ret) {
        os_closesocket(newsocket);
        return ret;
    }
 
    // initialize stream
    memset(s, 0, sizeof(*s));
    s->socket = newsocket;
    s->address = net_from;
    s->state = NS_CONNECTED;
 
    // initialize io entry
    e = NET_AddFd(newsocket);
    //e->wantwrite = qtrue;
    e->wantread = qtrue;
 
    return NET_OK;
}

Referenced by NET_Accept().

NET_AddFd()

ioentry_t* NET_AddFd

(

qsocket_t

fd

)

Definition at line 671 of file net.c.

{
    ioentry_t *e = os_add_io(fd);
 
    e->inuse = qtrue;
    return e;
}

Referenced by NET_AcceptSocket(), NET_Connect(), NET_Listen4(), NET_Listen6(), NET_OpenServer(), and NET_OpenServer6().

NET_AdrToString()

char* NET_AdrToString

(

const netadr_t *

a

)

Definition at line 257 of file net.c.

{
    static char s[MAX_QPATH];
 
    switch (a->type) {
    case NA_UNSPECIFIED:
        return strcpy(s, "<unspecified>");
    case NA_LOOPBACK:
        return strcpy(s, "loopback");
    default:
        Q_snprintf(s, sizeof(s), (a->type == NA_IP6) ? "[%s]:%u" : "%s:%u",
                   NET_BaseAdrToString(a), BigShort(a->port));
    }
    return s;
}

Referenced by AC_ClientBegin(), AC_ParseFileViolation(), AC_ParseViolation(), AC_Reconnect(), AC_Run(), accept_client(), AddServer(), check_reconnect(), CL_ConnectionlessPacket(), CL_DumpStatusResponse(), CL_FollowIP_f(), CL_GTV_Run(), CL_GTV_Status_f(), CL_PacketEvent(), CL_PassiveConnect_f(), CL_RecentIP_g(), CL_ServerStatus_f(), drop_client(), dump_clients(), dump_socket(), find_client_slot(), gtv_run(), HTTP_SetServer(), MVD_Connect_f(), MVD_ListServers_f(), NET_GetUdpPackets(), NET_SendPacket(), NetchanNew_Process(), NetchanNew_Transmit(), NetchanOld_Process(), NetchanOld_Transmit(), parse_hello(), parse_stringcmd(), print_drop_reason(), process_error_queue(), resolve_masters(), SV_ConnectionlessPacket(), SV_CvarResult_f(), SV_ListMasters_f(), SV_MasterHeartbeat(), SV_MasterShutdown(), SV_MvdRunClients(), SV_SetMaster_f(), SV_UserinfoChanged(), SVC_Ack(), SVC_RemoteCommand(), SVC_Status(), UI_StatusEvent(), and userinfo_ip_string().

NET_BaseAdrToString()

char* NET_BaseAdrToString

(

const netadr_t *

a

)

Definition at line 216 of file net.c.

{
    static char s[MAX_QPATH];
 
    switch (a->type) {
    case NA_UNSPECIFIED:
        return strcpy(s, "<unspecified>");
    case NA_LOOPBACK:
        return strcpy(s, "loopback");
    case NA_IP:
    case NA_BROADCAST:
        if (os_inet_ntop(AF_INET, &a->ip, s, sizeof(s)))
            return s;
        else
            return strcpy(s, "<invalid>");
    case NA_IP6:
        if (a->scope_id) {
            struct sockaddr_storage addr;
            size_t addrlen;
 
            addrlen = NET_NetadrToSockadr(a, &addr);
            if (getnameinfo((struct sockaddr *)&addr, addrlen,
                            s, sizeof(s), NULL, 0, NI_NUMERICHOST) == 0)
                return s;
        }
        if (os_inet_ntop(AF_INET6, &a->ip, s, sizeof(s)))
            return s;
        else
            return strcpy(s, "<invalid>");
    default:
        Com_Error(ERR_FATAL, "%s: bad address type", __func__);
    }
 
    return NULL;
}

Referenced by format_mask(), and NET_AdrToString().

NET_CloseStream()

void NET_CloseStream

(

netstream_t *

s

)

Definition at line 1371 of file net.c.

{
    if (!s->state) {
        return;
    }
 
    NET_RemoveFd(s->socket);
    os_closesocket(s->socket);
    s->socket = -1;
    s->state = NS_DISCONNECTED;
}

Referenced by AC_Disconnect(), AC_Drop(), accept_client(), drop_client(), gtv_destroy(), gtv_drop(), and remove_client().

NET_Config()

void NET_Config

(

netflag_t

flag

)

Definition at line 1312 of file net.c.

{
    netsrc_t sock;
 
    if (flag == net_active) {
        return;
    }
 
    if (flag == NET_NONE) {
        // shut down any existing sockets
        for (sock = 0; sock < NS_COUNT; sock++) {
            if (udp_sockets[sock] != -1) {
                NET_RemoveFd(udp_sockets[sock]);
                os_closesocket(udp_sockets[sock]);
                udp_sockets[sock] = -1;
            }
            if (udp6_sockets[sock] != -1) {
                NET_RemoveFd(udp6_sockets[sock]);
                os_closesocket(udp6_sockets[sock]);
                udp6_sockets[sock] = -1;
            }
        }
        net_active = NET_NONE;
        return;
    }
 
#if USE_CLIENT
    if (flag & NET_CLIENT) {
        NET_OpenClient();
        NET_OpenClient6();
    }
#endif
 
    if (flag & NET_SERVER) {
        NET_OpenServer();
        NET_OpenServer6();
    }
 
    net_active |= flag;
}

Referenced by CL_Connect_f(), CL_PassiveConnect_f(), CL_PingServers_f(), CL_SendRcon(), CL_ServerStatus_f(), NET_Restart_f(), NET_Shutdown(), Qcommon_Init(), and SV_InitGame().

NET_Connect()

neterr_t NET_Connect	(	const netadr_t *	peer,
		netstream_t *	s
	)

Definition at line 1536 of file net.c.

{
    qsocket_t socket;
    ioentry_t *e;
    neterr_t ret;
 
    // always bind to `net_ip' for outgoing TCP connections
    // to avoid problems with AC or MVD/GTV auth on a multi IP system
    switch (peer->type) {
    case NA_IP:
        socket = TCP_OpenSocket(net_ip->string, PORT_ANY, AF_INET, NS_CLIENT);
        break;
    case NA_IP6:
        socket = TCP_OpenSocket(net_ip6->string, PORT_ANY, AF_INET6, NS_CLIENT);
        break;
    default:
        return NET_ERROR;
    }
 
    if (socket == -1) {
        return NET_ERROR;
    }
 
    ret = os_connect(socket, peer);
    if (ret) {
        os_closesocket(socket);
        return NET_ERROR;
    }
 
    // initialize stream
    memset(s, 0, sizeof(*s));
    s->state = NS_CONNECTING;
    s->address = *peer;
    s->socket = socket;
 
    // initialize io entry
    e = NET_AddFd(socket);
    e->wantwrite = qtrue;
#ifdef _WIN32
    e->wantexcept = qtrue;
#endif
 
    return NET_OK;
}

Referenced by AC_Reconnect(), check_reconnect(), and MVD_Connect_f().

NET_DnRate_m()

static size_t NET_DnRate_m ( char *  buffer, size_t  size  )

static

Definition at line 535 of file net.c.

{
    return Q_scnprintf(buffer, size, "%"PRIz, net_rate_dn);
}

Referenced by NET_Init().

NET_Dns_f()

static void NET_Dns_f ( void  )

static

Definition at line 1831 of file net.c.

{
    char buffer[MAX_STRING_CHARS], *h, *p;
    struct addrinfo hints, *res, *rp;
    int err;
 
    if (Cmd_Argc() != 2) {
        Com_Printf("Usage: %s <address>\n", Cmd_Argv(0));
        return;
    }
 
    Cmd_ArgvBuffer(1, buffer, sizeof(buffer));
 
    // parse IPv6 address square brackets
    h = p = buffer;
    if (*h == '[') {
        h++;
        p = strchr(h, ']');
        if (!p) {
            Com_Printf("Bad IPv6 address\n");
            return;
        }
        *p++ = 0;
    }
 
    // strip off a trailing :port if present
    p = strchr(p, ':');
    if (p)
        *p++ = 0;
 
    memset(&hints, 0, sizeof(hints));
    hints.ai_flags = AI_CANONNAME;
    hints.ai_socktype = SOCK_STREAM;
 
    if (net_enable_ipv6->integer < 1)
        hints.ai_family = AF_INET;
 
    err = getaddrinfo(h, NULL, &hints, &res);
    if (err) {
        Com_Printf("Couldn't resolve %s: %s\n", h, gai_strerror(err));
        return;
    }
 
    if (res->ai_canonname)
        Com_Printf("Hostname: %s\n", res->ai_canonname);
 
    for (rp = res; rp; rp = rp->ai_next)
        dump_addrinfo(rp);
 
    freeaddrinfo(res);
}

Referenced by NET_Init().

NET_EnableIP6()

static const char* NET_EnableIP6 ( void  )

static

Definition at line 1917 of file net.c.

{
    qsocket_t s = os_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
 
    if (s == -1)
        return "0";
 
    os_closesocket(s);
    return "1";
}

Referenced by NET_Init().

NET_ErrorString()

const char* NET_ErrorString

(

void

)

Definition at line 659 of file net.c.

{
    return os_error_string(net_error);
}

Referenced by AC_Reconnect(), AC_Run(), check_reconnect(), CL_GTV_Start_f(), CL_ServerStatus_f(), dump_socket(), gtv_run(), MVD_Connect_f(), NET_GetUdpPackets(), NET_SendPacket(), NET_Sleep(), SV_MvdInit(), SV_MvdRunClients(), TCP_OpenSocket(), and UDP_OpenSocket().

NET_GetAddress()

qboolean NET_GetAddress	(	netsrc_t	sock,
		netadr_t *	adr
	)

Definition at line 1358 of file net.c.

{
    if (udp_sockets[sock] == -1)
        return qfalse;
 
    if (os_getsockname(udp_sockets[sock], adr))
        return qfalse;
 
    return qtrue;
}

Referenced by CL_PassiveConnect_f().

NET_GetPackets()

void NET_GetPackets	(	netsrc_t	sock,
		void(*)(void)	packet_cb
	)

Definition at line 895 of file net.c.

{
#if USE_CLIENT
    memset(&net_from, 0, sizeof(net_from));
    net_from.type = NA_LOOPBACK;
 
    // process loopback packets
    NET_GetLoopPackets(sock, packet_cb);
#endif
 
    // process UDP packets
    NET_GetUdpPackets(udp_sockets[sock], packet_cb);
 
    // process UDP6 packets
    NET_GetUdpPackets(udp6_sockets[sock], packet_cb);
}

Referenced by CL_ProcessEvents(), and SV_Frame().

NET_GetUdpPackets()

static void NET_GetUdpPackets ( qsocket_t  sock, void(*)(void)  packet_cb  )

static

Definition at line 845 of file net.c.

{
    ioentry_t *e;
    ssize_t ret;
 
    if (sock == -1)
        return;
 
    e = os_get_io(sock);
    if (!e->canread)
        return;
 
    while (1) {
        ret = os_udp_recv(sock, msg_read_buffer, MAX_PACKETLEN, &net_from);
        if (ret == NET_AGAIN) {
            e->canread = qfalse;
            break;
        }
 
        if (ret == NET_ERROR) {
            Com_DPrintf("%s: %s from %s\n", __func__,
                        NET_ErrorString(), NET_AdrToString(&net_from));
            net_recv_errors++;
            break;
        }
 
#ifdef _DEBUG
        if (net_log_enable->integer)
            NET_LogPacket(&net_from, "UDP recv", msg_read_buffer, ret);
#endif
 
        net_rate_rcvd += ret;
        net_bytes_rcvd += ret;
        net_packets_rcvd++;
 
        SZ_Init(&msg_read, msg_read_buffer, sizeof(msg_read_buffer));
        msg_read.cursize = ret;
 
        (*packet_cb)();
    }
}

Referenced by NET_GetPackets().

NET_Init()

void NET_Init

(

void

)

Definition at line 1933 of file net.c.

{
    os_net_init();
 
    net_ip = Cvar_Get("net_ip", "", 0);
    net_ip->changed = net_udp_param_changed;
    net_ip6 = Cvar_Get("net_ip6", "", 0);
    net_ip6->changed = net_udp_param_changed;
    net_port = Cvar_Get("net_port", STRINGIFY(PORT_SERVER), 0);
    net_port->changed = net_udp_param_changed;
 
#if USE_CLIENT
    net_clientport = Cvar_Get("net_clientport", STRINGIFY(PORT_ANY), 0);
    net_clientport->changed = net_udp_param_changed;
    net_dropsim = Cvar_Get("net_dropsim", "0", 0);
#endif
 
#if _DEBUG
    net_log_enable = Cvar_Get("net_log_enable", "0", 0);
    net_log_enable->changed = net_log_enable_changed;
    net_log_name = Cvar_Get("net_log_name", "network", 0);
    net_log_name->changed = net_log_param_changed;
    net_log_flush = Cvar_Get("net_log_flush", "0", 0);
    net_log_flush->changed = net_log_param_changed;
#endif
 
    net_enable_ipv6 = Cvar_Get("net_enable_ipv6", NET_EnableIP6(), 0);
    net_enable_ipv6->changed = net_udp_param_changed;
 
#if USE_ICMP
    net_ignore_icmp = Cvar_Get("net_ignore_icmp", "0", 0);
#endif
 
#if _DEBUG
    net_log_enable_changed(net_log_enable);
#endif
 
    net_rate_time = com_eventTime;
 
    Cmd_AddCommand("net_restart", NET_Restart_f);
    Cmd_AddCommand("net_stats", NET_Stats_f);
    Cmd_AddCommand("showip", NET_ShowIP_f);
    Cmd_AddCommand("dns", NET_Dns_f);
 
    Cmd_AddMacro("net_uprate", NET_UpRate_m);
    Cmd_AddMacro("net_dnrate", NET_DnRate_m);
}

Referenced by Qcommon_Init().

NET_Listen()

neterr_t NET_Listen

(

qboolean

arg

)

Definition at line 1466 of file net.c.

{
    neterr_t ret4, ret6;
 
    ret4 = NET_Listen4(arg);
    ret6 = NET_Listen6(arg);
 
    if (ret4 == NET_OK || ret6 == NET_OK)
        return NET_OK;
 
    if (ret4 == NET_ERROR || ret6 == NET_ERROR)
        return NET_ERROR;
 
    return NET_AGAIN;
}

Referenced by CL_GTV_Start_f(), CL_GTV_Stop_f(), NET_Shutdown(), SV_MvdInit(), and SV_MvdShutdown().

NET_Listen4()

static neterr_t NET_Listen4 ( qboolean  arg )

static

Definition at line 1383 of file net.c.

{
    qsocket_t s;
    ioentry_t *e;
    neterr_t ret;
 
    if (!arg) {
        if (tcp_socket != -1) {
            NET_RemoveFd(tcp_socket);
            os_closesocket(tcp_socket);
            tcp_socket = -1;
        }
        return NET_OK;
    }
 
    if (tcp_socket != -1) {
        return NET_AGAIN;
    }
 
    s = TCP_OpenSocket(net_ip->string, net_port->integer, AF_INET, NS_SERVER);
    if (s == -1) {
        return NET_ERROR;
    }
 
    ret = os_listen(s, 16);
    if (ret) {
        os_closesocket(s);
        return ret;
    }
 
    tcp_socket = s;
 
    // initialize io entry
    e = NET_AddFd(s);
    e->wantread = qtrue;
 
    return NET_OK;
}

Referenced by NET_Listen(), and NET_Restart_f().

NET_Listen6()

static neterr_t NET_Listen6 ( qboolean  arg )

static

Definition at line 1422 of file net.c.

{
    qsocket_t s;
    ioentry_t *e;
    neterr_t ret;
 
    if (!arg) {
        if (tcp6_socket != -1) {
            NET_RemoveFd(tcp6_socket);
            os_closesocket(tcp6_socket);
            tcp6_socket = -1;
        }
        return NET_OK;
    }
 
 
    if (tcp6_socket != -1) {
        return NET_AGAIN;
    }
 
    if (net_enable_ipv6->integer < 2) {
        return NET_AGAIN;
    }
 
    s = TCP_OpenSocket(net_ip6->string, net_port->integer, AF_INET6, NS_SERVER);
    if (s == -1) {
        return NET_ERROR;
    }
 
    ret = os_listen(s, 16);
    if (ret) {
        os_closesocket(s);
        return ret;
    }
 
    tcp6_socket = s;
 
    // initialize io entry
    e = NET_AddFd(s);
    e->wantread = qtrue;
 
    return NET_OK;
}

Referenced by NET_Listen(), and NET_Restart_f().

NET_NetadrToSockadr()

static size_t NET_NetadrToSockadr ( const netadr_t *  a, struct sockaddr_storage *  s  )

static

Definition at line 145 of file net.c.

{
    struct sockaddr_in  *s4 = (struct sockaddr_in  *)s;
    struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)s;
 
    memset(s, 0, sizeof(*s));
 
    switch (a->type) {
    case NA_BROADCAST:
        s4->sin_family = AF_INET;
        s4->sin_addr.s_addr = INADDR_BROADCAST;
        s4->sin_port = a->port;
        return sizeof(*s4);
    case NA_IP:
        s4->sin_family = AF_INET;
        memcpy(&s4->sin_addr, &a->ip, 4);
        s4->sin_port = a->port;
        return sizeof(*s4);
    case NA_IP6:
        s6->sin6_family = AF_INET6;
        memcpy(&s6->sin6_addr, &a->ip, 16);
        s6->sin6_port = a->port;
        s6->sin6_scope_id = a->scope_id;
        return sizeof(*s6);
    default:
        break;
    }
 
    return 0;
}

Referenced by NET_BaseAdrToString(), os_connect(), and os_udp_send().

NET_OpenServer()

static void NET_OpenServer ( void  )

static

Definition at line 1195 of file net.c.

{
    static int saved_port;
    ioentry_t *e;
    qsocket_t s;
 
    if (udp_sockets[NS_SERVER] != -1)
        return;
 
    s = UDP_OpenSocket(net_ip->string, net_port->integer, AF_INET);
    if (s != -1) {
        saved_port = net_port->integer;
        udp_sockets[NS_SERVER] = s;
        e = NET_AddFd(s);
        e->wantread = qtrue;
        return;
    }
 
    if (saved_port && saved_port != net_port->integer) {
        // revert to the last valid port
        Com_Printf("Reverting to the last valid port %d...\n", saved_port);
        Cbuf_AddText(&cmd_buffer, va("set net_port %d\n", saved_port));
        return;
    }
 
#if USE_CLIENT
    if (!dedicated->integer) {
        Com_WPrintf("Couldn't open server UDP port.\n");
        return;
    }
#endif
 
    Com_Error(ERR_FATAL, "Couldn't open dedicated server UDP port");
}

Referenced by NET_Config().

NET_OpenServer6()

static void NET_OpenServer6 ( void  )

static

Definition at line 1230 of file net.c.

{
    ioentry_t *e;
    qsocket_t s;
 
    if (net_enable_ipv6->integer < 2)
        return;
 
    if (udp6_sockets[NS_SERVER] != -1)
        return;
 
    s = UDP_OpenSocket(net_ip6->string, net_port->integer, AF_INET6);
    if (s == -1)
        return;
 
    udp6_sockets[NS_SERVER] = s;
    e = NET_AddFd(s);
    e->wantread = qtrue;
}

Referenced by NET_Config().

NET_RemoveFd()

void NET_RemoveFd

(

qsocket_t

fd

)

Definition at line 686 of file net.c.

{
    ioentry_t *e = os_get_io(fd);
    int i;
 
    memset(e, 0, sizeof(*e));
 
    for (i = io_numfds - 1; i >= 0; i--) {
        e = &io_entries[i];
        if (e->inuse) {
            break;
        }
    }
 
    io_numfds = i + 1;
}

Referenced by NET_CloseStream(), NET_Config(), NET_Listen4(), and NET_Listen6().

NET_Restart_f()

static void NET_Restart_f ( void  )

static

Definition at line 1888 of file net.c.

{
    netflag_t flag = net_active;
    qboolean listen4 = (tcp_socket != -1);
    qboolean listen6 = (tcp6_socket != -1);
 
    Com_DPrintf("%s\n", __func__);
 
    NET_Listen4(qfalse);
    NET_Listen6(qfalse);
    NET_Config(NET_NONE);
 
    listen6 |= listen4;
    listen6 &= net_enable_ipv6->integer > 1;
 
    NET_Config(flag);
    NET_Listen4(listen4);
    NET_Listen6(listen6);
 
#if USE_SYSCON
    SV_SetConsoleTitle();
#endif
}

Referenced by NET_Init(), and net_udp_param_changed().

NET_RunConnect()

neterr_t NET_RunConnect

(

netstream_t *

s

)

Definition at line 1581 of file net.c.

{
    ioentry_t *e;
    neterr_t ret;
    int err;
 
    if (s->state != NS_CONNECTING) {
        return NET_AGAIN;
    }
 
    e = os_get_io(s->socket);
    if (!e->canwrite
#ifdef _WIN32
        && !e->canexcept
#endif
       ) {
        return NET_AGAIN;
    }
 
    ret = os_getsockopt(s->socket, SOL_SOCKET, SO_ERROR, &err);
    if (ret) {
        goto fail;
    }
    if (err) {
        net_error = err;
        goto fail;
    }
 
    s->state = NS_CONNECTED;
    e->wantwrite = qfalse;
    e->wantread = qtrue;
#ifdef _WIN32
    e->wantexcept = qfalse;
#endif
    return NET_OK;
 
fail:
    s->state = NS_BROKEN;
    e->wantwrite = qfalse;
    e->wantread = qfalse;
#ifdef _WIN32
    e->wantexcept = qfalse;
#endif
    return NET_ERROR;
}

Referenced by AC_Run(), and run_connect().

NET_RunStream()

neterr_t NET_RunStream

(

netstream_t *

s

)

Definition at line 1647 of file net.c.

{
    ssize_t ret;
    size_t len;
    void *data;
    neterr_t result = NET_AGAIN;
    ioentry_t *e;
 
    if (s->state != NS_CONNECTED) {
        return result;
    }
 
    e = os_get_io(s->socket);
    if (e->wantread && e->canread) {
        // read as much as we can
        data = FIFO_Reserve(&s->recv, &len);
        if (len) {
            ret = os_recv(s->socket, data, len, 0);
            if (!ret) {
                goto closed;
            }
            if (ret == NET_ERROR) {
                goto error;
            }
            if (ret == NET_AGAIN) {
                // wouldblock is silent
                e->canread = qfalse;
            } else {
                FIFO_Commit(&s->recv, ret);
#if _DEBUG
                if (net_log_enable->integer) {
                    NET_LogPacket(&s->address, "TCP recv", data, ret);
                }
#endif
                net_rate_rcvd += ret;
                net_bytes_rcvd += ret;
 
                result = NET_OK;
 
                // now see if there's more space to read
                FIFO_Reserve(&s->recv, &len);
                if (!len) {
                    e->wantread = qfalse;
                }
            }
        }
    }
 
    if (e->wantwrite && e->canwrite) {
        // write as much as we can
        data = FIFO_Peek(&s->send, &len);
        if (len) {
            ret = os_send(s->socket, data, len, 0);
            if (!ret) {
                goto closed;
            }
            if (ret == NET_ERROR) {
                goto error;
            }
            if (ret == NET_AGAIN) {
                // wouldblock is silent
                e->canwrite = qfalse;
            } else {
                FIFO_Decommit(&s->send, ret);
#if _DEBUG
                if (net_log_enable->integer) {
                    NET_LogPacket(&s->address, "TCP send", data, ret);
                }
#endif
                net_rate_sent += ret;
                net_bytes_sent += ret;
 
                //result = NET_OK;
 
                // now see if there's more data to write
                FIFO_Peek(&s->send, &len);
                if (!len) {
                    e->wantwrite = qfalse;
                }
 
            }
        }
    }
 
    return result;
 
closed:
    s->state = NS_CLOSED;
    e->wantread = qfalse;
    return NET_CLOSED;
 
error:
    s->state = NS_BROKEN;
    e->wantread = qfalse;
    e->wantwrite = qfalse;
    return NET_ERROR;
}

Referenced by AC_Run(), CL_GTV_Run(), drop_client(), mvd_drop(), run_stream(), and SV_MvdRunClients().

NET_SearchAdrrInfo()

static struct addrinfo* NET_SearchAdrrInfo ( struct addrinfo *  rp, int  family  )

static

Definition at line 273 of file net.c.

{
    while (rp) {
        if (rp->ai_family == family)
            return rp;
        rp = rp->ai_next;
    }
 
    return NULL;
}

Referenced by NET_StringPairToAdr().

NET_SendPacket()

qboolean NET_SendPacket	(	netsrc_t	sock,
		const void *	data,
		size_t	len,
		const netadr_t *	to
	)

Definition at line 918 of file net.c.

{
    ssize_t ret;
    qsocket_t s;
 
    if (len == 0)
        return qfalse;
 
    if (len > MAX_PACKETLEN) {
        Com_EPrintf("%s: oversize packet to %s\n", __func__,
                    NET_AdrToString(to));
        return qfalse;
    }
 
    switch (to->type) {
    case NA_UNSPECIFIED:
        return qfalse;
#if USE_CLIENT
    case NA_LOOPBACK:
        return NET_SendLoopPacket(sock, data, len, to);
#endif
    case NA_IP:
    case NA_BROADCAST:
        s = udp_sockets[sock];
        break;
    case NA_IP6:
        s = udp6_sockets[sock];
        break;
    default:
        Com_Error(ERR_FATAL, "%s: bad address type", __func__);
    }
 
    if (s == -1)
        return qfalse;
 
    ret = os_udp_send(s, data, len, to);
    if (ret == NET_AGAIN)
        return qfalse;
 
    if (ret == NET_ERROR) {
        Com_DPrintf("%s: %s to %s\n", __func__,
                    NET_ErrorString(), NET_AdrToString(to));
        net_send_errors++;
        return qfalse;
    }
 
    if (ret < len)
        Com_WPrintf("%s: short send to %s\n", __func__,
                    NET_AdrToString(to));
 
#ifdef _DEBUG
    if (net_log_enable->integer)
        NET_LogPacket(to, "UDP send", data, ret);
#endif
 
    net_rate_sent += ret;
    net_bytes_sent += ret;
    net_packets_sent++;
 
    return qtrue;
}

Referenced by Netchan_OutOfBand(), NetchanNew_Transmit(), NetchanNew_TransmitNextFragment(), NetchanOld_Transmit(), redirect(), SV_FlushRedirect(), SV_MasterHeartbeat(), SVC_Info(), and SVC_Status().

NET_ShowIP_f()

static void NET_ShowIP_f ( void  )

static

Definition at line 1783 of file net.c.

{
    char buffer[MAX_STRING_CHARS];
    struct addrinfo hints, *res, *rp;
    int err;
 
    if (gethostname(buffer, sizeof(buffer)) == -1) {
        Com_EPrintf("Couldn't get system host name\n");
        return;
    }
 
    memset(&hints, 0, sizeof(hints));
    hints.ai_flags = AI_CANONNAME;
    hints.ai_socktype = SOCK_STREAM;
 
    if (net_enable_ipv6->integer < 1)
        hints.ai_family = AF_INET;
 
    err = getaddrinfo(buffer, NULL, &hints, &res);
    if (err) {
        Com_Printf("Couldn't resolve %s: %s\n", buffer, gai_strerror(err));
        return;
    }
 
    if (res->ai_canonname)
        Com_Printf("Hostname: %s\n", res->ai_canonname);
 
    for (rp = res; rp; rp = rp->ai_next)
        dump_addrinfo(rp);
 
    freeaddrinfo(res);
 
    // dump listening IP sockets
    dump_socket(udp_sockets[NS_CLIENT], "Client", "UDP");
    dump_socket(udp_sockets[NS_SERVER], "Server", "UDP");
    dump_socket(tcp_socket, "Server", "TCP");
 
    // dump listening IPv6 sockets
    dump_socket(udp6_sockets[NS_CLIENT], "Client", "UDP6");
    dump_socket(udp6_sockets[NS_SERVER], "Server", "UDP6");
    dump_socket(tcp6_socket, "Server", "TCP6");
}

Referenced by NET_Init().

NET_Shutdown()

void NET_Shutdown

(

void

)

Definition at line 1986 of file net.c.

{
#if _DEBUG
    logfile_close();
#endif
 
    NET_Listen(qfalse);
    NET_Config(NET_NONE);
    os_net_shutdown();
 
    Cmd_RemoveCommand("net_restart");
    Cmd_RemoveCommand("net_stats");
    Cmd_RemoveCommand("showip");
    Cmd_RemoveCommand("dns");
}

Referenced by Com_Error(), and Com_Quit().

NET_Sleep()

int NET_Sleep

(

int

msec

)

Definition at line 712 of file net.c.

{
    struct timeval tv;
    fd_set rfds, wfds, efds;
    ioentry_t *e;
    qsocket_t fd;
    int i, ret;
 
    if (!io_numfds) {
        // don't bother with select()
        Sys_Sleep(msec);
        return 0;
    }
 
    FD_ZERO(&rfds);
    FD_ZERO(&wfds);
    FD_ZERO(&efds);
 
    for (i = 0, e = io_entries; i < io_numfds; i++, e++) {
        if (!e->inuse) {
            continue;
        }
        fd = os_get_fd(e);
        e->canread = qfalse;
        e->canwrite = qfalse;
        e->canexcept = qfalse;
        if (e->wantread) FD_SET(fd, &rfds);
        if (e->wantwrite) FD_SET(fd, &wfds);
        if (e->wantexcept) FD_SET(fd, &efds);
    }
 
    tv.tv_sec = msec / 1000;
    tv.tv_usec = (msec % 1000) * 1000;
 
    ret = os_select(io_numfds, &rfds, &wfds, &efds, &tv);
    if (ret == -1) {
        Com_EPrintf("%s: %s\n", __func__, NET_ErrorString());
        return ret;
    }
 
    if (ret == 0)
        return ret;
 
    for (i = 0; i < io_numfds; i++) {
        e = &io_entries[i];
        if (!e->inuse) {
            continue;
        }
        fd = os_get_fd(e);
        if (FD_ISSET(fd, &rfds)) e->canread = qtrue;
        if (FD_ISSET(fd, &wfds)) e->canwrite = qtrue;
        if (FD_ISSET(fd, &efds)) e->canexcept = qtrue;
    }
 
    return ret;
}

Referenced by drop_client(), mvd_drop(), and Qcommon_Frame().

NET_SockadrToNetadr()

static void NET_SockadrToNetadr ( const struct sockaddr_storage *  s, netadr_t *  a  )

static

Definition at line 176 of file net.c.

{
    const struct sockaddr_in  *s4 = (const struct sockaddr_in  *)s;
    const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *)s;
 
    memset(a, 0, sizeof(*a));
 
    switch (s->ss_family) {
    case AF_INET:
        a->type = NA_IP;
        memcpy(&a->ip, &s4->sin_addr, 4);
        a->port = s4->sin_port;
        break;
    case AF_INET6:
        if (IN6_IS_ADDR_V4MAPPED(&s6->sin6_addr)) {
            a->type = NA_IP;
            memcpy(&a->ip, &s6->sin6_addr.s6_addr[12], 4);
        } else {
            a->type = NA_IP6;
            memcpy(&a->ip, &s6->sin6_addr, 16);
            a->scope_id = s6->sin6_scope_id;
        }
        a->port = s6->sin6_port;
        break;
    default:
        break;
    }
}

Referenced by NET_StringPairToAdr(), os_accept(), os_getsockname(), os_udp_recv(), and process_error_queue().

NET_Stats_f()

static void NET_Stats_f ( void  )

static

Definition at line 496 of file net.c.

{
    time_t diff, now = time(NULL);
    char buffer[MAX_QPATH];
 
    if (com_startTime > now) {
        com_startTime = now;
    }
    diff = now - com_startTime;
    if (diff < 1) {
        diff = 1;
    }
 
    Com_FormatTime(buffer, sizeof(buffer), diff);
    Com_Printf("Network uptime: %s\n", buffer);
    Com_Printf("Bytes sent: %"PRIu64" (%"PRIu64" bytes/sec)\n",
               net_bytes_sent, net_bytes_sent / diff);
    Com_Printf("Bytes rcvd: %"PRIu64" (%"PRIu64" bytes/sec)\n",
               net_bytes_rcvd, net_bytes_rcvd / diff);
    Com_Printf("Packets sent: %"PRIu64" (%"PRIu64" packets/sec)\n",
               net_packets_sent, net_packets_sent / diff);
    Com_Printf("Packets rcvd: %"PRIu64" (%"PRIu64" packets/sec)\n",
               net_packets_rcvd, net_packets_rcvd / diff);
#if USE_ICMP
    Com_Printf("Total errors: %"PRIu64"/%"PRIu64"/%"PRIu64" (send/recv/icmp)\n",
               net_send_errors, net_recv_errors, net_icmp_errors);
#else
    Com_Printf("Total errors: %"PRIu64"/%"PRIu64" (send/recv)\n",
               net_send_errors, net_recv_errors);
#endif
    Com_Printf("Current upload rate: %"PRIz" bytes/sec\n", net_rate_up);
    Com_Printf("Current download rate: %"PRIz" bytes/sec\n", net_rate_dn);
}

Referenced by NET_Init().

NET_StringPairToAdr()

qboolean NET_StringPairToAdr	(	const char *	host,
		const char *	port,
		netadr_t *	a
	)

Definition at line 284 of file net.c.

{
    byte buf[128];
    struct addrinfo hints, *res, *rp;
    int err;
 
    memset(&hints, 0, sizeof(hints));
 
    if (net_enable_ipv6->integer < 1)
        hints.ai_family = AF_INET;
 
    if (os_inet_pton(AF_INET, host, buf) == 1 ||
        os_inet_pton(AF_INET6, host, buf) == 1)
        hints.ai_flags |= AI_NUMERICHOST;
 
#ifdef AI_NUMERICSERV
    if (port && COM_IsUint(port))
        hints.ai_flags |= AI_NUMERICSERV;
#endif
 
    err = getaddrinfo(host, port, &hints, &res);
    if (err)
        return qfalse;
 
    rp = res;
    if (net_enable_ipv6->integer < 2) {
        rp = NET_SearchAdrrInfo(res, AF_INET);
        if (!rp)
            rp = res;
    }
 
    NET_SockadrToNetadr((struct sockaddr_storage *)rp->ai_addr, a);
 
    freeaddrinfo(res);
    return qtrue;
}

Referenced by NET_StringToAdr().

NET_StringToAdr()

qboolean NET_StringToAdr	(	const char *	s,
		netadr_t *	a,
		int	default_port
	)

Definition at line 332 of file net.c.

{
    char copy[MAX_STRING_CHARS], *h, *p;
    size_t len;
 
    len = Q_strlcpy(copy, s, sizeof(copy));
    if (len >= sizeof(copy))
        return qfalse;
 
    // parse IPv6 address in square brackets
    h = p = copy;
    if (*h == '[') {
        h++;
        p = strchr(h, ']');
        if (!p)
            return qfalse;
        *p++ = 0;
    }
 
    // strip off a trailing :port if present
    p = strchr(p, ':');
    if (p)
        *p++ = 0;
 
    if (!NET_StringPairToAdr(h, p, a))
        return qfalse;
 
    if (!a->port)
        a->port = BigShort(default_port);
 
    return qtrue;
}

Referenced by AC_Reconnect(), AddServer(), check_reconnect(), CL_Connect_f(), CL_PingServers_f(), CL_Rcon_f(), CL_ServerStatus_f(), Con_RemoteMode_f(), MVD_Connect_f(), resolve_masters(), SV_PickClient_f(), and SV_SetMaster_f().

net_udp_param_changed()

static void net_udp_param_changed ( cvar_t *  self )

static

Definition at line 1912 of file net.c.

{
    NET_Restart_f();
}

Referenced by NET_Init().

NET_UpdateStats()

void NET_UpdateStats

(

void

)

Definition at line 472 of file net.c.

{
    unsigned diff;
 
    if (net_rate_time > com_eventTime) {
        net_rate_time = com_eventTime;
    }
    diff = com_eventTime - net_rate_time;
    if (diff < RATE_SECS * 1000) {
        return;
    }
    net_rate_time = com_eventTime;
 
    net_rate_dn = net_rate_rcvd / RATE_SECS;
    net_rate_up = net_rate_sent / RATE_SECS;
    net_rate_sent = 0;
    net_rate_rcvd = 0;
}

Referenced by Qcommon_Frame().

NET_UpdateStream()

void NET_UpdateStream

(

netstream_t *

s

)

Definition at line 1628 of file net.c.

{
    size_t len;
    ioentry_t *e;
 
    if (s->state != NS_CONNECTED) {
        return;
    }
 
    e = os_get_io(s->socket);
 
    FIFO_Reserve(&s->recv, &len);
    e->wantread = len ? qtrue : qfalse;
 
    FIFO_Peek(&s->send, &len);
    e->wantwrite = len ? qtrue : qfalse;
}

Referenced by AC_Flush(), AC_Run(), AC_Write(), CL_GTV_Run(), CL_GTV_Transmit(), drop_client(), gtv_forward_cmd(), gtv_run(), gtv_wait_start(), mvd_drop(), resume_streams(), suspend_streams(), SV_MvdEndFrame(), SV_MvdMapChanged(), and SV_MvdRunClients().

NET_UpRate_m()

static size_t NET_UpRate_m ( char *  buffer, size_t  size  )

static

Definition at line 530 of file net.c.

{
    return Q_scnprintf(buffer, size, "%"PRIz, net_rate_up);
}

Referenced by NET_Init().

TCP_OpenSocket()

static qsocket_t TCP_OpenSocket ( const char *  iface, int  port, int  family, netsrc_t  who  )

static

Definition at line 1101 of file net.c.

{
    qsocket_t s, newsocket;
    struct addrinfo hints, *res, *rp;
    char buf[MAX_QPATH];
    const char *node, *service;
    int err;
 
    Com_DPrintf("Opening TCP%s socket: %s:%d\n",
                (family == AF_INET6) ? "6" : "", iface, port);
 
    memset(&hints, 0, sizeof(hints));
    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = family;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
 
    // empty string binds to all interfaces
    if (!*iface) {
        node = NULL;
    } else {
        node = iface;
    }
 
    if (port == PORT_ANY) {
        service = "0";
    } else {
        Q_snprintf(buf, sizeof(buf), "%d", port);
        service = buf;
    }
 
#ifdef AI_NUMERICSERV
    hints.ai_flags |= AI_NUMERICSERV;
#endif
 
    // resolve iface addr
    err = getaddrinfo(node, service, &hints, &res);
    if (err) {
        Com_EPrintf("%s: %s:%d: bad interface address: %s\n",
                    __func__, iface, port, gai_strerror(err));
        return -1;
    }
 
    newsocket = -1;
    for (rp = res; rp; rp = rp->ai_next) {
        s = os_socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
        if (s == -1) {
            Com_EPrintf("%s: %s:%d: can't create socket: %s\n",
                        __func__, iface, port, NET_ErrorString());
            continue;
        }
 
        // make it non-blocking
        if (os_make_nonblock(s, 1)) {
            Com_EPrintf("%s: %s:%d: can't make socket non-blocking: %s\n",
                        __func__, iface, port, NET_ErrorString());
            os_closesocket(s);
            continue;
        }
 
        if (who == NS_SERVER) {
            // give it a chance to reuse previous port
            if (os_setsockopt(s, SOL_SOCKET, SO_REUSEADDR, 1)) {
                Com_WPrintf("%s: %s:%d: can't force socket to reuse address: %s\n",
                            __func__, iface, port, NET_ErrorString());
            }
        }
 
        if (rp->ai_family == AF_INET6) {
#ifdef IPV6_V6ONLY
            // disable IPv4-mapped addresses
            if (os_setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, 1)) {
                Com_WPrintf("%s: %s:%d: can't make socket IPv6-only: %s\n",
                            __func__, iface, port, NET_ErrorString());
            }
#endif
        }
 
        if (os_bind(s, rp->ai_addr, rp->ai_addrlen)) {
            Com_EPrintf("%s: %s:%d: can't bind socket: %s\n",
                        __func__, iface, port, NET_ErrorString());
            os_closesocket(s);
            continue;
        }
 
        newsocket = s;
        break;
    }
 
    freeaddrinfo(res);
 
    return newsocket;
}

Referenced by NET_Connect(), NET_Listen4(), and NET_Listen6().

UDP_OpenSocket()

static qsocket_t UDP_OpenSocket ( const char *  iface, int  port, int  family  )

static

Definition at line 983 of file net.c.

{
    qsocket_t s, newsocket;
    struct addrinfo hints, *res, *rp;
    char buf[MAX_QPATH];
    const char *node, *service;
    int err;
 
    Com_DPrintf("Opening UDP%s socket: %s:%d\n",
                (family == AF_INET6) ? "6" : "", iface, port);
 
    memset(&hints, 0, sizeof(hints));
    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = family;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_protocol = IPPROTO_UDP;
 
    // empty string binds to all interfaces
    if (!*iface) {
        node = NULL;
    } else {
        node = iface;
    }
 
    if (port == PORT_ANY) {
        service = "0";
    } else {
        Q_snprintf(buf, sizeof(buf), "%d", port);
        service = buf;
    }
 
#ifdef AI_NUMERICSERV
    hints.ai_flags |= AI_NUMERICSERV;
#endif
 
    // resolve iface addr
    err = getaddrinfo(node, service, &hints, &res);
    if (err) {
        Com_EPrintf("%s: %s:%d: bad interface address: %s\n",
                    __func__, iface, port, gai_strerror(err));
        return -1;
    }
 
    newsocket = -1;
    for (rp = res; rp; rp = rp->ai_next) {
        s = os_socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
        if (s == -1) {
            Com_EPrintf("%s: %s:%d: can't create socket: %s\n",
                        __func__, iface, port, NET_ErrorString());
            continue;
        }
 
        // make it non-blocking
        if (os_make_nonblock(s, 1)) {
            Com_EPrintf("%s: %s:%d: can't make socket non-blocking: %s\n",
                        __func__, iface, port, NET_ErrorString());
            os_closesocket(s);
            continue;
        }
 
        if (rp->ai_family == AF_INET) {
            // make it broadcast capable
            if (os_setsockopt(s, SOL_SOCKET, SO_BROADCAST, 1)) {
                Com_WPrintf("%s: %s:%d: can't make socket broadcast capable: %s\n",
                            __func__, iface, port, NET_ErrorString());
            }
 
#ifdef IP_RECVERR
            // enable ICMP error queue
            if (os_setsockopt(s, IPPROTO_IP, IP_RECVERR, 1)) {
                Com_WPrintf("%s: %s:%d: can't enable ICMP error queue: %s\n",
                            __func__, iface, port, NET_ErrorString());
            }
#endif
 
#ifdef IP_MTU_DISCOVER
            // allow IP fragmentation by disabling path MTU discovery
            if (os_setsockopt(s, IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_DONT)) {
                Com_WPrintf("%s: %s:%d: can't disable path MTU discovery: %s\n",
                            __func__, iface, port, NET_ErrorString());
            }
#endif
        }
 
        if (rp->ai_family == AF_INET6) {
#ifdef IPV6_RECVERR
            // enable ICMP6 error queue
            if (os_setsockopt(s, IPPROTO_IPV6, IPV6_RECVERR, 1)) {
                Com_WPrintf("%s: %s:%d: can't enable ICMP6 error queue: %s\n",
                            __func__, iface, port, NET_ErrorString());
            }
#endif
 
#ifdef IPV6_V6ONLY
            // disable IPv4-mapped addresses
            if (os_setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, 1)) {
                Com_WPrintf("%s: %s:%d: can't make socket IPv6-only: %s\n",
                            __func__, iface, port, NET_ErrorString());
            }
#endif
        }
 
        if (os_bind(s, rp->ai_addr, rp->ai_addrlen)) {
            Com_EPrintf("%s: %s:%d: can't bind socket: %s\n",
                        __func__, iface, port, NET_ErrorString());
            os_closesocket(s);
            continue;
        }
 
        newsocket = s;
        break;
    }
 
    freeaddrinfo(res);
 
    return newsocket;
}

Referenced by NET_OpenServer(), and NET_OpenServer6().

Variable Documentation

io_entries

ioentry_t io_entries[FD_SETSIZE]

static

Definition at line 122 of file net.c.

Referenced by _os_get_io(), NET_RemoveFd(), NET_Sleep(), os_add_io(), os_get_fd(), and os_get_io().

io_numfds

int io_numfds

static

Definition at line 123 of file net.c.

Referenced by NET_RemoveFd(), NET_Sleep(), os_add_io(), and os_get_io().

net_active

netflag_t net_active

static

Definition at line 109 of file net.c.

Referenced by NET_Config(), and NET_Restart_f().

net_bytes_rcvd

uint64_t net_bytes_rcvd

static

Definition at line 138 of file net.c.

Referenced by NET_GetUdpPackets(), NET_RunStream(), and NET_Stats_f().

net_bytes_sent

uint64_t net_bytes_sent

static

Definition at line 139 of file net.c.

Referenced by NET_RunStream(), NET_SendPacket(), and NET_Stats_f().

net_enable_ipv6

cvar_t* net_enable_ipv6

static

Definition at line 103 of file net.c.

Referenced by NET_Dns_f(), NET_Init(), NET_Listen6(), NET_OpenServer6(), NET_Restart_f(), NET_ShowIP_f(), and NET_StringPairToAdr().

net_error

int net_error

static

Definition at line 110 of file net.c.

Referenced by NET_ErrorString(), NET_RunConnect(), os_bind(), os_connect(), os_get_error(), os_getsockname(), os_getsockopt(), os_listen(), os_make_nonblock(), os_select(), os_setsockopt(), os_socket(), os_udp_recv(), and os_udp_send().

net_from

netadr_t net_from

Definition at line 90 of file net.c.

Referenced by AC_ClientConnect(), CL_ConnectionlessPacket(), CL_DumpStatusResponse(), CL_FindRequest(), CL_PacketEvent(), CL_ParsePrintMessage(), find_client_slot(), NET_AcceptSocket(), NET_GetPackets(), NET_GetUdpPackets(), parse_packet_length(), permit_connection(), redirect(), send_connect_packet(), SV_ConnectionlessPacket(), SV_FlushRedirect(), SV_MvdRunClients(), SV_PacketEvent(), SVC_Ack(), SVC_DirectConnect(), SVC_GetChallenge(), SVC_Info(), SVC_Ping(), SVC_RemoteCommand(), SVC_Status(), UI_StatusEvent(), and userinfo_ip_string().

net_ip

cvar_t* net_ip

Definition at line 86 of file net.c.

Referenced by NET_Connect(), NET_Init(), NET_Listen4(), and NET_OpenServer().

net_ip6

cvar_t* net_ip6

Definition at line 87 of file net.c.

Referenced by NET_Connect(), NET_Init(), NET_Listen6(), and NET_OpenServer6().

net_packets_rcvd

uint64_t net_packets_rcvd

static

Definition at line 140 of file net.c.

Referenced by NET_GetUdpPackets(), and NET_Stats_f().

net_packets_sent

uint64_t net_packets_sent

static

Definition at line 141 of file net.c.

Referenced by NET_SendPacket(), and NET_Stats_f().

net_port

cvar_t* net_port

Definition at line 88 of file net.c.

Referenced by AC_SendHello(), MVD_Spawn(), NET_Init(), NET_Listen4(), NET_Listen6(), NET_OpenServer(), NET_OpenServer6(), and SV_SpawnServer().

net_rate_dn

size_t net_rate_dn

static

Definition at line 129 of file net.c.

Referenced by NET_DnRate_m(), NET_Stats_f(), and NET_UpdateStats().

net_rate_rcvd

size_t net_rate_rcvd

static

Definition at line 127 of file net.c.

Referenced by NET_GetUdpPackets(), NET_RunStream(), and NET_UpdateStats().

net_rate_sent

size_t net_rate_sent

static

Definition at line 128 of file net.c.

Referenced by NET_RunStream(), NET_SendPacket(), and NET_UpdateStats().

net_rate_time

unsigned net_rate_time

static

Definition at line 126 of file net.c.

Referenced by NET_Init(), and NET_UpdateStats().

net_rate_up

size_t net_rate_up

static

Definition at line 130 of file net.c.

Referenced by NET_Stats_f(), NET_UpdateStats(), and NET_UpRate_m().

net_recv_errors

uint64_t net_recv_errors

static

Definition at line 133 of file net.c.

Referenced by NET_GetUdpPackets(), and NET_Stats_f().

net_send_errors

uint64_t net_send_errors

static

Definition at line 134 of file net.c.

Referenced by NET_SendPacket(), and NET_Stats_f().

tcp6_socket

qsocket_t tcp6_socket = -1

static

Definition at line 116 of file net.c.

Referenced by NET_Accept(), NET_Listen6(), NET_Restart_f(), and NET_ShowIP_f().

tcp_socket

qsocket_t tcp_socket = -1

static

Definition at line 113 of file net.c.

Referenced by NET_Accept(), NET_Listen4(), NET_Restart_f(), and NET_ShowIP_f().

udp6_sockets

qsocket_t udp6_sockets[NS_COUNT] = { -1, -1 }

static

Definition at line 115 of file net.c.

Referenced by NET_Config(), NET_GetPackets(), NET_OpenServer6(), NET_SendPacket(), and NET_ShowIP_f().

udp_sockets

qsocket_t udp_sockets[NS_COUNT] = { -1, -1 }

static

Definition at line 112 of file net.c.

Referenced by NET_Config(), NET_GetAddress(), NET_GetPackets(), NET_OpenServer(), NET_SendPacket(), and NET_ShowIP_f().