Changeset 2044


Ignore:
Timestamp:
Jun 21, 2008 5:51:31 PM (11 years ago)
Author:
bennylp
Message:

Added more API to initialize STUN message and attributes without pool

Location:
pjproject/trunk/pjnath
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjnath/include/pjnath/stun_msg.h

    r2041 r2044  
    12261226 
    12271227/** 
     1228 * Initialize a generic STUN message. 
     1229 * 
     1230 * @param msg           The message structure to be initialized. 
     1231 * @param msg_type      The 14bit message type (see pj_stun_msg_type  
     1232 *                      constants). 
     1233 * @param magic         Magic value to be put to the mesage; for requests, 
     1234 *                      the value normally should be PJ_STUN_MAGIC. 
     1235 * @param tsx_id        Optional transaction ID, or NULL to let the 
     1236 *                      function generates a random transaction ID. 
     1237 * 
     1238 * @return              PJ_SUCCESS on success. 
     1239 */ 
     1240PJ_DECL(pj_status_t) pj_stun_msg_init(pj_stun_msg *msg, 
     1241                                      unsigned msg_type, 
     1242                                      pj_uint32_t magic, 
     1243                                      const pj_uint8_t tsx_id[12]); 
     1244 
     1245/** 
    12281246 * Create a generic STUN message. 
    12291247 * 
     
    14361454 
    14371455/** 
     1456 * Initialize generic STUN IP address attribute. The \a addr_len and 
     1457 * \a addr parameters specify whether the address is IPv4 or IPv4 
     1458 * address. 
     1459 * 
     1460 * @param attr          The socket address attribute to initialize. 
     1461 * @param attr_type     Attribute type, from #pj_stun_attr_type. 
     1462 * @param xor_ed        If non-zero, the port and address will be XOR-ed 
     1463 *                      with magic, to make the XOR-MAPPED-ADDRESS attribute. 
     1464 * @param addr          A pj_sockaddr_in or pj_sockaddr_in6 structure. 
     1465 * @param addr_len      Length of \a addr parameter. 
     1466 * 
     1467 * @return              PJ_SUCCESS on success or the appropriate error code. 
     1468 */ 
     1469PJ_DECL(pj_status_t) pj_stun_sockaddr_attr_init(pj_stun_sockaddr_attr *attr, 
     1470                                                int attr_type,  
     1471                                                pj_bool_t xor_ed, 
     1472                                                const pj_sockaddr_t *addr, 
     1473                                                unsigned addr_len); 
     1474 
     1475/** 
    14381476 * Create a generic STUN IP address attribute. The \a addr_len and 
    14391477 * \a addr parameters specify whether the address is IPv4 or IPv4 
     
    14811519 
    14821520/** 
     1521 * Initialize a STUN generic string attribute. 
     1522 * 
     1523 * @param attr          The string attribute to be initialized. 
     1524 * @param pool          Pool to duplicate the value into the attribute, 
     1525 *                      if value is not NULL or empty. 
     1526 * @param attr_type     Attribute type, from #pj_stun_attr_type. 
     1527 * @param value         The string value to be assigned to the attribute. 
     1528 * 
     1529 * @return              PJ_SUCCESS on success or the appropriate error code. 
     1530 */ 
     1531PJ_DECL(pj_status_t) pj_stun_string_attr_init(pj_stun_string_attr *attr, 
     1532                                              pj_pool_t *pool, 
     1533                                              int attr_type, 
     1534                                              const pj_str_t *value); 
     1535 
     1536/** 
    14831537 * Create a STUN generic string attribute. 
    14841538 * 
     
    16571711                                                  unsigned attr_cnt, 
    16581712                                                  const pj_uint16_t attr[]); 
     1713 
     1714/** 
     1715 * Initialize STUN binary attribute. 
     1716 * 
     1717 * @param attr          The attribute to be initialized. 
     1718 * @param pool          Pool to copy data, if the data and length are set. 
     1719 * @param attr_type     The attribute type, from #pj_stun_attr_type. 
     1720 * @param data          Data to be coped to the attribute, or NULL 
     1721 *                      if no data to be copied now. 
     1722 * @param length        Length of data, or zero if no data is to be 
     1723 *                      copied now. 
     1724 * 
     1725 * @return              PJ_SUCCESS on success or the appropriate error code. 
     1726 */ 
     1727PJ_DECL(pj_status_t) pj_stun_binary_attr_init(pj_stun_binary_attr *attr, 
     1728                                              pj_pool_t *pool, 
     1729                                              int attr_type, 
     1730                                              const pj_uint8_t *data, 
     1731                                              unsigned length); 
    16591732 
    16601733/** 
  • pjproject/trunk/pjnath/src/pjnath/stun_msg.c

    r2041 r2044  
    713713 
    714714/* 
     715 * Init sockaddr attr 
     716 */ 
     717PJ_DEF(pj_status_t) pj_stun_sockaddr_attr_init( pj_stun_sockaddr_attr *attr, 
     718                                                int attr_type,  
     719                                                pj_bool_t xor_ed, 
     720                                                const pj_sockaddr_t *addr, 
     721                                                unsigned addr_len) 
     722{ 
     723    PJ_ASSERT_RETURN(attr && addr_len && addr, PJ_EINVAL); 
     724    PJ_ASSERT_RETURN(addr_len == sizeof(pj_sockaddr_in) || 
     725                     addr_len == sizeof(pj_sockaddr_in6), PJ_EINVAL); 
     726 
     727    INIT_ATTR(attr, attr_type, STUN_GENERIC_IP_ADDR_LEN); 
     728 
     729    pj_memcpy(&attr->sockaddr, addr, addr_len); 
     730    attr->xor_ed = xor_ed; 
     731 
     732    return PJ_SUCCESS; 
     733} 
     734 
     735 
     736/* 
    715737 * Create a generic STUN IP address attribute for IPv4 address. 
    716738 */ 
     
    724746    pj_stun_sockaddr_attr *attr; 
    725747 
    726     PJ_ASSERT_RETURN(pool && addr_len && addr && p_attr, PJ_EINVAL); 
    727     PJ_ASSERT_RETURN(addr_len == sizeof(pj_sockaddr_in) || 
    728                      addr_len == sizeof(pj_sockaddr_in6), PJ_EINVAL); 
    729  
     748    PJ_ASSERT_RETURN(pool && p_attr, PJ_EINVAL); 
    730749    attr = PJ_POOL_ZALLOC_T(pool, pj_stun_sockaddr_attr); 
    731     INIT_ATTR(attr, attr_type, STUN_GENERIC_IP_ADDR_LEN); 
    732  
    733     pj_memcpy(&attr->sockaddr, addr, addr_len); 
    734     attr->xor_ed = xor_ed; 
    735  
    736750    *p_attr = attr; 
    737  
    738     return PJ_SUCCESS; 
     751    return pj_stun_sockaddr_attr_init(attr, attr_type, xor_ed,  
     752                                      addr, addr_len); 
    739753} 
    740754 
     
    898912 
    899913/* 
     914 * Initialize a STUN generic string attribute. 
     915 */ 
     916PJ_DEF(pj_status_t) pj_stun_string_attr_init( pj_stun_string_attr *attr, 
     917                                              pj_pool_t *pool, 
     918                                              int attr_type, 
     919                                              const pj_str_t *value) 
     920{ 
     921    INIT_ATTR(attr, attr_type, value->slen); 
     922    if (value && value->slen) 
     923        pj_strdup(pool, &attr->value, value); 
     924    else 
     925        attr->value.slen = 0; 
     926    return PJ_SUCCESS; 
     927} 
     928 
     929 
     930/* 
    900931 * Create a STUN generic string attribute. 
    901932 */ 
     
    910941 
    911942    attr = PJ_POOL_ZALLOC_T(pool, pj_stun_string_attr); 
    912     INIT_ATTR(attr, attr_type, value->slen); 
    913     pj_strdup(pool, &attr->value, value); 
    914  
    915943    *p_attr = attr; 
    916944 
    917     return PJ_SUCCESS; 
     945    return pj_stun_string_attr_init(attr, pool, attr_type, value); 
    918946} 
    919947 
     
    16421670 
    16431671/* 
     1672 * Initialize STUN binary attribute. 
     1673 */ 
     1674PJ_DEF(pj_status_t) pj_stun_binary_attr_init( pj_stun_binary_attr *attr, 
     1675                                              pj_pool_t *pool, 
     1676                                              int attr_type, 
     1677                                              const pj_uint8_t *data, 
     1678                                              unsigned length) 
     1679{ 
     1680    PJ_ASSERT_RETURN(attr_type, PJ_EINVAL); 
     1681 
     1682    INIT_ATTR(attr, attr_type, length); 
     1683 
     1684    attr->magic = PJ_STUN_MAGIC; 
     1685 
     1686    if (data && length) { 
     1687        attr->length = length; 
     1688        attr->data = (pj_uint8_t*) pj_pool_alloc(pool, length); 
     1689        pj_memcpy(attr->data, data, length); 
     1690    } else { 
     1691        attr->data = NULL; 
     1692        attr->length = 0; 
     1693    } 
     1694 
     1695    return PJ_SUCCESS; 
     1696} 
     1697 
     1698 
     1699/* 
    16441700 * Create a blank binary attribute. 
    16451701 */ 
     
    16531709 
    16541710    PJ_ASSERT_RETURN(pool && attr_type && p_attr, PJ_EINVAL); 
    1655  
    16561711    attr = PJ_POOL_ZALLOC_T(pool, pj_stun_binary_attr); 
    1657     INIT_ATTR(attr, attr_type, length); 
    1658  
    1659     attr->magic = PJ_STUN_MAGIC; 
    1660  
    1661     if (data && length) { 
    1662         attr->length = length; 
    1663         attr->data = (pj_uint8_t*) pj_pool_alloc(pool, length); 
    1664         pj_memcpy(attr->data, data, length); 
    1665     } 
    1666  
    16671712    *p_attr = attr; 
    1668  
    1669     return PJ_SUCCESS; 
     1713    return pj_stun_binary_attr_init(attr, pool, attr_type, data, length); 
    16701714} 
    16711715 
     
    17541798 
    17551799/* 
    1756  * Create a blank STUN message. 
    1757  */ 
    1758 PJ_DEF(pj_status_t) pj_stun_msg_create( pj_pool_t *pool, 
    1759                                         unsigned msg_type, 
    1760                                         pj_uint32_t magic, 
    1761                                         const pj_uint8_t tsx_id[12], 
    1762                                         pj_stun_msg **p_msg) 
    1763 { 
    1764     pj_stun_msg *msg; 
    1765  
    1766     PJ_ASSERT_RETURN(pool && msg_type && p_msg, PJ_EINVAL); 
    1767  
    1768     msg = PJ_POOL_ZALLOC_T(pool, pj_stun_msg); 
     1800 * Initialize a generic STUN message. 
     1801 */ 
     1802PJ_DEF(pj_status_t) pj_stun_msg_init( pj_stun_msg *msg, 
     1803                                      unsigned msg_type, 
     1804                                      pj_uint32_t magic, 
     1805                                      const pj_uint8_t tsx_id[12]) 
     1806{ 
     1807    PJ_ASSERT_RETURN(msg && msg_type, PJ_EINVAL); 
     1808 
    17691809    msg->hdr.type = (pj_uint16_t) msg_type; 
     1810    msg->hdr.length = 0; 
    17701811    msg->hdr.magic = magic; 
     1812    msg->attr_count = 0; 
    17711813 
    17721814    if (tsx_id) { 
     
    17811823        static pj_uint32_t pj_stun_tsx_id_counter; 
    17821824 
     1825        if (!pj_stun_tsx_id_counter) 
     1826            pj_stun_tsx_id_counter = pj_rand(); 
     1827 
    17831828        id.proc_id = pj_getpid(); 
    17841829        id.random = pj_rand(); 
     
    17881833    } 
    17891834 
     1835    return PJ_SUCCESS; 
     1836} 
     1837 
     1838 
     1839/* 
     1840 * Create a blank STUN message. 
     1841 */ 
     1842PJ_DEF(pj_status_t) pj_stun_msg_create( pj_pool_t *pool, 
     1843                                        unsigned msg_type, 
     1844                                        pj_uint32_t magic, 
     1845                                        const pj_uint8_t tsx_id[12], 
     1846                                        pj_stun_msg **p_msg) 
     1847{ 
     1848    pj_stun_msg *msg; 
     1849 
     1850    PJ_ASSERT_RETURN(pool && msg_type && p_msg, PJ_EINVAL); 
     1851 
     1852    msg = PJ_POOL_ZALLOC_T(pool, pj_stun_msg); 
    17901853    *p_msg = msg; 
    1791  
    1792     return PJ_SUCCESS; 
     1854    return pj_stun_msg_init(msg, msg_type, magic, tsx_id); 
    17931855} 
    17941856 
Note: See TracChangeset for help on using the changeset viewer.