Changeset 217


Ignore:
Timestamp:
Feb 22, 2006 10:10:42 PM (19 years ago)
Author:
bennylp
Message:

Started errno framework in pjlib-util

Location:
pjproject/trunk/pjlib-util
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/pjlib-util/build/pjlib_util.dsp

    r77 r217  
    4242# PROP Target_Dir "" 
    4343# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c 
    44 # ADD CPP /nologo /MD /W3 /GX /Zi /O2 /Oy /Ob2 /I "../include" /I "../../pjlib/include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D PJ_WIN32=1 /D PJ_M_I386=1 /FR /YX /FD /c 
     44# ADD CPP /nologo /MD /W3 /GX /Zi /O2 /Ob2 /I "../include" /I "../../pjlib/include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D PJ_WIN32=1 /D PJ_M_I386=1 /FR /YX /FD /c 
    4545# ADD BASE RSC /l 0x409 /d "NDEBUG" 
    4646# ADD RSC /l 0x409 /d "NDEBUG" 
    … …  
    8484 
    8585# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" 
     86# Begin Source File 
     87 
     88SOURCE="..\src\pjlib-util\errno.c" 
     89# End Source File 
    8690# Begin Source File 
    8791 
    … …  
    128132# Begin Source File 
    129133 
     134SOURCE="..\include\pjlib-util\errno.h" 
     135# End Source File 
     136# Begin Source File 
     137 
    130138SOURCE="..\include\pjlib-util\md5.h" 
    131139# End Source File 

  • pjproject/trunk/pjlib-util/include/pjlib-util.h

    r166 r217  
    1717 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
    1818 */ 
     19#ifndef __PJLIB_UTIL_H__ 
     20#define __PJLIB_UTIL_H__ 
     21 
     22#include <pjlib-util/errno.h> 
    1923#include <pjlib-util/md5.h> 
    2024#include <pjlib-util/scanner.h> 
    2125#include <pjlib-util/stun.h> 
    2226#include <pjlib-util/xml.h> 
     27 
     28 
     29PJ_BEGIN_DECL 
     30 
     31/** 
     32 * Initialize PJLIB UTIL (defined in errno.c) 
     33 * 
     34 * @return PJ_SUCCESS on success. 
     35 */ 
     36PJ_DECL(pj_status_t) pjlib_util_init(void); 
     37 
     38 
     39PJ_END_DECL 
     40 
     41 
     42#endif  /* __PJLIB_UTIL_H__ */ 

  • pjproject/trunk/pjlib-util/include/pjlib-util/stun.h

    r166 r217  
    119119PJ_DECL(void*) pj_stun_msg_find_attr( pj_stun_msg *msg, pj_stun_attr_type t); 
    120120 
    121 /* STUN simple client API (stun_client.c) */ 
    122 enum pj_stun_err_code { 
    123     PJ_STUN_ERR_MEMORY          = (-2), 
    124     PJ_STUN_ERR_RESOLVE         = (-3), 
    125     PJ_STUN_ERR_TRANSPORT       = (-4), 
    126     PJ_STUN_ERR_INVALID_MSG     = (-5), 
    127     PJ_STUN_ERR_NO_RESPONSE     = (-6), 
    128     PJ_STUN_ERR_SYMETRIC        = (-7), 
    129 }; 
    130  
    131121PJ_DECL(pj_status_t) pj_stun_get_mapped_addr( pj_pool_factory *pf, 
    132122                                              int sock_cnt, pj_sock_t sock[], 
    … …  
    134124                                              const pj_str_t *srv2, int port2, 
    135125                                              pj_sockaddr_in mapped_addr[]); 
    136 PJ_DECL(const char*) pj_stun_get_err_msg(pj_status_t status); 
    137126 
    138127PJ_END_DECL 

  • pjproject/trunk/pjlib-util/src/pjlib-util/stun.c

    r65 r217  
    1818 */ 
    1919#include <pjlib-util/stun.h> 
     20#include <pjlib-util/errno.h> 
    2021#include <pj/pool.h> 
    2122#include <pj/log.h> 
    … …  
    2324#include <pj/os.h> 
    2425 
    25 #define THIS_FILE   "stun" 
     26#define THIS_FILE   "stun.c" 
    2627 
    2728PJ_DEF(pj_status_t) pj_stun_create_bind_req( pj_pool_t *pool,  
    … …  
    3435    PJ_CHECK_STACK(); 
    3536 
    36     PJ_LOG(5,(THIS_FILE, "pj_stun_create_bind_req")); 
    3737 
    3838    hdr = pj_pool_calloc(pool, 1, sizeof(pj_stun_msg_hdr)); 
    39     if (!hdr) { 
    40         PJ_LOG(5,(THIS_FILE, "Error allocating memory!")); 
    41         return -1; 
    42     } 
     39    if (!hdr) 
     40        return PJ_ENOMEM; 
    4341 
    4442    hdr->type = pj_htons(PJ_STUN_BINDING_REQUEST); 
    … …  
    4846    *len = sizeof(pj_stun_msg_hdr); 
    4947 
    50     return 0; 
     48    return PJ_SUCCESS; 
    5149} 
    5250 
    … …  
    5856 
    5957    PJ_CHECK_STACK(); 
    60  
    61     PJ_LOG(5,(THIS_FILE, "pj_stun_parse_msg %p, len=%d", buf, len)); 
    6258 
    6359    msg->hdr = (pj_stun_msg_hdr*)buf; 
    … …  
    7369        break; 
    7470    default: 
    75         PJ_LOG(5,(THIS_FILE, "Error: unknown msg type %d", msg_type)); 
    76         return -1; 
     71        PJ_LOG(4,(THIS_FILE, "Error: unknown msg type %d", msg_type)); 
     72        return PJLIB_UTIL_ESTUNINMSGTYPE; 
    7773    } 
    7874 
    7975    msg_len = pj_ntohs(msg->hdr->length); 
    8076    if (msg_len != len - sizeof(pj_stun_msg_hdr)) { 
    81         PJ_LOG(5,(THIS_FILE, "Error: invalid msg_len %d (expecting %d)",  
     77        PJ_LOG(4,(THIS_FILE, "Error: invalid msg_len %d (expecting %d)",  
    8278                             msg_len, len - sizeof(pj_stun_msg_hdr))); 
    83         return -1; 
     79        return PJLIB_UTIL_ESTUNINMSGLEN; 
    8480    } 
    8581 
    … …  
    9591 
    9692        if (msg_len < len) { 
    97             PJ_LOG(5,(THIS_FILE, "Error: length mismatch in attr %d",  
     93            PJ_LOG(4,(THIS_FILE, "Error: length mismatch in attr %d",  
    9894                                 msg->attr_count)); 
    99             return -1; 
     95            return PJLIB_UTIL_ESTUNINATTRLEN; 
    10096        } 
    10197 
    10298        if (pj_ntohs((*attr)->type) > PJ_STUN_ATTR_REFLECTED_FORM) { 
    103             PJ_LOG(5,(THIS_FILE, "Error: invalid attr type %d in attr %d", 
     99            PJ_LOG(4,(THIS_FILE, "Error: invalid attr type %d in attr %d", 
    104100                                 pj_ntohs((*attr)->type), msg->attr_count)); 
    105             return -1; 
     101            return PJLIB_UTIL_ESTUNINATTRTYPE; 
    106102        } 
    107103 
    … …  
    111107    } 
    112108 
    113     return 0; 
     109    return PJ_SUCCESS; 
    114110} 
    115111 

  • pjproject/trunk/pjlib-util/src/pjlib-util/stun_client.c

    r185 r217  
    1818 */ 
    1919#include <pjlib-util/stun.h> 
     20#include <pjlib-util/errno.h> 
     21#include <pj/os.h> 
    2022#include <pj/pool.h> 
    21 #include <pj/log.h> 
     23#include <pj/rand.h> 
     24#include <pj/sock_select.h> 
    2225#include <pj/string.h> 
    23 #include <pj/os.h> 
    24 #include <pj/sock_select.h> 
     26 
    2527 
    2628enum { MAX_REQUEST = 3 }; 
    2729static int stun_timer[] = {1600, 1600, 1600 }; 
    2830 
    29 #define THIS_FILE       "stunclient" 
     31#define THIS_FILE       "stun_client.c" 
    3032#define LOG_ADDR(addr)  pj_inet_ntoa(addr.sin_addr), pj_ntohs(addr.sin_port) 
    3133 
    … …  
    3840{ 
    3941    pj_sockaddr_in srv_addr[2]; 
    40     int i, j, rc, send_cnt = 0; 
     42    int i, j, send_cnt = 0; 
    4143    pj_pool_t *pool; 
    4244    struct { 
    … …  
    4951    pj_size_t   out_msg_len; 
    5052    int wait_resp = 0; 
    51     int mapped_status = 0; 
     53    pj_status_t status; 
    5254 
    5355    PJ_CHECK_STACK(); 
    … …  
    5557    /* Create pool. */ 
    5658    pool = pj_pool_create(pf, "stun%p", 1024, 1024, NULL); 
    57     if (!pool) { 
    58         mapped_status = PJ_STUN_ERR_MEMORY;  
    59         return -1; 
    60     } 
     59    if (!pool) 
     60        return PJ_ENOMEM; 
     61 
    6162 
    6263    /* Allocate client records */ 
    6364    rec = pj_pool_calloc(pool, sock_cnt, sizeof(*rec)); 
    6465    if (!rec) { 
    65         mapped_status = PJ_STUN_ERR_MEMORY;  
     66        status = PJ_ENOMEM; 
    6667        goto on_error; 
    6768    } 
    6869 
     70 
    6971    /* Create the outgoing BIND REQUEST message template */ 
    70     rc = pj_stun_create_bind_req( pool, &out_msg, &out_msg_len, 0, 0); 
    71     if (rc != 0) { 
    72         mapped_status = -1; 
    73         goto on_error; 
    74     } 
     72    status = pj_stun_create_bind_req( pool, &out_msg, &out_msg_len,  
     73                                      pj_rand(), pj_rand()); 
     74    if (status != PJ_SUCCESS) 
     75        goto on_error; 
    7576 
    7677    /* Resolve servers. */ 
    77     if (pj_sockaddr_in_init(&srv_addr[0], srv1, (pj_uint16_t)port1) != 0) { 
    78         mapped_status = PJ_STUN_ERR_RESOLVE;  
    79         goto on_error; 
    80     } 
    81     if (pj_sockaddr_in_init(&srv_addr[1], srv2, (pj_uint16_t)port2) != 0) { 
    82         mapped_status = PJ_STUN_ERR_RESOLVE; 
    83         goto on_error; 
    84     } 
     78    status = pj_sockaddr_in_init(&srv_addr[0], srv1, (pj_uint16_t)port1); 
     79    if (status != PJ_SUCCESS) 
     80        goto on_error; 
     81 
     82    status = pj_sockaddr_in_init(&srv_addr[1], srv2, (pj_uint16_t)port2); 
     83    if (status != PJ_SUCCESS) 
     84        goto on_error; 
    8585 
    8686    /* Init mapped addresses to zero */ 
    … …  
    9393        int select_rc; 
    9494 
    95         PJ_LOG(4,(THIS_FILE, "STUN retransmit %d, wait_resp=%d",  
    96                              send_cnt, wait_resp)); 
    97  
    9895        PJ_FD_ZERO(&r); 
    9996 
    10097        /* Send messages to servers that has not given us response. */ 
    101         for (i=0; i<sock_cnt && mapped_status==0; ++i) { 
    102             for (j=0; j<2 && mapped_status==0; ++j) { 
     98        for (i=0; i<sock_cnt && status==PJ_SUCCESS; ++i) { 
     99            for (j=0; j<2 && status==PJ_SUCCESS; ++j) { 
    103100                pj_stun_msg_hdr *msg_hdr = out_msg; 
    104101                pj_ssize_t sent_len; 
    … …  
    113110                /* Send! */ 
    114111                sent_len = out_msg_len; 
    115                 rc = pj_sock_sendto(sock[i], out_msg, &sent_len, 0, 
    116                                     (pj_sockaddr_t*)&srv_addr[j],  
    117                                     sizeof(pj_sockaddr_in)); 
    118                 if (sent_len != (int)out_msg_len) { 
    119                     PJ_LOG(4,(THIS_FILE,  
    120                               "Error sending STUN request to %s:%d", 
    121                               LOG_ADDR(srv_addr[j]))); 
    122                     mapped_status = PJ_STUN_ERR_TRANSPORT;  
    123                 } else { 
     112                status = pj_sock_sendto(sock[i], out_msg, &sent_len, 0, 
     113                                        (pj_sockaddr_t*)&srv_addr[j],  
     114                                        sizeof(pj_sockaddr_in)); 
     115                if (status == PJ_SUCCESS) 
    124116                    ++wait_resp; 
    125                 } 
    126117            } 
    127118        } 
    … …  
    140131 
    141132        for (pj_gettimeofday(&now), select_rc=1;  
    142              mapped_status==0 && select_rc==1 && wait_resp>0 && PJ_TIME_VAL_LT(now, next_tx);  
     133             status==PJ_SUCCESS && select_rc==1 && wait_resp>0  
     134               && PJ_TIME_VAL_LT(now, next_tx);  
    143135             pj_gettimeofday(&now))  
    144136        { 
    … …  
    169161 
    170162                len = sizeof(recv_buf); 
    171                 pj_sock_recvfrom( sock[i], recv_buf,  
    172                                   &len, 0, 
    173                                   (pj_sockaddr_t*)&addr, 
    174                                   &addrlen); 
     163                status = pj_sock_recvfrom( sock[i], recv_buf,  
     164                                           &len, 0, 
     165                                           (pj_sockaddr_t*)&addr, 
     166                                           &addrlen); 
    175167 
    176168                --wait_resp; 
    177169 
    178                 if (len < 1) { 
    179                     mapped_status = PJ_STUN_ERR_TRANSPORT;  
    180                     continue; 
    181                 } 
    182  
    183                 if (pj_stun_parse_msg(recv_buf, len, &msg) != 0) { 
    184                     PJ_LOG(4,(THIS_FILE,  
    185                                 "Error parsing STUN response from %s:%d", 
    186                                 LOG_ADDR(addr))); 
    187                     mapped_status = PJ_STUN_ERR_INVALID_MSG; 
    188                     continue; 
    189                 } 
     170                if (status != PJ_SUCCESS) 
     171                    continue; 
     172 
     173                status = pj_stun_parse_msg(recv_buf, len, &msg); 
     174                if (status != PJ_SUCCESS) { 
     175                    continue; 
     176                } 
     177 
    190178 
    191179                sock_idx = pj_ntohl(msg.hdr->tsx[2]); 
    … …  
    193181 
    194182                if (sock_idx<0 || sock_idx>=sock_cnt || srv_idx<0 || srv_idx>=2) { 
    195                     PJ_LOG(4,(THIS_FILE,  
    196                                 "Invalid transaction ID from %s:%d",  
    197                                 LOG_ADDR(addr))); 
    198                     mapped_status = PJ_STUN_ERR_INVALID_MSG; 
     183                    status = PJLIB_UTIL_ESTUNININDEX; 
    199184                    continue; 
    200185                } 
    201186 
    202187                if (pj_ntohs(msg.hdr->type) != PJ_STUN_BINDING_RESPONSE) { 
    203                     PJ_LOG(4,(THIS_FILE,  
    204                                 "Non binding response %d from %s:%d",  
    205                                 pj_ntohs(msg.hdr->type), LOG_ADDR(addr))); 
    206                     mapped_status = PJ_STUN_ERR_INVALID_MSG; 
     188                    status = PJLIB_UTIL_ESTUNNOBINDRES; 
    207189                    continue; 
    208190                } 
    209191 
    210192                if (pj_stun_msg_find_attr(&msg, PJ_STUN_ATTR_ERROR_CODE) != NULL) { 
    211                     PJ_LOG(4,(THIS_FILE,  
    212                                 "Got STUN error attribute from %s:%d", 
    213                                 LOG_ADDR(addr))); 
    214                     mapped_status = PJ_STUN_ERR_INVALID_MSG; 
     193                    status = PJLIB_UTIL_ESTUNRECVERRATTR; 
    215194                    continue; 
    216195                } 
    … …  
    218197                attr = (void*)pj_stun_msg_find_attr(&msg, PJ_STUN_ATTR_MAPPED_ADDR); 
    219198                if (!attr) { 
    220                     PJ_LOG(4,(THIS_FILE, 
    221                                 "No mapped address in response from %s:%d", 
    222                                 LOG_ADDR(addr))); 
    223                     mapped_status = PJ_STUN_ERR_INVALID_MSG; 
     199                    status = PJLIB_UTIL_ESTUNNOMAP; 
    224200                    continue; 
    225201                } 
    … …  
    237213    } 
    238214 
    239     for (i=0; i<sock_cnt && mapped_status==0; ++i) { 
     215    for (i=0; i<sock_cnt && status==PJ_SUCCESS; ++i) { 
    240216        if (rec[i].srv[0].mapped_addr == rec[i].srv[1].mapped_addr && 
    241217            rec[i].srv[0].mapped_port == rec[i].srv[1].mapped_port) 
    … …  
    246222 
    247223            if (rec[i].srv[0].mapped_addr == 0 || rec[i].srv[0].mapped_port == 0) { 
    248                 mapped_status = PJ_STUN_ERR_NO_RESPONSE; 
     224                status = PJLIB_UTIL_ESTUNNOTRESPOND; 
    249225                break; 
    250226            } 
    251227        } else { 
    252             mapped_status = PJ_STUN_ERR_SYMETRIC; 
     228            status = PJLIB_UTIL_ESTUNSYMMETRIC; 
    253229            break; 
    254230        } 
    … …  
    257233    pj_pool_release(pool); 
    258234 
    259     return mapped_status; 
     235    return status; 
    260236 
    261237on_error: 
    262238    if (pool) pj_pool_release(pool); 
    263     return -1; 
     239    return status; 
    264240} 
    265241 
    266 PJ_DEF(const char*) pj_stun_get_err_msg(pj_status_t status) 
    267 { 
    268     switch (status) { 
    269     case 0:                         return "No error"; 
    270     case -1:                        return "General error"; 
    271     case PJ_STUN_ERR_MEMORY:        return "Memory allocation failed"; 
    272     case PJ_STUN_ERR_RESOLVE:       return "Invalid IP or unable to resolve STUN server"; 
    273     case PJ_STUN_ERR_TRANSPORT:     return "Unable to contact STUN server"; 
    274     case PJ_STUN_ERR_INVALID_MSG:   return "Invalid response from STUN server"; 
    275     case PJ_STUN_ERR_NO_RESPONSE:   return "No response from STUN server"; 
    276     case PJ_STUN_ERR_SYMETRIC:      return "Different mappings are returned from servers"; 
    277     } 
    278     return "Unknown error"; 
    279 } 
Note: See TracChangeset for help on using the changeset viewer.