Ignore:
Timestamp:
Mar 10, 2007 11:15:36 PM (17 years ago)
Author:
bennylp
Message:

Completed and tested (simple test) the TURN server and command line STUN/TURN client

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1053 r1054  
    9090}; 
    9191 
    92 static pj_status_t decode_ip_addr_attr(pj_pool_t *pool,  
     92static pj_status_t decode_sockaddr_attr(pj_pool_t *pool,  
    9393                                       const pj_uint8_t *buf,  
    9494                                       void **p_attr); 
    95 static pj_status_t encode_ip_addr_attr(const void *a, pj_uint8_t *buf,  
     95static pj_status_t decode_xored_sockaddr_attr(pj_pool_t *pool,  
     96                                              const pj_uint8_t *buf,  
     97                                              void **p_attr); 
     98static pj_status_t encode_sockaddr_attr(const void *a, pj_uint8_t *buf,  
    9699                                       unsigned len,  
    97100                                       unsigned *printed); 
    … …  
    144147        /* PJ_STUN_ATTR_MAPPED_ADDR, */ 
    145148        "MAPPED-ADDRESS", 
    146         &decode_ip_addr_attr, 
    147         &encode_ip_addr_attr 
     149        &decode_sockaddr_attr, 
     150        &encode_sockaddr_attr 
    148151    }, 
    149152    { 
    150153        /* PJ_STUN_ATTR_RESPONSE_ADDR, */ 
    151154        "RESPONSE-ADDRESS", 
    152         &decode_ip_addr_attr, 
    153         &encode_ip_addr_attr 
     155        &decode_sockaddr_attr, 
     156        &encode_sockaddr_attr 
    154157    }, 
    155158    { 
    … …  
    162165        /* PJ_STUN_ATTR_SOURCE_ADDR, */ 
    163166        "SOURCE-ADDRESS", 
    164         &decode_ip_addr_attr, 
    165         &encode_ip_addr_attr 
     167        &decode_sockaddr_attr, 
     168        &encode_sockaddr_attr 
    166169    }, 
    167170    { 
    168171        /* PJ_STUN_ATTR_CHANGED_ADDR, */ 
    169172        "CHANGED-ADDRESS", 
    170         &decode_ip_addr_attr, 
    171         &encode_ip_addr_attr 
     173        &decode_sockaddr_attr, 
     174        &encode_sockaddr_attr 
    172175    }, 
    173176    { 
    … …  
    204207        /* PJ_STUN_ATTR_REFLECTED_FROM, */ 
    205208        "REFLECTED-FROM", 
    206         &decode_ip_addr_attr, 
    207         &encode_ip_addr_attr 
     209        &decode_sockaddr_attr, 
     210        &encode_sockaddr_attr 
    208211    }, 
    209212    { 
    … …  
    246249        /* PJ_STUN_ATTR_REMOTE_ADDRESS, */ 
    247250        "REMOTE-ADDRESS", 
    248         &decode_ip_addr_attr, 
    249         &encode_ip_addr_attr 
     251        &decode_sockaddr_attr, 
     252        &encode_sockaddr_attr 
    250253    }, 
    251254    { 
    … …  
    270273        /* PJ_STUN_ATTR_RELAY_ADDRESS, */ 
    271274        "RELAY-ADDRESS", 
    272         &decode_ip_addr_attr, 
    273         &encode_ip_addr_attr 
     275        &decode_sockaddr_attr, 
     276        &encode_sockaddr_attr 
    274277    }, 
    275278    { 
    … …  
    330333        /* PJ_STUN_ATTR_XOR_MAPPED_ADDRESS, */ 
    331334        "XOR-MAPPED-ADDRESS", 
    332         &decode_ip_addr_attr, 
    333         &encode_ip_addr_attr 
     335        &decode_xored_sockaddr_attr, 
     336        &encode_sockaddr_attr 
    334337    }, 
    335338    { 
    … …  
    342345        /* PJ_STUN_ATTR_REQUESTED_IP, */ 
    343346        "REQUESTED-IP", 
    344         &decode_ip_addr_attr, 
    345         &encode_ip_addr_attr 
     347        &decode_sockaddr_attr, 
     348        &encode_sockaddr_attr 
    346349    }, 
    347350    { 
    348351        /* PJ_STUN_ATTR_XOR_REFLECTED_FROM, */ 
    349352        "XOR-REFLECTED-FROM", 
    350         &decode_ip_addr_attr, 
    351         &encode_ip_addr_attr 
     353        &decode_xored_sockaddr_attr, 
     354        &encode_sockaddr_attr 
    352355    }, 
    353356    { 
    … …  
    366369        /* PJ_STUN_ATTR_XOR_INTERNAL_ADDR, */ 
    367370        "XOR-INTERNAL-ADDRESS", 
    368         &decode_ip_addr_attr, 
    369         &encode_ip_addr_attr 
     371        &decode_xored_sockaddr_attr, 
     372        &encode_sockaddr_attr 
    370373    }, 
    371374 
    … …  
    396399        /* PJ_STUN_ATTR_ALTERNATE_SERVER, */ 
    397400        "ALTERNATE-SERVER", 
    398         &decode_ip_addr_attr, 
    399         &encode_ip_addr_attr 
     401        &decode_sockaddr_attr, 
     402        &encode_sockaddr_attr 
    400403    }, 
    401404    { 
    … …  
    540543 */ 
    541544PJ_DEF(pj_status_t)  
    542 pj_stun_ip_addr_attr_create(pj_pool_t *pool, 
    543                             int attr_type, 
    544                             pj_bool_t xor_ed, 
    545                             const pj_sockaddr_t *addr, 
    546                             unsigned addr_len, 
    547                             pj_stun_ip_addr_attr **p_attr) 
    548 { 
    549     pj_stun_ip_addr_attr *attr; 
     545pj_stun_sockaddr_attr_create(pj_pool_t *pool, 
     546                             int attr_type, 
     547                             pj_bool_t xor_ed, 
     548                             const pj_sockaddr_t *addr, 
     549                             unsigned addr_len, 
     550                             pj_stun_sockaddr_attr **p_attr) 
     551{ 
     552    pj_stun_sockaddr_attr *attr; 
    550553 
    551554    PJ_ASSERT_RETURN(pool && addr_len && addr && p_attr, PJ_EINVAL); 
    … …  
    553556                     addr_len == sizeof(pj_sockaddr_in6), PJ_EINVAL); 
    554557 
    555     attr = PJ_POOL_ZALLOC_T(pool, pj_stun_ip_addr_attr); 
     558    attr = PJ_POOL_ZALLOC_T(pool, pj_stun_sockaddr_attr); 
    556559    INIT_ATTR(attr, attr_type, STUN_GENERIC_IP_ADDR_LEN); 
    557560 
    558     if (!xor_ed) { 
    559         pj_memcpy(&attr->addr, addr, addr_len); 
    560     } else if (addr_len == sizeof(pj_sockaddr_in)) { 
    561         const pj_sockaddr_in *addr4 = (const pj_sockaddr_in*) addr; 
    562  
    563         pj_sockaddr_in_init(&attr->addr.ipv4, NULL, 0); 
    564         attr->addr.ipv4.sin_port = (pj_uint16_t)(addr4->sin_port ^ 0x2112); 
    565         attr->addr.ipv4.sin_addr.s_addr = (addr4->sin_addr.s_addr ^  
    566                                            pj_htonl(0x2112A442)); 
    567     } else if (addr_len == sizeof(pj_sockaddr_in6)) { 
    568         return PJLIB_UTIL_ESTUNIPV6NOTSUPP; 
    569     } else { 
    570         return PJLIB_UTIL_ESTUNINADDRLEN; 
    571     } 
     561    pj_memcpy(&attr->addr, addr, addr_len); 
     562    attr->xor_ed = xor_ed; 
    572563 
    573564    *p_attr = attr; 
    … …  
    581572 */ 
    582573PJ_DEF(pj_status_t)  
    583 pj_stun_msg_add_ip_addr_attr(pj_pool_t *pool, 
    584                              pj_stun_msg *msg, 
    585                              int attr_type,  
    586                              pj_bool_t xor_ed, 
    587                              const pj_sockaddr_t *addr, 
    588                              unsigned addr_len) 
    589 { 
    590     pj_stun_ip_addr_attr *attr; 
     574pj_stun_msg_add_sockaddr_attr(pj_pool_t *pool, 
     575                              pj_stun_msg *msg, 
     576                              int attr_type,  
     577                              pj_bool_t xor_ed, 
     578                              const pj_sockaddr_t *addr, 
     579                              unsigned addr_len) 
     580{ 
     581    pj_stun_sockaddr_attr *attr; 
    591582    pj_status_t status; 
    592583 
    593     status = pj_stun_ip_addr_attr_create(pool, attr_type, xor_ed, 
     584    status = pj_stun_sockaddr_attr_create(pool, attr_type, xor_ed, 
    594585                                                 addr, addr_len, &attr); 
    595586    if (status != PJ_SUCCESS) 
    … …  
    599590} 
    600591 
    601 static pj_status_t decode_ip_addr_attr(pj_pool_t *pool,  
    602                                        const pj_uint8_t *buf,  
    603                                        void **p_attr) 
    604 { 
    605     pj_stun_ip_addr_attr *attr; 
     592static pj_status_t decode_sockaddr_attr(pj_pool_t *pool,  
     593                                        const pj_uint8_t *buf,  
     594                                        void **p_attr) 
     595{ 
     596    pj_stun_sockaddr_attr *attr; 
    606597    pj_uint32_t val; 
    607598 
    608599    /* Create the attribute */ 
    609     attr = PJ_POOL_ZALLOC_T(pool, pj_stun_ip_addr_attr); 
     600    attr = PJ_POOL_ZALLOC_T(pool, pj_stun_sockaddr_attr); 
    610601    pj_memcpy(attr, buf, ATTR_HDR_LEN); 
    611602 
    … …  
    627618    /* Get port and address */ 
    628619    pj_sockaddr_in_init(&attr->addr.ipv4, NULL, 0); 
    629     attr->addr.ipv4.sin_port = getval16(buf, ATTR_HDR_LEN + 2); 
     620    pj_memcpy(&attr->addr.ipv4.sin_port, buf+ATTR_HDR_LEN+2, 2); 
    630621    pj_memcpy(&attr->addr.ipv4.sin_addr, buf+ATTR_HDR_LEN+4, 4); 
    631622 
    … …  
    637628 
    638629 
    639 static pj_status_t encode_ip_addr_attr(const void *a, pj_uint8_t *buf,  
    640                                        unsigned len, unsigned *printed) 
     630static pj_status_t decode_xored_sockaddr_attr(pj_pool_t *pool,  
     631                                              const pj_uint8_t *buf,  
     632                                              void **p_attr) 
     633{ 
     634    pj_stun_sockaddr_attr *attr; 
     635    pj_uint32_t val; 
     636 
     637    /* Create the attribute */ 
     638    attr = PJ_POOL_ZALLOC_T(pool, pj_stun_sockaddr_attr); 
     639    pj_memcpy(attr, buf, ATTR_HDR_LEN); 
     640 
     641    /* Convert to host byte order */ 
     642    attr->hdr.type = pj_ntohs(attr->hdr.type); 
     643    attr->hdr.length = pj_ntohs(attr->hdr.length); 
     644 
     645    /* Check that the attribute length is valid */ 
     646    if (attr->hdr.length != STUN_GENERIC_IP_ADDR_LEN) 
     647        return PJLIB_UTIL_ESTUNINATTRLEN; 
     648 
     649    /* Check address family */ 
     650    val = *(pj_uint8_t*)(buf + ATTR_HDR_LEN + 1); 
     651 
     652    /* Check address family is valid (only supports ipv4 for now) */ 
     653    if (val != 1) 
     654        return PJLIB_UTIL_ESTUNIPV6NOTSUPP; 
     655 
     656    /* Get port and address */ 
     657    pj_sockaddr_in_init(&attr->addr.ipv4, NULL, 0); 
     658    pj_memcpy(&attr->addr.ipv4.sin_port, buf+ATTR_HDR_LEN+2, 2); 
     659    pj_memcpy(&attr->addr.ipv4.sin_addr, buf+ATTR_HDR_LEN+4, 4); 
     660 
     661    attr->addr.ipv4.sin_port ^= 0x2112; 
     662    attr->addr.ipv4.sin_addr.s_addr ^= pj_htonl(0x2112A442); 
     663 
     664    /* Done */ 
     665    *p_attr = attr; 
     666 
     667    return PJ_SUCCESS; 
     668} 
     669 
     670 
     671static pj_status_t encode_sockaddr_attr(const void *a, pj_uint8_t *buf,  
     672                                        unsigned len, unsigned *printed) 
    641673{ 
    642674    enum { 
    … …  
    644676    }; 
    645677    pj_uint8_t *start_buf = buf; 
    646     const pj_stun_ip_addr_attr *ca =  
    647         (const pj_stun_ip_addr_attr *)a; 
    648     pj_stun_ip_addr_attr *attr; 
     678    const pj_stun_sockaddr_attr *ca =  
     679        (const pj_stun_sockaddr_attr *)a; 
     680    pj_stun_sockaddr_attr *attr; 
    649681 
    650682    if (len < ATTR_LEN)  
    … …  
    653685    /* Copy and convert headers to network byte order */ 
    654686    pj_memcpy(buf, a, ATTR_HDR_LEN); 
    655     attr = (pj_stun_ip_addr_attr*) buf; 
     687    attr = (pj_stun_sockaddr_attr*) buf; 
    656688    attr->hdr.type = pj_htons(attr->hdr.type); 
    657689    attr->hdr.length = pj_htons((pj_uint16_t)STUN_GENERIC_IP_ADDR_LEN); 
    … …  
    665697    *buf++ = 1; 
    666698 
    667     /* Port */ 
    668     pj_memcpy(buf, &ca->addr.ipv4.sin_port, 2); 
    669     buf += 2; 
    670  
    671     /* Address */ 
    672     pj_memcpy(buf, &ca->addr.ipv4.sin_addr, 4); 
    673     buf += 4; 
     699    if (ca->xor_ed) { 
     700        pj_uint32_t addr; 
     701        pj_uint16_t port; 
     702 
     703        addr = ca->addr.ipv4.sin_addr.s_addr; 
     704        port = ca->addr.ipv4.sin_port; 
     705 
     706        port ^= 0x2112; 
     707        addr ^= pj_htonl(0x2112A442); 
     708 
     709        /* Port */ 
     710        pj_memcpy(buf, &port, 2); 
     711        buf += 2; 
     712 
     713        /* Address */ 
     714        pj_memcpy(buf, &addr, 4); 
     715        buf += 4; 
     716 
     717    } else { 
     718        /* Port */ 
     719        pj_memcpy(buf, &ca->addr.ipv4.sin_port, 2); 
     720        buf += 2; 
     721 
     722        /* Address */ 
     723        pj_memcpy(buf, &ca->addr.ipv4.sin_addr, 4); 
     724        buf += 4; 
     725    } 
    674726 
    675727    pj_assert(buf - start_buf == ATTR_LEN); 
Note: See TracChangeset for help on using the changeset viewer.