From 947b02aaa62b13463265ad577cfaf35e576e1ba7 Mon Sep 17 00:00:00 2001 From: Benny Prijono Date: Sat, 21 Jun 2008 17:51:31 +0000 Subject: Added more API to initialize STUN message and attributes without pool git-svn-id: http://svn.pjsip.org/repos/pjproject/trunk@2044 74dad513-b988-da41-8d7b-12977e46ad98 --- pjnath/include/pjnath/stun_msg.h | 73 ++++++++++++++++++++ pjnath/src/pjnath/stun_msg.c | 140 ++++++++++++++++++++++++++++----------- 2 files changed, 174 insertions(+), 39 deletions(-) (limited to 'pjnath') diff --git a/pjnath/include/pjnath/stun_msg.h b/pjnath/include/pjnath/stun_msg.h index 61cff153..a122ba87 100644 --- a/pjnath/include/pjnath/stun_msg.h +++ b/pjnath/include/pjnath/stun_msg.h @@ -1224,6 +1224,24 @@ PJ_DECL(pj_str_t) pj_stun_get_err_reason(int err_code); PJ_DECL(int) pj_stun_set_padding_char(int chr); +/** + * Initialize a generic STUN message. + * + * @param msg The message structure to be initialized. + * @param msg_type The 14bit message type (see pj_stun_msg_type + * constants). + * @param magic Magic value to be put to the mesage; for requests, + * the value normally should be PJ_STUN_MAGIC. + * @param tsx_id Optional transaction ID, or NULL to let the + * function generates a random transaction ID. + * + * @return PJ_SUCCESS on success. + */ +PJ_DECL(pj_status_t) pj_stun_msg_init(pj_stun_msg *msg, + unsigned msg_type, + pj_uint32_t magic, + const pj_uint8_t tsx_id[12]); + /** * Create a generic STUN message. * @@ -1434,6 +1452,26 @@ PJ_DECL(pj_stun_attr_hdr*) pj_stun_attr_clone(pj_pool_t *pool, const pj_stun_attr_hdr *attr); +/** + * Initialize generic STUN IP address attribute. The \a addr_len and + * \a addr parameters specify whether the address is IPv4 or IPv4 + * address. + * + * @param attr The socket address attribute to initialize. + * @param attr_type Attribute type, from #pj_stun_attr_type. + * @param xor_ed If non-zero, the port and address will be XOR-ed + * with magic, to make the XOR-MAPPED-ADDRESS attribute. + * @param addr A pj_sockaddr_in or pj_sockaddr_in6 structure. + * @param addr_len Length of \a addr parameter. + * + * @return PJ_SUCCESS on success or the appropriate error code. + */ +PJ_DECL(pj_status_t) pj_stun_sockaddr_attr_init(pj_stun_sockaddr_attr *attr, + int attr_type, + pj_bool_t xor_ed, + const pj_sockaddr_t *addr, + unsigned addr_len); + /** * Create a generic STUN IP address attribute. The \a addr_len and * \a addr parameters specify whether the address is IPv4 or IPv4 @@ -1479,6 +1517,22 @@ PJ_DECL(pj_status_t) pj_stun_msg_add_sockaddr_attr(pj_pool_t *pool, const pj_sockaddr_t *addr, unsigned addr_len); +/** + * Initialize a STUN generic string attribute. + * + * @param attr The string attribute to be initialized. + * @param pool Pool to duplicate the value into the attribute, + * if value is not NULL or empty. + * @param attr_type Attribute type, from #pj_stun_attr_type. + * @param value The string value to be assigned to the attribute. + * + * @return PJ_SUCCESS on success or the appropriate error code. + */ +PJ_DECL(pj_status_t) pj_stun_string_attr_init(pj_stun_string_attr *attr, + pj_pool_t *pool, + int attr_type, + const pj_str_t *value); + /** * Create a STUN generic string attribute. * @@ -1657,6 +1711,25 @@ PJ_DECL(pj_status_t) pj_stun_msg_add_unknown_attr(pj_pool_t *pool, unsigned attr_cnt, const pj_uint16_t attr[]); +/** + * Initialize STUN binary attribute. + * + * @param attr The attribute to be initialized. + * @param pool Pool to copy data, if the data and length are set. + * @param attr_type The attribute type, from #pj_stun_attr_type. + * @param data Data to be coped to the attribute, or NULL + * if no data to be copied now. + * @param length Length of data, or zero if no data is to be + * copied now. + * + * @return PJ_SUCCESS on success or the appropriate error code. + */ +PJ_DECL(pj_status_t) pj_stun_binary_attr_init(pj_stun_binary_attr *attr, + pj_pool_t *pool, + int attr_type, + const pj_uint8_t *data, + unsigned length); + /** * Create STUN binary attribute. * diff --git a/pjnath/src/pjnath/stun_msg.c b/pjnath/src/pjnath/stun_msg.c index 2bbc2fdf..3e82a21c 100644 --- a/pjnath/src/pjnath/stun_msg.c +++ b/pjnath/src/pjnath/stun_msg.c @@ -711,6 +711,28 @@ static void GETATTRHDR(const pj_uint8_t *buf, pj_stun_attr_hdr *hdr) */ #define STUN_GENERIC_IP_ADDR_LEN 8 +/* + * Init sockaddr attr + */ +PJ_DEF(pj_status_t) pj_stun_sockaddr_attr_init( pj_stun_sockaddr_attr *attr, + int attr_type, + pj_bool_t xor_ed, + const pj_sockaddr_t *addr, + unsigned addr_len) +{ + PJ_ASSERT_RETURN(attr && addr_len && addr, PJ_EINVAL); + PJ_ASSERT_RETURN(addr_len == sizeof(pj_sockaddr_in) || + addr_len == sizeof(pj_sockaddr_in6), PJ_EINVAL); + + INIT_ATTR(attr, attr_type, STUN_GENERIC_IP_ADDR_LEN); + + pj_memcpy(&attr->sockaddr, addr, addr_len); + attr->xor_ed = xor_ed; + + return PJ_SUCCESS; +} + + /* * Create a generic STUN IP address attribute for IPv4 address. */ @@ -723,19 +745,11 @@ PJ_DEF(pj_status_t) pj_stun_sockaddr_attr_create(pj_pool_t *pool, { pj_stun_sockaddr_attr *attr; - PJ_ASSERT_RETURN(pool && addr_len && addr && p_attr, PJ_EINVAL); - PJ_ASSERT_RETURN(addr_len == sizeof(pj_sockaddr_in) || - addr_len == sizeof(pj_sockaddr_in6), PJ_EINVAL); - + PJ_ASSERT_RETURN(pool && p_attr, PJ_EINVAL); attr = PJ_POOL_ZALLOC_T(pool, pj_stun_sockaddr_attr); - INIT_ATTR(attr, attr_type, STUN_GENERIC_IP_ADDR_LEN); - - pj_memcpy(&attr->sockaddr, addr, addr_len); - attr->xor_ed = xor_ed; - *p_attr = attr; - - return PJ_SUCCESS; + return pj_stun_sockaddr_attr_init(attr, attr_type, xor_ed, + addr, addr_len); } @@ -896,6 +910,23 @@ static void* clone_sockaddr_attr(pj_pool_t *pool, const void *src) * STUN generic string attribute */ +/* + * Initialize a STUN generic string attribute. + */ +PJ_DEF(pj_status_t) pj_stun_string_attr_init( pj_stun_string_attr *attr, + pj_pool_t *pool, + int attr_type, + const pj_str_t *value) +{ + INIT_ATTR(attr, attr_type, value->slen); + if (value && value->slen) + pj_strdup(pool, &attr->value, value); + else + attr->value.slen = 0; + return PJ_SUCCESS; +} + + /* * Create a STUN generic string attribute. */ @@ -909,12 +940,9 @@ PJ_DEF(pj_status_t) pj_stun_string_attr_create(pj_pool_t *pool, PJ_ASSERT_RETURN(pool && value && p_attr, PJ_EINVAL); attr = PJ_POOL_ZALLOC_T(pool, pj_stun_string_attr); - INIT_ATTR(attr, attr_type, value->slen); - pj_strdup(pool, &attr->value, value); - *p_attr = attr; - return PJ_SUCCESS; + return pj_stun_string_attr_init(attr, pool, attr_type, value); } @@ -1641,19 +1669,16 @@ static void* clone_unknown_attr(pj_pool_t *pool, const void *src) */ /* - * Create a blank binary attribute. + * Initialize STUN binary attribute. */ -PJ_DEF(pj_status_t) pj_stun_binary_attr_create(pj_pool_t *pool, - int attr_type, - const pj_uint8_t *data, - unsigned length, - pj_stun_binary_attr **p_attr) +PJ_DEF(pj_status_t) pj_stun_binary_attr_init( pj_stun_binary_attr *attr, + pj_pool_t *pool, + int attr_type, + const pj_uint8_t *data, + unsigned length) { - pj_stun_binary_attr *attr; - - PJ_ASSERT_RETURN(pool && attr_type && p_attr, PJ_EINVAL); + PJ_ASSERT_RETURN(attr_type, PJ_EINVAL); - attr = PJ_POOL_ZALLOC_T(pool, pj_stun_binary_attr); INIT_ATTR(attr, attr_type, length); attr->magic = PJ_STUN_MAGIC; @@ -1662,14 +1687,33 @@ PJ_DEF(pj_status_t) pj_stun_binary_attr_create(pj_pool_t *pool, attr->length = length; attr->data = (pj_uint8_t*) pj_pool_alloc(pool, length); pj_memcpy(attr->data, data, length); + } else { + attr->data = NULL; + attr->length = 0; } - *p_attr = attr; - return PJ_SUCCESS; } +/* + * Create a blank binary attribute. + */ +PJ_DEF(pj_status_t) pj_stun_binary_attr_create(pj_pool_t *pool, + int attr_type, + const pj_uint8_t *data, + unsigned length, + pj_stun_binary_attr **p_attr) +{ + pj_stun_binary_attr *attr; + + PJ_ASSERT_RETURN(pool && attr_type && p_attr, PJ_EINVAL); + attr = PJ_POOL_ZALLOC_T(pool, pj_stun_binary_attr); + *p_attr = attr; + return pj_stun_binary_attr_init(attr, pool, attr_type, data, length); +} + + /* Create and add binary attr. */ PJ_DEF(pj_status_t) pj_stun_msg_add_binary_attr(pj_pool_t *pool, pj_stun_msg *msg, @@ -1753,21 +1797,19 @@ static void* clone_binary_attr(pj_pool_t *pool, const void *src) ////////////////////////////////////////////////////////////////////////////// /* - * Create a blank STUN message. + * Initialize a generic STUN message. */ -PJ_DEF(pj_status_t) pj_stun_msg_create( pj_pool_t *pool, - unsigned msg_type, - pj_uint32_t magic, - const pj_uint8_t tsx_id[12], - pj_stun_msg **p_msg) +PJ_DEF(pj_status_t) pj_stun_msg_init( pj_stun_msg *msg, + unsigned msg_type, + pj_uint32_t magic, + const pj_uint8_t tsx_id[12]) { - pj_stun_msg *msg; - - PJ_ASSERT_RETURN(pool && msg_type && p_msg, PJ_EINVAL); + PJ_ASSERT_RETURN(msg && msg_type, PJ_EINVAL); - msg = PJ_POOL_ZALLOC_T(pool, pj_stun_msg); msg->hdr.type = (pj_uint16_t) msg_type; + msg->hdr.length = 0; msg->hdr.magic = magic; + msg->attr_count = 0; if (tsx_id) { pj_memcpy(&msg->hdr.tsx_id, tsx_id, sizeof(msg->hdr.tsx_id)); @@ -1780,6 +1822,9 @@ PJ_DEF(pj_status_t) pj_stun_msg_create( pj_pool_t *pool, } id; static pj_uint32_t pj_stun_tsx_id_counter; + if (!pj_stun_tsx_id_counter) + pj_stun_tsx_id_counter = pj_rand(); + id.proc_id = pj_getpid(); id.random = pj_rand(); id.counter = pj_stun_tsx_id_counter++; @@ -1787,12 +1832,29 @@ PJ_DEF(pj_status_t) pj_stun_msg_create( pj_pool_t *pool, pj_memcpy(&msg->hdr.tsx_id, &id, sizeof(msg->hdr.tsx_id)); } - *p_msg = msg; - return PJ_SUCCESS; } +/* + * Create a blank STUN message. + */ +PJ_DEF(pj_status_t) pj_stun_msg_create( pj_pool_t *pool, + unsigned msg_type, + pj_uint32_t magic, + const pj_uint8_t tsx_id[12], + pj_stun_msg **p_msg) +{ + pj_stun_msg *msg; + + PJ_ASSERT_RETURN(pool && msg_type && p_msg, PJ_EINVAL); + + msg = PJ_POOL_ZALLOC_T(pool, pj_stun_msg); + *p_msg = msg; + return pj_stun_msg_init(msg, msg_type, magic, tsx_id); +} + + /* * Clone a STUN message with all of its attributes. */ -- cgit v1.2.3