STUN code

Collaboration diagram for STUN code:

Data Structures
struct	switch_stun_packet_header_t
struct	switch_stun_packet_attribute_t
struct	switch_stun_packet_t
struct	switch_stun_ip_t
struct	switch_stun_error_code_t

Macros
#define	SWITCH_STUN_DEFAULT_PORT   3478
#define	SWITCH_STUN_PACKET_MIN_LEN   20
#define	SWITCH_STUN_ATTRIBUTE_MIN_LEN   8
#define	STUN_MAGIC_COOKIE   0x2112A442
#define	switch_stun_attribute_padded_length(attribute)   (int16_t)((attribute->length & 0x3) ? 0x4 + (attribute->length & ~0x3) : attribute->length)
	Obtain the padded length of an attribute's value. More...
#define	switch_stun_attribute_padded_length_hbo(attribute)   (int16_t)((ntohs(attribute->length) & 0x3) ? 0x4 + (ntohs(attribute->length) & ~0x3) : ntohs(attribute->length))
#define	switch_stun_packet_first_attribute(packet, attribute)   attribute = (switch_stun_packet_attribute_t *)(&packet->first_attribute);
	set a switch_stun_packet_attribute_t pointer to point at the first attribute in a packet More...
#define	switch_stun_packet_next_attribute(attribute, end)   (attribute && (attribute = (switch_stun_packet_attribute_t *) (attribute->value + switch_stun_attribute_padded_length(attribute))) && ((void *)attribute < end) && attribute->type && (((switch_byte_t *)attribute + switch_stun_attribute_padded_length(attribute)) < (switch_byte_t *)end))
	Increment an attribute pointer to the next attribute in it's packet. More...
#define	switch_stun_packet_next_attribute_hbo(attribute, end)   (attribute && (attribute = (switch_stun_packet_attribute_t *) (attribute->value + switch_stun_attribute_padded_length_hbo(attribute))) && ((void *)attribute < end) && attribute->type && (((switch_byte_t *)attribute + switch_stun_attribute_padded_length_hbo(attribute)) < (switch_byte_t *)end))
#define	switch_stun_packet_length(packet)   ntohs(packet->header.length) + (sizeof(switch_stun_packet_header_t))
	Obtain the correct length in bytes of a stun packet. More...

Enumerations
enum	switch_stun_message_t {   SWITCH_STUN_BINDING_REQUEST = 0x0001, SWITCH_STUN_BINDING_RESPONSE = 0x0101, SWITCH_STUN_BINDING_ERROR_RESPONSE = 0x0111, SWITCH_STUN_SHARED_SECRET_REQUEST = 0x0002,   SWITCH_STUN_SHARED_SECRET_RESPONSE = 0x0102, SWITCH_STUN_SHARED_SECRET_ERROR_RESPONSE = 0x0112, SWITCH_STUN_ALLOCATE_REQUEST = 0x0003, SWITCH_STUN_ALLOCATE_RESPONSE = 0x0103,   SWITCH_STUN_ALLOCATE_ERROR_RESPONSE = 0x0113, SWITCH_STUN_SEND_REQUEST = 0x0004, SWITCH_STUN_SEND_RESPONSE = 0x0104, SWITCH_STUN_SEND_ERROR_RESPONSE = 0x0114,   SWITCH_STUN_DATA_INDICATION = 0x0115 }
enum	switch_stun_attribute_t {   SWITCH_STUN_ATTR_MAPPED_ADDRESS = 0x0001, SWITCH_STUN_ATTR_RESPONSE_ADDRESS = 0x0002, SWITCH_STUN_ATTR_CHANGE_REQUEST = 0x0003, SWITCH_STUN_ATTR_SOURCE_ADDRESS = 0x0004,   SWITCH_STUN_ATTR_CHANGED_ADDRESS = 0x0005, SWITCH_STUN_ATTR_USERNAME = 0x0006, SWITCH_STUN_ATTR_PASSWORD = 0x0007, SWITCH_STUN_ATTR_MESSAGE_INTEGRITY = 0x0008,   SWITCH_STUN_ATTR_ERROR_CODE = 0x0009, SWITCH_STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000a, SWITCH_STUN_ATTR_REFLECTED_FROM = 0x000b, SWITCH_STUN_ATTR_TRANSPORT_PREFERENCES = 0x000c,   SWITCH_STUN_ATTR_LIFETIME = 0x000d, SWITCH_STUN_ATTR_ALTERNATE_SERVER = 0x000e, SWITCH_STUN_ATTR_MAGIC_COOKIE = 0x000f, SWITCH_STUN_ATTR_BANDWIDTH = 0x0010,   SWITCH_STUN_ATTR_DESTINATION_ADDRESS = 0x0011, SWITCH_STUN_ATTR_SOURCE_ADDRESS2 = 0x0012, SWITCH_STUN_ATTR_DATA = 0x0013, SWITCH_STUN_ATTR_OPTIONS = 0x8001,   SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS = 0x0020, SWITCH_STUN_ATTR_PRIORITY = 0x0024, SWITCH_STUN_ATTR_USE_CAND = 0x0025, SWITCH_STUN_ATTR_PADDING = 0x0026,   SWITCH_STUN_ATTR_RESP_PORT = 0x0027, SWITCH_STUN_ATTR_SOFTWARE = 0x8022, SWITCH_STUN_ATTR_ALT_SERVER = 0x8023, SWITCH_STUN_ATTR_FINGERPRINT = 0x8028,   SWITCH_STUN_ATTR_CONTROLLED = 0x8029, SWITCH_STUN_ATTR_CONTROLLING = 0x802a, SWITCH_STUN_ATTR_RESP_ORIGIN = 0x802b, SWITCH_STUN_ATTR_OTHER_ADDR = 0x802c }
enum	switch_stun_error_t {   SWITCH_STUN_ERROR_BAD_REQUEST = 400, SWITCH_STUN_ERROR_UNAUTHORIZED = 401, SWITCH_STUN_ERROR_UNKNOWN_ATTRIBUTE = 420, SWITCH_STUN_ERROR_STALE_CREDENTIALS = 430,   SWITCH_STUN_ERROR_INTEGRITY_CHECK_FAILURE = 431, SWITCH_STUN_ERROR_MISSING_USERNAME = 432, SWITCH_STUN_ERROR_USE_TLS = 433, SWITCH_STUN_ERROR_SERVER_ERROR = 500,   SWITCH_STUN_ERROR_GLOBAL_FAILURE = 600 }
enum	switch_stun_type_t { SWITCH_STUN_TYPE_PACKET_TYPE, SWITCH_STUN_TYPE_ATTRIBUTE, SWITCH_STUN_TYPE_ERROR }

Functions
void	switch_stun_random_string (char *buf, uint16_t len, char *set)
	Writes random characters into a buffer. More...
switch_stun_packet_t *	switch_stun_packet_parse (uint8_t *buf, uint32_t len)
	Prepare a raw packet for parsing. More...
const char *	switch_stun_value_to_name (int32_t type, uint32_t value)
	Obtain a printable string form of a given value. More...
char *	switch_stun_host_lookup (const char *host, switch_memory_pool_t *pool)
uint8_t	switch_stun_packet_attribute_get_mapped_address (switch_stun_packet_attribute_t *attribute, char *ipstr, switch_size_t iplen, uint16_t *port)
	Extract a mapped address (IP:PORT) from a packet attribute. More...
uint8_t	switch_stun_packet_attribute_get_xor_mapped_address (switch_stun_packet_attribute_t *attribute, switch_stun_packet_header_t *header, char *ipstr, switch_size_t iplen, uint16_t *port)
char *	switch_stun_packet_attribute_get_username (switch_stun_packet_attribute_t *attribute, char *username, uint16_t len)
	Extract a username from a packet attribute. More...
switch_stun_packet_t *	switch_stun_packet_build_header (switch_stun_message_t type, char *id, uint8_t *buf)
	Prepare a new outbound packet of a certian type and id. More...
uint8_t	switch_stun_packet_attribute_add_username (switch_stun_packet_t *packet, char *username, uint16_t ulen)
	Add a username packet attribute. More...
uint8_t	switch_stun_packet_attribute_add_password (switch_stun_packet_t *packet, char *password, uint16_t ulen)
uint8_t	switch_stun_packet_attribute_add_software (switch_stun_packet_t *packet, char *software, uint16_t ulen)
uint8_t	switch_stun_packet_attribute_add_binded_address (switch_stun_packet_t *packet, char *ipstr, uint16_t port, int family)
	Add a binded address packet attribute. More...
uint8_t	switch_stun_packet_attribute_add_xor_binded_address (switch_stun_packet_t *packet, char *ipstr, uint16_t port, int family)
uint8_t	switch_stun_packet_attribute_add_integrity (switch_stun_packet_t *packet, const char *pass)
uint32_t	switch_crc32_8bytes (const void *data, size_t length)
uint8_t	switch_stun_packet_attribute_add_fingerprint (switch_stun_packet_t *packet)
uint8_t	switch_stun_packet_attribute_add_use_candidate (switch_stun_packet_t *packet)
uint8_t	switch_stun_packet_attribute_add_controlling (switch_stun_packet_t *packet)
uint8_t	switch_stun_packet_attribute_add_controlled (switch_stun_packet_t *packet)
uint8_t	switch_stun_packet_attribute_add_priority (switch_stun_packet_t *packet, uint32_t priority)
switch_status_t	switch_stun_lookup (char **ip, switch_port_t *port, char *stunip, switch_port_t stunport, char **err, switch_memory_pool_t *pool)
	Perform a stun lookup. More...

Detailed Description

Macro Definition Documentation

#define STUN_MAGIC_COOKIE   0x2112A442

Definition at line 60 of file switch_stun.h.

Referenced by switch_stun_packet_attribute_add_binded_address(), switch_stun_packet_attribute_add_xor_binded_address(), and switch_stun_packet_build_header().

#define SWITCH_STUN_ATTRIBUTE_MIN_LEN   8

Definition at line 43 of file switch_stun.h.

Referenced by switch_stun_packet_parse().

#define switch_stun_attribute_padded_length

(

attribute

)

(int16_t)((attribute->length & 0x3) ? 0x4 + (attribute->length & ~0x3) : attribute->length)

Obtain the padded length of an attribute's value.

Parameters

attribute

the attribute

Returns

the padded size in bytes

Definition at line 268 of file switch_stun.h.

Referenced by handle_ice(), switch_stun_lookup(), and switch_stun_packet_parse().

#define switch_stun_attribute_padded_length_hbo

(

attribute

)

(int16_t)((ntohs(attribute->length) & 0x3) ? 0x4 + (ntohs(attribute->length) & ~0x3) : ntohs(attribute->length))

Definition at line 269 of file switch_stun.h.

#define SWITCH_STUN_DEFAULT_PORT   3478

Definition at line 41 of file switch_stun.h.

Referenced by switch_core_media_ext_address_lookup().

#define switch_stun_packet_first_attribute	(		packet,
			attribute
	)		attribute = (switch_stun_packet_attribute_t *)(&packet->first_attribute);

set a switch_stun_packet_attribute_t pointer to point at the first attribute in a packet

Parameters

packet	the packet in question
attribute	the pointer to set up

Definition at line 277 of file switch_stun.h.

Referenced by handle_ice(), switch_stun_lookup(), and switch_stun_packet_parse().

#define switch_stun_packet_length

(

packet

)

ntohs(packet->header.length) + (sizeof(switch_stun_packet_header_t))

Obtain the correct length in bytes of a stun packet.

Parameters

packet

the packet in question

Returns

the size in bytes (host order) of the entire packet

Definition at line 295 of file switch_stun.h.

Referenced by handle_ice(), ice_out(), and switch_stun_lookup().

#define SWITCH_STUN_PACKET_MIN_LEN   20

Definition at line 42 of file switch_stun.h.

Referenced by switch_stun_packet_parse().

#define switch_stun_packet_next_attribute	(		attribute,
			end
	)		(attribute && (attribute = (switch_stun_packet_attribute_t *) (attribute->value + switch_stun_attribute_padded_length(attribute))) && ((void *)attribute < end) && attribute->type && (((switch_byte_t *)attribute + switch_stun_attribute_padded_length(attribute)) < (switch_byte_t *)end))

Increment an attribute pointer to the next attribute in it's packet.

Parameters

attribute	the pointer to increment
end	pointer to the end of the buffer

Returns

true or false depending on if there are any more attributes

Definition at line 286 of file switch_stun.h.

Referenced by handle_ice(), and switch_stun_lookup().

#define switch_stun_packet_next_attribute_hbo	(		attribute,
			end
	)		(attribute && (attribute = (switch_stun_packet_attribute_t *) (attribute->value + switch_stun_attribute_padded_length_hbo(attribute))) && ((void *)attribute < end) && attribute->type && (((switch_byte_t *)attribute + switch_stun_attribute_padded_length_hbo(attribute)) < (switch_byte_t *)end))

Definition at line 288 of file switch_stun.h.

Enumeration Type Documentation

enum switch_stun_attribute_t

Enumerator
SWITCH_STUN_ATTR_MAPPED_ADDRESS
SWITCH_STUN_ATTR_RESPONSE_ADDRESS
SWITCH_STUN_ATTR_CHANGE_REQUEST
SWITCH_STUN_ATTR_SOURCE_ADDRESS
SWITCH_STUN_ATTR_CHANGED_ADDRESS
SWITCH_STUN_ATTR_USERNAME
SWITCH_STUN_ATTR_PASSWORD
SWITCH_STUN_ATTR_MESSAGE_INTEGRITY
SWITCH_STUN_ATTR_ERROR_CODE
SWITCH_STUN_ATTR_UNKNOWN_ATTRIBUTES
SWITCH_STUN_ATTR_REFLECTED_FROM
SWITCH_STUN_ATTR_TRANSPORT_PREFERENCES
SWITCH_STUN_ATTR_LIFETIME
SWITCH_STUN_ATTR_ALTERNATE_SERVER
SWITCH_STUN_ATTR_MAGIC_COOKIE
SWITCH_STUN_ATTR_BANDWIDTH
SWITCH_STUN_ATTR_DESTINATION_ADDRESS
SWITCH_STUN_ATTR_SOURCE_ADDRESS2
SWITCH_STUN_ATTR_DATA
SWITCH_STUN_ATTR_OPTIONS
SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS
SWITCH_STUN_ATTR_PRIORITY
SWITCH_STUN_ATTR_USE_CAND
SWITCH_STUN_ATTR_PADDING
SWITCH_STUN_ATTR_RESP_PORT
SWITCH_STUN_ATTR_SOFTWARE
SWITCH_STUN_ATTR_ALT_SERVER
SWITCH_STUN_ATTR_FINGERPRINT
SWITCH_STUN_ATTR_CONTROLLED
SWITCH_STUN_ATTR_CONTROLLING
SWITCH_STUN_ATTR_RESP_ORIGIN
SWITCH_STUN_ATTR_OTHER_ADDR

Definition at line 62 of file switch_stun.h.

             {
        SWITCH_STUN_ATTR_MAPPED_ADDRESS = 0x0001,       /* Address */
        SWITCH_STUN_ATTR_RESPONSE_ADDRESS = 0x0002,     /* Address */
        SWITCH_STUN_ATTR_CHANGE_REQUEST = 0x0003,       /* UInt32 */
        SWITCH_STUN_ATTR_SOURCE_ADDRESS = 0x0004,       /* Address */
        SWITCH_STUN_ATTR_CHANGED_ADDRESS = 0x0005,      /* Address */
        SWITCH_STUN_ATTR_USERNAME = 0x0006,     /* ByteString, multiple of 4 bytes */
        SWITCH_STUN_ATTR_PASSWORD = 0x0007,     /* ByteString, multiple of 4 bytes */
        SWITCH_STUN_ATTR_MESSAGE_INTEGRITY = 0x0008,    /* ByteString, 20 bytes */
        SWITCH_STUN_ATTR_ERROR_CODE = 0x0009,   /* ErrorCode */
        SWITCH_STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000a,   /* UInt16List */
        SWITCH_STUN_ATTR_REFLECTED_FROM = 0x000b,       /* Address */
        SWITCH_STUN_ATTR_TRANSPORT_PREFERENCES = 0x000c,        /* TransportPrefs */
        SWITCH_STUN_ATTR_LIFETIME = 0x000d,     /* UInt32 */
        SWITCH_STUN_ATTR_ALTERNATE_SERVER = 0x000e,     /* Address */
        SWITCH_STUN_ATTR_MAGIC_COOKIE = 0x000f, /* ByteString, 4 bytes */
        SWITCH_STUN_ATTR_BANDWIDTH = 0x0010,    /* UInt32 */
        SWITCH_STUN_ATTR_DESTINATION_ADDRESS = 0x0011,  /* Address */
        SWITCH_STUN_ATTR_SOURCE_ADDRESS2 = 0x0012,      /* Address */
        SWITCH_STUN_ATTR_DATA = 0x0013, /* ByteString */
        SWITCH_STUN_ATTR_OPTIONS = 0x8001,      /* UInt32 */
        SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS = 0x0020,   /* Address */  

        /* ice crap */

        SWITCH_STUN_ATTR_PRIORITY           = 0x0024,
        SWITCH_STUN_ATTR_USE_CAND           = 0x0025,
        SWITCH_STUN_ATTR_PADDING            = 0x0026,
        SWITCH_STUN_ATTR_RESP_PORT          = 0x0027,
        SWITCH_STUN_ATTR_SOFTWARE           = 0x8022,
        SWITCH_STUN_ATTR_ALT_SERVER         = 0x8023,
        SWITCH_STUN_ATTR_FINGERPRINT        = 0x8028,
        SWITCH_STUN_ATTR_CONTROLLED         = 0x8029,
        SWITCH_STUN_ATTR_CONTROLLING        = 0x802a,
        SWITCH_STUN_ATTR_RESP_ORIGIN        = 0x802b,
        SWITCH_STUN_ATTR_OTHER_ADDR         = 0x802c

} switch_stun_attribute_t;

enum switch_stun_error_t

Enumerator
SWITCH_STUN_ERROR_BAD_REQUEST
SWITCH_STUN_ERROR_UNAUTHORIZED
SWITCH_STUN_ERROR_UNKNOWN_ATTRIBUTE
SWITCH_STUN_ERROR_STALE_CREDENTIALS
SWITCH_STUN_ERROR_INTEGRITY_CHECK_FAILURE
SWITCH_STUN_ERROR_MISSING_USERNAME
SWITCH_STUN_ERROR_USE_TLS
SWITCH_STUN_ERROR_SERVER_ERROR
SWITCH_STUN_ERROR_GLOBAL_FAILURE

Definition at line 101 of file switch_stun.h.

             {
        SWITCH_STUN_ERROR_BAD_REQUEST = 400,
        SWITCH_STUN_ERROR_UNAUTHORIZED = 401,
        SWITCH_STUN_ERROR_UNKNOWN_ATTRIBUTE = 420,
        SWITCH_STUN_ERROR_STALE_CREDENTIALS = 430,
        SWITCH_STUN_ERROR_INTEGRITY_CHECK_FAILURE = 431,
        SWITCH_STUN_ERROR_MISSING_USERNAME = 432,
        SWITCH_STUN_ERROR_USE_TLS = 433,
        SWITCH_STUN_ERROR_SERVER_ERROR = 500,
        SWITCH_STUN_ERROR_GLOBAL_FAILURE = 600
} switch_stun_error_t;

enum switch_stun_message_t

Enumerator
SWITCH_STUN_BINDING_REQUEST
SWITCH_STUN_BINDING_RESPONSE
SWITCH_STUN_BINDING_ERROR_RESPONSE
SWITCH_STUN_SHARED_SECRET_REQUEST
SWITCH_STUN_SHARED_SECRET_RESPONSE
SWITCH_STUN_SHARED_SECRET_ERROR_RESPONSE
SWITCH_STUN_ALLOCATE_REQUEST
SWITCH_STUN_ALLOCATE_RESPONSE
SWITCH_STUN_ALLOCATE_ERROR_RESPONSE
SWITCH_STUN_SEND_REQUEST
SWITCH_STUN_SEND_RESPONSE
SWITCH_STUN_SEND_ERROR_RESPONSE
SWITCH_STUN_DATA_INDICATION

Definition at line 44 of file switch_stun.h.

                     {
        SWITCH_STUN_BINDING_REQUEST = 0x0001,
        SWITCH_STUN_BINDING_RESPONSE = 0x0101,
        SWITCH_STUN_BINDING_ERROR_RESPONSE = 0x0111,
        SWITCH_STUN_SHARED_SECRET_REQUEST = 0x0002,
        SWITCH_STUN_SHARED_SECRET_RESPONSE = 0x0102,
        SWITCH_STUN_SHARED_SECRET_ERROR_RESPONSE = 0x0112,
        SWITCH_STUN_ALLOCATE_REQUEST = 0x0003,
        SWITCH_STUN_ALLOCATE_RESPONSE = 0x0103,
        SWITCH_STUN_ALLOCATE_ERROR_RESPONSE = 0x0113,
        SWITCH_STUN_SEND_REQUEST = 0x0004,
        SWITCH_STUN_SEND_RESPONSE = 0x0104,
        SWITCH_STUN_SEND_ERROR_RESPONSE = 0x0114,
        SWITCH_STUN_DATA_INDICATION = 0x0115
} switch_stun_message_t;

enum switch_stun_type_t

Enumerator
SWITCH_STUN_TYPE_PACKET_TYPE
SWITCH_STUN_TYPE_ATTRIBUTE
SWITCH_STUN_TYPE_ERROR

Definition at line 113 of file switch_stun.h.

             {
        SWITCH_STUN_TYPE_PACKET_TYPE,
        SWITCH_STUN_TYPE_ATTRIBUTE,
        SWITCH_STUN_TYPE_ERROR
} switch_stun_type_t;

Function Documentation

uint32_t switch_crc32_8bytes	(	const void *	data,
		size_t	length
	)

Definition at line 1140 of file switch_stun.c.

References crc32Lookup.

Referenced by switch_stun_packet_attribute_add_fingerprint().

{
        uint32_t *current = (uint32_t *) data;
        uint32_t previousCrc32 = 0;
        uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
        uint8_t *currentChar;

        // process eight bytes at once
        while (length >= 8)
                {
                        uint32_t one = *current++ ^ crc;
                        uint32_t two = *current++;
                        crc  = crc32Lookup[7][ one      & 0xFF] ^
                                crc32Lookup[6][(one>> 8) & 0xFF] ^
                                crc32Lookup[5][(one>>16) & 0xFF] ^
                                crc32Lookup[4][ one>>24        ] ^
                                crc32Lookup[3][ two      & 0xFF] ^
                                crc32Lookup[2][(two>> 8) & 0xFF] ^
                                crc32Lookup[1][(two>>16) & 0xFF] ^
                                crc32Lookup[0][ two>>24        ];
                        length -= 8;
                }

        currentChar = (uint8_t*) current;
        // remaining 1 to 7 bytes (standard CRC table-based algorithm)
        while (length--)
                crc = (crc >> 8) ^ crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];

        return ~crc; // same as crc ^ 0xFFFFFFFF
}

char* switch_stun_host_lookup	(	const char *	host,
		switch_memory_pool_t *	pool
	)

Definition at line 688 of file switch_stun.c.

References buf, switch_core_strdup, switch_get_addr(), switch_sockaddr_info_get(), switch_str_nil, and SWITCH_UNSPEC.

Referenced by switch_core_media_ext_address_lookup().

{
        switch_sockaddr_t *addr = NULL;
        char buf[30];

        switch_sockaddr_info_get(&addr, host, SWITCH_UNSPEC, 0, 0, pool);
        return switch_core_strdup(pool, switch_str_nil(switch_get_addr(buf, sizeof(buf), addr)));

}

switch_status_t switch_stun_lookup	(	char **	ip,
		switch_port_t *	port,
		char *	stunip,
		switch_port_t	stunport,
		char **	err,
		switch_memory_pool_t *	pool
	)

Perform a stun lookup.

Parameters

ip	the local ip to use (replaced with stun results)
port	the local port to use (replaced with stun results)
stunip	the ip of the stun server
stunport	the port of the stun server
err	a pointer to describe errors
pool	the memory pool to use

Returns

SUCCESS or FAIL

Definition at line 698 of file switch_stun.c.

References switch_stun_ip_t::address, buf, switch_stun_packet_t::header, switch_stun_packet_header_t::length, switch_assert, switch_cond_next(), switch_core_strdup, switch_micro_time_now(), SWITCH_SHUTDOWN_READWRITE, SWITCH_SO_NONBLOCK, switch_sockaddr_info_get(), switch_socket_bind(), switch_socket_close(), switch_socket_create(), switch_socket_opt_set(), switch_socket_recvfrom(), switch_socket_sendto(), switch_socket_shutdown(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, SWITCH_STUN_ATTR_MAPPED_ADDRESS, SWITCH_STUN_ATTR_USERNAME, SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS, switch_stun_attribute_padded_length, SWITCH_STUN_BINDING_REQUEST, SWITCH_STUN_BINDING_RESPONSE, switch_stun_packet_attribute_add_username(), switch_stun_packet_attribute_get_mapped_address(), switch_stun_packet_attribute_get_username(), switch_stun_packet_attribute_get_xor_mapped_address(), switch_stun_packet_build_header(), switch_stun_packet_first_attribute, switch_stun_packet_length, switch_stun_packet_next_attribute, switch_stun_packet_parse(), switch_stun_random_string(), SWITCH_UNSPEC, TRUE, switch_stun_packet_header_t::type, switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by switch_core_media_ext_address_lookup().

{
        switch_sockaddr_t *local_addr = NULL, *remote_addr = NULL, *from_addr = NULL;
        switch_socket_t *sock = NULL;
        uint8_t buf[260] = { 0 };
        uint8_t *start = buf;
        void *end_buf;
        switch_stun_packet_t *packet;
        switch_stun_packet_attribute_t *attr;
        switch_size_t bytes = 0;
        char username[33] = { 0 };
        char rip[50] = { 0 };
        uint16_t rport = 0;
        switch_time_t started = 0;
        unsigned int elapsed = 0;
        int funny = 0;
        int size = sizeof(buf);
        int xlen = sizeof(switch_stun_packet_header_t); 

        switch_assert(err);

        if (*err && !strcmp(*err, "funny")) {
                funny = 1;
        }

        *err = "Success";

        switch_sockaddr_info_get(&from_addr, NULL, SWITCH_UNSPEC, 0, 0, pool);

        if (switch_sockaddr_info_get(&local_addr, *ip, SWITCH_UNSPEC, *port, 0, pool) != SWITCH_STATUS_SUCCESS) {
                *err = "Local Address Error!";
                return SWITCH_STATUS_FALSE;
        }

        if (switch_sockaddr_info_get(&remote_addr, stunip, SWITCH_UNSPEC, stunport, 0, pool) != SWITCH_STATUS_SUCCESS) {
                *err = "Remote Address Error!";
                return SWITCH_STATUS_FALSE;
        }

        if (switch_socket_create(&sock, AF_INET, SOCK_DGRAM, 0, pool) != SWITCH_STATUS_SUCCESS) {
                *err = "Socket Error!";
                return SWITCH_STATUS_FALSE;
        }

        if (switch_socket_bind(sock, local_addr) != SWITCH_STATUS_SUCCESS) {
                *err = "Bind Error!";
                return SWITCH_STATUS_FALSE;
        }

        if (funny) {
                *start++ = 0;
                *start++ = 0;
                *start++ = 0x22;
                *start++ = 0x22;
        }

        switch_socket_opt_set(sock, SWITCH_SO_NONBLOCK, TRUE);
        packet = switch_stun_packet_build_header(SWITCH_STUN_BINDING_REQUEST, NULL, start);
        switch_stun_random_string(username, 32, NULL);
        switch_stun_packet_attribute_add_username(packet, username, 32);
        bytes = switch_stun_packet_length(packet);

        if (funny) {
                packet = (switch_stun_packet_t *) buf;
                bytes += 4;
                buf[bytes++] = 0;
                buf[bytes++] = 0;
                buf[bytes++] = 0;
                buf[bytes++] = 0;
        }

        switch_socket_sendto(sock, remote_addr, 0, (void *) packet, &bytes);
        started = switch_micro_time_now();

        *ip = NULL;
        *port = 0;


        for (;;) {
                bytes = sizeof(buf);
                if (switch_socket_recvfrom(from_addr, sock, 0, (char *) &buf, &bytes) == SWITCH_STATUS_SUCCESS && bytes > 0) {
                        break;
                }

                if ((elapsed = (unsigned int) ((switch_micro_time_now() - started) / 1000)) > 5000) {
                        *err = "Timeout";
                        switch_socket_shutdown(sock, SWITCH_SHUTDOWN_READWRITE);
                        switch_socket_close(sock);
                        return SWITCH_STATUS_TIMEOUT;
                }
                switch_cond_next();
        }
        switch_socket_close(sock);

        if (funny) {
                size -= 4;
        }

        packet = switch_stun_packet_parse(start, size);
        if (!packet) {
                *err = "Invalid STUN/ICE packet";
                return SWITCH_STATUS_FALSE;
        }
        end_buf = buf + ((sizeof(buf) > packet->header.length) ? packet->header.length : sizeof(buf));

        switch_stun_packet_first_attribute(packet, attr);
        do {
                switch (attr->type) {
                case SWITCH_STUN_ATTR_MAPPED_ADDRESS:
                        if (attr->type) {
                                if (funny) {
                                        switch_stun_ip_t *tmp = (switch_stun_ip_t *) attr->value;
                                        tmp->address ^= ntohl(0xabcdabcd);
                                }
                                switch_stun_packet_attribute_get_mapped_address(attr, rip, sizeof(rip), &rport);
                        }
                        break;
                case SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS:
                        if (attr->type) {
                                switch_stun_packet_attribute_get_xor_mapped_address(attr, &packet->header, rip, sizeof(rip), &rport);
                        }
                        break;
                case SWITCH_STUN_ATTR_USERNAME:
                        if (attr->type) {
                                switch_stun_packet_attribute_get_username(attr, username, 32);
                        }
                        break;
                }

                if (!switch_stun_packet_next_attribute(attr, end_buf)) {
                        break;
                }
                xlen += 4 + switch_stun_attribute_padded_length(attr);
        } while (xlen <= packet->header.length);

        if (packet->header.type == SWITCH_STUN_BINDING_RESPONSE) {
                *ip = switch_core_strdup(pool, rip);
                *port = rport;
                return SWITCH_STATUS_SUCCESS;
        } else {
                *err = "Invalid Reply";
        }

        return SWITCH_STATUS_FALSE;
}

uint8_t switch_stun_packet_attribute_add_binded_address	(	switch_stun_packet_t *	packet,
		char *	ipstr,
		uint16_t	port,
		int	family
	)

Add a binded address packet attribute.

Parameters

packet	the packet to add the attribute to
ipstr	the string representation of the ip
port	the port of the mapped address

Returns

true or false

Definition at line 451 of file switch_stun.c.

References switch_stun_ip_t::address, switch_stun_ip_t::family, switch_stun_packet_attribute_t::length, switch_stun_ip_t::port, STUN_MAGIC_COOKIE, SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS, switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

{
        switch_stun_packet_attribute_t *attribute;
        switch_stun_ip_t *ip;
        
        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS);

        if (family == AF_INET6) {
                attribute->length = htons(20);
        } else {
                attribute->length = htons(8);
        }

        ip = (switch_stun_ip_t *) attribute->value;

        ip->port = htons(port ^ (STUN_MAGIC_COOKIE >> 16));

        if (family == AF_INET6) {
                ip->family = 2;
        } else {
                ip->family = 1;
        }

        if (family == AF_INET6) {
                inet_pton(AF_INET6, ipstr, (struct in6_addr *) &ip->address);
        } else {
                inet_pton(AF_INET, ipstr, (int *) &ip->address);
        }

        packet->header.length += htons(sizeof(switch_stun_packet_attribute_t)) + attribute->length;
        return 1;
}

uint8_t switch_stun_packet_attribute_add_controlled

(

switch_stun_packet_t *

packet

)

Definition at line 600 of file switch_stun.c.

References buf, switch_stun_packet_attribute_t::length, SWITCH_STUN_ATTR_CONTROLLED, switch_stun_random_string(), switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by ice_out().

{
        switch_stun_packet_attribute_t *attribute;
        char buf[8];

        switch_stun_random_string(buf, 8, NULL);

        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_CONTROLLED);
        attribute->length = htons(8);
        memcpy(attribute->value, buf, 8);
        packet->header.length += htons(sizeof(switch_stun_packet_attribute_t)) + attribute->length;
        return 1;
}

uint8_t switch_stun_packet_attribute_add_controlling

(

switch_stun_packet_t *

packet

)

Definition at line 585 of file switch_stun.c.

References buf, switch_stun_packet_attribute_t::length, SWITCH_STUN_ATTR_CONTROLLING, switch_stun_random_string(), switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by ice_out().

{
        switch_stun_packet_attribute_t *attribute;
        char buf[8];

        switch_stun_random_string(buf, 8, NULL);

        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_CONTROLLING);
        attribute->length = htons(8);
        memcpy(attribute->value, buf, 8);
        packet->header.length += htons(sizeof(switch_stun_packet_attribute_t)) + attribute->length;
        return 1;
}

uint8_t switch_stun_packet_attribute_add_fingerprint

(

switch_stun_packet_t *

packet

)

Definition at line 552 of file switch_stun.c.

References switch_stun_packet_attribute_t::length, switch_crc32_8bytes(), SWITCH_STUN_ATTR_FINGERPRINT, switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by handle_ice(), and ice_out().

{
        switch_stun_packet_attribute_t *attribute;
        uint32_t crc;
        uint16_t xlen;

        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_FINGERPRINT);
        attribute->length = htons(4);

        xlen = ntohs(packet->header.length) + sizeof(switch_stun_packet_header_t);

        packet->header.length += htons(sizeof(switch_stun_packet_attribute_t)) + attribute->length;

        crc = htonl(switch_crc32_8bytes(packet, xlen) ^ 0x5354554e);

        memcpy(attribute->value, &crc, 4);

        return 1;
}

uint8_t switch_stun_packet_attribute_add_integrity	(	switch_stun_packet_t *	packet,
		const char *	pass
	)

Definition at line 535 of file switch_stun.c.

References switch_stun_packet_attribute_t::length, SWITCH_STUN_ATTR_MESSAGE_INTEGRITY, switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by handle_ice(), and ice_out().

{
        switch_stun_packet_attribute_t *attribute;
        uint16_t xlen;

        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_MESSAGE_INTEGRITY);
        attribute->length = htons(20);

        xlen = ntohs(packet->header.length) + sizeof(switch_stun_packet_header_t);
        packet->header.length += htons(sizeof(switch_stun_packet_attribute_t)) + attribute->length;

        HMAC(EVP_sha1(), (unsigned char *)pass, (int)strlen(pass), (void *)packet, xlen, (void *)attribute->value, NULL);

        return 1;
}

uint8_t switch_stun_packet_attribute_add_password	(	switch_stun_packet_t *	packet,
		char *	password,
		uint16_t	ulen
	)

Definition at line 664 of file switch_stun.c.

References switch_stun_packet_attribute_t::length, SWITCH_STUN_ATTR_PASSWORD, switch_stun_random_string(), switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

{
        switch_stun_packet_attribute_t *attribute;
        int m = ulen % 4;
        int padding = 0;

        if (m) {
                padding = 4 - m;
        }

        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_PASSWORD);
        attribute->length = htons(ulen);
        if (password) {
                memcpy(attribute->value, password, ulen);
        } else {
                switch_stun_random_string(attribute->value, ulen, NULL);
        }

        packet->header.length += htons((u_short)(sizeof(switch_stun_packet_attribute_t) + padding)) + attribute->length;

        return 1;
}

uint8_t switch_stun_packet_attribute_add_priority	(	switch_stun_packet_t *	packet,
		uint32_t	priority
	)

Definition at line 521 of file switch_stun.c.

References switch_stun_packet_attribute_t::length, SWITCH_STUN_ATTR_PRIORITY, switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by ice_out().

{
        switch_stun_packet_attribute_t *attribute;

        priority = htonl(priority);
        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_PRIORITY);
        attribute->length = htons(4);
        memcpy(attribute->value, &priority, 4);

        packet->header.length += htons(sizeof(switch_stun_packet_attribute_t)) + attribute->length;
        return 1;
}

uint8_t switch_stun_packet_attribute_add_software	(	switch_stun_packet_t *	packet,
		char *	software,
		uint16_t	ulen
	)

Definition at line 640 of file switch_stun.c.

References switch_stun_packet_attribute_t::length, SWITCH_STUN_ATTR_SOFTWARE, switch_stun_random_string(), switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by ice_out().

{
        switch_stun_packet_attribute_t *attribute;
        int m = ulen % 4;
        int padding = 0;

        if (m) {
                padding = 4 - m;
        }

        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_SOFTWARE);
        attribute->length = htons(ulen);
        if (software) {
                memcpy(attribute->value, software, ulen);
        } else {
                switch_stun_random_string(attribute->value, ulen, NULL);
        }

        packet->header.length += htons((u_short)(sizeof(switch_stun_packet_attribute_t) + padding)) + attribute->length;

        return 1;
}

uint8_t switch_stun_packet_attribute_add_use_candidate

(

switch_stun_packet_t *

packet

)

Definition at line 574 of file switch_stun.c.

References switch_stun_packet_attribute_t::length, SWITCH_STUN_ATTR_USE_CAND, and switch_stun_packet_attribute_t::type.

Referenced by ice_out().

{
        switch_stun_packet_attribute_t *attribute;

        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_USE_CAND);
        attribute->length = htons(0);
        packet->header.length += htons(sizeof(switch_stun_packet_attribute_t)) + attribute->length;
        return 1;
}

uint8_t switch_stun_packet_attribute_add_username	(	switch_stun_packet_t *	packet,
		char *	username,
		uint16_t	ulen
	)

Add a username packet attribute.

Parameters

packet	the packet to add the attribute to
username	the string representation of the username
ulen	the length of the username

Returns

true or false

Definition at line 616 of file switch_stun.c.

References switch_stun_packet_attribute_t::length, SWITCH_STUN_ATTR_USERNAME, switch_stun_random_string(), switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by handle_ice(), ice_out(), and switch_stun_lookup().

{
        switch_stun_packet_attribute_t *attribute;
        int m = ulen % 4;
        int padding = 0;

        if (m) {
                padding = 4 - m;
        }

        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_USERNAME);
        attribute->length = htons(ulen);
        if (username) {
                memcpy(attribute->value, username, ulen);
        } else {
                switch_stun_random_string(attribute->value, ulen, NULL);
        }

        packet->header.length += htons((u_short)(sizeof(switch_stun_packet_attribute_t) + padding)) + attribute->length;

        return 1;
}

uint8_t switch_stun_packet_attribute_add_xor_binded_address	(	switch_stun_packet_t *	packet,
		char *	ipstr,
		uint16_t	port,
		int	family
	)

Definition at line 485 of file switch_stun.c.

References switch_stun_ip_t::address, switch_stun_ip_t::family, switch_stun_packet_attribute_t::length, switch_stun_ip_t::port, STUN_MAGIC_COOKIE, SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS, switch_stun_packet_attribute_t::type, v6_xor(), and switch_stun_packet_attribute_t::value.

Referenced by handle_ice().

{
        switch_stun_packet_attribute_t *attribute;
        switch_stun_ip_t *ip;
        
        attribute = (switch_stun_packet_attribute_t *) ((uint8_t *) & packet->first_attribute + ntohs(packet->header.length));
        attribute->type = htons(SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS);

        if (family == AF_INET6) {
                attribute->length = htons(20);
        } else {
                attribute->length = htons(8);
        }

        ip = (switch_stun_ip_t *) attribute->value;

        ip->port = htons(port ^ (STUN_MAGIC_COOKIE >> 16));

        if (family == AF_INET6) {
                ip->family = 2;
        } else {
                ip->family = 1;
        }

        if (family == AF_INET6) {
                inet_pton(AF_INET6, ipstr, (struct in6_addr *) &ip->address);
                v6_xor((uint8_t *)&ip->address, (uint8_t *)packet->header.id);
        } else {
                inet_pton(AF_INET, ipstr, (int *) &ip->address);
                ip->address = htonl(ntohl(ip->address) ^ STUN_MAGIC_COOKIE);
        }

        packet->header.length += htons(sizeof(switch_stun_packet_attribute_t)) + attribute->length;
        return 1;
}

uint8_t switch_stun_packet_attribute_get_mapped_address	(	switch_stun_packet_attribute_t *	attribute,
		char *	ipstr,
		switch_size_t	iplen,
		uint16_t *	port
	)

Extract a mapped address (IP:PORT) from a packet attribute.

Parameters

attribute	the attribute from which to extract
ipstr	a buffer to write the string representation of the ip
port	the port

Returns

true or false

Definition at line 377 of file switch_stun.c.

References switch_stun_ip_t::address, and switch_stun_ip_t::port.

Referenced by handle_ice(), and switch_stun_lookup().

{
        switch_stun_ip_t *ip;
        uint8_t x, *i;
        char *p = ipstr;

        ip = (switch_stun_ip_t *) attribute->value;
        i = (uint8_t *) & ip->address;
        *ipstr = 0;
        for (x = 0; x < 4; x++) {
                sprintf(p, "%u%s", i[x], x == 3 ? "" : ".");
                p = ipstr + strlen(ipstr);
        }
        *port = ip->port;
        return 1;
}

char* switch_stun_packet_attribute_get_username	(	switch_stun_packet_attribute_t *	attribute,
		char *	username,
		uint16_t	len
	)

Extract a username from a packet attribute.

Parameters

attribute	the attribute from which to extract
username	a buffer to write the string representation of the username
len	the maximum size of the username buffer

Returns

a pointer to the username or NULL

Definition at line 423 of file switch_stun.c.

Referenced by handle_ice(), and switch_stun_lookup().

{
        uint16_t cpylen;

        cpylen = attribute->length < len ? attribute->length : len;
        return memcpy(username, attribute->value, cpylen);
}

uint8_t switch_stun_packet_attribute_get_xor_mapped_address	(	switch_stun_packet_attribute_t *	attribute,
		switch_stun_packet_header_t *	header,
		char *	ipstr,
		switch_size_t	iplen,
		uint16_t *	port
	)

Definition at line 394 of file switch_stun.c.

References switch_stun_ip_t::address, switch_stun_ip_t::family, if(), switch_stun_ip_t::port, and v6_xor().

Referenced by handle_ice(), and switch_stun_lookup().

{
        switch_stun_ip_t *ip;
        uint8_t x, *i;
        char *p = ipstr;

        ip = (switch_stun_ip_t *) attribute->value;

        if (ip->family == 2) {
                uint8_t *v6addr = (uint8_t *) &ip->address;
                v6_xor(v6addr, (uint8_t *)header->id);
                inet_ntop(AF_INET6, v6addr, ipstr, iplen);
        } else {
                ip->address ^= header->cookie;

                i = (uint8_t *) & ip->address;
                *ipstr = 0;
                for (x = 0; x < 4; x++) {
                        sprintf(p, "%u%s", i[x], x == 3 ? "" : ".");
                        p = ipstr + strlen(ipstr);
                }
        }

        ip->port ^= ntohl(header->cookie) >> 16;
        *port = ip->port;

        return 1;
}

switch_stun_packet_t* switch_stun_packet_build_header	(	switch_stun_message_t	type,
		char *	id,
		uint8_t *	buf
	)

Prepare a new outbound packet of a certian type and id.

Parameters

id	id to use (NULL for an auto generated id)
type	the stun packet type
buf	a pointer to data to use for the packet

Returns

a pointer to a ready-to-use stun packet

Definition at line 431 of file switch_stun.c.

References buf, switch_stun_packet_header_t::cookie, switch_stun_packet_header_t::id, switch_stun_packet_header_t::length, STUN_MAGIC_COOKIE, switch_stun_random_string(), and switch_stun_packet_header_t::type.

Referenced by handle_ice(), ice_out(), and switch_stun_lookup().

{
        switch_stun_packet_header_t *header;


        header = (switch_stun_packet_header_t *) buf;
        header->type = htons(type);
        header->length = 0;
        header->cookie = htonl(STUN_MAGIC_COOKIE);

        if (id) {
                memcpy(header->id, id, 12);
        } else {
                switch_stun_random_string(header->id, 12, NULL);
        }

        return (switch_stun_packet_t *) buf;
}

switch_stun_packet_t* switch_stun_packet_parse	(	uint8_t *	buf,
		uint32_t	len
	)

Prepare a raw packet for parsing.

Parameters

buf	the raw data
len	the length of the data

Returns

a stun packet pointer to buf to use as an access point

Definition at line 144 of file switch_stun.c.

References switch_stun_ip_t::family, switch_stun_packet_t::header, if(), switch_stun_packet_header_t::length, switch_stun_packet_attribute_t::length, switch_stun_ip_t::port, SWITCH_STUN_ALLOCATE_ERROR_RESPONSE, SWITCH_STUN_ALLOCATE_REQUEST, SWITCH_STUN_ALLOCATE_RESPONSE, SWITCH_STUN_ATTR_ALTERNATE_SERVER, SWITCH_STUN_ATTR_BANDWIDTH, SWITCH_STUN_ATTR_CHANGE_REQUEST, SWITCH_STUN_ATTR_CHANGED_ADDRESS, SWITCH_STUN_ATTR_DATA, SWITCH_STUN_ATTR_DESTINATION_ADDRESS, SWITCH_STUN_ATTR_ERROR_CODE, SWITCH_STUN_ATTR_LIFETIME, SWITCH_STUN_ATTR_MAGIC_COOKIE, SWITCH_STUN_ATTR_MAPPED_ADDRESS, SWITCH_STUN_ATTR_MESSAGE_INTEGRITY, SWITCH_STUN_ATTR_OPTIONS, SWITCH_STUN_ATTR_PASSWORD, SWITCH_STUN_ATTR_PRIORITY, SWITCH_STUN_ATTR_REFLECTED_FROM, SWITCH_STUN_ATTR_RESPONSE_ADDRESS, SWITCH_STUN_ATTR_SOFTWARE, SWITCH_STUN_ATTR_SOURCE_ADDRESS, SWITCH_STUN_ATTR_SOURCE_ADDRESS2, SWITCH_STUN_ATTR_TRANSPORT_PREFERENCES, SWITCH_STUN_ATTR_UNKNOWN_ATTRIBUTES, SWITCH_STUN_ATTR_USERNAME, SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS, SWITCH_STUN_ATTRIBUTE_MIN_LEN, switch_stun_attribute_padded_length, SWITCH_STUN_BINDING_ERROR_RESPONSE, SWITCH_STUN_BINDING_REQUEST, SWITCH_STUN_BINDING_RESPONSE, SWITCH_STUN_DATA_INDICATION, switch_stun_packet_first_attribute, SWITCH_STUN_PACKET_MIN_LEN, SWITCH_STUN_SEND_ERROR_RESPONSE, SWITCH_STUN_SEND_REQUEST, SWITCH_STUN_SEND_RESPONSE, SWITCH_STUN_SHARED_SECRET_ERROR_RESPONSE, SWITCH_STUN_SHARED_SECRET_REQUEST, SWITCH_STUN_SHARED_SECRET_RESPONSE, switch_stun_packet_header_t::type, switch_stun_packet_attribute_t::type, and switch_stun_packet_attribute_t::value.

Referenced by handle_ice(), and switch_stun_lookup().

{
        switch_stun_packet_t *packet;
        switch_stun_packet_attribute_t *attr;
        uint32_t bytes_left = len;
        void *end_buf = buf + len;
        int xlen = 0;

        if (len < SWITCH_STUN_PACKET_MIN_LEN) {
                return NULL;
        }

        packet = (switch_stun_packet_t *) buf;
        packet->header.type = ntohs(packet->header.type);
        packet->header.length = ntohs(packet->header.length);
        if (packet->header.length > (bytes_left -= 20)) return NULL;

        /*
         * Check packet type (RFC3489(bis?) values)
         */
        switch (packet->header.type) {
        case SWITCH_STUN_BINDING_REQUEST:
        case SWITCH_STUN_BINDING_RESPONSE:
        case SWITCH_STUN_BINDING_ERROR_RESPONSE:
        case SWITCH_STUN_SHARED_SECRET_REQUEST:
        case SWITCH_STUN_SHARED_SECRET_RESPONSE:
        case SWITCH_STUN_SHARED_SECRET_ERROR_RESPONSE:
        case SWITCH_STUN_ALLOCATE_REQUEST:
        case SWITCH_STUN_ALLOCATE_RESPONSE:
        case SWITCH_STUN_ALLOCATE_ERROR_RESPONSE:
        case SWITCH_STUN_SEND_REQUEST:
        case SWITCH_STUN_SEND_RESPONSE:
        case SWITCH_STUN_SEND_ERROR_RESPONSE:
        case SWITCH_STUN_DATA_INDICATION:
                /* Valid */
                break;

        default:
                /* Invalid value */
                return NULL;
        }

        /*
         * Check for length overflow
         */
        if (bytes_left <= 0) {
                /* Invalid */
                return NULL;
        }

        /*
         * No payload?
         */
        if (packet->header.length == 0) {
                /* Invalid?! */
                return NULL;
        }

        /* check if we have enough bytes left for an attribute */
        if (bytes_left < SWITCH_STUN_ATTRIBUTE_MIN_LEN) {
                return NULL;
        }

        switch_stun_packet_first_attribute(packet, attr);
        do {
                attr->length = ntohs(attr->length);
                attr->type = ntohs(attr->type);
                bytes_left -= 4;                /* attribute header consumed */

                if (switch_stun_attribute_padded_length(attr) > (int)bytes_left) {
                        /*
                         * Note we simply don't "break" here out of the loop anymore because
                         * we don't want the upper layers to have to deal with attributes without a value
                         * (or worse: invalid length)
                         */
                        return NULL;
                }

                /*
                 * Handle STUN attributes
                 */
                switch (attr->type) {
                case SWITCH_STUN_ATTR_MAPPED_ADDRESS:   /* Address, we only care about this one, but parse the others too */
                case SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS:
                case SWITCH_STUN_ATTR_RESPONSE_ADDRESS:
                case SWITCH_STUN_ATTR_SOURCE_ADDRESS:
                case SWITCH_STUN_ATTR_CHANGED_ADDRESS:
                case SWITCH_STUN_ATTR_REFLECTED_FROM:
                case SWITCH_STUN_ATTR_ALTERNATE_SERVER:
                case SWITCH_STUN_ATTR_DESTINATION_ADDRESS:
                case SWITCH_STUN_ATTR_PRIORITY:
                        {
                                switch_stun_ip_t *ip = (switch_stun_ip_t *) attr->value;
                                ip->port = ntohs(ip->port);
                        }
                        break;
                case SWITCH_STUN_ATTR_SOURCE_ADDRESS2:
                        {
                                switch_stun_ip_t *ip;
                                uint32_t addr_length = 0;
                                ip = (switch_stun_ip_t *) attr->value;

                                switch (ip->family) {
                                case 0x01:              /* IPv4 */
                                        addr_length = 4;
                                        break;

                                case 0x02:              /* IPv6 */
                                        addr_length = 16;
                                        break;

                                default:                /* Invalid */
                                        return NULL;
                                }

                                /* attribute payload length must be == address length + size of other payload fields (family...) */
                                if (attr->length != addr_length + 4) {
                                        /* Invalid */
                                        return NULL;
                                }

                                ip->port = ntohs(ip->port);
                        }
                        break;

                case SWITCH_STUN_ATTR_CHANGE_REQUEST:   /* UInt32 */
                case SWITCH_STUN_ATTR_LIFETIME:
                case SWITCH_STUN_ATTR_BANDWIDTH:
                case SWITCH_STUN_ATTR_OPTIONS:
                        {
                                uint32_t *val = (uint32_t *) attr->value;

                                if (attr->length != sizeof(uint32_t)) {
                                        /* Invalid */
                                        return NULL;
                                }

                                *val = ntohl(*val);     /* should we do this here? */
                        }
                        break;
                case SWITCH_STUN_ATTR_ERROR_CODE:       /* ErrorCode */
                        {
                                uint32_t *u = (uint32_t *) attr->value;
                                *u = htonl(*u);
                        }
                        break;

                case SWITCH_STUN_ATTR_SOFTWARE:
                case SWITCH_STUN_ATTR_USERNAME: /* ByteString, multiple of 4 bytes */
                case SWITCH_STUN_ATTR_PASSWORD: /* ByteString, multiple of 4 bytes */
                case SWITCH_STUN_ATTR_DATA:     /* ByteString */
                case SWITCH_STUN_ATTR_TRANSPORT_PREFERENCES:    /* TransportPrefs */
                        /*
                         * No length checking here, since we already checked against the padded length
                         * before
                         */
                        break;

                case SWITCH_STUN_ATTR_MESSAGE_INTEGRITY:        /* ByteString, 20 bytes */
                        if (attr->length != 20) {
                                /* Invalid */
                                return NULL;
                        }
                        break;

                case SWITCH_STUN_ATTR_MAGIC_COOKIE:     /* ByteString, 4 bytes */
                        if (attr->length != 4) {
                                /* Invalid */
                                return NULL;
                        }
                        break;

                case SWITCH_STUN_ATTR_UNKNOWN_ATTRIBUTES:       /* UInt16List (= multiple of 2 bytes) */
                        if (attr->length % 2 != 0) {
                                return NULL;
                        }
                        break;

                default:
                        break;
                }

                bytes_left -= switch_stun_attribute_padded_length(attr);        /* attribute value consumed, substract padded length */
                xlen += 4 + switch_stun_attribute_padded_length(attr);

                attr = (switch_stun_packet_attribute_t *) (attr->value + switch_stun_attribute_padded_length(attr));
                if ((void *)attr > end_buf) {
                        break;
                }
        } while (xlen < packet->header.length);
        
        if ((uint32_t) (packet->header.length + 20) > (uint32_t) (len - bytes_left)) {
                /*
                 * the packet length is longer than the length of all attributes?
                 * for now simply decrease the packet size
                 */
                packet->header.length = (uint16_t) ((len - bytes_left) - 20);
        }
        
        return packet;
}

void switch_stun_random_string	(	char *	buf,
		uint16_t	len,
		char *	set
	)

Writes random characters into a buffer.

Parameters

buf	the buffer
len	the length of the data
set	the set of chars to use (NULL for auto)

Definition at line 125 of file switch_stun.c.

Referenced by gen_ice(), generate_m(), switch_core_media_gen_local_sdp(), switch_rtp_get_random(), switch_stun_lookup(), switch_stun_packet_attribute_add_controlled(), switch_stun_packet_attribute_add_controlling(), switch_stun_packet_attribute_add_password(), switch_stun_packet_attribute_add_software(), switch_stun_packet_attribute_add_username(), and switch_stun_packet_build_header().

{
        char chars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        int max;
        uint16_t x;

        if (!set) {
                set = chars;
        }

        max = (int) strlen(set);

        for (x = 0; x < len; x++) {
                int j = (int) (max * 1.0 * rand() / (RAND_MAX + 1.0));
                buf[x] = set[j];
        }
}

const char* switch_stun_value_to_name	(	int32_t	type,
		uint32_t	value
	)

Obtain a printable string form of a given value.

Parameters

type	the type of message
value	the value to look up

Returns

a sring version of value

Definition at line 347 of file switch_stun.c.

References ATTR_TYPES, ERROR_TYPES, value_mapping::name, PACKET_TYPES, SWITCH_STUN_TYPE_ATTRIBUTE, SWITCH_STUN_TYPE_ERROR, SWITCH_STUN_TYPE_PACKET_TYPE, and value_mapping::value.

Referenced by handle_ice().

{
        uint32_t x = 0;
        const struct value_mapping *map = NULL;
        switch (type) {
        case SWITCH_STUN_TYPE_PACKET_TYPE:
                map = PACKET_TYPES;
                break;
        case SWITCH_STUN_TYPE_ATTRIBUTE:
                map = ATTR_TYPES;
                break;
        case SWITCH_STUN_TYPE_ERROR:
                map = ERROR_TYPES;
                break;
        default:
                map = NULL;
                break;
        }

        if (map) {
                for (x = 0; map[x].value; x++) {
                        if (map[x].value == value) {
                                return map[x].name;
                        }
                }
        }

        return "INVALID";
}