switch_nat.c File Reference

#include <switch.h>
#include "../libs/miniupnpc/miniwget.h"
#include "../libs/miniupnpc/miniupnpc.h"
#include "../libs/miniupnpc/upnpcommands.h"
#include "../libs/miniupnpc/upnperrors.h"
#include "../libs/libnatpmp/natpmp.h"

Include dependency graph for switch_nat.c:

Go to the source code of this file.

Data Structures
struct	nat_globals_t
struct	nat_globals_perm_t

Macros
#define	MULTICAST_BUFFSIZE   65536
#define	IP_LEN   16
#define	NAT_REFRESH_INTERVAL   900

Functions
static switch_status_t	get_upnp_pubaddr (char *pub_addr)
static int	init_upnp (void)
static int	get_pmp_pubaddr (char *pub_addr)
static int	init_pmp (void)
void	switch_nat_set_mapping (switch_bool_t mapping)
	Update the setting if port mapping will be created. More...
void	switch_nat_reinit (void)
	re-initializes NAT subsystem More...
switch_status_t	init_nat_monitor (switch_memory_pool_t *pool)
static void *SWITCH_THREAD_FUNC	switch_nat_multicast_runtime (switch_thread_t *thread, void *obj)
void	switch_nat_thread_start (void)
void	switch_nat_thread_stop (void)
void	switch_nat_init (switch_memory_pool_t *pool, switch_bool_t mapping)
	Initilize the NAT Traversal System. More...
static switch_status_t	switch_nat_add_mapping_pmp (switch_port_t port, switch_nat_ip_proto_t proto, switch_port_t *external_port)
static switch_status_t	switch_nat_add_mapping_upnp (switch_port_t port, switch_nat_ip_proto_t proto)
static switch_status_t	switch_nat_del_mapping_pmp (switch_port_t port, switch_nat_ip_proto_t proto)
static switch_status_t	switch_nat_del_mapping_upnp (switch_port_t port, switch_nat_ip_proto_t proto)
const char *	switch_nat_get_type (void)
switch_status_t	switch_nat_add_mapping_internal (switch_port_t port, switch_nat_ip_proto_t proto, switch_port_t *external_port, switch_bool_t sticky, switch_bool_t publish)
switch_status_t	switch_nat_add_mapping (switch_port_t port, switch_nat_ip_proto_t proto, switch_port_t *external_port, switch_bool_t sticky)
	Maps a port through the NAT Traversal System. More...
switch_status_t	switch_nat_del_mapping (switch_port_t port, switch_nat_ip_proto_t proto)
	Deletes a NAT mapping. More...
void	switch_nat_republish (void)
	Republishes the nap mappings. More...
	SWITCH_STANDARD_SCHED_FUNC (switch_nat_republish_sched)
void	switch_nat_late_init (void)
	Initilize the rest of the NAT Traversal System. More...
char *	switch_nat_status (void)
	Returns a list of nat mappings and other status info. More...
switch_bool_t	switch_nat_is_initialized (void)
	Has the NAT subsystem been initialized. More...
void	switch_nat_shutdown (void)
	Shuts down the NAT Traversal System. More...

Variables
static nat_globals_t	nat_globals
static nat_globals_perm_t	nat_globals_perm
static switch_bool_t	first_init = SWITCH_TRUE
static switch_bool_t	initialized = SWITCH_FALSE
switch_thread_t *	nat_thread_p = NULL

Macro Definition Documentation

IP_LEN

#define IP_LEN   16

Definition at line 43 of file switch_nat.c.

Referenced by get_pmp_pubaddr(), switch_nat_add_mapping_upnp(), and switch_nat_del_mapping_upnp().

MULTICAST_BUFFSIZE

#define MULTICAST_BUFFSIZE   65536

Definition at line 42 of file switch_nat.c.

Referenced by switch_nat_multicast_runtime().

NAT_REFRESH_INTERVAL

#define NAT_REFRESH_INTERVAL   900

Definition at line 44 of file switch_nat.c.

Referenced by switch_nat_late_init(), and SWITCH_STANDARD_SCHED_FUNC().

Function Documentation

get_pmp_pubaddr()

static int get_pmp_pubaddr ( char *  pub_addr )

static

Definition at line 147 of file switch_nat.c.

References IP_LEN, nat_globals_t::nat_type, SWITCH_CHANNEL_LOG, switch_copy_string(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_NAT_TYPE_PMP, SWITCH_POLL_ERROR, SWITCH_POLL_HUP, SWITCH_POLL_READ, and switch_wait_sock().

Referenced by init_pmp(), and switch_nat_multicast_runtime().

{
        int r = 0, i = 0, max = 5;
        natpmpresp_t response;
        char *pubaddr = NULL;
        natpmp_t natpmp;
        const char *err = NULL;
        int pflags;

        if ((r = initnatpmp(&natpmp)) < 0) {
                err = "init failed";
                goto end;
        }

        if ((r = sendpublicaddressrequest(&natpmp)) < 0) {
                err = "pub addr req failed";
                goto end;
        }

        do {
                struct timeval timeout = { 1, 0 };

                i++;
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Checking for PMP %d/%d\n", i, max);
                if ((r = getnatpmprequesttimeout(&natpmp, &timeout)) < 0) {
                        err = "get timeout failed";
                        goto end;
                }

                pflags = switch_wait_sock(natpmp.s, 1000, SWITCH_POLL_READ | SWITCH_POLL_ERROR | SWITCH_POLL_HUP);

                if ((pflags & SWITCH_POLL_ERROR) || (pflags & SWITCH_POLL_HUP)) {
                        err = "wait sock failed";
                        goto end;
                }
                r = readnatpmpresponseorretry(&natpmp, &response);
        } while (r == NATPMP_TRYAGAIN && i < max);

        if (r < 0) {
                err = "general error";
                goto end;
        }

        pubaddr = inet_ntoa(response.pnu.publicaddress.addr);
        switch_copy_string(pub_addr, pubaddr, IP_LEN);
        nat_globals.nat_type = SWITCH_NAT_TYPE_PMP;

        closenatpmp(&natpmp);

  end:

        if (err) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error checking for PMP [%s]\n", err);
        }

        return r;
}

get_upnp_pubaddr()

static switch_status_t get_upnp_pubaddr ( char *  pub_addr )

static

Definition at line 71 of file switch_nat.c.

References nat_globals_t::data, SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, nat_globals_t::urls, and zstr_buf.

Referenced by init_upnp(), and switch_nat_multicast_runtime().

{
        if (UPNP_GetExternalIPAddress(nat_globals.urls.controlURL, nat_globals.data.servicetype, pub_addr) == UPNPCOMMAND_SUCCESS) {
                if (!strcmp(pub_addr, "0.0.0.0") || zstr_buf(pub_addr)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                          "uPNP Device (url: %s) returned an invalid external address of '%s'.  Disabling uPNP\n", nat_globals.urls.controlURL,
                                                          pub_addr);
                        return SWITCH_STATUS_GENERR;
                }
        } else {
                return SWITCH_STATUS_GENERR;
        }
        return SWITCH_STATUS_SUCCESS;
}

init_nat_monitor()

switch_status_t init_nat_monitor

(

switch_memory_pool_t *

pool

)

Definition at line 220 of file switch_nat.c.

References nat_globals_perm_t::maddress, nat_globals_perm_t::msocket, nat_globals_t::nat_type, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_mcast_join(), SWITCH_NAT_TYPE_PMP, SWITCH_NAT_TYPE_UPNP, SWITCH_SO_NONBLOCK, SWITCH_SO_REUSEADDR, switch_sockaddr_info_get(), switch_socket_bind(), switch_socket_close(), switch_socket_create(), switch_socket_opt_set(), SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TERM, SWITCH_UNSPEC, and TRUE.

Referenced by switch_nat_thread_start().

{
        char *addr = NULL;
        switch_port_t port = 0;

        if (nat_globals.nat_type == SWITCH_NAT_TYPE_UPNP) {
                addr = "239.255.255.250";
                port = 1900;
        } else if (nat_globals.nat_type == SWITCH_NAT_TYPE_PMP) {
                addr = "224.0.0.1";
                port = 5350;
        }

        if (switch_sockaddr_info_get(&nat_globals_perm.maddress, addr, SWITCH_UNSPEC, port, 0, pool) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot find address\n");
                return SWITCH_STATUS_TERM;
        }

        if (switch_socket_create(&nat_globals_perm.msocket, AF_INET, SOCK_DGRAM, 0, pool) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Socket Error\n");
                return SWITCH_STATUS_TERM;
        }

        if (switch_socket_opt_set(nat_globals_perm.msocket, SWITCH_SO_REUSEADDR, 1) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Socket Option Error\n");
                switch_socket_close(nat_globals_perm.msocket);
                return SWITCH_STATUS_TERM;
        }

        if (switch_mcast_join(nat_globals_perm.msocket, nat_globals_perm.maddress, NULL, NULL) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Multicast Error\n");
                switch_socket_close(nat_globals_perm.msocket);
                return SWITCH_STATUS_TERM;
        }

        if (switch_socket_bind(nat_globals_perm.msocket, nat_globals_perm.maddress) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Bind Error\n");
                switch_socket_close(nat_globals_perm.msocket);
                return SWITCH_STATUS_TERM;
        }

        switch_socket_opt_set(nat_globals_perm.msocket, SWITCH_SO_NONBLOCK, TRUE);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "NAT thread configured\n");
        return SWITCH_STATUS_SUCCESS;
}

init_pmp()

static int init_pmp ( void  )

static

Definition at line 205 of file switch_nat.c.

References get_pmp_pubaddr(), and nat_globals_t::pub_addr.

Referenced by switch_nat_init().

{
        return get_pmp_pubaddr(nat_globals.pub_addr);
}

init_upnp()

static int init_upnp ( void  )

static

Definition at line 86 of file switch_nat.c.

References nat_globals_t::data, nat_globals_t::descURL, get_upnp_pubaddr(), memset(), nat_globals_t::nat_type, nat_globals_t::pub_addr, SWITCH_CHANNEL_LOG, switch_core_get_variable(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_NAT_TYPE_UPNP, SWITCH_STATUS_SUCCESS, switch_stristr(), and nat_globals_t::urls.

Referenced by switch_nat_init().

{
        struct UPNPDev *devlist;
        struct UPNPDev *dev = NULL;
        struct UPNPDev *trydev = NULL;
        char *descXML;
        int descXMLsize = 0;
        const char *minissdpdpath = switch_core_get_variable("local_ip_v4");

        memset(&nat_globals.urls, 0, sizeof(struct UPNPUrls));
        memset(&nat_globals.data, 0, sizeof(struct IGDdatas));

        devlist = upnpDiscover(3000, minissdpdpath, minissdpdpath, 0);

        if (devlist) {
                dev = devlist;
                while (dev) {
                        if (strstr(dev->st, "InternetGatewayDevice")) {
                                break;
                        }
                        if (!trydev && !switch_stristr("printer", dev->descURL)) {
                                trydev = dev;
                        }

                        dev = dev->pNext;
                }

        }

        if (!dev && trydev) {
                dev = trydev; /* defaulting to first device */
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "No InternetGatewayDevice, using first entry as default (%s).\n", dev->descURL);
        } else if (devlist && !dev && !trydev) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "No InternetGatewayDevice found and I am NOT going to try your printer because printers should not route to the internet, that would be DAFT\n");
        }

        if (dev) {
                descXML = miniwget(dev->descURL, &descXMLsize);

                nat_globals.descURL = strdup(dev->descURL);

                if (descXML) {
                        parserootdesc(descXML, descXMLsize, &nat_globals.data);
                        free(descXML);
                        descXML = 0;
                        GetUPNPUrls(&nat_globals.urls, &nat_globals.data, dev->descURL);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Unable to retrieve device description XML (%s).\n", dev->descURL);
                }

                freeUPNPDevlist(devlist);
        }

        if (get_upnp_pubaddr(nat_globals.pub_addr) == SWITCH_STATUS_SUCCESS) {
                nat_globals.nat_type = SWITCH_NAT_TYPE_UPNP;
                return 0;
        }

        return -2;
}

switch_nat_add_mapping_internal()

switch_status_t switch_nat_add_mapping_internal	(	switch_port_t	port,
		switch_nat_ip_proto_t	proto,
		switch_port_t *	external_port,
		switch_bool_t	sticky,
		switch_bool_t	publish
	)

Definition at line 580 of file switch_nat.c.

References initialized, nat_globals_t::mapping, nat_globals_t::nat_type, SWITCH_CHANNEL_LOG, switch_event_add_header(), switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_NAT, SWITCH_LOG_INFO, switch_log_printf(), switch_nat_add_mapping_pmp(), switch_nat_add_mapping_upnp(), SWITCH_NAT_TYPE_PMP, SWITCH_NAT_TYPE_UPNP, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_nat_add_mapping(), and switch_nat_republish().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_event_t *event = NULL;

        if (!initialized || !nat_globals.nat_type) return status;
        if (!nat_globals.mapping) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "NAT port mapping disabled\n");
                return status;
        }

        switch (nat_globals.nat_type) {
        case SWITCH_NAT_TYPE_PMP:
                status = switch_nat_add_mapping_pmp(port, proto, external_port);
                break;
        case SWITCH_NAT_TYPE_UPNP:
                if ((status = switch_nat_add_mapping_upnp(port, proto)) == SWITCH_STATUS_SUCCESS) {
                        if (external_port) {
                                *external_port = port;
                        }
                }
                break;
        default:
                break;
        }

        if (publish && status == SWITCH_STATUS_SUCCESS) {
                switch_event_create(&event, SWITCH_EVENT_NAT);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "op", "add");
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "port", "%d", port);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", "%d", proto);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "sticky", (sticky ? "true" : "false"));
                switch_event_fire(&event);
        }

        return status;
}

switch_nat_add_mapping_pmp()

static switch_status_t switch_nat_add_mapping_pmp ( switch_port_t  port, switch_nat_ip_proto_t  proto, switch_port_t *  external_port  )

static

Definition at line 444 of file switch_nat.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, switch_log_printf(), SWITCH_NAT_TCP, SWITCH_NAT_UDP, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_nat_add_mapping_internal().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        natpmpresp_t response;
        int r;
        natpmp_t natpmp;

        initnatpmp(&natpmp);

        if (proto == SWITCH_NAT_TCP) {
                sendnewportmappingrequest(&natpmp, NATPMP_PROTOCOL_TCP, port, port, 31104000);
        } else if (proto == SWITCH_NAT_UDP) {
                sendnewportmappingrequest(&natpmp, NATPMP_PROTOCOL_UDP, port, port, 31104000);
        }

        do {
                fd_set fds;
                struct timeval timeout = { 1, 0 };
                FD_ZERO(&fds);
                FD_SET(natpmp.s, &fds);
                getnatpmprequesttimeout(&natpmp, &timeout);
                select(FD_SETSIZE, &fds, NULL, NULL, &timeout);
                r = readnatpmpresponseorretry(&natpmp, &response);
        } while (r == NATPMP_TRYAGAIN);

        if (r == 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "mapped public port %hu protocol %s to localport %hu\n",
                                                  response.pnu.newportmapping.mappedpublicport,
                                                  response.type == NATPMP_RESPTYPE_UDPPORTMAPPING ? "UDP" :
                                                  (response.type == NATPMP_RESPTYPE_TCPPORTMAPPING ? "TCP" : "UNKNOWN"), response.pnu.newportmapping.privateport);
                if (external_port) {
                        *external_port = response.pnu.newportmapping.mappedpublicport;
                } else if (response.pnu.newportmapping.mappedpublicport != response.pnu.newportmapping.privateport) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "External port %hu protocol %s was not available, it was instead mapped to %hu\n",
                                                          response.pnu.newportmapping.privateport,
                                                          response.type == NATPMP_RESPTYPE_UDPPORTMAPPING ? "UDP" :
                                                          (response.type == NATPMP_RESPTYPE_TCPPORTMAPPING ? "TCP" : "UNKNOWN"), response.pnu.newportmapping.mappedpublicport);
                }

                status = SWITCH_STATUS_SUCCESS;
        }

        closenatpmp(&natpmp);

        return status;
}

switch_nat_add_mapping_upnp()

static switch_status_t switch_nat_add_mapping_upnp ( switch_port_t  port, switch_nat_ip_proto_t  proto  )

static

Definition at line 491 of file switch_nat.c.

References nat_globals_t::data, IP_LEN, nat_globals_t::pvt_addr, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_NAT_TCP, SWITCH_NAT_UDP, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and nat_globals_t::urls.

Referenced by switch_nat_add_mapping_internal().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        char port_str[IP_LEN];
        int r = UPNPCOMMAND_UNKNOWN_ERROR;

        sprintf(port_str, "%d", port);

        if (proto == SWITCH_NAT_TCP) {
                r = UPNP_AddPortMapping(nat_globals.urls.controlURL, nat_globals.data.servicetype, port_str, port_str,
                                                                nat_globals.pvt_addr, "FreeSWITCH", "TCP", 0);
        } else if (proto == SWITCH_NAT_UDP) {
                r = UPNP_AddPortMapping(nat_globals.urls.controlURL, nat_globals.data.servicetype, port_str, port_str,
                                                                nat_globals.pvt_addr, "FreeSWITCH", "UDP", 0);
        }

        if (r == UPNPCOMMAND_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "mapped public port %s protocol %s to localport %s\n", port_str,
                                                  (proto == SWITCH_NAT_TCP) ? "TCP" : "UDP", port_str);
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_nat_del_mapping_pmp()

static switch_status_t switch_nat_del_mapping_pmp ( switch_port_t  port, switch_nat_ip_proto_t  proto  )

static

Definition at line 516 of file switch_nat.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_NAT_TCP, SWITCH_NAT_UDP, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_nat_del_mapping().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        natpmpresp_t response;
        int r;
        natpmp_t natpmp;

        initnatpmp(&natpmp);

        if (proto == SWITCH_NAT_TCP) {
                sendnewportmappingrequest(&natpmp, NATPMP_PROTOCOL_TCP, port, port, 0);
        } else if (proto == SWITCH_NAT_UDP) {
                sendnewportmappingrequest(&natpmp, NATPMP_PROTOCOL_UDP, port, port, 0);
        }

        do {
                fd_set fds;
                struct timeval timeout;
                FD_ZERO(&fds);
                FD_SET(natpmp.s, &fds);
                getnatpmprequesttimeout(&natpmp, &timeout);
                select(FD_SETSIZE, &fds, NULL, NULL, &timeout);
                r = readnatpmpresponseorretry(&natpmp, &response);
        } while (r == NATPMP_TRYAGAIN);

        if (r == 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "unmapped public port %hu protocol %s to localport %hu\n", response.pnu.newportmapping.privateport,     /* This might be wrong but its so 0 isn't displayed */
                                                  response.type == NATPMP_RESPTYPE_UDPPORTMAPPING ? "UDP" :
                                                  (response.type == NATPMP_RESPTYPE_TCPPORTMAPPING ? "TCP" : "UNKNOWN"), response.pnu.newportmapping.privateport);
                status = SWITCH_STATUS_SUCCESS;
        }

        closenatpmp(&natpmp);

        return status;
}

switch_nat_del_mapping_upnp()

static switch_status_t switch_nat_del_mapping_upnp ( switch_port_t  port, switch_nat_ip_proto_t  proto  )

static

Definition at line 553 of file switch_nat.c.

References nat_globals_t::data, IP_LEN, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_NAT_TCP, SWITCH_NAT_UDP, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and nat_globals_t::urls.

Referenced by switch_nat_del_mapping().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        char port_str[IP_LEN];
        int r = UPNPCOMMAND_UNKNOWN_ERROR;

        sprintf(port_str, "%d", port);

        if (proto == SWITCH_NAT_TCP) {
                r = UPNP_DeletePortMapping(nat_globals.urls.controlURL, nat_globals.data.servicetype, port_str, "TCP", 0);
        } else if (proto == SWITCH_NAT_UDP) {
                r = UPNP_DeletePortMapping(nat_globals.urls.controlURL, nat_globals.data.servicetype, port_str, "UDP", 0);
        }

        if (r == UPNPCOMMAND_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "unmapped public port %s protocol %s to localport %s\n", port_str,
                                                  (proto == SWITCH_NAT_TCP) ? "TCP" : "UDP", port_str);
                status = SWITCH_STATUS_SUCCESS;
        }
        return status;
}

switch_nat_multicast_runtime()

static void* SWITCH_THREAD_FUNC switch_nat_multicast_runtime ( switch_thread_t *  thread, void *  obj  )

static

Definition at line 266 of file switch_nat.c.

References buf, nat_globals_t::data, nat_globals_t::descURL, get_pmp_pubaddr(), get_upnp_pubaddr(), nat_globals_perm_t::maddress, memset(), nat_globals_perm_t::msocket, MULTICAST_BUFFSIZE, nat_globals_t::nat_type, nat_globals_t::pub_addr, nat_globals_perm_t::running, switch_assert, SWITCH_CHANNEL_LOG, switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_TRAP, SWITCH_FALSE, SWITCH_LOG_DEBUG, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, switch_nat_reinit(), switch_nat_republish(), SWITCH_NAT_TYPE_UPNP, switch_safe_free, switch_set_string, switch_socket_recvfrom(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_IS_BREAK, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_yield.

Referenced by switch_nat_thread_start().

{
        char *buf = NULL;
        char newip[16] = "";
        char *pos;
        switch_event_t *event = NULL;

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "NAT thread started\n");

        buf = (char *) malloc(MULTICAST_BUFFSIZE);
        switch_assert(buf);
        nat_globals_perm.running = 1;

        while (nat_globals_perm.running == 1) {
                size_t len = MULTICAST_BUFFSIZE;
                switch_status_t status;
                switch_bool_t do_repub = SWITCH_FALSE;
                memset(buf, 0, len);

                status = switch_socket_recvfrom(nat_globals_perm.maddress, nat_globals_perm.msocket, 0, buf, &len);

                if (!len) {
                        if (SWITCH_STATUS_IS_BREAK(status)) {
                                switch_yield(5000000);
                                continue;
                        }

                        break;
                }

                if (nat_globals.nat_type == SWITCH_NAT_TYPE_UPNP) {
                        /* look for our desc URL and servicetype in the packet */
                        if (strstr(buf, nat_globals.descURL) && strstr(buf, nat_globals.data.servicetype)) {
                                if ((pos = strstr(buf, "NTS:"))) {
                                        pos = pos + 4;
                                        while (*pos && *pos == ' ') {
                                                pos++;
                                        }
                                        if (!strncmp(pos, "ssdp:alive", 10)) {
                                                /* switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "got UPnP keep alive packet: \n%s\n", buf); */
                                                /* did pub ip change */
                                                newip[0] = '\0';
                                                if (get_upnp_pubaddr(newip) != SWITCH_STATUS_SUCCESS) {
                                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
                                                                                          "Unable to get current pubaddr after receiving UPnP keep alive packet.\n");
                                                }
                                        } else if (!strncmp(pos, "ssdp:byebye", 11)) {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
                                                                                  "got UPnP signoff packet.  Your NAT gateway is probably going offline.\n");
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "got UPnP signoff packet: \n%s\n", buf);
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "got UNKNOWN UPnP keep alive packet: \n%s\n", buf);
                                        }
                                }
                        }
                } else {
                        /* got some data in NAT-PMP mode, treat any data as a republish event */
                        if (get_pmp_pubaddr(newip) < 0) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unable to get current pubaddr after receiving UPnP keep alive packet.\n");
                        }
                }

                if ((strlen(newip) > 0) && strcmp(newip, "0.0.0.0") && strcmp(newip, nat_globals.pub_addr)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Public IP changed from '%s' to '%s'.\n", nat_globals.pub_addr, newip);
                        do_repub = SWITCH_TRUE;

                        switch_event_create(&event, SWITCH_EVENT_TRAP);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "condition", "network-external-address-change");
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-external-address-previous-v4", nat_globals.pub_addr);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-external-address-change-v4", newip);
                        switch_event_fire(&event);

                        switch_set_string(nat_globals.pub_addr, newip);
                        switch_nat_reinit();
                }

                if (do_repub) {
                        switch_nat_republish();
                }
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "NAT thread ending\n");
        nat_globals_perm.running = 0;

        switch_safe_free(buf);

        return NULL;
}

switch_nat_thread_start()

void switch_nat_thread_start

(

void

)

Definition at line 357 of file switch_nat.c.

References init_nat_monitor(), nat_thread_p, nat_globals_perm_t::pool, SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), switch_nat_multicast_runtime(), SWITCH_STATUS_SUCCESS, switch_thread_create(), and switch_threadattr_create().

Referenced by switch_nat_init().

{

        switch_threadattr_t *thd_attr;

        if (init_nat_monitor(nat_globals_perm.pool) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to initialize NAT thread\n");
                return;
        }

        switch_threadattr_create(&thd_attr, nat_globals_perm.pool);
        switch_thread_create(&nat_thread_p, thd_attr, switch_nat_multicast_runtime, NULL, nat_globals_perm.pool);
}

switch_nat_thread_stop()

void switch_nat_thread_stop

(

void

)

Definition at line 371 of file switch_nat.c.

References nat_thread_p, nat_globals_perm_t::running, SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, switch_log_printf(), SWITCH_LOG_WARNING, switch_thread_join(), and switch_yield.

Referenced by switch_nat_shutdown().

{
        /* don't do anything if no thread ptr */
        if (!nat_thread_p) {
                return;
        }
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping NAT Task Thread\n");
        if (nat_globals_perm.running == 1) {
                int sanity = 0;
                switch_status_t st;

                nat_globals_perm.running = -1;

                switch_thread_join(&st, nat_thread_p);

                while (nat_globals_perm.running) {
                        switch_yield(1000000);  /* can take up to 5s for the thread to terminate, so wait for 10 */
                        if (++sanity > 10) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Timed out waiting for NAT Task Thread to stop\n");
                                break;
                        }
                }
        }

        nat_thread_p = NULL;
}

SWITCH_STANDARD_SCHED_FUNC()

SWITCH_STANDARD_SCHED_FUNC

(

switch_nat_republish_sched

)

Definition at line 700 of file switch_nat.c.

References NAT_REFRESH_INTERVAL, nat_globals_perm_t::running, switch_epoch_time_now(), and switch_nat_republish().

{
        switch_nat_republish();
        if (nat_globals_perm.running == 1) {
                task->runtime = switch_epoch_time_now(NULL) + NAT_REFRESH_INTERVAL;
        }
}

Variable Documentation

first_init

switch_bool_t first_init = SWITCH_TRUE

static

Definition at line 68 of file switch_nat.c.

Referenced by switch_nat_init().

initialized

switch_bool_t initialized = SWITCH_FALSE

static

Definition at line 69 of file switch_nat.c.

Referenced by switch_nat_add_mapping_internal(), switch_nat_init(), and switch_nat_is_initialized().

nat_globals

nat_globals_t nat_globals

static

Definition at line 57 of file switch_nat.c.

nat_globals_perm

nat_globals_perm_t nat_globals_perm

static

Definition at line 66 of file switch_nat.c.

nat_thread_p

switch_thread_t* nat_thread_p = NULL

Definition at line 355 of file switch_nat.c.

Referenced by switch_nat_init(), switch_nat_thread_start(), and switch_nat_thread_stop().