stun.c File Reference

STUN Support. More...

#include "asterisk.h"
#include "asterisk/logger.h"
#include "asterisk/logger_category.h"
#include "asterisk/_private.h"
#include "asterisk/stun.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/channel.h"

Include dependency graph for stun.c:

Go to the source code of this file.

Data Structures
struct	stun_addr
struct	stun_attr
struct	stun_header
struct	stun_state
	here we store credentials extracted from a message More...
struct	stun_trans_id
	STUN support code. More...

Macros
#define	STUN_BINDERR   0x0111
#define	STUN_BINDREQ   0x0001
	STUN message types 'BIND' refers to transactions used to determine the externally visible addresses. 'SEC' refers to transactions used to establish a session key for subsequent requests. 'SEC' functionality is not supported here. More...
#define	STUN_BINDRESP   0x0101
#define	STUN_CHANGE_REQUEST   0x0003
#define	STUN_CHANGED_ADDRESS   0x0005
#define	STUN_ERROR_CODE   0x0009
#define	STUN_MAPPED_ADDRESS   0x0001
	Basic attribute types in stun messages. Messages can also contain custom attributes (codes above 0x7fff) More...
#define	STUN_MAX_RETRIES   3
#define	STUN_MESSAGE_INTEGRITY   0x0008
#define	STUN_PASSWORD   0x0007
#define	STUN_REFLECTED_FROM   0x000b
#define	STUN_RESPONSE_ADDRESS   0x0002
#define	STUN_SECERR   0x0112
#define	STUN_SECREQ   0x0002
#define	STUN_SECRESP   0x0102
#define	STUN_SOURCE_ADDRESS   0x0004
#define	STUN_UNKNOWN_ATTRIBUTES   0x000a
#define	STUN_USERNAME   0x0006

Functions
static void	append_attr_address (struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
	append an address to an STUN message More...
static void	append_attr_string (struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
	append a string to an STUN message More...
uintmax_t	ast_debug_category_stun_id (void)
uintmax_t	ast_debug_category_stun_packet_id (void)
int	ast_stun_handle_packet (int s, struct sockaddr_in *src, unsigned char *data, size_t len, stun_cb_f *stun_cb, void *arg)
	handle an incoming STUN message. More...
void	ast_stun_init (void)
	Initialize the STUN system in Asterisk. More...
int	ast_stun_request (int s, struct sockaddr_in *dst, const char *username, struct sockaddr_in *answer)
	Generic STUN request. More...
static char *	handle_cli_stun_set_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	handle_stun_timeout (int retry, struct sockaddr_in *dst)
static const char *	stun_attr2str (int msg)
	helper function to print attribute names More...
static int	stun_get_mapped (struct stun_attr *attr, void *arg)
	Extract the STUN_MAPPED_ADDRESS from the stun response. This is used as a callback for stun_handle_response when called from ast_stun_request. More...
static int	stun_id_cmp (stun_trans_id *left, stun_trans_id *right)
static const char *	stun_msg2str (int msg)
	helper function to print message names More...
static int	stun_process_attr (struct stun_state *state, struct stun_attr *attr)
static void	stun_req_id (struct stun_header *req)
	helper function to generate a random request id More...
static int	stun_send (int s, struct sockaddr_in *dst, struct stun_header *resp)
	wrapper to send an STUN message More...
static void	stun_shutdown (void)

Variables
static struct ast_cli_entry	cli_stun []
static uintmax_t	debug_category_stun_id
static uintmax_t	debug_category_stun_packet_id

Detailed Description

STUN Support.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Note

STUN is defined in RFC 3489.

Definition in file stun.c.

Macro Definition Documentation

STUN_BINDERR

#define STUN_BINDERR   0x0111

Definition at line 103 of file stun.c.

STUN_BINDREQ

#define STUN_BINDREQ   0x0001

STUN message types 'BIND' refers to transactions used to determine the externally visible addresses. 'SEC' refers to transactions used to establish a session key for subsequent requests. 'SEC' functionality is not supported here.

Definition at line 101 of file stun.c.

STUN_BINDRESP

#define STUN_BINDRESP   0x0101

Definition at line 102 of file stun.c.

STUN_CHANGE_REQUEST

#define STUN_CHANGE_REQUEST   0x0003

Definition at line 113 of file stun.c.

STUN_CHANGED_ADDRESS

#define STUN_CHANGED_ADDRESS   0x0005

Definition at line 115 of file stun.c.

STUN_ERROR_CODE

#define STUN_ERROR_CODE   0x0009

Definition at line 119 of file stun.c.

STUN_MAPPED_ADDRESS

#define STUN_MAPPED_ADDRESS   0x0001

Basic attribute types in stun messages. Messages can also contain custom attributes (codes above 0x7fff)

Definition at line 111 of file stun.c.

STUN_MAX_RETRIES

#define STUN_MAX_RETRIES   3

Definition at line 123 of file stun.c.

STUN_MESSAGE_INTEGRITY

#define STUN_MESSAGE_INTEGRITY   0x0008

Definition at line 118 of file stun.c.

STUN_PASSWORD

#define STUN_PASSWORD   0x0007

Definition at line 117 of file stun.c.

STUN_REFLECTED_FROM

#define STUN_REFLECTED_FROM   0x000b

Definition at line 121 of file stun.c.

STUN_RESPONSE_ADDRESS

#define STUN_RESPONSE_ADDRESS   0x0002

Definition at line 112 of file stun.c.

STUN_SECERR

#define STUN_SECERR   0x0112

Definition at line 106 of file stun.c.

STUN_SECREQ

#define STUN_SECREQ   0x0002

Definition at line 104 of file stun.c.

STUN_SECRESP

#define STUN_SECRESP   0x0102

Definition at line 105 of file stun.c.

STUN_SOURCE_ADDRESS

#define STUN_SOURCE_ADDRESS   0x0004

Definition at line 114 of file stun.c.

STUN_UNKNOWN_ATTRIBUTES

#define STUN_UNKNOWN_ATTRIBUTES   0x000a

Definition at line 120 of file stun.c.

STUN_USERNAME

#define STUN_USERNAME   0x0006

Definition at line 116 of file stun.c.

Function Documentation

append_attr_address()

static void append_attr_address ( struct stun_attr **  attr, int  attrval, struct sockaddr_in *  sin, int *  len, int *  left  )

static

append an address to an STUN message

Definition at line 222 of file stun.c.

{
    int size = sizeof(**attr) + 8;
    struct stun_addr *addr;
    if (*left > size) {
        (*attr)->attr = htons(attrval);
        (*attr)->len = htons(8);
        addr = (struct stun_addr *)((*attr)->value);
        addr->unused = 0;
        addr->family = 0x01;
        addr->port = sin->sin_port;
        addr->addr = sin->sin_addr.s_addr;
        (*attr) = (struct stun_attr *)((*attr)->value + 8);
        *len += size;
        *left -= size;
    }
}

References stun_addr::addr, and len().

Referenced by ast_stun_handle_packet().

append_attr_string()

static void append_attr_string ( struct stun_attr **  attr, int  attrval, const char *  s, int *  len, int *  left  )

static

append a string to an STUN message

Definition at line 205 of file stun.c.

{
    int str_length = strlen(s);
    int attr_length = str_length + ((~(str_length - 1)) & 0x3);
    int size = sizeof(**attr) + attr_length;
    if (*left > size) {
        (*attr)->attr = htons(attrval);
        (*attr)->len = htons(attr_length);
        memcpy((*attr)->value, s, str_length);
        memset((*attr)->value + str_length, 0, attr_length - str_length);
        (*attr) = (struct stun_attr *)((*attr)->value + attr_length);
        *len += size;
        *left -= size;
    }
}

References len().

Referenced by ast_stun_handle_packet(), and ast_stun_request().

ast_debug_category_stun_id()

uintmax_t ast_debug_category_stun_id

(

void

)

Definition at line 555 of file stun.c.

{
    return debug_category_stun_id;
}

References debug_category_stun_id.

ast_debug_category_stun_packet_id()

uintmax_t ast_debug_category_stun_packet_id

(

void

)

Definition at line 562 of file stun.c.

{
    return debug_category_stun_packet_id;
}

References debug_category_stun_packet_id.

ast_stun_handle_packet()

int ast_stun_handle_packet	(	int	s,
		struct sockaddr_in *	src,
		unsigned char *	data,
		size_t	len,
		stun_cb_f *	stun_cb,
		void *	arg
	)

handle an incoming STUN message.

Parameters

s	Socket to send any response to.
src	Address where packet came from.
data	STUN packet buffer to process.
len	Length of packet
stun_cb	If not NULL, callback for each STUN attribute.
arg	Arg to pass to callback.

Do some basic sanity checks on packet size and content, try to extract a bit of information, and possibly reply. At the moment this only processes BIND requests, and returns the externally visible address of the request. If a callback is specified, invoke it with the attribute.

Return values

AST_STUN_ACCEPT	if responed to a STUN request
AST_STUN_IGNORE
-1	on error

Definition at line 293 of file stun.c.

{
    struct stun_header *hdr = (struct stun_header *)data;
    struct stun_attr *attr;
    struct stun_state st;
    int ret = AST_STUN_IGNORE;
    int x;
 
    /* On entry, 'len' is the length of the udp payload. After the
     * initial checks it becomes the size of unprocessed options,
     * while 'data' is advanced accordingly.
     */
    if (len < sizeof(struct stun_header)) {
        ast_debug_stun(1, "Runt STUN packet (only %d, wanting at least %d)\n", (int) len, (int) sizeof(struct stun_header));
        return -1;
    }
    len -= sizeof(struct stun_header);
    data += sizeof(struct stun_header);
    x = ntohs(hdr->msglen); /* len as advertised in the message */
    if (ast_debug_stun_packet_is_allowed)
        ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), (unsigned)ntohs(hdr->msgtype), x);
    if (x > len) {
        ast_debug_stun(1, "Scrambled STUN packet length (got %d, expecting %d)\n", x, (int)len);
    } else
        len = x;
    memset(&st, 0, sizeof(st));
    while (len) {
        if (len < sizeof(struct stun_attr)) {
            ast_debug_stun(1, "Runt Attribute (got %d, expecting %d)\n", (int)len, (int) sizeof(struct stun_attr));
            break;
        }
        attr = (struct stun_attr *)data;
        /* compute total attribute length */
        x = ntohs(attr->len) + sizeof(struct stun_attr);
        if (x > len) {
            ast_debug_stun(1, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", x, (int)len);
            break;
        }
        if (stun_cb)
            stun_cb(attr, arg);
        if (stun_process_attr(&st, attr)) {
            ast_debug_stun(1, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), (unsigned)ntohs(attr->attr));
            break;
        }
        /* Clear attribute id: in case previous entry was a string,
         * this will act as the terminator for the string.
         */
        attr->attr = 0;
        data += x;
        len -= x;
    }
    /* Null terminate any string.
     * XXX NOTE, we write past the size of the buffer passed by the
     * caller, so this is potentially dangerous. The only thing that
     * saves us is that usually we read the incoming message in a
     * much larger buffer in the struct ast_rtp
     */
    *data = '\0';
 
    /* Now prepare to generate a reply, which at the moment is done
     * only for properly formed (len == 0) STUN_BINDREQ messages.
     */
    if (len == 0) {
        unsigned char respdata[1024];
        struct stun_header *resp = (struct stun_header *)respdata;
        int resplen = 0;    /* len excluding header */
        int respleft = sizeof(respdata) - sizeof(struct stun_header);
        char combined[33];
 
        resp->id = hdr->id;
        resp->msgtype = 0;
        resp->msglen = 0;
        attr = (struct stun_attr *)resp->ies;
        switch (ntohs(hdr->msgtype)) {
        case STUN_BINDREQ:
            if (ast_debug_stun_packet_is_allowed)
                ast_verbose("STUN Bind Request, username: %s\n",
                        st.username ? st.username : "<none>");
            if (st.username) {
                append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
                /*
                 * For Google Voice, the stun username is made up of the local
                 * and remote usernames, each being fixed at 16 bytes.  We have
                 * to swap the two at this point.
                 */
                snprintf(combined, 17, "%16s", st.username + 16);
                snprintf(combined + 16, 17, "%16s", st.username);
            } else {
                combined[0] = '\0';
            }
 
            append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
            resp->msglen = htons(resplen);
            resp->msgtype = htons(STUN_BINDRESP);
            stun_send(s, src, resp);
            ast_stun_request(s, src, combined, NULL);
            ret = AST_STUN_ACCEPT;
            break;
        default:
            if (ast_debug_stun_packet_is_allowed)
                ast_verbose("Dunno what to do with STUN message %04x (%s)\n", (unsigned)ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
        }
    }
    return ret;
}

References append_attr_address(), append_attr_string(), ast_debug_stun, ast_debug_stun_packet_is_allowed, AST_STUN_ACCEPT, AST_STUN_IGNORE, ast_stun_request(), ast_verbose(), stun_attr::attr, stun_header::id, stun_header::ies, len(), stun_header::msglen, stun_header::msgtype, NULL, stun_attr2str(), STUN_BINDREQ, STUN_BINDRESP, STUN_MAPPED_ADDRESS, stun_msg2str(), stun_process_attr(), stun_send(), STUN_USERNAME, and stun_state::username.

Referenced by ast_rtcp_read(), ast_rtp_read(), and ast_stun_request().

ast_stun_init()

void ast_stun_init

(

void

)

Initialize the STUN system in Asterisk.

Provided by stun.c

Definition at line 576 of file stun.c.

{
    ast_cli_register_multiple(cli_stun, sizeof(cli_stun) / sizeof(struct ast_cli_entry));
    debug_category_stun_id = ast_debug_category_register(AST_LOG_CATEGORY_STUN);
    debug_category_stun_packet_id = ast_debug_category_register(AST_LOG_CATEGORY_STUN_PACKET);
 
    /*
     * Normnally a core module should call ast_register_cleanup
     * which doesn't run if any module fails to unload.  This
     * prevents resources being pulled out from under a running
     * module and ppossibly causing a segfault.  In this case however,
     * the only thing we're cleaning up is the cli command and
     * the registers of the debug categories.
     */
    ast_register_atexit(stun_shutdown);
 
}

References ast_cli_register_multiple, ast_debug_category_register(), AST_LOG_CATEGORY_STUN, AST_LOG_CATEGORY_STUN_PACKET, ast_register_atexit(), cli_stun, debug_category_stun_id, debug_category_stun_packet_id, and stun_shutdown().

Referenced by asterisk_daemon().

ast_stun_request()

int ast_stun_request	(	int	s,
		struct sockaddr_in *	dst,
		const char *	username,
		struct sockaddr_in *	answer
	)

Generic STUN request.

Parameters

s	The socket used to send the request.
dst	If non null, the address of the STUN server. Only needed if the socket is not bound or connected.
username	If non null, add the username in the request.
answer	If non null, the function waits for a response and puts here the externally visible address.

Send a generic STUN request to the server specified, possibly waiting for a reply and filling the answer parameter with the externally visible address. Note that in this case the request will be blocking.

Note

The interface may change slightly in the future.

Return values

0	on success.
<0	on error.
>0	on timeout.

Definition at line 415 of file stun.c.

{
    struct stun_header *req;
    struct stun_header *rsp;
    unsigned char req_buf[1024];
    unsigned char rsp_buf[1024];
    int reqlen, reqleft;
    struct stun_attr *attr;
    int res = -1;
    int retry;
 
    if (answer) {
        /* Always clear answer in case the request fails. */
        memset(answer, 0, sizeof(struct sockaddr_in));
    }
 
    /* Create STUN bind request */
    req = (struct stun_header *) req_buf;
    stun_req_id(req);
    reqlen = 0;
    reqleft = sizeof(req_buf) - sizeof(struct stun_header);
    attr = (struct stun_attr *) req->ies;
    if (username) {
        append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
    }
    req->msglen = htons(reqlen);
    req->msgtype = htons(STUN_BINDREQ);
 
    for (retry = 0; retry++ < STUN_MAX_RETRIES;) {  /* XXX make retries configurable */
        /* send request, possibly wait for reply */
        struct sockaddr_in src;
        socklen_t srclen;
        struct timeval start;
 
        /* Send STUN message. */
        res = stun_send(s, dst, req);
        if (res < 0) {
            ast_debug_stun(1, "stun_send try %d failed: %s\n", retry, strerror(errno));
            break;
        }
        if (!answer) {
            /* Successful send since we don't care about any response. */
            res = 0;
            break;
        }
 
        start = ast_tvnow();
try_again:
        /* Wait for response. */
        {
            struct pollfd pfds = { .fd = s, .events = POLLIN };
            int ms;
 
            ms = ast_remaining_ms(start, 3000);
            if (ms <= 0) {
                /* No response, timeout */
                handle_stun_timeout(retry, dst);
                res = 1;
                continue;
            }
            res = ast_poll(&pfds, 1, ms);
            if (res < 0) {
                /* Error */
                continue;
            }
            if (!res) {
                /* No response, timeout */
                handle_stun_timeout(retry, dst);
                res = 1;
                continue;
            }
        }
 
        /* Read STUN response. */
        memset(&src, 0, sizeof(src));
        srclen = sizeof(src);
        /* XXX pass sizeof(rsp_buf) - 1 in the size, because stun_handle_packet might
         * write past the end of the buffer.
         */
        res = recvfrom(s, rsp_buf, sizeof(rsp_buf) - 1,
            0, (struct sockaddr *) &src, &srclen);
        if (res < 0) {
            ast_debug_stun(1, "recvfrom try %d failed: %s\n", retry, strerror(errno));
            break;
        }
 
        /* Process the STUN response. */
        rsp = (struct stun_header *) rsp_buf;
        if (ast_stun_handle_packet(s, &src, rsp_buf, res, stun_get_mapped, answer)
            || (rsp->msgtype != htons(STUN_BINDRESP)
                && rsp->msgtype != htons(STUN_BINDERR))
            || stun_id_cmp(&req->id, &rsp->id)) {
            /* Bad STUN packet, not right type, or transaction ID did not match. */
            memset(answer, 0, sizeof(struct sockaddr_in));
 
            /* Was not a resonse to our request. */
            goto try_again;
        }
        /* Success.  answer contains the external address if available. */
        res = 0;
        break;
    }
    return res;
}

References answer(), append_attr_string(), ast_debug_stun, ast_poll, ast_remaining_ms(), ast_stun_handle_packet(), ast_tvnow(), stun_attr::attr, errno, handle_stun_timeout(), stun_header::id, stun_header::ies, if(), stun_header::msglen, stun_header::msgtype, STUN_BINDERR, STUN_BINDREQ, STUN_BINDRESP, stun_get_mapped(), stun_id_cmp(), STUN_MAX_RETRIES, stun_req_id(), stun_send(), and STUN_USERNAME.

Referenced by ast_rtp_stun_request(), ast_stun_handle_packet(), and stun_monitor_request().

handle_cli_stun_set_debug()

static char * handle_cli_stun_set_debug ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 521 of file stun.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "stun set debug {on|off}";
        e->usage =
            "Usage: stun set debug {on|off}\n"
            "       Enable/Disable STUN (Simple Traversal of UDP through NATs)\n"
            "       debugging\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
 
    if (!strncasecmp(a->argv[e->args-1], "on", 2))
        ast_debug_category_set_sublevel(AST_LOG_CATEGORY_STUN_PACKET, AST_LOG_CATEGORY_ENABLED);
    else if (!strncasecmp(a->argv[e->args-1], "off", 3))
        ast_debug_category_set_sublevel(AST_LOG_CATEGORY_STUN_PACKET, AST_LOG_CATEGORY_DISABLED);
    else
        return CLI_SHOWUSAGE;
 
    ast_cli(a->fd, "STUN Debugging %s\n", ast_debug_stun_packet_is_allowed ? "Enabled" : "Disabled");
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli(), ast_debug_category_set_sublevel(), ast_debug_stun_packet_is_allowed, AST_LOG_CATEGORY_DISABLED, AST_LOG_CATEGORY_ENABLED, AST_LOG_CATEGORY_STUN_PACKET, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

handle_stun_timeout()

static void handle_stun_timeout ( int  retry, struct sockaddr_in *  dst  )

static

Definition at line 240 of file stun.c.

{
    char *stun_destination = "";
    if (dst) {
        ast_asprintf(&stun_destination, "to '%s' ", ast_inet_ntoa(dst->sin_addr));
    }
    if (retry < STUN_MAX_RETRIES) {
        ast_log(LOG_NOTICE,
            "Attempt %d to send STUN request %stimed out.\n",
            retry,
            stun_destination);
    } else {
        ast_log(LOG_WARNING,
            "Attempt %d to send STUN request %stimed out. "
            "Check that the server address is correct and reachable.\n",
            retry,
            stun_destination);
    }
    if (dst) {
        ast_free(stun_destination);
    }
}

References ast_asprintf, ast_free, ast_inet_ntoa(), ast_log, LOG_NOTICE, LOG_WARNING, and STUN_MAX_RETRIES.

Referenced by ast_stun_request().

stun_attr2str()

static const char * stun_attr2str ( int  msg )

static

helper function to print attribute names

Definition at line 146 of file stun.c.

{
    switch (msg) {
    case STUN_MAPPED_ADDRESS:
        return "Mapped Address";
    case STUN_RESPONSE_ADDRESS:
        return "Response Address";
    case STUN_CHANGE_REQUEST:
        return "Change Request";
    case STUN_SOURCE_ADDRESS:
        return "Source Address";
    case STUN_CHANGED_ADDRESS:
        return "Changed Address";
    case STUN_USERNAME:
        return "Username";
    case STUN_PASSWORD:
        return "Password";
    case STUN_MESSAGE_INTEGRITY:
        return "Message Integrity";
    case STUN_ERROR_CODE:
        return "Error Code";
    case STUN_UNKNOWN_ATTRIBUTES:
        return "Unknown Attributes";
    case STUN_REFLECTED_FROM:
        return "Reflected From";
    }
    return "Non-RFC3489 Attribute";
}

References STUN_CHANGE_REQUEST, STUN_CHANGED_ADDRESS, STUN_ERROR_CODE, STUN_MAPPED_ADDRESS, STUN_MESSAGE_INTEGRITY, STUN_PASSWORD, STUN_REFLECTED_FROM, STUN_RESPONSE_ADDRESS, STUN_SOURCE_ADDRESS, STUN_UNKNOWN_ATTRIBUTES, and STUN_USERNAME.

Referenced by ast_stun_handle_packet(), and stun_process_attr().

stun_get_mapped()

static int stun_get_mapped ( struct stun_attr *  attr, void *  arg  )

static

Extract the STUN_MAPPED_ADDRESS from the stun response. This is used as a callback for stun_handle_response when called from ast_stun_request.

Definition at line 403 of file stun.c.

{
    struct stun_addr *addr = (struct stun_addr *)(attr + 1);
    struct sockaddr_in *sa = (struct sockaddr_in *)arg;
 
    if (ntohs(attr->attr) != STUN_MAPPED_ADDRESS || ntohs(attr->len) != 8)
        return 1;   /* not us. */
    sa->sin_port = addr->port;
    sa->sin_addr.s_addr = addr->addr;
    return 0;
}

References stun_addr::addr, stun_attr::attr, stun_attr::len, stun_addr::port, and STUN_MAPPED_ADDRESS.

Referenced by ast_stun_request().

stun_id_cmp()

static int stun_id_cmp ( stun_trans_id *  left, stun_trans_id *  right  )

static

Definition at line 280 of file stun.c.

{
    return memcmp(left, right, sizeof(*left));
}

Referenced by ast_stun_request().

stun_msg2str()

static const char * stun_msg2str ( int  msg )

static

helper function to print message names

Definition at line 126 of file stun.c.

{
    switch (msg) {
    case STUN_BINDREQ:
        return "Binding Request";
    case STUN_BINDRESP:
        return "Binding Response";
    case STUN_BINDERR:
        return "Binding Error Response";
    case STUN_SECREQ:
        return "Shared Secret Request";
    case STUN_SECRESP:
        return "Shared Secret Response";
    case STUN_SECERR:
        return "Shared Secret Error Response";
    }
    return "Non-RFC3489 Message";
}

References STUN_BINDERR, STUN_BINDREQ, STUN_BINDRESP, STUN_SECERR, STUN_SECREQ, and STUN_SECRESP.

Referenced by ast_stun_handle_packet().

stun_process_attr()

static int stun_process_attr ( struct stun_state *  state, struct stun_attr *  attr  )

static

Definition at line 181 of file stun.c.

{
    if (ast_debug_stun_packet_is_allowed) {
        ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
            stun_attr2str(ntohs(attr->attr)), (unsigned)ntohs(attr->attr), ntohs(attr->len));
    }
    switch (ntohs(attr->attr)) {
    case STUN_USERNAME:
        state->username = (const char *) (attr->value);
        break;
    case STUN_PASSWORD:
        state->password = (const char *) (attr->value);
        break;
    default:
        if (ast_debug_stun_packet_is_allowed) {
            ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n",
                stun_attr2str(ntohs(attr->attr)), (unsigned)ntohs(attr->attr), ntohs(attr->len));
        }
    }
 
    return 0;
}

References ast_debug_stun_packet_is_allowed, ast_verbose(), stun_attr::attr, stun_attr::len, stun_attr2str(), STUN_PASSWORD, STUN_USERNAME, and stun_attr::value.

Referenced by ast_stun_handle_packet().

stun_req_id()

static void stun_req_id ( struct stun_header *  req )

static

helper function to generate a random request id

Definition at line 286 of file stun.c.

{
    int x;
    for (x = 0; x < 4; x++)
        req->id.id[x] = ast_random();
}

References ast_random(), stun_trans_id::id, and stun_header::id.

Referenced by ast_stun_request().

stun_send()

static int stun_send ( int  s, struct sockaddr_in *  dst, struct stun_header *  resp  )

static

wrapper to send an STUN message

Definition at line 264 of file stun.c.

{
    return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
              (struct sockaddr *)dst, sizeof(*dst));
}

References stun_header::msglen.

Referenced by ast_stun_handle_packet(), and ast_stun_request().

stun_shutdown()

static void stun_shutdown ( void  )

static

Definition at line 567 of file stun.c.

{
    ast_cli_unregister_multiple(cli_stun, sizeof(cli_stun) / sizeof(struct ast_cli_entry));
 
    ast_debug_category_unregister(AST_LOG_CATEGORY_STUN_PACKET);
    ast_debug_category_unregister(AST_LOG_CATEGORY_STUN);
}

References ast_cli_unregister_multiple(), ast_debug_category_unregister(), AST_LOG_CATEGORY_STUN, AST_LOG_CATEGORY_STUN_PACKET, and cli_stun.

Referenced by ast_stun_init().

Variable Documentation

cli_stun

struct ast_cli_entry cli_stun[]

static

Initial value:

= {
    { .handler =  handle_cli_stun_set_debug , .summary =  "Enable/Disable STUN debugging" ,},
}

Definition at line 549 of file stun.c.

Referenced by ast_stun_init(), and stun_shutdown().

debug_category_stun_id

uintmax_t debug_category_stun_id

static

Definition at line 553 of file stun.c.

Referenced by ast_debug_category_stun_id(), and ast_stun_init().

debug_category_stun_packet_id

uintmax_t debug_category_stun_packet_id

static

Definition at line 560 of file stun.c.

Referenced by ast_debug_category_stun_packet_id(), and ast_stun_init().