Changeset 992


Ignore:
Timestamp:
Feb 21, 2007 12:40:05 AM (13 years ago)
Author:
bennylp
Message:

Merged the ICE branch into the trunk

Location:
pjproject/trunk
Files:
3 deleted
10 edited
16 copied

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjlib-util/build/Makefile

    r805 r992  
    2828export PJLIB_UTIL_OBJS += $(OS_OBJS) $(M_OBJS) $(CC_OBJS) $(HOST_OBJS) \ 
    2929                errno.o dns.o dns_dump.o getopt.o md5.o resolver.o \ 
    30                 scanner.o stun.o string.o stun_client.o xml.o 
     30                scanner.o string.o stun_simple.o stun_simple_client.o xml.o 
    3131export PJLIB_UTIL_CFLAGS += $(_CFLAGS) 
    3232 
  • pjproject/trunk/pjlib-util/build/pjlib_util.dsp

    r754 r992  
    130130# Begin Source File 
    131131 
    132 SOURCE="..\src\pjlib-util\stun.c" 
    133 # End Source File 
    134 # Begin Source File 
    135  
    136 SOURCE="..\src\pjlib-util\stun_client.c" 
     132SOURCE="..\src\pjlib-util\stun_endpoint.c" 
     133# End Source File 
     134# Begin Source File 
     135 
     136SOURCE="..\src\pjlib-util\stun_msg.c" 
     137# End Source File 
     138# Begin Source File 
     139 
     140SOURCE="..\src\pjlib-util\stun_server.c" 
     141# End Source File 
     142# Begin Source File 
     143 
     144SOURCE="..\src\pjlib-util\stun_simple.c" 
     145# End Source File 
     146# Begin Source File 
     147 
     148SOURCE="..\src\pjlib-util\stun_simple_client.c" 
     149# End Source File 
     150# Begin Source File 
     151 
     152SOURCE="..\src\pjlib-util\stun_transaction.c" 
    137153# End Source File 
    138154# Begin Source File 
     
    194210# Begin Source File 
    195211 
    196 SOURCE="..\include\pjlib-util\stun.h" 
     212SOURCE="..\include\pjlib-util\stun_doc.h" 
     213# End Source File 
     214# Begin Source File 
     215 
     216SOURCE="..\include\pjlib-util\stun_endpoint.h" 
     217# End Source File 
     218# Begin Source File 
     219 
     220SOURCE="..\include\pjlib-util\stun_msg.h" 
     221# End Source File 
     222# Begin Source File 
     223 
     224SOURCE="..\include\pjlib-util\stun_server.h" 
     225# End Source File 
     226# Begin Source File 
     227 
     228SOURCE="..\include\pjlib-util\stun_simple.h" 
     229# End Source File 
     230# Begin Source File 
     231 
     232SOURCE="..\include\pjlib-util\stun_transaction.h" 
    197233# End Source File 
    198234# Begin Source File 
  • pjproject/trunk/pjlib-util/build/pjlib_util.dsw

    r65 r992  
    2020Package=<5> 
    2121{{{ 
    22     begin source code control 
    23     "$/pjproject/pjlib/build", UIAAAAAA 
    24     ..\..\pjlib\build 
    25     end source code control 
    2622}}} 
    2723 
     
    6258############################################################################### 
    6359 
     60Project: "pjstun_srv"=".\pjstun_srv.dsp" - Package Owner=<4> 
     61 
     62Package=<5> 
     63{{{ 
     64}}} 
     65 
     66Package=<4> 
     67{{{ 
     68    Begin Project Dependency 
     69    Project_Dep_Name pjlib 
     70    End Project Dependency 
     71    Begin Project Dependency 
     72    Project_Dep_Name pjlib_util 
     73    End Project Dependency 
     74}}} 
     75 
     76############################################################################### 
     77 
    6478Global: 
    6579 
  • pjproject/trunk/pjlib-util/build/pjlib_util.vcproj

    r898 r992  
    400400                        </File> 
    401401                        <File 
    402                                 RelativePath="..\src\pjlib-util\stun.c" 
    403                                 > 
    404                                 <FileConfiguration 
    405                                         Name="Release|Win32" 
    406                                         > 
    407                                         <Tool 
    408                                                 Name="VCCLCompilerTool" 
    409                                                 AdditionalIncludeDirectories="" 
    410                                                 PreprocessorDefinitions="" 
    411                                         /> 
    412                                 </FileConfiguration> 
    413                                 <FileConfiguration 
    414                                         Name="Debug|Win32" 
    415                                         > 
    416                                         <Tool 
    417                                                 Name="VCCLCompilerTool" 
    418                                                 AdditionalIncludeDirectories="" 
    419                                                 PreprocessorDefinitions="" 
    420                                         /> 
    421                                 </FileConfiguration> 
    422                         </File> 
    423                         <File 
    424                                 RelativePath="..\src\pjlib-util\stun_client.c" 
    425                                 > 
    426                                 <FileConfiguration 
    427                                         Name="Release|Win32" 
    428                                         > 
    429                                         <Tool 
    430                                                 Name="VCCLCompilerTool" 
    431                                                 AdditionalIncludeDirectories="" 
    432                                                 PreprocessorDefinitions="" 
    433                                         /> 
    434                                 </FileConfiguration> 
    435                                 <FileConfiguration 
    436                                         Name="Debug|Win32" 
    437                                         > 
    438                                         <Tool 
    439                                                 Name="VCCLCompilerTool" 
    440                                                 AdditionalIncludeDirectories="" 
    441                                                 PreprocessorDefinitions="" 
    442                                         /> 
    443                                 </FileConfiguration> 
     402                                RelativePath="..\src\pjlib-util\stun_simple.c" 
     403                                > 
     404                        </File> 
     405                        <File 
     406                                RelativePath="..\src\pjlib-util\stun_simple_client.c" 
     407                                > 
    444408                        </File> 
    445409                        <File 
     
    537501                        </File> 
    538502                        <File 
    539                                 RelativePath="..\include\pjlib-util\stun.h" 
     503                                RelativePath="..\include\pjlib-util\stun_simple.h" 
    540504                                > 
    541505                        </File> 
  • pjproject/trunk/pjlib-util/include/pjlib-util.h

    r974 r992  
    3131#include <pjlib-util/resolver.h> 
    3232#include <pjlib-util/scanner.h> 
    33 #include <pjlib-util/stun.h> 
    3433#include <pjlib-util/xml.h> 
    3534 
     35/* New STUN */ 
     36#include <pjlib-util/stun_endpoint.h> 
     37#include <pjlib-util/stun_msg.h> 
     38#include <pjlib-util/stun_server.h> 
     39#include <pjlib-util/stun_transaction.h> 
     40 
     41/* Old STUN */ 
     42#include <pjlib-util/stun_simple.h> 
    3643 
    3744/** 
  • pjproject/trunk/pjlib-util/include/pjlib-util/config.h

    r974 r992  
    192192 
    193193/** 
    194  * Maximum number of attributes in the STUN packet. 
     194 * Maximum number of attributes in the STUN packet (for the old STUN 
     195 * library). 
     196 * 
     197 * Default: 16 
     198 */ 
     199#ifndef PJSTUN_MAX_ATTR 
     200#   define PJSTUN_MAX_ATTR                          16 
     201#endif 
     202 
     203 
     204/** 
     205 * Maximum number of attributes in the STUN packet (for the new STUN 
     206 * library). 
    195207 * 
    196208 * Default: 16 
     
    200212#endif 
    201213 
    202  
    203214/** 
    204215 * @} 
  • pjproject/trunk/pjlib-util/include/pjlib-util/errno.h

    r974 r992  
    5151/** 
    5252 * @hideinitializer 
    53  * Invalid STUN message length. 
     53 * Invalid STUN message length 
    5454 */ 
    5555#define PJLIB_UTIL_ESTUNINMSGLEN    (PJLIB_UTIL_ERRNO_START+3)  /* 320003 */ 
    5656/** 
    5757 * @hideinitializer 
    58  * STUN attribute length error. 
     58 * Invalid STUN attribute length 
    5959 */ 
    6060#define PJLIB_UTIL_ESTUNINATTRLEN   (PJLIB_UTIL_ERRNO_START+4)  /* 320004 */ 
     
    246246 
    247247 
     248/************************************************************ 
     249 * NEW STUN ERROR 
     250 ***********************************************************/ 
     251/* Messaging errors */ 
     252/** 
     253 * @hideinitializer 
     254 * Invalid STUN attribute 
     255 */ 
     256#define PJLIB_UTIL_ESTUNINATTR      (PJLIB_UTIL_ERRNO_START+110)/* 320110 */ 
     257/** 
     258 * @hideinitializer 
     259 * Too many STUN attributes. 
     260 */ 
     261#define PJLIB_UTIL_ESTUNTOOMANYATTR (PJLIB_UTIL_ERRNO_START+111)/* 320111 */ 
     262/** 
     263 * @hideinitializer 
     264 * Unknown STUN attribute. 
     265 */ 
     266#define PJLIB_UTIL_ESTUNUNKNOWNATTR (PJLIB_UTIL_ERRNO_START+112)/* 320112 */ 
     267/** 
     268 * @hideinitializer 
     269 * Invalid socket address length. 
     270 */ 
     271#define PJLIB_UTIL_ESTUNINADDRLEN   (PJLIB_UTIL_ERRNO_START+113)/* 320113 */ 
     272/** 
     273 * @hideinitializer 
     274 * IPv6 attribute not supported 
     275 */ 
     276#define PJLIB_UTIL_ESTUNIPV6NOTSUPP (PJLIB_UTIL_ERRNO_START+113)/* 320113 */ 
     277/** 
     278 * @hideinitializer 
     279 * Expecting STUN response message. 
     280 */ 
     281#define PJLIB_UTIL_ESTUNNOTRESPONSE (PJLIB_UTIL_ERRNO_START+114)/* 320114 */ 
     282/** 
     283 * @hideinitializer 
     284 * Transaction ID mismatch. 
     285 */ 
     286#define PJLIB_UTIL_ESTUNINVALIDID   (PJLIB_UTIL_ERRNO_START+115)/* 320115 */ 
     287/** 
     288 * @hideinitializer 
     289 * Unable to find handler for the request. 
     290 */ 
     291#define PJLIB_UTIL_ESTUNNOHANDLER   (PJLIB_UTIL_ERRNO_START+116)/* 320116 */ 
     292 
     293 
     294#define PJ_STATUS_FROM_STUN_CODE(code)  -1 
     295 
     296 
     297 
     298 
    248299/** 
    249300 * @} 
  • pjproject/trunk/pjlib-util/include/pjlib-util/stun_msg.h

    r991 r992  
    146146 * message. 
    147147 */ 
    148 #define PJ_STUN_GET_METHOD(msg_type)    ((msg_type) & 0x000F) 
     148#define PJ_STUN_GET_METHOD(msg_type)    ((msg_type) & 0xFEEF) 
    149149 
    150150 
     
    10471047 
    10481048 
     1049/** 
     1050 * Get STUN message method name. 
     1051 * 
     1052 * @param msg_type      The STUN message type (in host byte order) 
     1053 * 
     1054 * @return              The STUN message method name string. 
     1055 */ 
     1056PJ_DECL(const char*) pj_stun_get_method_name(unsigned msg_type); 
     1057 
     1058 
     1059/** 
     1060 * Get STUN message class name. 
     1061 * 
     1062 * @param msg_type      The STUN message type (in host byte order) 
     1063 * 
     1064 * @return              The STUN message class name string. 
     1065 */ 
     1066PJ_DECL(const char*) pj_stun_get_class_name(unsigned msg_type); 
     1067 
     1068 
     1069/** 
     1070 * Get STUN attribute name. 
     1071 * 
     1072 * @return attr_type    The STUN attribute type (in host byte order). 
     1073 * 
     1074 * @return              The STUN attribute type name string. 
     1075 */ 
     1076PJ_DECL(const char*) pj_stun_get_attr_name(unsigned attr_type); 
     1077 
    10491078 
    10501079/** 
  • pjproject/trunk/pjlib-util/include/pjlib-util/stun_simple.h

    r991 r992  
    1717 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
    1818 */ 
    19 #ifndef __PJ_STUN_H__ 
    20 #define __PJ_STUN_H__ 
     19#ifndef __PJSTUN_H__ 
     20#define __PJSTUN_H__ 
    2121 
    2222/** 
     
    3434 * This enumeration describes STUN message types. 
    3535 */ 
    36 typedef enum pj_stun_msg_type 
    37 { 
    38     PJ_STUN_BINDING_REQUEST                 = 0x0001, 
    39     PJ_STUN_BINDING_RESPONSE                = 0x0101, 
    40     PJ_STUN_BINDING_ERROR_RESPONSE          = 0x0111, 
    41     PJ_STUN_SHARED_SECRET_REQUEST           = 0x0002, 
    42     PJ_STUN_SHARED_SECRET_RESPONSE          = 0x0102, 
    43     PJ_STUN_SHARED_SECRET_ERROR_RESPONSE    = 0x0112 
    44 } pj_stun_msg_type; 
     36typedef enum pjstun_msg_type 
     37{ 
     38    PJSTUN_BINDING_REQUEST                  = 0x0001, 
     39    PJSTUN_BINDING_RESPONSE                 = 0x0101, 
     40    PJSTUN_BINDING_ERROR_RESPONSE           = 0x0111, 
     41    PJSTUN_SHARED_SECRET_REQUEST            = 0x0002, 
     42    PJSTUN_SHARED_SECRET_RESPONSE           = 0x0102, 
     43    PJSTUN_SHARED_SECRET_ERROR_RESPONSE    = 0x0112 
     44} pjstun_msg_type; 
    4545 
    4646 
     
    4848 * This enumeration describes STUN attribute types. 
    4949 */ 
    50 typedef enum pj_stun_attr_type 
    51 { 
    52     PJ_STUN_ATTR_MAPPED_ADDR = 1, 
    53     PJ_STUN_ATTR_RESPONSE_ADDR, 
    54     PJ_STUN_ATTR_CHANGE_REQUEST, 
    55     PJ_STUN_ATTR_SOURCE_ADDR, 
    56     PJ_STUN_ATTR_CHANGED_ADDR, 
    57     PJ_STUN_ATTR_USERNAME, 
    58     PJ_STUN_ATTR_PASSWORD, 
    59     PJ_STUN_ATTR_MESSAGE_INTEGRITY, 
    60     PJ_STUN_ATTR_ERROR_CODE, 
    61     PJ_STUN_ATTR_UNKNOWN_ATTRIBUTES, 
    62     PJ_STUN_ATTR_REFLECTED_FORM 
    63 } pj_stun_attr_type; 
     50typedef enum pjstun_attr_type 
     51{ 
     52    PJSTUN_ATTR_MAPPED_ADDR = 1, 
     53    PJSTUN_ATTR_RESPONSE_ADDR, 
     54    PJSTUN_ATTR_CHANGE_REQUEST, 
     55    PJSTUN_ATTR_SOURCE_ADDR, 
     56    PJSTUN_ATTR_CHANGED_ADDR, 
     57    PJSTUN_ATTR_USERNAME, 
     58    PJSTUN_ATTR_PASSWORD, 
     59    PJSTUN_ATTR_MESSAGE_INTEGRITY, 
     60    PJSTUN_ATTR_ERROR_CODE, 
     61    PJSTUN_ATTR_UNKNOWN_ATTRIBUTES, 
     62    PJSTUN_ATTR_REFLECTED_FORM 
     63} pjstun_attr_type; 
    6464 
    6565 
     
    6767 * This structre describes STUN message header. 
    6868 */ 
    69 typedef struct pj_stun_msg_hdr 
     69typedef struct pjstun_msg_hdr 
    7070{ 
    7171    pj_uint16_t         type; 
    7272    pj_uint16_t         length; 
    7373    pj_uint32_t         tsx[4]; 
    74 } pj_stun_msg_hdr; 
     74} pjstun_msg_hdr; 
    7575 
    7676 
     
    7878 * This structre describes STUN attribute header. 
    7979 */ 
    80 typedef struct pj_stun_attr_hdr 
     80typedef struct pjstun_attr_hdr 
    8181{ 
    8282    pj_uint16_t         type; 
    8383    pj_uint16_t         length; 
    84 } pj_stun_attr_hdr; 
     84} pjstun_attr_hdr; 
    8585 
    8686 
     
    8888 * This structre describes STUN MAPPED-ADDR attribute. 
    8989 */ 
    90 typedef struct pj_stun_mapped_addr_attr 
    91 { 
    92     pj_stun_attr_hdr    hdr; 
     90typedef struct pjstun_mapped_addr_attr 
     91{ 
     92    pjstun_attr_hdr     hdr; 
    9393    pj_uint8_t          ignored; 
    9494    pj_uint8_t          family; 
    9595    pj_uint16_t         port; 
    9696    pj_uint32_t         addr; 
    97 } pj_stun_mapped_addr_attr; 
    98  
    99 typedef pj_stun_mapped_addr_attr pj_stun_response_addr_attr; 
    100 typedef pj_stun_mapped_addr_attr pj_stun_changed_addr_attr; 
    101 typedef pj_stun_mapped_addr_attr pj_stun_src_addr_attr; 
    102 typedef pj_stun_mapped_addr_attr pj_stun_reflected_form_attr; 
    103  
    104 typedef struct pj_stun_change_request_attr 
    105 { 
    106     pj_stun_attr_hdr    hdr; 
     97} pjstun_mapped_addr_attr; 
     98 
     99typedef pjstun_mapped_addr_attr pjstun_response_addr_attr; 
     100typedef pjstun_mapped_addr_attr pjstun_changed_addr_attr; 
     101typedef pjstun_mapped_addr_attr pjstun_src_addr_attr; 
     102typedef pjstun_mapped_addr_attr pjstun_reflected_form_attr; 
     103 
     104typedef struct pjstun_change_request_attr 
     105{ 
     106    pjstun_attr_hdr     hdr; 
    107107    pj_uint32_t         value; 
    108 } pj_stun_change_request_attr; 
    109  
    110 typedef struct pj_stun_username_attr 
    111 { 
    112     pj_stun_attr_hdr    hdr; 
     108} pjstun_change_request_attr; 
     109 
     110typedef struct pjstun_username_attr 
     111{ 
     112    pjstun_attr_hdr     hdr; 
    113113    pj_uint32_t         value[1]; 
    114 } pj_stun_username_attr; 
    115  
    116 typedef pj_stun_username_attr pj_stun_password_attr; 
    117  
    118 typedef struct pj_stun_error_code_attr 
    119 { 
    120     pj_stun_attr_hdr    hdr; 
     114} pjstun_username_attr; 
     115 
     116typedef pjstun_username_attr pjstun_password_attr; 
     117 
     118typedef struct pjstun_error_code_attr 
     119{ 
     120    pjstun_attr_hdr     hdr; 
    121121    pj_uint16_t         ignored; 
    122122    pj_uint8_t          err_class; 
    123123    pj_uint8_t          number; 
    124124    char                reason[4]; 
    125 } pj_stun_error_code_attr; 
    126  
    127 typedef struct pj_stun_msg 
    128 { 
    129     pj_stun_msg_hdr    *hdr; 
     125} pjstun_error_code_attr; 
     126 
     127typedef struct pjstun_msg 
     128{ 
     129    pjstun_msg_hdr    *hdr; 
    130130    int                 attr_count; 
    131     pj_stun_attr_hdr   *attr[PJ_STUN_MAX_ATTR]; 
    132 } pj_stun_msg; 
     131    pjstun_attr_hdr   *attr[PJSTUN_MAX_ATTR]; 
     132} pjstun_msg; 
    133133 
    134134/* STUN message API (stun.c). */ 
    135135 
    136 PJ_DECL(pj_status_t) pj_stun_create_bind_req( pj_pool_t *pool,  
     136PJ_DECL(pj_status_t) pjstun_create_bind_req( pj_pool_t *pool,  
    137137                                              void **msg, pj_size_t *len, 
    138138                                              pj_uint32_t id_hi, 
    139139                                              pj_uint32_t id_lo); 
    140 PJ_DECL(pj_status_t) pj_stun_parse_msg( void *buf, pj_size_t len, 
    141                                         pj_stun_msg *msg); 
    142 PJ_DECL(void*) pj_stun_msg_find_attr( pj_stun_msg *msg, pj_stun_attr_type t); 
     140PJ_DECL(pj_status_t) pjstun_parse_msg( void *buf, pj_size_t len, 
     141                                        pjstun_msg *msg); 
     142PJ_DECL(void*) pjstun_msg_find_attr( pjstun_msg *msg, pjstun_attr_type t); 
    143143 
    144144 
     
    150150 * 
    151151 * This is the older implementation of STUN client, with only one function 
    152  * provided (pj_stun_get_mapped_addr()) to retrieve the public IP address 
     152 * provided (pjstun_get_mapped_addr()) to retrieve the public IP address 
    153153 * of multiple sockets. 
    154154 */ 
     
    192192 * 
    193193 */ 
    194 PJ_DECL(pj_status_t) pj_stun_get_mapped_addr( pj_pool_factory *pf, 
     194PJ_DECL(pj_status_t) pjstun_get_mapped_addr( pj_pool_factory *pf, 
    195195                                              int sock_cnt, pj_sock_t sock[], 
    196196                                              const pj_str_t *srv1, int port1, 
     
    204204 */ 
    205205 
    206 #endif  /* __PJ_STUN_H__ */ 
    207  
     206#endif  /* __PJSTUN_H__ */ 
     207 
  • pjproject/trunk/pjlib-util/src/pjlib-util/stun_msg.c

    r991 r992  
    2727 
    2828#define THIS_FILE   "stun_msg.c" 
     29 
     30 
     31static const char *stun_method_names[] =  
     32{ 
     33    "Unknown",                  /* 0 */ 
     34    "Binding",                  /* 1 */ 
     35    "Shared Secret",            /* 2 */ 
     36    "Allocate",                 /* 3 */ 
     37    "Send",                     /* 4 */ 
     38    "Data",                     /* 5 */ 
     39    "Set Active Destination",   /* 6 */ 
     40    "Connect",                  /* 7 */ 
     41    "Connect Status"            /* 8 */ 
     42}; 
    2943 
    3044static struct 
     
    6074 
    6175 
     76 
     77struct attr_desc 
     78{ 
     79    const char   *name; 
     80    pj_status_t (*decode_attr)(pj_pool_t *pool, const pj_uint8_t *buf,  
     81                               void **p_attr); 
     82    pj_status_t (*encode_attr)(const void *a, pj_uint8_t *buf,  
     83                               unsigned len, unsigned *printed); 
     84 
     85}; 
     86 
     87static pj_status_t decode_generic_ip_addr_attr(pj_pool_t *pool,  
     88                                               const pj_uint8_t *buf,  
     89                                               void **p_attr); 
     90static pj_status_t encode_generic_ip_addr_attr(const void *a, pj_uint8_t *buf,  
     91                                               unsigned len,  
     92                                               unsigned *printed); 
     93static pj_status_t decode_generic_string_attr(pj_pool_t *pool,  
     94                                              const pj_uint8_t *buf,  
     95                                              void **p_attr); 
     96static pj_status_t encode_generic_string_attr(const void *a, pj_uint8_t *buf,  
     97                                              unsigned len, unsigned *printed); 
     98static pj_status_t decode_msg_integrity_attr(pj_pool_t *pool,  
     99                                             const pj_uint8_t *buf, 
     100                                             void **p_attr); 
     101static pj_status_t encode_msg_integrity_attr(const void *a, pj_uint8_t *buf,  
     102                                             unsigned len, unsigned *printed); 
     103static pj_status_t decode_error_code_attr(pj_pool_t *pool,  
     104                                          const pj_uint8_t *buf, 
     105                                          void **p_attr); 
     106static pj_status_t encode_error_code_attr(const void *a, pj_uint8_t *buf,  
     107                                          unsigned len, unsigned *printed); 
     108static pj_status_t decode_unknown_attr(pj_pool_t *pool,  
     109                                       const pj_uint8_t *buf,  
     110                                       void **p_attr); 
     111static pj_status_t encode_unknown_attr(const void *a, pj_uint8_t *buf,  
     112                                       unsigned len, unsigned *printed); 
     113static pj_status_t decode_generic_uint_attr(pj_pool_t *pool,  
     114                                            const pj_uint8_t *buf,  
     115                                            void **p_attr); 
     116static pj_status_t encode_generic_uint_attr(const void *a, pj_uint8_t *buf,  
     117                                            unsigned len, unsigned *printed); 
     118static pj_status_t decode_binary_attr(pj_pool_t *pool,  
     119                                      const pj_uint8_t *buf, 
     120                                      void **p_attr); 
     121static pj_status_t encode_binary_attr(const void *a, pj_uint8_t *buf,  
     122                                      unsigned len, unsigned *printed); 
     123static pj_status_t decode_empty_attr(pj_pool_t *pool,  
     124                                     const pj_uint8_t *buf,  
     125                                     void **p_attr); 
     126static pj_status_t encode_empty_attr(const void *a, pj_uint8_t *buf,  
     127                                     unsigned len, unsigned *printed); 
     128 
     129 
     130struct attr_desc mandatory_attr_desc[] =  
     131{ 
     132    { 
     133        /* type zero */ 
     134        NULL, 
     135        NULL, 
     136        NULL 
     137    }, 
     138    { 
     139        /* PJ_STUN_ATTR_MAPPED_ADDR, */ 
     140        "MAPPED-ADDRESS", 
     141        &decode_generic_ip_addr_attr, 
     142        &encode_generic_ip_addr_attr 
     143    }, 
     144    { 
     145        /* PJ_STUN_ATTR_RESPONSE_ADDR, */ 
     146        "RESPONSE-ADDRESS", 
     147        &decode_generic_ip_addr_attr, 
     148        &encode_generic_ip_addr_attr 
     149    }, 
     150    { 
     151        /* PJ_STUN_ATTR_CHANGE_REQUEST, */ 
     152        "CHANGE-REQUEST", 
     153        &decode_generic_uint_attr, 
     154        &encode_generic_uint_attr 
     155    }, 
     156    { 
     157        /* PJ_STUN_ATTR_SOURCE_ADDR, */ 
     158        "SOURCE-ADDRESS", 
     159        &decode_generic_ip_addr_attr, 
     160        &encode_generic_ip_addr_attr 
     161    }, 
     162    { 
     163        /* PJ_STUN_ATTR_CHANGED_ADDR, */ 
     164        "CHANGED-ADDRESS", 
     165        &decode_generic_ip_addr_attr, 
     166        &encode_generic_ip_addr_attr 
     167    }, 
     168    { 
     169        /* PJ_STUN_ATTR_USERNAME, */ 
     170        "USERNAME", 
     171        &decode_generic_string_attr, 
     172        &encode_generic_string_attr 
     173    }, 
     174    { 
     175        /* PJ_STUN_ATTR_PASSWORD, */ 
     176        "PASSWORD", 
     177        &decode_generic_string_attr, 
     178        &encode_generic_string_attr 
     179    }, 
     180    { 
     181        /* PJ_STUN_ATTR_MESSAGE_INTEGRITY, */ 
     182        "MESSAGE-INTEGRITY", 
     183        &decode_msg_integrity_attr, 
     184        &encode_msg_integrity_attr 
     185    }, 
     186    { 
     187        /* PJ_STUN_ATTR_ERROR_CODE, */ 
     188        "ERROR-CODE", 
     189        &decode_error_code_attr, 
     190        &encode_error_code_attr 
     191    }, 
     192    { 
     193        /* PJ_STUN_ATTR_UNKNOWN_ATTRIBUTES, */ 
     194        "UNKNOWN-ATTRIBUTES", 
     195        &decode_unknown_attr, 
     196        &encode_unknown_attr 
     197    }, 
     198    { 
     199        /* PJ_STUN_ATTR_REFLECTED_FROM, */ 
     200        "REFLECTED-FROM", 
     201        &decode_generic_ip_addr_attr, 
     202        &encode_generic_ip_addr_attr 
     203    }, 
     204    { 
     205        /* ID 0x000C is not assigned */ 
     206        NULL, 
     207        NULL, 
     208        NULL 
     209    }, 
     210    { 
     211        /* PJ_STUN_ATTR_LIFETIME, */ 
     212        "LIFETIME", 
     213        &decode_generic_uint_attr, 
     214        &encode_generic_uint_attr 
     215    }, 
     216    { 
     217        /* ID 0x000E is not assigned */ 
     218        NULL, 
     219        NULL, 
     220        NULL 
     221    }, 
     222    { 
     223        /* ID 0x000F is not assigned */ 
     224        NULL, 
     225        NULL, 
     226        NULL 
     227    }, 
     228    { 
     229        /* PJ_STUN_ATTR_BANDWIDTH, */ 
     230        "BANDWIDTH", 
     231        &decode_generic_uint_attr, 
     232        &encode_generic_uint_attr 
     233    }, 
     234    { 
     235        /* ID 0x0011 is not assigned */ 
     236        NULL, 
     237        NULL, 
     238        NULL 
     239    }, 
     240    { 
     241        /* PJ_STUN_ATTR_REMOTE_ADDRESS, */ 
     242        "REMOTE-ADDRESS", 
     243        &decode_generic_ip_addr_attr, 
     244        &encode_generic_ip_addr_attr 
     245    }, 
     246    { 
     247        /* PJ_STUN_ATTR_DATA, */ 
     248        "DATA", 
     249        &decode_binary_attr, 
     250        &encode_binary_attr 
     251    }, 
     252    { 
     253        /* PJ_STUN_ATTR_REALM, */ 
     254        "REALM", 
     255        &decode_generic_string_attr, 
     256        &encode_generic_string_attr 
     257    }, 
     258    { 
     259        /* PJ_STUN_ATTR_NONCE, */ 
     260        "NONCE", 
     261        &decode_generic_string_attr, 
     262        &encode_generic_string_attr 
     263    }, 
     264    { 
     265        /* PJ_STUN_ATTR_RELAY_ADDRESS, */ 
     266        "RELAY-ADDRESS", 
     267        &decode_generic_ip_addr_attr, 
     268        &encode_generic_ip_addr_attr 
     269    }, 
     270    { 
     271        /* PJ_STUN_ATTR_REQUESTED_ADDR_TYPE, */ 
     272        "REQUESTED-ADDRESS-TYPE", 
     273        &decode_generic_uint_attr, 
     274        &encode_generic_uint_attr 
     275    }, 
     276    { 
     277        /* PJ_STUN_ATTR_REQUESTED_PORT_PROPS, */ 
     278        "REQUESTED-PORT-PROPS", 
     279        &decode_generic_uint_attr, 
     280        &encode_generic_uint_attr 
     281    }, 
     282    { 
     283        /* PJ_STUN_ATTR_REQUESTED_TRANSPORT, */ 
     284        "REQUESTED-TRANSPORT", 
     285        &decode_generic_uint_attr, 
     286        &encode_generic_uint_attr 
     287    }, 
     288    { 
     289        /* ID 0x001A is not assigned */ 
     290        NULL, 
     291        NULL, 
     292        NULL 
     293    }, 
     294    { 
     295        /* ID 0x001B is not assigned */ 
     296        NULL, 
     297        NULL, 
     298        NULL 
     299    }, 
     300    { 
     301        /* ID 0x001C is not assigned */ 
     302        NULL, 
     303        NULL, 
     304        NULL 
     305    }, 
     306    { 
     307        /* ID 0x001D is not assigned */ 
     308        NULL, 
     309        NULL, 
     310        NULL 
     311    }, 
     312    { 
     313        /* ID 0x001E is not assigned */ 
     314        NULL, 
     315        NULL, 
     316        NULL 
     317    }, 
     318    { 
     319        /* ID 0x001F is not assigned */ 
     320        NULL, 
     321        NULL, 
     322        NULL 
     323    }, 
     324    { 
     325        /* PJ_STUN_ATTR_XOR_MAPPED_ADDRESS, */ 
     326        "XOR-MAPPED-ADDRESS", 
     327        &decode_generic_ip_addr_attr, 
     328        &encode_generic_ip_addr_attr 
     329    }, 
     330    { 
     331        /* PJ_STUN_ATTR_TIMER_VAL, */ 
     332        "TIMER-VAL", 
     333        &decode_generic_uint_attr, 
     334        &encode_generic_uint_attr 
     335    }, 
     336    { 
     337        /* PJ_STUN_ATTR_REQUESTED_IP, */ 
     338        "REQUESTED-IP", 
     339        &decode_generic_ip_addr_attr, 
     340        &encode_generic_ip_addr_attr 
     341    }, 
     342    { 
     343        /* PJ_STUN_ATTR_XOR_REFLECTED_FROM, */ 
     344        "XOR-REFLECTED-FROM", 
     345        &decode_generic_ip_addr_attr, 
     346        &encode_generic_ip_addr_attr 
     347    }, 
     348    { 
     349        /* PJ_STUN_ATTR_PRIORITY, */ 
     350        "PRIORITY", 
     351        &decode_generic_uint_attr, 
     352        &encode_generic_uint_attr 
     353    }, 
     354    { 
     355        /* PJ_STUN_ATTR_USE_CANDIDATE, */ 
     356        "USE-CANDIDATE", 
     357        &decode_empty_attr, 
     358        &encode_empty_attr 
     359    }, 
     360    { 
     361        /* PJ_STUN_ATTR_XOR_INTERNAL_ADDR, */ 
     362        "XOR-INTERNAL-ADDRESS", 
     363        &decode_generic_ip_addr_attr, 
     364        &encode_generic_ip_addr_attr 
     365    }, 
     366 
     367    /* Sentinel */ 
     368    { 
     369        /* PJ_STUN_ATTR_END_MANDATORY_ATTR */ 
     370        NULL, 
     371        NULL, 
     372        NULL 
     373    } 
     374}; 
     375 
     376static struct attr_desc extended_attr_desc[] = 
     377{ 
     378    { 
     379        /* PJ_STUN_ATTR_FINGERPRINT, */ 
     380        "FINGERPRINT", 
     381        &decode_generic_uint_attr, 
     382        &encode_generic_uint_attr 
     383    }, 
     384    { 
     385        /* PJ_STUN_ATTR_SERVER, */ 
     386        "SERVER", 
     387        &decode_generic_string_attr, 
     388        &encode_generic_string_attr 
     389    }, 
     390    { 
     391        /* PJ_STUN_ATTR_ALTERNATE_SERVER, */ 
     392        "ALTERNATE-SERVER", 
     393        &decode_generic_ip_addr_attr, 
     394        &encode_generic_ip_addr_attr 
     395    }, 
     396    { 
     397        /* PJ_STUN_ATTR_REFRESH_INTERVAL, */ 
     398        "REFRESH-INTERVAL", 
     399        &decode_generic_uint_attr, 
     400        &encode_generic_uint_attr 
     401    }, 
     402}; 
     403 
     404 
     405 
     406/* 
     407 * Get STUN message type name. 
     408 */ 
     409PJ_DEF(const char*) pj_stun_get_method_name(unsigned msg_type) 
     410{ 
     411    unsigned method = PJ_STUN_GET_METHOD(msg_type); 
     412 
     413    if (method >= PJ_ARRAY_SIZE(stun_method_names)) 
     414        return "???"; 
     415 
     416    return stun_method_names[method]; 
     417} 
     418 
     419 
     420/* 
     421 * Get STUN message class name. 
     422 */ 
     423PJ_DEF(const char*) pj_stun_get_class_name(unsigned msg_type) 
     424{ 
     425    if (PJ_STUN_IS_REQUEST(msg_type)) 
     426        return "request"; 
     427    else if (PJ_STUN_IS_RESPONSE(msg_type)) 
     428        return "success response"; 
     429    else if (PJ_STUN_IS_ERROR_RESPONSE(msg_type)) 
     430        return "error response"; 
     431    else if (PJ_STUN_IS_INDICATION(msg_type)) 
     432        return "indication"; 
     433    else 
     434        return "???"; 
     435} 
     436 
     437 
     438static const struct attr_desc *find_attr_desc(unsigned attr_type) 
     439{ 
     440    struct attr_desc *desc; 
     441 
     442    /* Check that attr_desc array is valid */ 
     443    pj_assert(PJ_ARRAY_SIZE(mandatory_attr_desc)== 
     444              PJ_STUN_ATTR_END_MANDATORY_ATTR+1); 
     445    pj_assert(mandatory_attr_desc[PJ_STUN_ATTR_END_MANDATORY_ATTR].decode_attr 
     446              == NULL); 
     447    pj_assert(mandatory_attr_desc[PJ_STUN_ATTR_USE_CANDIDATE].decode_attr  
     448              == &decode_empty_attr); 
     449    pj_assert(PJ_ARRAY_SIZE(extended_attr_desc) == 
     450              PJ_STUN_ATTR_END_EXTENDED_ATTR-PJ_STUN_ATTR_START_EXTENDED_ATTR); 
     451 
     452    if (attr_type < PJ_STUN_ATTR_START_EXTENDED_ATTR) 
     453        desc = &mandatory_attr_desc[attr_type]; 
     454    else if (attr_type >= PJ_STUN_ATTR_START_EXTENDED_ATTR && 
     455             attr_type < PJ_STUN_ATTR_END_EXTENDED_ATTR) 
     456        desc = &extended_attr_desc[attr_type-PJ_STUN_ATTR_START_EXTENDED_ATTR]; 
     457    else 
     458        return NULL; 
     459 
     460    return desc->decode_attr == NULL ? NULL : desc; 
     461} 
     462 
     463 
     464/* 
     465 * Get STUN attribute name. 
     466 */ 
     467PJ_DEF(const char*) pj_stun_get_attr_name(unsigned attr_type) 
     468{ 
     469    const struct attr_desc *attr_desc; 
     470 
     471    attr_desc = find_attr_desc(attr_type); 
     472    if (!attr_desc || attr_desc->name==NULL) 
     473        return "???"; 
     474 
     475    return attr_desc->name; 
     476} 
     477 
     478 
    62479/** 
    63480 * Get STUN standard reason phrase for the specified error code. 
     
    119536        attr->addr.ipv4.sin_addr.s_addr = (addr4->sin_addr.s_addr ^  
    120537                                           pj_htonl(0x2112A442)); 
     538    } else if (addr_len == sizeof(pj_sockaddr_in6)) { 
     539        return PJLIB_UTIL_ESTUNIPV6NOTSUPP; 
    121540    } else { 
    122         return PJ_ENOTSUP; 
     541        return PJLIB_UTIL_ESTUNINADDRLEN; 
    123542    } 
    124543 
     
    153572    /* Check address family is valid (only supports ipv4 for now) */ 
    154573    if (val != 1) 
    155         return PJLIB_UTIL_ESTUNINATTR; 
     574        return PJLIB_UTIL_ESTUNIPV6NOTSUPP; 
    156575 
    157576    /* Get port and address */ 
     
    185604    attr = (pj_stun_generic_ip_addr_attr*) buf; 
    186605    attr->hdr.type = pj_htons(attr->hdr.type); 
    187     attr->hdr.length = pj_htons((pj_uint16_t)ATTR_LEN); 
     606    attr->hdr.length = pj_htons((pj_uint16_t)STUN_GENERIC_IP_ADDR_LEN); 
    188607    buf += ATTR_HDR_LEN; 
    189608     
     
    371790    attr = (pj_stun_empty_attr*) buf; 
    372791    attr->hdr.type = pj_htons(attr->hdr.type); 
    373     attr->hdr.length = pj_htons(attr->hdr.length); 
     792    pj_assert(attr->hdr.length == ATTR_HDR_LEN); 
     793    attr->hdr.length = pj_htons(ATTR_HDR_LEN); 
    374794 
    375795    /* Done */ 
     
    458878    attr = (pj_stun_generic_uint_attr*) buf; 
    459879    attr->hdr.type = pj_htons(attr->hdr.type); 
    460     attr->hdr.length = pj_htons(attr->hdr.length); 
     880    pj_assert(attr->hdr.length == STUN_UINT_LEN); 
     881    attr->hdr.length = pj_htons(STUN_UINT_LEN); 
    461882    attr->value = pj_htonl(attr->value); 
    462883 
     
    539960    attr = (pj_stun_msg_integrity_attr*) buf; 
    540961    attr->hdr.type = pj_htons(attr->hdr.type); 
    541     attr->hdr.length = pj_htons(attr->hdr.length); 
     962    pj_assert(attr->hdr.length == STUN_MSG_INTEGRITY_LEN); 
     963    attr->hdr.length = pj_htons(STUN_MSG_INTEGRITY_LEN); 
    542964 
    543965    /* Done */ 
     
    8471269 
    8481270////////////////////////////////////////////////////////////////////////////// 
    849  
    850  
    851 struct attr_desc 
    852 { 
    853     pj_status_t (*decode_attr)(pj_pool_t *pool, const pj_uint8_t *buf,  
    854                                void **p_attr); 
    855     pj_status_t (*encode_attr)(const void *a, pj_uint8_t *buf,  
    856                                unsigned len, unsigned *printed); 
    857  
    858 }; 
    859  
    860 struct attr_desc mandatory_attr_desc[] =  
    861 { 
    862     { 
    863         /* type zero */ 
    864         NULL, 
    865         NULL 
    866     }, 
    867     { 
    868         /* PJ_STUN_ATTR_MAPPED_ADDR, */ 
    869         &decode_generic_ip_addr_attr, 
    870         &encode_generic_ip_addr_attr 
    871     }, 
    872     { 
    873         /* PJ_STUN_ATTR_RESPONSE_ADDR, */ 
    874         &decode_generic_ip_addr_attr, 
    875         &encode_generic_ip_addr_attr 
    876     }, 
    877     { 
    878         /* PJ_STUN_ATTR_CHANGE_REQUEST, */ 
    879         &decode_generic_uint_attr, 
    880         &encode_generic_uint_attr 
    881     }, 
    882     { 
    883         /* PJ_STUN_ATTR_SOURCE_ADDR, */ 
    884         &decode_generic_ip_addr_attr, 
    885         &encode_generic_ip_addr_attr 
    886     }, 
    887     { 
    888         /* PJ_STUN_ATTR_CHANGED_ADDR, */ 
    889         &decode_generic_ip_addr_attr, 
    890         &encode_generic_ip_addr_attr 
    891     }, 
    892     { 
    893         /* PJ_STUN_ATTR_USERNAME, */ 
    894         &decode_generic_string_attr, 
    895         &encode_generic_string_attr 
    896     }, 
    897     { 
    898         /* PJ_STUN_ATTR_PASSWORD, */ 
    899         &decode_generic_string_attr, 
    900         &encode_generic_string_attr 
    901     }, 
    902     { 
    903         /* PJ_STUN_ATTR_MESSAGE_INTEGRITY, */ 
    904         &decode_msg_integrity_attr, 
    905         &encode_msg_integrity_attr 
    906     }, 
    907     { 
    908         /* PJ_STUN_ATTR_ERROR_CODE, */ 
    909         &decode_error_code_attr, 
    910         &encode_error_code_attr 
    911     }, 
    912     { 
    913         /* PJ_STUN_ATTR_UNKNOWN_ATTRIBUTES, */ 
    914         &decode_unknown_attr, 
    915         &encode_unknown_attr 
    916     }, 
    917     { 
    918         /* PJ_STUN_ATTR_REFLECTED_FROM, */ 
    919         &decode_generic_ip_addr_attr, 
    920         &encode_generic_ip_addr_attr 
    921     }, 
    922     { 
    923         /* ID 0x000C is not assigned */ 
    924         NULL, 
    925         NULL 
    926     }, 
    927     { 
    928         /* PJ_STUN_ATTR_LIFETIME, */ 
    929         &decode_generic_uint_attr, 
    930         &encode_generic_uint_attr 
    931     }, 
    932     { 
    933         /* ID 0x000E is not assigned */ 
    934         NULL, 
    935         NULL 
    936     }, 
    937     { 
    938         /* ID 0x000F is not assigned */ 
    939         NULL, 
    940         NULL 
    941     }, 
    942     { 
    943         /* PJ_STUN_ATTR_BANDWIDTH, */ 
    944         &decode_generic_uint_attr, 
    945         &encode_generic_uint_attr 
    946     }, 
    947     { 
    948         /* ID 0x0011 is not assigned */ 
    949         NULL, 
    950         NULL 
    951     }, 
    952     { 
    953         /* PJ_STUN_ATTR_REMOTE_ADDRESS, */ 
    954         &decode_generic_ip_addr_attr, 
    955         &encode_generic_ip_addr_attr 
    956     }, 
    957     { 
    958         /* PJ_STUN_ATTR_DATA, */ 
    959         &decode_binary_attr, 
    960         &encode_binary_attr 
    961     }, 
    962     { 
    963         /* PJ_STUN_ATTR_REALM, */ 
    964         &decode_generic_string_attr, 
    965         &encode_generic_string_attr 
    966     }, 
    967     { 
    968         /* PJ_STUN_ATTR_NONCE, */ 
    969         &decode_generic_string_attr, 
    970         &encode_generic_string_attr 
    971     }, 
    972     { 
    973         /* PJ_STUN_ATTR_RELAY_ADDRESS, */ 
    974         &decode_generic_ip_addr_attr, 
    975         &encode_generic_ip_addr_attr 
    976     }, 
    977     { 
    978         /* PJ_STUN_ATTR_REQUESTED_ADDR_TYPE, */ 
    979         &decode_generic_uint_attr, 
    980         &encode_generic_uint_attr 
    981     }, 
    982     { 
    983         /* PJ_STUN_ATTR_REQUESTED_PORT_PROPS, */ 
    984         &decode_generic_uint_attr, 
    985         &encode_generic_uint_attr 
    986     }, 
    987     { 
    988         /* PJ_STUN_ATTR_REQUESTED_TRANSPORT, */ 
    989         &decode_generic_uint_attr, 
    990         &encode_generic_uint_attr 
    991     }, 
    992     { 
    993         /* ID 0x001A is not assigned */ 
    994         NULL, 
    995         NULL 
    996     }, 
    997     { 
    998         /* ID 0x001B is not assigned */ 
    999         NULL, 
    1000         NULL 
    1001     }, 
    1002     { 
    1003         /* ID 0x001C is not assigned */ 
    1004         NULL, 
    1005         NULL 
    1006     }, 
    1007     { 
    1008         /* ID 0x001D is not assigned */ 
    1009         NULL, 
    1010         NULL 
    1011     }, 
    1012     { 
    1013         /* ID 0x001E is not assigned */ 
    1014         NULL, 
    1015         NULL 
    1016     }, 
    1017     { 
    1018         /* ID 0x001F is not assigned */ 
    1019         NULL, 
    1020         NULL 
    1021     }, 
    1022     { 
    1023         /* PJ_STUN_ATTR_XOR_MAPPED_ADDRESS, */ 
    1024         &decode_generic_ip_addr_attr, 
    1025         &encode_generic_ip_addr_attr 
    1026     }, 
    1027     { 
    1028         /* PJ_STUN_ATTR_TIMER_VAL, */ 
    1029         &decode_generic_uint_attr, 
    1030         &encode_generic_uint_attr 
    1031     }, 
    1032     { 
    1033         /* PJ_STUN_ATTR_REQUESTED_IP, */ 
    1034         &decode_generic_ip_addr_attr, 
    1035         &encode_generic_ip_addr_attr 
    1036     }, 
    1037     { 
    1038         /* PJ_STUN_ATTR_XOR_REFLECTED_FROM, */ 
    1039         &decode_generic_ip_addr_attr, 
    1040         &encode_generic_ip_addr_attr 
    1041     }, 
    1042     { 
    1043         /* PJ_STUN_ATTR_PRIORITY, */ 
    1044         &decode_generic_uint_attr, 
    1045         &encode_generic_uint_attr 
    1046     }, 
    1047     { 
    1048         /* PJ_STUN_ATTR_USE_CANDIDATE, */ 
    1049         &decode_empty_attr, 
    1050         &encode_empty_attr 
    1051     }, 
    1052     { 
    1053         /* PJ_STUN_ATTR_XOR_INTERNAL_ADDR, */ 
    1054         &decode_generic_ip_addr_attr, 
    1055         &encode_generic_ip_addr_attr 
    1056     }, 
    1057  
    1058     /* Sentinel */ 
    1059     { 
    1060         /* PJ_STUN_ATTR_END_MANDATORY_ATTR */ 
    1061         NULL, 
    1062         NULL 
    1063     } 
    1064 }; 
    1065  
    1066 static struct attr_desc extended_attr_desc[] = 
    1067 { 
    1068     { 
    1069         /* PJ_STUN_ATTR_FINGERPRINT, */ 
    1070         &decode_generic_uint_attr, 
    1071         &encode_generic_uint_attr 
    1072     }, 
    1073     { 
    1074         /* PJ_STUN_ATTR_SERVER, */ 
    1075         &decode_generic_string_attr, 
    1076         &encode_generic_string_attr 
    1077     }, 
    1078     { 
    1079         /* PJ_STUN_ATTR_ALTERNATE_SERVER, */ 
    1080         &decode_generic_ip_addr_attr, 
    1081         &encode_generic_ip_addr_attr 
    1082     }, 
    1083     { 
    1084         /* PJ_STUN_ATTR_REFRESH_INTERVAL, */ 
    1085         &decode_generic_uint_attr, 
    1086         &encode_generic_uint_attr 
    1087     }, 
    1088 }; 
    1089  
    1090  
    1091 static const struct attr_desc *find_attr_desc(unsigned attr_type) 
    1092 { 
    1093     struct attr_desc *desc; 
    1094  
    1095     /* Check that attr_desc array is valid */ 
    1096     pj_assert(PJ_ARRAY_SIZE(mandatory_attr_desc)== 
    1097               PJ_STUN_ATTR_END_MANDATORY_ATTR+1); 
    1098     pj_assert(mandatory_attr_desc[PJ_STUN_ATTR_END_MANDATORY_ATTR].decode_attr 
    1099               == NULL); 
    1100     pj_assert(mandatory_attr_desc[PJ_STUN_ATTR_USE_CANDIDATE].decode_attr  
    1101               == &decode_empty_attr); 
    1102     pj_assert(PJ_ARRAY_SIZE(extended_attr_desc) == 
    1103               PJ_STUN_ATTR_END_EXTENDED_ATTR-PJ_STUN_ATTR_START_EXTENDED_ATTR); 
    1104  
    1105     if (attr_type < PJ_STUN_ATTR_START_EXTENDED_ATTR) 
    1106         desc = &mandatory_attr_desc[attr_type]; 
    1107     else if (attr_type >= PJ_STUN_ATTR_START_EXTENDED_ATTR && 
    1108              attr_type < PJ_STUN_ATTR_END_EXTENDED_ATTR) 
    1109         desc = &extended_attr_desc[attr_type-PJ_STUN_ATTR_START_EXTENDED_ATTR]; 
    1110     else 
    1111         return NULL; 
    1112  
    1113     return desc->decode_attr == NULL ? NULL : desc; 
    1114 } 
    1115  
    11161271 
    11171272/* 
     
    13771532     * Note that length is not including the 20 bytes header. 
    13781533     */ 
    1379     hdr->length = pj_htons((pj_uint16_t)(buf - start)); 
     1534    hdr->length = (pj_uint16_t)((buf - start) - 20); 
     1535    hdr->length = pj_htons(hdr->length); 
    13801536 
    13811537    /* Done */ 
  • pjproject/trunk/pjlib-util/src/pjlib-util/stun_simple.c

    r991 r992  
    2626#define THIS_FILE   "stun.c" 
    2727 
    28 PJ_DEF(pj_status_t) pj_stun_create_bind_req( pj_pool_t *pool,  
     28PJ_DEF(pj_status_t) pjstun_create_bind_req( pj_pool_t *pool,  
    2929                                             void **msg, pj_size_t *len, 
    3030                                             pj_uint32_t id_hi,  
    3131                                             pj_uint32_t id_lo) 
    3232{ 
    33     pj_stun_msg_hdr *hdr; 
     33    pjstun_msg_hdr *hdr; 
    3434     
    3535    PJ_CHECK_STACK(); 
    3636 
    3737 
    38     hdr = pj_pool_calloc(pool, 1, sizeof(pj_stun_msg_hdr)); 
     38    hdr = pj_pool_calloc(pool, 1, sizeof(pjstun_msg_hdr)); 
    3939    if (!hdr) 
    4040        return PJ_ENOMEM; 
    4141 
    42     hdr->type = pj_htons(PJ_STUN_BINDING_REQUEST); 
     42    hdr->type = pj_htons(PJSTUN_BINDING_REQUEST); 
    4343    hdr->tsx[2] = pj_htonl(id_hi); 
    4444    hdr->tsx[3] = pj_htonl(id_lo); 
    4545    *msg = hdr; 
    46     *len = sizeof(pj_stun_msg_hdr); 
     46    *len = sizeof(pjstun_msg_hdr); 
    4747 
    4848    return PJ_SUCCESS; 
    4949} 
    5050 
    51 PJ_DEF(pj_status_t) pj_stun_parse_msg( void *buf, pj_size_t len,  
    52                                        pj_stun_msg *msg) 
     51PJ_DEF(pj_status_t) pjstun_parse_msg( void *buf, pj_size_t len,  
     52                                       pjstun_msg *msg) 
    5353{ 
    5454    pj_uint16_t msg_type, msg_len; 
     
    5757    PJ_CHECK_STACK(); 
    5858 
    59     msg->hdr = (pj_stun_msg_hdr*)buf; 
     59    msg->hdr = (pjstun_msg_hdr*)buf; 
    6060    msg_type = pj_ntohs(msg->hdr->type); 
    6161 
    6262    switch (msg_type) { 
    63     case PJ_STUN_BINDING_REQUEST: 
    64     case PJ_STUN_BINDING_RESPONSE: 
    65     case PJ_STUN_BINDING_ERROR_RESPONSE: 
    66     case PJ_STUN_SHARED_SECRET_REQUEST: 
    67     case PJ_STUN_SHARED_SECRET_RESPONSE: 
    68     case PJ_STUN_SHARED_SECRET_ERROR_RESPONSE: 
     63    case PJSTUN_BINDING_REQUEST: 
     64    case PJSTUN_BINDING_RESPONSE: 
     65    case PJSTUN_BINDING_ERROR_RESPONSE: 
     66    case PJSTUN_SHARED_SECRET_REQUEST: 
     67    case PJSTUN_SHARED_SECRET_RESPONSE: 
     68    case PJSTUN_SHARED_SECRET_ERROR_RESPONSE: 
    6969        break; 
    7070    default: 
     
    7474 
    7575    msg_len = pj_ntohs(msg->hdr->length); 
    76     if (msg_len != len - sizeof(pj_stun_msg_hdr)) { 
     76    if (msg_len != len - sizeof(pjstun_msg_hdr)) { 
    7777        PJ_LOG(4,(THIS_FILE, "Error: invalid msg_len %d (expecting %d)",  
    78                              msg_len, len - sizeof(pj_stun_msg_hdr))); 
     78                             msg_len, len - sizeof(pjstun_msg_hdr))); 
    7979        return PJLIB_UTIL_ESTUNINMSGLEN; 
    8080    } 
    8181 
    8282    msg->attr_count = 0; 
    83     p_attr = (char*)buf + sizeof(pj_stun_msg_hdr); 
     83    p_attr = (char*)buf + sizeof(pjstun_msg_hdr); 
    8484 
    8585    while (msg_len > 0) { 
    86         pj_stun_attr_hdr **attr = &msg->attr[msg->attr_count]; 
     86        pjstun_attr_hdr **attr = &msg->attr[msg->attr_count]; 
    8787        pj_uint32_t len; 
    8888 
    89         *attr = (pj_stun_attr_hdr*)p_attr; 
    90         len = pj_ntohs((pj_uint16_t) ((*attr)->length)) + sizeof(pj_stun_attr_hdr); 
     89        *attr = (pjstun_attr_hdr*)p_attr; 
     90        len = pj_ntohs((pj_uint16_t) ((*attr)->length)) + sizeof(pjstun_attr_hdr); 
    9191 
    9292        if (msg_len < len) { 
     
    9696        } 
    9797 
    98         if (pj_ntohs((*attr)->type) > PJ_STUN_ATTR_REFLECTED_FORM) { 
     98        if (pj_ntohs((*attr)->type) > PJSTUN_ATTR_REFLECTED_FORM) { 
    9999            PJ_LOG(5,(THIS_FILE, "Warning: unknown attr type %x in attr %d. " 
    100100                                 "Attribute was ignored.", 
     
    110110} 
    111111 
    112 PJ_DEF(void*) pj_stun_msg_find_attr( pj_stun_msg *msg, pj_stun_attr_type t) 
     112PJ_DEF(void*) pjstun_msg_find_attr( pjstun_msg *msg, pjstun_attr_type t) 
    113113{ 
    114114    int i; 
     
    117117 
    118118    for (i=0; i<msg->attr_count; ++i) { 
    119         pj_stun_attr_hdr *attr = msg->attr[i]; 
     119        pjstun_attr_hdr *attr = msg->attr[i]; 
    120120        if (pj_ntohs(attr->type) == t) 
    121121            return attr; 
  • pjproject/trunk/pjlib-util/src/pjlib-util/stun_simple_client.c

    r991 r992  
    3333 
    3434 
    35 PJ_DECL(pj_status_t) pj_stun_get_mapped_addr( pj_pool_factory *pf, 
     35PJ_DECL(pj_status_t) pjstun_get_mapped_addr( pj_pool_factory *pf, 
    3636                                              int sock_cnt, pj_sock_t sock[], 
    3737                                              const pj_str_t *srv1, int port1, 
     
    7070 
    7171    /* Create the outgoing BIND REQUEST message template */ 
    72     status = pj_stun_create_bind_req( pool, &out_msg, &out_msg_len,  
     72    status = pjstun_create_bind_req( pool, &out_msg, &out_msg_len,  
    7373                                      pj_rand(), pj_rand()); 
    7474    if (status != PJ_SUCCESS) 
     
    9898        for (i=0; i<sock_cnt && status==PJ_SUCCESS; ++i) { 
    9999            for (j=0; j<2 && status==PJ_SUCCESS; ++j) { 
    100                 pj_stun_msg_hdr *msg_hdr = out_msg; 
     100                pjstun_msg_hdr *msg_hdr = out_msg; 
    101101                pj_ssize_t sent_len; 
    102102 
     
    151151                int sock_idx, srv_idx; 
    152152                pj_ssize_t len; 
    153                 pj_stun_msg msg; 
     153                pjstun_msg msg; 
    154154                pj_sockaddr_in addr; 
    155155                int addrlen = sizeof(addr); 
    156                 pj_stun_mapped_addr_attr *attr; 
     156                pjstun_mapped_addr_attr *attr; 
    157157                char recv_buf[128]; 
    158158 
     
    171171                    continue; 
    172172 
    173                 status = pj_stun_parse_msg(recv_buf, len, &msg); 
     173                status = pjstun_parse_msg(recv_buf, len, &msg); 
    174174                if (status != PJ_SUCCESS) { 
    175175                    continue; 
     
    185185                } 
    186186 
    187                 if (pj_ntohs(msg.hdr->type) != PJ_STUN_BINDING_RESPONSE) { 
     187                if (pj_ntohs(msg.hdr->type) != PJSTUN_BINDING_RESPONSE) { 
    188188                    status = PJLIB_UTIL_ESTUNNOBINDRES; 
    189189                    continue; 
    190190                } 
    191191 
    192                 if (pj_stun_msg_find_attr(&msg, PJ_STUN_ATTR_ERROR_CODE) != NULL) { 
     192                if (pjstun_msg_find_attr(&msg, PJSTUN_ATTR_ERROR_CODE) != NULL) { 
    193193                    status = PJLIB_UTIL_ESTUNRECVERRATTR; 
    194194                    continue; 
    195195                } 
    196196 
    197                 attr = (void*)pj_stun_msg_find_attr(&msg, PJ_STUN_ATTR_MAPPED_ADDR); 
     197                attr = (void*)pjstun_msg_find_attr(&msg, PJSTUN_ATTR_MAPPED_ADDR); 
    198198                if (!attr) { 
    199199                    status = PJLIB_UTIL_ESTUNNOMAP; 
  • pjproject/trunk/pjlib-util/src/pjstun-srv/server_main.c

    r991 r992  
    120120    } 
    121121 
     122    PJ_LOG(4,(THIS_FILE, "Sending STUN %s %s", 
     123              pj_stun_get_method_name(msg->hdr.type), 
     124              pj_stun_get_class_name(msg->hdr.type))); 
     125 
    122126    return (status == PJ_SUCCESS || status == PJ_EPENDING) ?  
    123127            PJ_SUCCESS : status; 
     
    230234                                NULL, &err_code, &uattr_cnt, uattr_types); 
    231235    if (status != PJ_SUCCESS) { 
     236        server_perror(THIS_FILE, "STUN msg_decode() error", status); 
    232237        if (err_code != 0 && rx_msg && PJ_STUN_IS_REQUEST(rx_msg->hdr.type)) { 
    233238            err_respond(svc, pool, rx_msg, err_code,  
     
    236241        goto next_read; 
    237242    } 
     243 
     244    PJ_LOG(4,(THIS_FILE, "RX STUN %s %s message",  
     245              pj_stun_get_method_name(rx_msg->hdr.type), 
     246              pj_stun_get_class_name(rx_msg->hdr.type))); 
    238247 
    239248    if (PJ_STUN_IS_REQUEST(rx_msg->hdr.type)) { 
  • pjproject/trunk/pjlib/include/pj/pool.h

    r974 r992  
    442442 * 
    443443 * @return pointer to the allocated memory. 
     444 * 
     445 * @see PJ_POOL_ALLOC_TYPE 
    444446 */ 
    445447PJ_IDECL(void*) pj_pool_alloc( pj_pool_t *pool, pj_size_t size); 
     
    461463 
    462464/** 
    463  * @def pj_pool_zalloc(pj_pool_t *pool, pj_size_t size) 
    464465 * Allocate storage from the pool and initialize it to zero. 
    465466 * 
     
    468469 * 
    469470 * @return          Pointer to the allocated memory. 
    470  */ 
    471 #define pj_pool_zalloc(pool, size)  pj_pool_calloc(pool, 1, size) 
     471 * 
     472 * @see PJ_POOL_ZALLOC_TYPE 
     473 */ 
     474PJ_INLINE(void*) pj_pool_zalloc(pj_pool_t *pool, pj_size_t size) 
     475{ 
     476    return pj_pool_calloc(pool, 1, size); 
     477} 
     478 
     479 
     480/** 
     481 * This macro allocates memory from the pool and returns the instance of 
     482 * the specified type. It provides a stricker type safety than pj_pool_alloc() 
     483 * since the return value of this macro will be type-casted to the specified 
     484 * type. 
     485 * 
     486 * @param pool      The pool 
     487 * @param type      The type of object to be allocated 
     488 * 
     489 * @return          Memory buffer of the specified type. 
     490 */ 
     491#define PJ_POOL_ALLOC_TYPE(pool,type) \ 
     492            ((type*)pj_pool_alloc(pool, sizeof(type))) 
     493 
     494/** 
     495 * This macro allocates memory from the pool, zeroes the buffer, and  
     496 * returns the instance of the specified type. It provides a stricker type  
     497 * safety than pj_pool_zalloc() since the return value of this macro will be  
     498 * type-casted to the specified type. 
     499 * 
     500 * @param pool      The pool 
     501 * @param type      The type of object to be allocated 
     502 * 
     503 * @return          Memory buffer of the specified type. 
     504 */ 
     505#define PJ_POOL_ZALLOC_TYPE(pool,type) \ 
     506            ((type*)pj_pool_zalloc(pool, sizeof(type))) 
     507 
    472508 
    473509 
  • pjproject/trunk/pjsip/src/pjsua-lib/pjsua_core.c

    r974 r992  
    871871         * STUN is specified, resolve the address with STUN. 
    872872         */ 
    873         status = pj_stun_get_mapped_addr(&pjsua_var.cp.factory, 1, &sock, 
     873        status = pjstun_get_mapped_addr(&pjsua_var.cp.factory, 1, &sock, 
    874874                                         &stun.stun_srv1,  
    875875                                          stun.stun_port1, 
  • pjproject/trunk/pjsip/src/pjsua-lib/pjsua_media.c

    r974 r992  
    273273         */ 
    274274        if (cfg->stun_config.stun_srv1.slen) { 
    275             status=pj_stun_get_mapped_addr(&pjsua_var.cp.factory, 2, sock, 
     275            status=pjstun_get_mapped_addr(&pjsua_var.cp.factory, 2, sock, 
    276276                                           &cfg->stun_config.stun_srv1,  
    277277                                           cfg->stun_config.stun_port1, 
Note: See TracChangeset for help on using the changeset viewer.