net.c File Reference

#include <arpa/inet.h>
#include <ifaddrs.h>
#include <netdb.h>
#include <netinet/ip.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "utils/net.h"
#include "utils/windows.h"
#include "debug.h"

Include dependency graph for net.c:

Go to the source code of this file.

Macros
#define	closesocket   close
#define	IN_LOOPBACKNET   127
#define	INVALID_SOCKET   (-1)
#define	IPV4_LL_PREFIX   ((169u<<8u) | 254u)
#define	MOD_NAME   "[utils/net] "

Functions
bool	get_local_addresses (struct sockaddr_storage *addrs, size_t *len, int ip_version)
unsigned	get_sockaddr_addr_port (struct sockaddr *sa)
void	get_sockaddr_addr_str (struct sockaddr *sa, char *buf, size_t n)
const char *	get_sockaddr_str (struct sockaddr *sa)
static bool	is_addr4 (const char *addr)
static bool	is_addr6 (const char *addr)
bool	is_addr_linklocal (struct sockaddr *sa)
bool	is_addr_loopback (struct sockaddr *sa)
bool	is_addr_multicast (const char *addr)
bool	is_addr_private (struct sockaddr *sa)
bool	is_host_loopback (const char *hostname)
bool	is_host_private (const char *hostname)
bool	is_ipv6_supported (void)
static struct addrinfo *	resolve_host (const char *hostname, const char *err_prefix)
uint16_t	socket_get_recv_port (int fd)
const char *	ug_gai_strerror (int errcode)

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file net.c.

Macro Definition Documentation

closesocket

#define closesocket   close

Definition at line 52 of file net.c.

Referenced by is_ipv6_supported().

IN_LOOPBACKNET

#define IN_LOOPBACKNET   127

Definition at line 74 of file net.c.

Referenced by is_addr_loopback().

INVALID_SOCKET

#define INVALID_SOCKET   (-1)

Definition at line 53 of file net.c.

Referenced by is_ipv6_supported().

IPV4_LL_PREFIX

#define IPV4_LL_PREFIX   ((169u<<8u) | 254u)

Definition at line 70 of file net.c.

Referenced by is_addr_linklocal().

MOD_NAME

#define MOD_NAME   "[utils/net] "

Definition at line 77 of file net.c.

Function Documentation

get_local_addresses()

bool get_local_addresses	(	struct sockaddr_storage *	addrs,
		size_t *	len,
		int	ip_version )

Returns (in output parameter) list of local public IP addresses

Code was taken perhaps from: https://social.msdn.microsoft.com/Forums/en-US/3b6a92ac-93d3-4f59-a914-340c1ba41cff/how-to-retrieve-ip-addresses-of-the-network-cards-with-getadaptersaddresses

Parameters

[out]	addrs	storage allocate to copy the addresses
[in]	len	length of allocated space (in bytes)
[out]	len	length of returned addresses (in parameter addrs, in bytes)
	ip_version	6 for IPv6, 4 for IPv6, 0 both

Definition at line 229 of file net.c.

{
        assert(ip_version == 0 || ip_version == 4 || ip_version == 6);
#ifdef _WIN32
#define WORKING_BUFFER_SIZE 15000
#define MAX_TRIES 3
        /* Declare and initialize variables */
        DWORD dwRetVal = 0;
        size_t len_remaining = *len;
        *len = 0;
 
        PIP_ADAPTER_ADDRESSES pAddresses = NULL;
        ULONG outBufLen = 0;
        ULONG Iterations = 0;
 
        PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
        PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
 
        // Allocate a 15 KB buffer to start with.
        outBufLen = WORKING_BUFFER_SIZE;
 
        do {
                pAddresses = (IP_ADAPTER_ADDRESSES *) malloc(outBufLen);
                if (pAddresses == NULL) {
                        printf
                                ("Memory allocation failed for IP_ADAPTER_ADDRESSES struct\n");
                        return false;
                }
 
                ULONG family = ip_version == 4 ? AF_INET
                        : ip_version == 6 ? AF_INET6
                        : AF_UNSPEC; // both
                dwRetVal =
                        GetAdaptersAddresses(family, 0, NULL, pAddresses, &outBufLen);
 
                if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
                        free(pAddresses);
                        pAddresses = NULL;
                } else {
                        break;
                }
                Iterations++;
        } while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations < MAX_TRIES));
 
        if (dwRetVal == NO_ERROR) {
                // If successful, output some information from the data we received
                pCurrAddresses = pAddresses;
                while (pCurrAddresses) {
 
                        pUnicast = pCurrAddresses->FirstUnicastAddress;
                        while (pUnicast != NULL) {
                                if (len_remaining < sizeof(addrs[0])) {
                                        printf("Warning: insufficient space for all addresses.\n");
                                        return true;
                                }
                                size_t sa_len = pUnicast->Address.lpSockaddr->sa_family == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
                                memcpy(addrs, pUnicast->Address.lpSockaddr, sa_len);
                                addrs += 1;
                                *len += sizeof(addrs[0]);
                                len_remaining -= sizeof(addrs[0]);
                                pUnicast = pUnicast->Next;
                        }
 
                        pCurrAddresses = pCurrAddresses->Next;
                }
        } else {
                printf("Call to GetAdaptersAddresses failed with error: %ld\n",
                                dwRetVal);
                if (dwRetVal == ERROR_NO_DATA)
                        printf("\tNo addresses were found for the requested parameters\n");
                else {
                        log_msg(LOG_LEVEL_ERROR, "Error: %s\n",
                                get_win32_error(dwRetVal));
                        if (pAddresses)
                                free(pAddresses);
                        return false;
                }
        }
 
        if (pAddresses) {
                free(pAddresses);
        }
 
        return true;
#else // ! defined _WIN32
        size_t available_len = *len;
        *len = 0;
        struct ifaddrs* a = NULL;
        getifaddrs(&a);
        struct ifaddrs* p = a;
        while (NULL != p) {
                if (p->ifa_addr == NULL ||
                    (ip_version == 0 && (p->ifa_addr->sa_family != AF_INET &&
                                         p->ifa_addr->sa_family != AF_INET6)) ||
                    (ip_version == 4 && p->ifa_addr->sa_family != AF_INET) ||
                    (ip_version == 6 && p->ifa_addr->sa_family != AF_INET6)) {
                        p = p->ifa_next;
                        continue;
                }
                if (available_len < sizeof addrs[0]) {
                        MSG(WARNING,
                            "Warning: insufficient space for all addresses.\n");
                        return true;
                }
                size_t sa_len = p->ifa_addr->sa_family == AF_INET
                                    ? sizeof(struct sockaddr_in)
                                    : sizeof(struct sockaddr_in6);
                memcpy(addrs, p->ifa_addr, sa_len);
                addrs += 1;
                *len += sizeof(addrs[0]);
                available_len -= sizeof(addrs[0]);
 
                p = p->ifa_next;
        }
        if (NULL != a) {
                freeifaddrs(a);
        }
        return true;
#endif
}

References len, LOG_LEVEL_ERROR, log_msg(), and MSG.

Referenced by new_sdp().

Here is the call graph for this function:

get_sockaddr_addr_port()

unsigned get_sockaddr_addr_port

(

struct sockaddr *

sa

)

Definition at line 414 of file net.c.

                                                    {
        unsigned port = 0;
        if (sa->sa_family == AF_INET6) {
                port = ntohs(((struct sockaddr_in6 *)(void *) sa)->sin6_port);
        } else if (sa->sa_family == AF_INET) {
                port = ntohs(((struct sockaddr_in *)(void *) sa)->sin_port);
        } else {
                return UINT_MAX;
        }
 
        return port;
}

Referenced by get_sockaddr_str(), and Participant_manager::tick().

get_sockaddr_addr_str()

void get_sockaddr_addr_str	(	struct sockaddr *	sa,
		char *	buf,
		size_t	n )

Definition at line 427 of file net.c.

                                                                    {
        assert(n >= IN6_MAX_ASCII_LEN + 3 /* []: */ + 1 /* \0 */);
        const void *src = NULL;
        if (sa->sa_family == AF_INET6) {
                snprintf(buf, n, "[");
                src = &((struct sockaddr_in6 *)(void *) sa)->sin6_addr;
        } else if (sa->sa_family == AF_INET) {
                src = &((struct sockaddr_in *)(void *) sa)->sin_addr;
        } else {
                snprintf(buf, n, "(unknown)");
                return;
        }
        if (inet_ntop(sa->sa_family, src, buf + strlen(buf), n - strlen(buf)) == NULL) {
                perror("get_sockaddr_str");
                snprintf(buf, n, "(error)");
                return;
        }
 
        if (sa->sa_family == AF_INET6) {
                snprintf(buf + strlen(buf), n - strlen(buf), "]");
        }
}

References IN6_MAX_ASCII_LEN.

Referenced by get_sockaddr_str(), and Participant_manager::tick().

get_sockaddr_str()

const char * get_sockaddr_str

(

struct sockaddr *

sa

)

Definition at line 450 of file net.c.

{
        enum { ADDR_LEN = IN6_MAX_ASCII_LEN + 3 /* []: */ + 5 /* port */ + 1 /* \0 */ };
        _Thread_local static char addr[ADDR_LEN] = "";
        addr[0] = '\0';
 
        get_sockaddr_addr_str(sa, addr, sizeof(addr));
 
        unsigned port = get_sockaddr_addr_port(sa);
        if(port == UINT_MAX)
                return addr;
        snprintf(addr + strlen(addr), ADDR_LEN - strlen(addr), ":%u", port);
 
        return addr;
}

References get_sockaddr_addr_port(), get_sockaddr_addr_str(), and IN6_MAX_ASCII_LEN.

Referenced by rtp_process_data(), and Participant_manager::tick().

Here is the call graph for this function:

is_addr4()

static bool is_addr4 ( const char * addr )

static

Checks if the address is a dot-separated numeric IPv4 address.

Definition at line 353 of file net.c.

                                       {
        // only basic check
        while (*addr != '\0') {
                if (!isdigit(*addr) && *addr != '.') {
                        return false;
                }
                addr++;
        }
        return true;
}

Referenced by is_addr_multicast().

is_addr6()

static bool is_addr6 ( const char * addr )

static

Checks if the address is a colon-separated numeric IPv6 address (with optional zone index).

Definition at line 368 of file net.c.

                                       {
        while (*addr != '\0') {
                if (*addr == '%') { // skip zone identification at the end
                        return true;
                }
                // only basic check
                if (!isxdigit(*addr) && *addr != ':') {
                        return false;
                }
                addr++;
        }
        return true;
}

Referenced by is_addr_multicast().

is_addr_linklocal()

bool is_addr_linklocal

(

struct sockaddr *

sa

)

Definition at line 79 of file net.c.

{
        switch (sa->sa_family) {
        case AF_INET:
        {
                struct sockaddr_in *sin = (struct sockaddr_in *)(void *) sa;
                uint32_t addr = ntohl(sin->sin_addr.s_addr);
                if ((addr >> 16u) == IPV4_LL_PREFIX) {
                        return true;
                }
                return false;
        }
        case AF_INET6:
        {
                struct sockaddr_in6 *sin = (struct sockaddr_in6 *)(void *) sa;
                if (IN6_IS_ADDR_V4MAPPED(&sin->sin6_addr)) {
                        uint32_t v4_addr = ntohl(*((uint32_t*)(void *)(sin->sin6_addr.s6_addr + 12)));
                        if ((v4_addr >> 16u) == IPV4_LL_PREFIX) {
                                return true;
                        }
                        return false;
                }
                return IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr);
        }
        default:
                return false;
        }
}

References IPV4_LL_PREFIX.

Referenced by new_sdp().

is_addr_loopback()

bool is_addr_loopback

(

struct sockaddr *

sa

)

Definition at line 108 of file net.c.

{
        switch (sa->sa_family) {
        case AF_UNIX:
                return true;
        case AF_INET:
        {
                struct sockaddr_in *sin = (struct sockaddr_in *)(void *) sa;
                uint32_t addr = ntohl(sin->sin_addr.s_addr);
                if ((addr >> 24u) == IN_LOOPBACKNET) {
                        return true;
                }
                return false;
        }
        case AF_INET6:
        {
                struct sockaddr_in6 *sin = (struct sockaddr_in6 *)(void *) sa;
                if (IN6_IS_ADDR_V4MAPPED(&sin->sin6_addr)) {
                        uint32_t v4_addr = ntohl(*((uint32_t*)(void *)(sin->sin6_addr.s6_addr + 12)));
                        if ((v4_addr >> 24u) == IN_LOOPBACKNET) {
                                return true;
                        }
                        return false;
                }
                return IN6_IS_ADDR_LOOPBACK(&sin->sin6_addr);
        }
        default:
                return false;
        }
}

References IN_LOOPBACKNET.

Referenced by control_thread(), is_host_loopback(), is_host_private(), and new_sdp().

is_addr_multicast()

bool is_addr_multicast

(

const char *

addr

)

Definition at line 382 of file net.c.

{
        if (is_addr4(addr)) {
                unsigned int first_addr_byte = atoi(addr);
                if ((first_addr_byte >> 4) == 0xe) {
                        return true;
                }
                return false;
 
        }
        if (is_addr6(addr)) {
                if (strlen(addr) >= 2 && addr[0] == 'f' && addr[1] == 'f') {
                        return true;
                }
                return false;
 
        }
        return false;
}

References is_addr4(), and is_addr6().

Referenced by udp_init_if().

Here is the call graph for this function:

is_addr_private()

bool is_addr_private

(

struct sockaddr *

sa

)

Definition at line 139 of file net.c.

{
        switch (sa->sa_family) {
        case AF_UNIX:
                return true;
        case AF_INET:
        {
                struct sockaddr_in *sin = (struct sockaddr_in *)(void *) sa;
                uint32_t addr = ntohl(sin->sin_addr.s_addr);
                return ((addr >> 24U) == 10) || ((addr >> 20U) == 2753) || ((addr >> 16U) == 49320);
        }
        case AF_INET6:
        {
                struct sockaddr_in6 *sin = (struct sockaddr_in6 *)(void *) sa;
                return (sin->sin6_addr.s6_addr[0] & 0xFEU) == 0xFCU; // ULA
        }
        default:
                return false;
        }
}

Referenced by start_nat_traverse().

is_host_loopback()

bool is_host_loopback

(

const char *

hostname

)

Definition at line 174 of file net.c.

{
        struct addrinfo *ai = resolve_host(hostname, "is_host_loopback: ");
        if (ai == NULL) {
                return false;
        }
 
        bool ret = is_addr_loopback(ai->ai_addr);
        freeaddrinfo(ai);
 
        return ret;
}

References is_addr_loopback(), and resolve_host().

Referenced by adjust_params(), rtp_init_if(), start_nat_traverse(), and udp_init_if().

Here is the call graph for this function:

is_host_private()

bool is_host_private

(

const char *

hostname

)

Definition at line 187 of file net.c.

{
        struct addrinfo *ai = resolve_host(hostname, "is_host_private: ");
        if (ai == NULL) {
                return false;
        }
 
        bool ret = is_addr_loopback(ai->ai_addr);
        freeaddrinfo(ai);
 
        return ret;
}

References is_addr_loopback(), and resolve_host().

Referenced by start_nat_traverse().

Here is the call graph for this function:

is_ipv6_supported()

bool is_ipv6_supported

(

void

)

Definition at line 402 of file net.c.

{
        fd_t fd = socket(AF_INET6, SOCK_DGRAM, 0);
        if (fd == INVALID_SOCKET && errno == EAFNOSUPPORT) {
                return false;
        }
        if (fd != INVALID_SOCKET) {
                closesocket(fd);
        }
        return true;
}

References closesocket, and INVALID_SOCKET.

Referenced by adjust_params().

resolve_host()

static struct addrinfo * resolve_host ( const char * hostname, const char * err_prefix )

static

Definition at line 160 of file net.c.

{
        int gai_err = 0;
        struct addrinfo *ai = NULL;
        struct addrinfo hints = { .ai_family = AF_UNSPEC, .ai_socktype = SOCK_DGRAM };
 
        if ((gai_err = getaddrinfo(hostname, NULL, &hints, &ai)) != 0) {
                error_msg("%sgetaddrinfo: %s: %s\n", err_prefix, hostname,
                                ug_gai_strerror(gai_err));
                return NULL;
        }
        return ai;
}

References error_msg, and ug_gai_strerror().

Referenced by is_host_loopback(), and is_host_private().

Here is the call graph for this function:

socket_get_recv_port()

uint16_t socket_get_recv_port

(

int

fd

)

Definition at line 200 of file net.c.

{
        struct sockaddr_storage ss;
        socklen_t len = sizeof(ss);
        if (getsockname(fd, (struct sockaddr *)&ss, &len) == -1) {
                perror("getsockname");
                return 0;
        }
        switch (ss.ss_family) {
        case AF_INET:
                return ntohs(((struct sockaddr_in *) &ss)->sin_port);
        case AF_INET6:
                return ntohs(((struct sockaddr_in6 *) &ss)->sin6_port);
        default:
                return 0;
        }
}

References len.

Referenced by control_start(), and process_messages().

ug_gai_strerror()

const char * ug_gai_strerror

(

int

errcode

)

Definition at line 466 of file net.c.

{
#ifdef _WIN32
        UNUSED(errcode);
        // also `win_wstr_to_str(gai_strerrorW(errcode);` would work; it is localized, but with correct diacritics
        return get_win32_error(WSAGetLastError());
#else
        return gai_strerror(errcode);
#endif // ! defined _WIN32
}

References UNUSED.

Referenced by resolve_addrinfo(), resolve_host(), udp_host_addr6(), and udp_init_if().