stun_msg.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
#ifndef __PJNATH_STUN_MSG_H__
#define __PJNATH_STUN_MSG_H__
 
#include <pjnath/types.h>
#include <pj/sock.h>
 
 
PJ_BEGIN_DECL
 
 
/* **************************************************************************/
#define PJ_STUN_MAGIC                       0x2112A442
 
 
enum pj_stun_method_e
{
    PJ_STUN_BINDING_METHOD                  = 1,
 
    PJ_STUN_SHARED_SECRET_METHOD            = 2,
 
    PJ_STUN_ALLOCATE_METHOD                 = 3,
 
    PJ_STUN_REFRESH_METHOD                  = 4,
 
    PJ_STUN_SEND_METHOD                     = 6,
 
    PJ_STUN_DATA_METHOD                     = 7,
 
    PJ_STUN_CREATE_PERM_METHOD              = 8,
 
    PJ_STUN_CHANNEL_BIND_METHOD             = 9,
 
    PJ_STUN_CONNECT_METHOD                  = 10,
 
    PJ_STUN_CONNECTION_BIND_METHOD          = 11,
 
    PJ_STUN_CONNECTION_ATTEMPT_METHOD       = 12,
 
    PJ_STUN_METHOD_MAX
};
 
 
#define PJ_STUN_GET_METHOD(msg_type)    ((msg_type) & 0xFEEF)
 
 
enum pj_stun_msg_class_e
{
    PJ_STUN_REQUEST_CLASS           = 0,
 
    PJ_STUN_INDICATION_CLASS        = 1,
 
    PJ_STUN_SUCCESS_CLASS           = 2,
 
    PJ_STUN_ERROR_CLASS             = 3
};
 
 
#define PJ_STUN_IS_REQUEST(msg_type)    (((msg_type) & 0x0110) == 0x0000)
 
 
#define PJ_STUN_IS_SUCCESS_RESPONSE(msg_type) (((msg_type) & 0x0110) == 0x0100)
 
#define PJ_STUN_SUCCESS_RESPONSE_BIT    (0x0100)
 
 
#define PJ_STUN_IS_ERROR_RESPONSE(msg_type) (((msg_type) & 0x0110) == 0x0110)
 
#define PJ_STUN_ERROR_RESPONSE_BIT      (0x0110)
 
#define PJ_STUN_IS_RESPONSE(msg_type) (((msg_type) & 0x0100) == 0x0100)
 
 
#define PJ_STUN_IS_INDICATION(msg_type) (((msg_type) & 0x0110) == 0x0010)
 
#define PJ_STUN_INDICATION_BIT          (0x0010)
 
 
typedef enum pj_stun_msg_type
{
    PJ_STUN_BINDING_REQUEST                 = 0x0001,
 
    PJ_STUN_BINDING_RESPONSE                = 0x0101,
 
    PJ_STUN_BINDING_ERROR_RESPONSE          = 0x0111,
 
    PJ_STUN_BINDING_INDICATION              = 0x0011,
 
    PJ_STUN_SHARED_SECRET_REQUEST           = 0x0002,
 
    PJ_STUN_SHARED_SECRET_RESPONSE          = 0x0102,
 
    PJ_STUN_SHARED_SECRET_ERROR_RESPONSE    = 0x0112,
 
 
    PJ_STUN_ALLOCATE_REQUEST                = 0x0003,
 
    PJ_STUN_ALLOCATE_RESPONSE               = 0x0103,
 
    PJ_STUN_ALLOCATE_ERROR_RESPONSE         = 0x0113,
 
 
    PJ_STUN_REFRESH_REQUEST                 = 0x0004,
 
    PJ_STUN_REFRESH_RESPONSE                = 0x0104,
 
    PJ_STUN_REFRESH_ERROR_RESPONSE          = 0x0114,
 
 
    PJ_STUN_SEND_INDICATION                 = 0x0016,
 
 
    PJ_STUN_DATA_INDICATION                 = 0x0017,
 
 
    PJ_STUN_CREATE_PERM_REQUEST             = 0x0008,
 
    PJ_STUN_CREATE_PERM_RESPONSE            = 0x0108,
 
    PJ_STUN_CREATE_PERM_ERROR_RESPONSE      = 0x0118,
 
 
    PJ_STUN_CHANNEL_BIND_REQUEST            = 0x0009,
 
    PJ_STUN_CHANNEL_BIND_RESPONSE           = 0x0109,
 
    PJ_STUN_CHANNEL_BIND_ERROR_RESPONSE     = 0x0119,
 
    PJ_STUN_CONNECT_REQUEST                 = 0x000a,
 
    PJ_STUN_CONNECTION_BIND_REQUEST         = 0x000b,
 
    PJ_STUN_CONNECTION_ATTEMPT_INDICATION   = 0x001c,
 
} pj_stun_msg_type;
 
 
 
typedef enum pj_stun_attr_type
{
    PJ_STUN_ATTR_MAPPED_ADDR        = 0x0001,
    PJ_STUN_ATTR_RESPONSE_ADDR      = 0x0002,
    PJ_STUN_ATTR_CHANGE_REQUEST     = 0x0003,
    PJ_STUN_ATTR_SOURCE_ADDR        = 0x0004,
    PJ_STUN_ATTR_CHANGED_ADDR       = 0x0005,
    PJ_STUN_ATTR_USERNAME           = 0x0006,
    PJ_STUN_ATTR_PASSWORD           = 0x0007,
    PJ_STUN_ATTR_MESSAGE_INTEGRITY  = 0x0008,
    PJ_STUN_ATTR_ERROR_CODE         = 0x0009,
    PJ_STUN_ATTR_UNKNOWN_ATTRIBUTES = 0x000A,
    PJ_STUN_ATTR_REFLECTED_FROM     = 0x000B,
    PJ_STUN_ATTR_CHANNEL_NUMBER     = 0x000C,
    PJ_STUN_ATTR_LIFETIME           = 0x000D,
    PJ_STUN_ATTR_MAGIC_COOKIE       = 0x000F,
    PJ_STUN_ATTR_BANDWIDTH          = 0x0010,
    PJ_STUN_ATTR_XOR_PEER_ADDR      = 0x0012,
    PJ_STUN_ATTR_DATA               = 0x0013,
    PJ_STUN_ATTR_REALM              = 0x0014,
    PJ_STUN_ATTR_NONCE              = 0x0015,
    PJ_STUN_ATTR_XOR_RELAYED_ADDR   = 0x0016,
    PJ_STUN_ATTR_REQ_ADDR_TYPE      = 0x0017,
    PJ_STUN_ATTR_REQ_ADDR_FAMILY    = 0x0017,
    PJ_STUN_ATTR_EVEN_PORT          = 0x0018,
    PJ_STUN_ATTR_REQ_TRANSPORT      = 0x0019,
    PJ_STUN_ATTR_DONT_FRAGMENT      = 0x001A,
    PJ_STUN_ATTR_XOR_MAPPED_ADDR    = 0x0020,
    PJ_STUN_ATTR_TIMER_VAL          = 0x0021,
    PJ_STUN_ATTR_RESERVATION_TOKEN  = 0x0022,
    PJ_STUN_ATTR_XOR_REFLECTED_FROM = 0x0023,
    PJ_STUN_ATTR_PRIORITY           = 0x0024,
    PJ_STUN_ATTR_USE_CANDIDATE      = 0x0025,
    PJ_STUN_ATTR_CONNECTION_ID      = 0x002a,
    PJ_STUN_ATTR_ICMP               = 0x0030,
    PJ_STUN_ATTR_END_MANDATORY_ATTR,
 
    PJ_STUN_ATTR_START_EXTENDED_ATTR= 0x8021,
 
    PJ_STUN_ATTR_SOFTWARE           = 0x8022,
    PJ_STUN_ATTR_ALTERNATE_SERVER   = 0x8023,
    PJ_STUN_ATTR_REFRESH_INTERVAL   = 0x8024,
    PJ_STUN_ATTR_FINGERPRINT        = 0x8028,
    PJ_STUN_ATTR_ICE_CONTROLLED     = 0x8029,
    PJ_STUN_ATTR_ICE_CONTROLLING    = 0x802a,
    PJ_STUN_ATTR_END_EXTENDED_ATTR
 
} pj_stun_attr_type;
 
 
typedef enum pj_stun_status
{
    PJ_STUN_SC_TRY_ALTERNATE            = 300,  
    PJ_STUN_SC_BAD_REQUEST              = 400,  
    PJ_STUN_SC_UNAUTHORIZED             = 401,  
    PJ_STUN_SC_FORBIDDEN                = 403,  
    PJ_STUN_SC_UNKNOWN_ATTRIBUTE        = 420,  
#if 0
    /* These were obsolete in recent rfc3489bis */
    //PJ_STUN_SC_STALE_CREDENTIALS      = 430,  /**< Stale Credentials      */
    //PJ_STUN_SC_INTEGRITY_CHECK_FAILURE= 431,  /**< Integrity Chk Fail     */
    //PJ_STUN_SC_MISSING_USERNAME       = 432,  /**< Missing Username       */
    //PJ_STUN_SC_USE_TLS                = 433,  /**< Use TLS                */
    //PJ_STUN_SC_MISSING_REALM          = 434,  /**< Missing Realm          */
    //PJ_STUN_SC_MISSING_NONCE          = 435,  /**< Missing Nonce          */
    //PJ_STUN_SC_UNKNOWN_USERNAME       = 436,  /**< Unknown Username       */
#endif
    PJ_STUN_SC_ALLOCATION_MISMATCH      = 437,  
    PJ_STUN_SC_STALE_NONCE              = 438,  
    PJ_STUN_SC_TRANSITIONING            = 439,  
    PJ_STUN_SC_WRONG_CREDENTIALS        = 441,  
    PJ_STUN_SC_UNSUPP_TRANSPORT_PROTO   = 442,  
    PJ_STUN_SC_OPER_TCP_ONLY            = 445,  
    PJ_STUN_SC_CONNECTION_FAILURE       = 446,  
    PJ_STUN_SC_CONNECTION_TIMEOUT       = 447,  
    PJ_STUN_SC_ALLOCATION_QUOTA_REACHED = 486,  
    PJ_STUN_SC_ROLE_CONFLICT            = 487,  
    PJ_STUN_SC_SERVER_ERROR             = 500,  
    PJ_STUN_SC_INSUFFICIENT_CAPACITY    = 508,  
    PJ_STUN_SC_GLOBAL_FAILURE           = 600   
} pj_stun_status;
 
 
typedef struct pj_stun_msg_hdr
{
    pj_uint16_t         type;
 
    pj_uint16_t         length;
 
    pj_uint32_t         magic;
 
    pj_uint8_t          tsx_id[12];
 
} pj_stun_msg_hdr;
 
 
typedef struct pj_stun_attr_hdr
{
    pj_uint16_t         type;
 
    pj_uint16_t         length;
 
} pj_stun_attr_hdr;
 
 
typedef struct pj_stun_sockaddr_attr
{
    pj_stun_attr_hdr    hdr;
 
    pj_bool_t           xor_ed;
 
    pj_sockaddr         sockaddr;
 
} pj_stun_sockaddr_attr;
 
 
typedef struct pj_stun_empty_attr
{
    pj_stun_attr_hdr    hdr;
 
} pj_stun_empty_attr;
 
 
typedef struct pj_stun_string_attr
{
    pj_stun_attr_hdr    hdr;
 
    pj_str_t            value;
 
} pj_stun_string_attr;
 
 
typedef struct pj_stun_uint_attr
{
    pj_stun_attr_hdr    hdr;
    
    pj_uint32_t         value;
 
} pj_stun_uint_attr;
 
 
typedef struct pj_stun_uint64_attr
{
    pj_stun_attr_hdr    hdr;
    
    pj_timestamp        value;
 
} pj_stun_uint64_attr;
 
 
typedef struct pj_stun_binary_attr
{
    pj_stun_attr_hdr    hdr;
    
    pj_uint32_t         magic;
 
    unsigned            length;
 
    pj_uint8_t         *data;
 
} pj_stun_binary_attr;
 
 
typedef struct pj_stun_msgint_attr
{
    pj_stun_attr_hdr    hdr;
 
    pj_uint8_t          hmac[20];
 
} pj_stun_msgint_attr;
 
 
typedef struct pj_stun_uint_attr pj_stun_fingerprint_attr;
 
 
typedef struct pj_stun_errcode_attr
{
    pj_stun_attr_hdr    hdr;
 
    int                 err_code;
 
    pj_str_t            reason;
 
} pj_stun_errcode_attr;
 
 
typedef struct pj_stun_string_attr pj_stun_realm_attr;
 
 
typedef struct pj_stun_string_attr pj_stun_nonce_attr;
 
 
typedef struct pj_stun_unknown_attr
{
    pj_stun_attr_hdr    hdr;
 
    unsigned            attr_count;
 
    pj_uint16_t         attrs[PJ_STUN_MAX_ATTR];
 
} pj_stun_unknown_attr;
 
 
typedef struct pj_stun_sockaddr_attr pj_stun_mapped_addr_attr;
 
 
typedef struct pj_stun_sockaddr_attr pj_stun_xor_mapped_addr_attr;
 
 
typedef struct pj_stun_string_attr pj_stun_software_attr;
 
 
typedef struct pj_stun_sockaddr_attr pj_stun_alt_server_attr;
 
 
typedef struct pj_stun_uint_attr pj_stun_refresh_interval_attr;
 
 
typedef struct pj_stun_sockaddr_attr pj_stun_response_addr_attr;
 
 
typedef struct pj_stun_sockaddr_attr pj_stun_changed_addr_attr;
 
 
typedef struct pj_stun_uint_attr pj_stun_change_request_attr;
 
typedef struct pj_stun_sockaddr_attr pj_stun_src_addr_attr;
 
 
typedef struct pj_stun_sockaddr_attr pj_stun_reflected_from_attr;
 
 
typedef struct pj_stun_string_attr pj_stun_username_attr;
 
 
typedef struct pj_stun_string_attr pj_stun_password_attr;
 
 
typedef struct pj_stun_uint_attr pj_stun_channel_number_attr;
 
#define PJ_STUN_GET_CH_NB(u32)      ((pj_uint16_t)(u32>>16))
 
#define PJ_STUN_SET_CH_NB(chnum)    (((pj_uint32_t)chnum) << 16)
 
 
typedef struct pj_stun_uint_attr pj_stun_lifetime_attr;
 
 
typedef struct pj_stun_uint_attr pj_stun_bandwidth_attr;
 
 
typedef struct pj_stun_sockaddr_attr pj_stun_xor_peer_addr_attr;
 
 
typedef struct pj_stun_binary_attr pj_stun_data_attr;
 
 
typedef struct pj_stun_sockaddr_attr pj_stun_xor_relayed_addr_attr;
 
 
typedef struct pj_stun_uint_attr pj_stun_req_addr_type_attr;
 
 
typedef struct pj_stun_uint_attr pj_stun_even_port_attr;
 
 
typedef struct pj_stun_uint_attr pj_stun_req_transport_attr;
 
#define PJ_STUN_GET_RT_PROTO(u32)   (u32 >> 24)
 
#define PJ_STUN_SET_RT_PROTO(proto)   (((pj_uint32_t)(proto)) << 24)
 
 
typedef struct pj_stun_empty_attr pj_stun_dont_fragment_attr;
 
 
typedef struct pj_stun_uint64_attr pj_stun_res_token_attr;
 
typedef struct pj_stun_sockaddr_attr pj_stun_xor_reflected_from_attr;
 
typedef struct pj_stun_uint_attr pj_stun_priority_attr;
 
typedef struct pj_stun_empty_attr pj_stun_use_candidate_attr;
 
typedef struct pj_stun_uint_attr pj_stun_timer_val_attr;
 
typedef struct pj_stun_uint64_attr pj_stun_ice_controlling_attr;
 
typedef struct pj_stun_uint64_attr pj_stun_ice_controlled_attr;
 
typedef struct pj_stun_uint_attr pj_stun_icmp_attr;
 
typedef struct pj_stun_msg
{
    pj_stun_msg_hdr     hdr;
 
    unsigned            attr_count;
 
    pj_stun_attr_hdr   *attr[PJ_STUN_MAX_ATTR];
 
} pj_stun_msg;
 
 
enum pj_stun_decode_options
{
    PJ_STUN_IS_DATAGRAM     = 1,
 
    PJ_STUN_CHECK_PACKET    = 2,
 
    PJ_STUN_NO_AUTHENTICATE = 4,
 
    PJ_STUN_NO_FINGERPRINT_CHECK = 8
};
 
 
PJ_DECL(const char*) pj_stun_get_method_name(unsigned msg_type);
 
 
PJ_DECL(const char*) pj_stun_get_class_name(unsigned msg_type);
 
 
PJ_DECL(const char*) pj_stun_get_attr_name(unsigned attr_type);
 
 
PJ_DECL(pj_str_t) pj_stun_get_err_reason(int err_code);
 
 
PJ_DECL(int) pj_stun_set_padding_char(int chr);
 
 
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]);
 
PJ_DECL(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_DECL(pj_stun_msg*) pj_stun_msg_clone(pj_pool_t *pool,
                                        const pj_stun_msg *msg);
 
PJ_DECL(pj_status_t) pj_stun_msg_create_response(pj_pool_t *pool,
                                                 const pj_stun_msg *req_msg,
                                                 unsigned err_code,
                                                 const pj_str_t *err_msg,
                                                 pj_stun_msg **p_response);
 
 
PJ_DECL(pj_status_t) pj_stun_msg_add_attr(pj_stun_msg *msg,
                                          pj_stun_attr_hdr *attr);
 
 
PJ_DECL(pj_status_t) pj_stun_msg_encode(pj_stun_msg *msg,
                                        pj_uint8_t *pkt_buf,
                                        pj_size_t buf_size,
                                        unsigned options,
                                        const pj_str_t *key,
                                        pj_size_t *p_msg_len);
 
PJ_DECL(pj_status_t) pj_stun_msg_check(const pj_uint8_t *pdu, 
                                       pj_size_t pdu_len, unsigned options);
 
 
PJ_DECL(pj_status_t) pj_stun_msg_decode(pj_pool_t *pool,
                                        const pj_uint8_t *pdu,
                                        pj_size_t pdu_len,
                                        unsigned options,
                                        pj_stun_msg **p_msg,
                                        pj_size_t *p_parsed_len,
                                        pj_stun_msg **p_response);
 
#if PJ_LOG_MAX_LEVEL > 0
PJ_DECL(char*) pj_stun_msg_dump(const pj_stun_msg *msg,
                                char *buffer,
                                unsigned length,
                                unsigned *printed_len);
#else
#   define pj_stun_msg_dump(msg, buf, length, printed_len)  ""
#endif
 
 
PJ_DECL(pj_stun_attr_hdr*) pj_stun_msg_find_attr(const pj_stun_msg *msg,
                                                 int attr_type,
                                                 unsigned start_index);
 
 
PJ_DECL(pj_stun_attr_hdr*) pj_stun_attr_clone(pj_pool_t *pool,
                                              const pj_stun_attr_hdr *attr);
 
 
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);
 
PJ_DECL(pj_status_t) pj_stun_sockaddr_attr_create(pj_pool_t *pool,
                                                int attr_type, 
                                                pj_bool_t xor_ed,
                                                const pj_sockaddr_t *addr,
                                                unsigned addr_len,
                                                pj_stun_sockaddr_attr **p_attr);
 
 
PJ_DECL(pj_status_t) pj_stun_msg_add_sockaddr_attr(pj_pool_t *pool,
                                                  pj_stun_msg *msg,
                                                  int attr_type, 
                                                  pj_bool_t xor_ed,
                                                  const pj_sockaddr_t *addr,
                                                  unsigned addr_len);
 
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);
 
PJ_DECL(pj_status_t) pj_stun_string_attr_create(pj_pool_t *pool,
                                                int attr_type,
                                                const pj_str_t *value,
                                                pj_stun_string_attr **p_attr);
 
PJ_DECL(pj_status_t) pj_stun_msg_add_string_attr(pj_pool_t *pool,
                                                 pj_stun_msg *msg,
                                                 int attr_type,
                                                 const pj_str_t *value);
 
PJ_DECL(pj_status_t) pj_stun_uint_attr_create(pj_pool_t *pool,
                                              int attr_type,
                                              pj_uint32_t value,
                                              pj_stun_uint_attr **p_attr);
 
PJ_DECL(pj_status_t) pj_stun_msg_add_uint_attr(pj_pool_t *pool,
                                               pj_stun_msg *msg,
                                               int attr_type,
                                               pj_uint32_t value);
 
 
PJ_DECL(pj_status_t)  pj_stun_uint64_attr_create(pj_pool_t *pool,
                                                int attr_type,
                                                const pj_timestamp *value,
                                                pj_stun_uint64_attr **p_attr);
 
 
PJ_DECL(pj_status_t)  pj_stun_msg_add_uint64_attr(pj_pool_t *pool,
                                                  pj_stun_msg *msg,
                                                  int attr_type,
                                                  const pj_timestamp *value);
 
PJ_DECL(pj_status_t) pj_stun_msgint_attr_create(pj_pool_t *pool,
                                                pj_stun_msgint_attr **p_attr);
 
PJ_DECL(pj_status_t) pj_stun_msg_add_msgint_attr(pj_pool_t *pool,
                                                 pj_stun_msg *msg);
 
PJ_DECL(pj_status_t) pj_stun_errcode_attr_create(pj_pool_t *pool,
                                                int err_code,
                                                const pj_str_t *err_reason,
                                                pj_stun_errcode_attr **p_attr);
 
 
PJ_DECL(pj_status_t) pj_stun_msg_add_errcode_attr(pj_pool_t *pool,
                                                  pj_stun_msg *msg,
                                                  int err_code,
                                                  const pj_str_t *err_reason);
 
PJ_DECL(pj_status_t) pj_stun_unknown_attr_create(pj_pool_t *pool,
                                                unsigned attr_cnt,
                                                const pj_uint16_t attr[],
                                                pj_stun_unknown_attr **p_attr);
 
PJ_DECL(pj_status_t) pj_stun_msg_add_unknown_attr(pj_pool_t *pool,
                                                  pj_stun_msg *msg,
                                                  unsigned attr_cnt,
                                                  const pj_uint16_t attr[]);
 
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);
 
PJ_DECL(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_DECL(pj_status_t) pj_stun_msg_add_binary_attr(pj_pool_t *pool,
                                                 pj_stun_msg *msg,
                                                 int attr_type,
                                                 const pj_uint8_t *data,
                                                 unsigned length);
 
PJ_DECL(pj_status_t) pj_stun_empty_attr_create(pj_pool_t *pool,
                                               int attr_type,
                                               pj_stun_empty_attr **p_attr);
 
PJ_DECL(pj_status_t) pj_stun_msg_add_empty_attr(pj_pool_t *pool,
                                                pj_stun_msg *msg,
                                                int attr_type);
 
PJ_END_DECL
 
 
#endif  /* __PJNATH_STUN_MSG_H__ */