Changeset 1054


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

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

Location:
pjproject/trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjlib-util/include/pjlib-util/stun_msg.h

    r1053 r1054  
    270270     * STUN/TURN Send Indication 
    271271     */ 
    272     PJ_STUN_SEND_INDICATION                 = 0x0004, 
     272    PJ_STUN_SEND_INDICATION                 = 0x0014, 
    273273 
    274274    /** 
    275275     * STUN/TURN Data Indication 
    276276     */ 
    277     PJ_STUN_DATA_INDICATION                 = 0x0115, 
     277    PJ_STUN_DATA_INDICATION                 = 0x0015, 
    278278 
    279279    /** 
     
    310310     * STUN/TURN Connect Status Indication 
    311311     */ 
    312     PJ_STUN_CONNECT_STATUS_INDICATION       = 0x0118 
     312    PJ_STUN_CONNECT_STATUS_INDICATION       = 0x0018 
    313313 
    314314 
     
    516516   \endverbatim 
    517517 */ 
    518 typedef struct pj_stun_ip_addr_attr 
     518typedef struct pj_stun_sockaddr_attr 
    519519{ 
    520520    /** 
     
    522522     */ 
    523523    pj_stun_attr_hdr    hdr; 
     524 
     525    /** 
     526     * Flag to indicate whether this attribute should be sent in XOR-ed 
     527     * format, or has been received in XOR-ed format. 
     528     */ 
     529    pj_bool_t           xor_ed; 
    524530 
    525531    /** 
     
    532538    } addr; 
    533539 
    534 } pj_stun_ip_addr_attr; 
     540} pj_stun_sockaddr_attr; 
    535541 
    536542 
     
    745751 * The MAPPED-ADDRESS attribute indicates the mapped transport address. 
    746752 */ 
    747 typedef struct pj_stun_ip_addr_attr pj_stun_mapped_addr_attr; 
     753typedef struct pj_stun_sockaddr_attr pj_stun_mapped_addr_attr; 
    748754 
    749755 
     
    757763 * through NATs which would otherwise interfere with STUN. 
    758764 */ 
    759 typedef struct pj_stun_ip_addr_attr pj_stun_xor_mapped_addr_attr; 
     765typedef struct pj_stun_sockaddr_attr pj_stun_xor_mapped_addr_attr; 
    760766 
    761767 
     
    777783 * MAPPED-ADDRESS. 
    778784 */ 
    779 typedef struct pj_stun_ip_addr_attr pj_stun_alt_server_attr; 
     785typedef struct pj_stun_sockaddr_attr pj_stun_alt_server_attr; 
    780786 
    781787 
     
    798804 * RFC 3489-bis standard. 
    799805 */ 
    800 typedef struct pj_stun_ip_addr_attr pj_stun_response_addr_attr; 
     806typedef struct pj_stun_sockaddr_attr pj_stun_response_addr_attr; 
    801807 
    802808 
     
    813819 * RFC 3489-bis standard. 
    814820 */ 
    815 typedef struct pj_stun_ip_addr_attr pj_stun_changed_addr_attr; 
     821typedef struct pj_stun_sockaddr_attr pj_stun_changed_addr_attr; 
    816822 
    817823 
     
    845851 * RFC 3489-bis standard. 
    846852 */ 
    847 typedef struct pj_stun_ip_addr_attr pj_stun_src_addr_attr; 
     853typedef struct pj_stun_sockaddr_attr pj_stun_src_addr_attr; 
    848854 
    849855 
     
    857863 * denial-of-service attacks. 
    858864 */ 
    859 typedef struct pj_stun_ip_addr_attr pj_stun_reflected_from_attr; 
     865typedef struct pj_stun_sockaddr_attr pj_stun_reflected_from_attr; 
    860866 
    861867 
     
    902908 * from the STUN relay server. 
    903909 */ 
    904 typedef struct pj_stun_ip_addr_attr pj_stun_remote_addr_attr; 
     910typedef struct pj_stun_sockaddr_attr pj_stun_remote_addr_attr; 
    905911 
    906912 
     
    920926 * address and port that the server allocated to the client. 
    921927 */ 
    922 typedef struct pj_stun_ip_addr_attr pj_stun_relay_addr_attr; 
     928typedef struct pj_stun_sockaddr_attr pj_stun_relay_addr_attr; 
    923929 
    924930 
     
    976982 * specific IP address be allocated to it. 
    977983 */ 
    978 typedef struct pj_stun_ip_addr_attr pj_stun_req_ip_attr; 
     984typedef struct pj_stun_sockaddr_attr pj_stun_req_ip_attr; 
    979985 
    980986/** 
     
    988994 * to XOR-MAPPED-ADDRESS. 
    989995 */ 
    990 typedef struct pj_stun_ip_addr_attr pj_stun_xor_reflected_from_attr; 
     996typedef struct pj_stun_sockaddr_attr pj_stun_xor_reflected_from_attr; 
    991997 
    992998/** 
     
    10161022 * the STUN-aware NATs along the path. 
    10171023 */ 
    1018 typedef pj_stun_ip_addr_attr pj_stun_xor_internal_addr_attr; 
     1024typedef pj_stun_sockaddr_attr pj_stun_xor_internal_addr_attr; 
    10191025 
    10201026/** 
     
    13051311 * @return              PJ_SUCCESS on success or the appropriate error code. 
    13061312 */ 
    1307 PJ_DECL(pj_status_t) pj_stun_ip_addr_attr_create(pj_pool_t *pool, 
     1313PJ_DECL(pj_status_t) pj_stun_sockaddr_attr_create(pj_pool_t *pool, 
    13081314                                                int attr_type,  
    13091315                                                pj_bool_t xor_ed, 
    13101316                                                const pj_sockaddr_t *addr, 
    13111317                                                unsigned addr_len, 
    1312                                                 pj_stun_ip_addr_attr **p_attr); 
     1318                                                pj_stun_sockaddr_attr **p_attr); 
    13131319 
    13141320 
     
    13281334 * @return              PJ_SUCCESS on success or the appropriate error code. 
    13291335 */ 
    1330 PJ_DECL(pj_status_t) pj_stun_msg_add_ip_addr_attr(pj_pool_t *pool, 
     1336PJ_DECL(pj_status_t) pj_stun_msg_add_sockaddr_attr(pj_pool_t *pool, 
    13311337                                                  pj_stun_msg *msg, 
    13321338                                                  int attr_type,  
  • 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); 
  • pjproject/trunk/pjlib-util/src/pjlib-util/stun_msg_dump.c

    r1052 r1054  
    7777    case PJ_STUN_ATTR_ALTERNATE_SERVER: 
    7878        { 
    79             const pj_stun_ip_addr_attr *attr; 
    80  
    81             attr = (const pj_stun_ip_addr_attr*)ahdr; 
     79            const pj_stun_sockaddr_attr *attr; 
     80 
     81            attr = (const pj_stun_sockaddr_attr*)ahdr; 
    8282 
    8383            if (attr->addr.addr.sa_family == PJ_AF_INET) { 
  • pjproject/trunk/pjlib-util/src/pjstun-client/client_main.c

    r1053 r1054  
    2222 
    2323#define THIS_FILE       "client_main.c" 
     24#define LOCAL_PORT      1998 
    2425#define BANDWIDTH       64                  /* -1 to disable */ 
    25 #define LIFETIME        30                  /* -1 to disable */ 
     26#define LIFETIME        600                 /* -1 to disable */ 
    2627#define REQ_TRANSPORT   -1                  /* 0: udp, 1: tcp, -1: disable */ 
    2728#define REQ_PORT_PROPS  -1                  /* -1 to disable */ 
     
    4041    pj_bool_t            quit; 
    4142    pj_sockaddr_in       peer_addr; 
    42     pj_sockaddr_in       srv_addr;  /**< server addr */ 
    43  
     43    pj_sockaddr_in       srv_addr; 
     44    pj_sockaddr_in       relay_addr; 
     45    char                 data_buf[256]; 
     46    char                *data; 
    4447} g; 
    4548 
     
    5255    char    *password; 
    5356    char    *nonce; 
     57    char    *peer_addr; 
    5458    pj_bool_t use_fingerprint; 
    5559} o; 
     60 
     61 
     62static pj_status_t parse_addr(const char *input, pj_sockaddr_in *addr); 
    5663 
    5764 
     
    8895{ 
    8996    if (status == PJ_SUCCESS) { 
    90         puts("Client transaction completes"); 
     97        switch (response->hdr.type) { 
     98        case PJ_STUN_ALLOCATE_RESPONSE: 
     99            { 
     100                pj_stun_relay_addr_attr *ar; 
     101 
     102                ar = (pj_stun_relay_addr_attr*) 
     103                     pj_stun_msg_find_attr(response,  
     104                                           PJ_STUN_ATTR_RELAY_ADDR, 0); 
     105                if (ar) { 
     106                    pj_memcpy(&g.relay_addr, &ar->addr.ipv4, 
     107                              sizeof(pj_sockaddr_in)); 
     108                    PJ_LOG(3,(THIS_FILE, "Relay address is %s:%d", 
     109                              pj_inet_ntoa(g.relay_addr.sin_addr), 
     110                              (int)pj_ntohs(g.relay_addr.sin_port))); 
     111                } else { 
     112                    pj_memset(&g.relay_addr, 0, sizeof(g.relay_addr)); 
     113                } 
     114            } 
     115            break; 
     116        } 
    91117    } else { 
    92118        my_perror("Client transaction error", status); 
     
    120146                addrlen = sizeof(addr); 
    121147                rc = pj_sock_recvfrom(g.sock, buffer, &len, 0, &addr, &addrlen); 
    122                 if (rc == PJ_SUCCESS && len > 0) { 
     148                if (rc != PJ_SUCCESS || len <= 0) 
     149                    continue; 
     150 
     151                if (pj_stun_msg_check(buffer, len, PJ_STUN_IS_DATAGRAM)==PJ_SUCCESS) { 
    123152                    rc = pj_stun_session_on_rx_pkt(g.sess, buffer, len,  
    124                                                    PJ_STUN_IS_DATAGRAM|PJ_STUN_CHECK_PACKET,  
     153                                                   0,  
    125154                                                   NULL, &addr, addrlen); 
    126155                    if (rc != PJ_SUCCESS) 
    127156                        my_perror("Error processing packet", rc); 
     157 
     158                } else { 
     159                    buffer[len] = '\0'; 
     160                    PJ_LOG(3,(THIS_FILE, "Received data: %s", (char*)buffer)); 
    128161                } 
    129162            } 
     
    139172    pj_sockaddr_in addr; 
    140173    pj_stun_session_cb stun_cb; 
     174    int len; 
    141175    pj_status_t status; 
    142176 
     
    182216    status = pj_sockaddr_in_init(&addr, NULL, 0); 
    183217    pj_assert(status == PJ_SUCCESS); 
     218 
     219    addr.sin_port = pj_htons((pj_uint16_t)LOCAL_PORT); 
     220    status = pj_sock_bind(g.sock, &addr, sizeof(addr)); 
     221    pj_assert(status == PJ_SUCCESS); 
     222 
     223    len = sizeof(addr); 
     224    status = pj_sock_getsockname(g.sock, &addr, &len); 
     225    pj_assert(status == PJ_SUCCESS); 
     226 
     227    PJ_LOG(3,(THIS_FILE, "Listening on port %d", (int)pj_ntohs(addr.sin_port))); 
     228 
     229    pj_memcpy(&g.peer_addr, &addr, sizeof(pj_sockaddr_in)); 
     230    if (g.peer_addr.sin_addr.s_addr == 0) 
     231        pj_gethostip(&g.peer_addr.sin_addr); 
    184232 
    185233    pj_memset(&stun_cb, 0, sizeof(stun_cb)); 
     
    207255    } else { 
    208256        puts("Credential not set"); 
     257    } 
     258 
     259    if (o.peer_addr) { 
     260        if (parse_addr(o.peer_addr, &g.peer_addr)!=PJ_SUCCESS) 
     261            return -1; 
    209262    } 
    210263 
     
    297350 
    298351            pj_sockaddr_in_init(&addr, pj_cstr(&tmp, REQ_IP), 0); 
    299             pj_stun_msg_add_ip_addr_attr(tdata->pool, tdata->msg, 
     352            pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg, 
    300353                                         PJ_STUN_ATTR_REQ_IP, PJ_FALSE, 
    301354                                         &addr, sizeof(addr)); 
     
    321374    } 
    322375 
    323     rc = pj_stun_session_create_req(g.sess, PJ_STUN_ALLOCATE_REQUEST, &tdata); 
     376    rc = pj_stun_session_create_req(g.sess, PJ_STUN_SET_ACTIVE_DESTINATION_REQUEST, &tdata); 
    324377    pj_assert(rc == PJ_SUCCESS); 
    325378 
    326379    if (set) { 
    327         pj_stun_msg_add_ip_addr_attr(tdata->pool, tdata->msg, 
     380        pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg, 
    328381                                     PJ_STUN_ATTR_REMOTE_ADDR, PJ_FALSE, 
    329382                                     &g.peer_addr, sizeof(g.peer_addr)); 
     
    338391static void send_send_ind(void) 
    339392{ 
    340 } 
    341  
    342 static void send_raw_data(void) 
    343 { 
     393    pj_stun_tx_data *tdata; 
     394    int len; 
     395    pj_status_t rc; 
     396 
     397    if (g.peer_addr.sin_addr.s_addr == 0 || 
     398        g.peer_addr.sin_port == 0) 
     399    { 
     400        puts("Error: peer address is not set"); 
     401        return; 
     402    } 
     403 
     404    len = strlen(g.data); 
     405    if (len==0) { 
     406        puts("Error: data is not set"); 
     407        return; 
     408    } 
     409 
     410    rc = pj_stun_session_create_ind(g.sess, PJ_STUN_SEND_INDICATION, &tdata); 
     411    pj_assert(rc == PJ_SUCCESS); 
     412 
     413    pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg, 
     414                                  PJ_STUN_ATTR_REMOTE_ADDR, PJ_FALSE, 
     415                                  &g.peer_addr, sizeof(g.peer_addr)); 
     416    pj_stun_msg_add_binary_attr(tdata->pool, tdata->msg, 
     417                                PJ_STUN_ATTR_DATA, g.data, len); 
     418 
     419    rc = pj_stun_session_send_msg(g.sess, PJ_FALSE,  
     420                                  &g.srv_addr, sizeof(g.srv_addr), 
     421                                  tdata); 
     422    pj_assert(rc == PJ_SUCCESS); 
     423 
     424} 
     425 
     426static void send_raw_data_to_srv(void) 
     427{ 
     428    pj_ssize_t len; 
     429 
     430    if (g.srv_addr.sin_addr.s_addr == 0 || 
     431        g.srv_addr.sin_port == 0) 
     432    { 
     433        puts("Error: server address is not set"); 
     434        return; 
     435    } 
     436 
     437    len = strlen(g.data); 
     438    if (len==0) { 
     439        puts("Error: data is not set"); 
     440        return; 
     441    } 
     442 
     443    len = strlen(g.data); 
     444    pj_sock_sendto(g.sock, g.data, &len, 0, &g.srv_addr, sizeof(g.srv_addr)); 
     445} 
     446 
     447static void send_raw_data_to_relay(void) 
     448{ 
     449    pj_ssize_t len; 
     450 
     451    if (g.relay_addr.sin_addr.s_addr == 0 || 
     452        g.relay_addr.sin_port == 0) 
     453    { 
     454        puts("Error: relay address is not set"); 
     455        return; 
     456    } 
     457 
     458    len = strlen(g.data); 
     459    if (len==0) { 
     460        puts("Error: data is not set"); 
     461        return; 
     462    } 
     463 
     464    len = strlen(g.data); 
     465    pj_sock_sendto(g.sock, g.data, &len, 0, &g.relay_addr, sizeof(g.relay_addr)); 
     466} 
     467 
     468static pj_status_t parse_addr(const char *input, 
     469                              pj_sockaddr_in *addr) 
     470{ 
     471    const char *pos; 
     472    pj_str_t ip; 
     473    pj_uint16_t port; 
     474    pj_sockaddr_in tmp_addr; 
     475 
     476    pos = pj_ansi_strchr(input, ':'); 
     477    if (pos==NULL) { 
     478        puts("Invalid format"); 
     479        return -1; 
     480    } 
     481 
     482    ip.ptr = (char*)input; 
     483    ip.slen = pos - input; 
     484    port = (pj_uint16_t)atoi(pos+1); 
     485 
     486    if (port==0) { 
     487        puts("Invalid port"); 
     488        return -1; 
     489    } 
     490 
     491    if (pj_sockaddr_in_init(&tmp_addr, &ip, port)!=PJ_SUCCESS) { 
     492        puts("Invalid address"); 
     493        return -1; 
     494    } 
     495 
     496    pj_memcpy(addr, &tmp_addr, sizeof(tmp_addr)); 
     497 
     498    return PJ_SUCCESS; 
    344499} 
    345500 
    346501static void set_peer_addr(void) 
    347502{ 
    348     char ip_addr[64]; 
    349     pj_str_t tmp; 
    350     pj_sockaddr_in addr; 
    351     int port; 
     503    char addr[64]; 
    352504 
    353505    printf("Current peer address: %s:%d\n",  
     
    357509    printf("Input peer address in IP:PORT format: "); 
    358510    fflush(stdout); 
    359  
    360     if (scanf("%s:%d", ip_addr, &port) != 2) { 
    361         puts("Error."); 
    362         return; 
    363     } 
    364  
    365     if (pj_sockaddr_in_init(&addr, pj_cstr(&tmp,ip_addr), (pj_uint16_t)port) != PJ_SUCCESS) { 
    366         puts("Error: invalid address"); 
    367         return; 
    368     } 
    369  
    370     g.peer_addr = addr; 
     511    gets(addr); 
     512 
     513    if (parse_addr(addr, &g.peer_addr) != PJ_SUCCESS) { 
     514        return; 
     515    } 
     516 
    371517} 
    372518 
     
    376522    printf("  pr      Set peer address (currently %s:%d)\n", 
    377523           pj_inet_ntoa(g.peer_addr.sin_addr), pj_ntohs(g.peer_addr.sin_port)); 
    378     puts(""); 
     524    printf("  dt      Set data (currently \"%s\")\n", g.data); 
    379525    puts("  br      Send Bind request"); 
    380526    puts("  ar      Send Allocate request"); 
    381527    puts("  dr      Send de-Allocate request"); 
    382     puts("  sr      Send Set Active Indication request"); 
    383     puts("  cr      Send clear Active Indication request"); 
     528    puts("  sr      Send Set Active Destination request"); 
     529    puts("  cr      Send clear Active Destination request"); 
    384530    puts("  si      Send data with Send Indication"); 
    385     puts("  rw      Send raw data"); 
     531    puts("  rw      Send raw data to TURN server"); 
     532    puts("  rW      Send raw data to relay address"); 
    386533    puts("  q       Quit"); 
    387534    puts(""); 
     
    399546        fgets(input, sizeof(input), stdin); 
    400547         
    401         if (input[0]=='b' && input[1]=='r') { 
     548        if (0) { 
     549 
     550        } else if (input[0]=='d' && input[1]=='t') { 
     551            printf("Input data: "); 
     552            gets(g.data); 
     553             
     554        } else if (input[0]=='p' && input[1]=='r') { 
     555            set_peer_addr(); 
     556             
     557        } else if (input[0]=='b' && input[1]=='r') { 
    402558            send_bind_request(); 
    403559             
     
    418574             
    419575        } else if (input[0]=='r' && input[1]=='w') { 
    420             send_raw_data(); 
    421              
    422         } else if (input[0]=='p' && input[1]=='r') { 
    423             set_peer_addr(); 
     576            send_raw_data_to_srv(); 
     577             
     578        } else if (input[0]=='r' && input[1]=='W') { 
     579            send_raw_data_to_relay(); 
    424580             
    425581        } else if (input[0]=='q') { 
     
    442598    puts(" --nonce, -N       Set NONCE");    
    443599    puts(" --fingerprint, -F Use fingerprint for outgoing requests"); 
     600    puts(" --peer, -P        Set peer address (address is in HOST:PORT format)"); 
     601    puts(" --data, -D        Set data"); 
    444602    puts(" --help, -h"); 
    445603} 
     
    453611        { "nonce",      1, 0, 'N'}, 
    454612        { "fingerprint",0, 0, 'F'}, 
     613        { "peer",       1, 0, 'P'}, 
     614        { "data",       1, 0, 'D'}, 
    455615        { "help",       0, 0, 'h'} 
    456616    }; 
     
    459619    pj_status_t status; 
    460620 
     621    g.data = g.data_buf; 
     622 
    461623    while((c=pj_getopt_long(argc,argv, "r:u:p:hF", long_options, &opt_id))!=-1) { 
    462624        switch (c) { 
     
    479641            o.use_fingerprint = PJ_TRUE; 
    480642            break; 
     643        case 'P': 
     644            o.peer_addr = pj_optarg; 
     645            break; 
     646        case 'D': 
     647            g.data = pj_optarg; 
     648            break; 
     649 
    481650        default: 
    482651            printf("Argument \"%s\" is not valid. Use -h to see help", 
  • pjproject/trunk/pjlib-util/src/pjstun-srv-test/bind_usage.c

    r1049 r1054  
    163163 
    164164    /* Create MAPPED-ADDRESS attribute */ 
    165     status = pj_stun_msg_add_ip_addr_attr(tdata->pool, tdata->msg, 
    166                                           PJ_STUN_ATTR_MAPPED_ADDR, 
    167                                           PJ_FALSE, 
    168                                           src_addr, src_addr_len); 
     165    status = pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg, 
     166                                           PJ_STUN_ATTR_MAPPED_ADDR, 
     167                                           PJ_FALSE, 
     168                                           src_addr, src_addr_len); 
    169169    if (status != PJ_SUCCESS) { 
    170170        pj_stun_perror(THIS_FILE, "Error creating response", status); 
     
    176176    if (msg->hdr.magic == PJ_STUN_MAGIC) { 
    177177        status =  
    178             pj_stun_msg_add_ip_addr_attr(tdata->pool, tdata->msg, 
    179                                          PJ_STUN_ATTR_XOR_MAPPED_ADDR, 
    180                                          PJ_TRUE, 
    181                                          src_addr, src_addr_len); 
     178            pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg, 
     179                                          PJ_STUN_ATTR_XOR_MAPPED_ADDR, 
     180                                          PJ_TRUE, 
     181                                          src_addr, src_addr_len); 
    182182        if (status != PJ_SUCCESS) { 
    183183            pj_stun_perror(THIS_FILE, "Error creating response", status); 
  • pjproject/trunk/pjlib-util/src/pjstun-srv-test/main.c

    r1049 r1054  
    123123    } 
    124124 
     125    /* 
    125126    status = pj_stun_bind_usage_create(srv, NULL, 3478, NULL); 
     127    if (status != PJ_SUCCESS) { 
     128        pj_stun_perror(THIS_FILE, "Unable to create bind usage", status); 
     129        return 1; 
     130    } 
     131    */ 
     132 
     133    status = pj_stun_turn_usage_create(srv, PJ_SOCK_DGRAM, NULL, 
     134                                       3478, NULL); 
    126135    if (status != PJ_SUCCESS) { 
    127136        pj_stun_perror(THIS_FILE, "Unable to create bind usage", status); 
  • pjproject/trunk/pjlib-util/src/pjstun-srv-test/server.h

    r1049 r1054  
    113113                                          unsigned addr_len); 
    114114 
    115 PJ_DEF(pj_status_t) pj_stun_bind_usage_create(pj_stun_server *srv, 
    116                                               const pj_str_t *ip_addr, 
    117                                               unsigned port, 
    118                                               pj_stun_usage **p_bu); 
     115PJ_DECL(pj_status_t) pj_stun_bind_usage_create(pj_stun_server *srv, 
     116                                               const pj_str_t *ip_addr, 
     117                                               unsigned port, 
     118                                               pj_stun_usage **p_bu); 
    119119 
     120PJ_DECL(pj_status_t) pj_stun_turn_usage_create(pj_stun_server *srv, 
     121                                               int type, 
     122                                               const pj_str_t *ip_addr, 
     123                                               unsigned port, 
     124                                               pj_stun_usage **p_bu); 
    120125 
    121126 
  • pjproject/trunk/pjlib-util/src/pjstun-srv-test/turn_usage.c

    r1053 r1054  
    5050                                         unsigned src_addr_len); 
    5151 
     52static pj_status_t handle_binding_req(pj_stun_session *session, 
     53                                      const pj_stun_msg *msg, 
     54                                      const pj_sockaddr_t *src_addr, 
     55                                      unsigned src_addr_len); 
     56 
    5257static pj_status_t client_create(struct turn_usage *tu, 
    5358                                 const pj_sockaddr_t *src_addr, 
     
    9196    pj_mutex_t          *mutex; 
    9297 
     98    pj_sockaddr_in       client_src_addr; 
     99 
    93100    /* Socket and socket address of the allocated port */ 
    94101    int                  sock_type; 
    95102    pj_sock_t            sock; 
    96103    pj_ioqueue_key_t    *key; 
    97     pj_sockaddr_in       client_addr; 
     104    pj_sockaddr_in       alloc_addr; 
    98105 
    99106    /* Allocation properties */ 
     
    150157    pj_status_t status; 
    151158 
    152     PJ_ASSERT_RETURN(srv && (type==PJ_SOCK_DGRAM||type==PJ_SOCK_STREAM) && 
    153                      p_bu, PJ_EINVAL); 
     159    PJ_ASSERT_RETURN(srv && (type==PJ_SOCK_DGRAM||type==PJ_SOCK_STREAM), 
     160                     PJ_EINVAL); 
    154161    si = pj_stun_server_get_info(srv); 
    155162 
     
    160167    tu->pf = si->pf; 
    161168    tu->endpt = si->endpt; 
     169    tu->ioqueue = si->ioqueue; 
    162170    tu->timer_heap = si->timer_heap; 
    163171    tu->next_port = START_PORT; 
     172    tu->max_bw_kbps = 64; 
     173    tu->max_lifetime = 10 * 60; 
    164174 
    165175    status = pj_sockaddr_in_init(&local_addr, ip_addr, (pj_uint16_t)port); 
     
    206216    } 
    207217 
    208     *p_bu = tu->usage; 
     218    if (p_bu) { 
     219        *p_bu = tu->usage; 
     220    } 
    209221 
    210222    return PJ_SUCCESS; 
     
    224236 
    225237    /* Destroy all clients */ 
    226     it = pj_hash_first(tu->client_htable, &hit); 
    227     while (it) { 
    228         struct turn_client *client; 
    229  
    230         client = (struct turn_client *)pj_hash_this(tu->client_htable, it); 
    231         client_destroy(client, PJ_SUCCESS); 
    232  
    233         it = pj_hash_next(tu->client_htable, it); 
     238    if (tu->client_htable) { 
     239        it = pj_hash_first(tu->client_htable, &hit); 
     240        while (it) { 
     241            struct turn_client *client; 
     242 
     243            client = (struct turn_client *)pj_hash_this(tu->client_htable, it); 
     244            client_destroy(client, PJ_SUCCESS); 
     245 
     246            it = pj_hash_first(tu->client_htable, &hit); 
     247        } 
    234248    } 
    235249 
     
    392406        } 
    393407 
     408        *p_sock = sock; 
    394409        return PJ_SUCCESS; 
    395410    } 
     
    420435    pj_assert(sd->client == NULL); 
    421436 
    422     if (msg->hdr.type != PJ_STUN_ALLOCATE_REQUEST) { 
     437    if (msg->hdr.type == PJ_STUN_BINDING_REQUEST) { 
     438        return handle_binding_req(sess, msg, src_addr, src_addr_len); 
     439 
     440    } else if (msg->hdr.type != PJ_STUN_ALLOCATE_REQUEST) { 
    423441        if (PJ_STUN_IS_REQUEST(msg->hdr.type)) { 
    424442            status = pj_stun_session_create_response(sess, msg,  
     
    506524static const char *get_tp_type(int type) 
    507525{ 
    508     if (type==0) 
     526    if (type==PJ_SOCK_DGRAM) 
    509527        return "udp"; 
    510     else if (type==1) 
     528    else if (type==PJ_SOCK_STREAM) 
    511529        return "tcp"; 
    512530    else 
     
    520538 * the packet is handed over to the client. 
    521539 */ 
    522 static pj_status_t client_sess_on_rx_request(pj_stun_session *sess, 
    523                                              const pj_uint8_t *pkt, 
    524                                              unsigned pkt_len, 
    525                                              const pj_stun_msg *msg, 
    526                                              const pj_sockaddr_t *src_addr, 
    527                                              unsigned src_addr_len) 
     540static pj_status_t client_sess_on_rx_msg(pj_stun_session *sess, 
     541                                         const pj_uint8_t *pkt, 
     542                                         unsigned pkt_len, 
     543                                         const pj_stun_msg *msg, 
     544                                         const pj_sockaddr_t *src_addr, 
     545                                         unsigned src_addr_len) 
    528546{ 
    529547    struct session_data *sd; 
     
    577595    pj_status_t status; 
    578596 
     597    PJ_ASSERT_RETURN(src_addr_len==sizeof(pj_sockaddr_in), PJ_EINVAL); 
     598 
    579599    pool = pj_pool_create(tu->pf, "turnc%p", 4000, 4000, NULL); 
    580600    client = PJ_POOL_ZALLOC_T(pool, struct turn_client); 
     
    582602    client->tu = tu; 
    583603    client->sock = PJ_INVALID_SOCKET; 
     604 
     605    pj_memcpy(&client->client_src_addr, src_addr, 
     606              sizeof(client->client_src_addr)); 
    584607 
    585608    if (src_addr) { 
     
    596619    pj_bzero(&sess_cb, sizeof(sess_cb)); 
    597620    sess_cb.on_send_msg = &client_sess_on_send_msg; 
    598     sess_cb.on_rx_request = &client_sess_on_rx_request; 
     621    sess_cb.on_rx_request = &client_sess_on_rx_msg; 
     622    sess_cb.on_rx_indication = &client_sess_on_rx_msg; 
    599623    status = pj_stun_session_create(tu->endpt, client->obj_name,  
    600624                                    &sess_cb, PJ_FALSE, 
     
    668692    pj_mutex_lock(tu->mutex); 
    669693    pj_hash_set(NULL, tu->client_htable,  
    670                 &client->client_addr, sizeof(client->client_addr), 0, NULL); 
     694                &client->client_src_addr, sizeof(client->client_src_addr),  
     695                0, NULL); 
    671696    pj_mutex_unlock(tu->mutex); 
    672697 
     
    710735    /* Update address */ 
    711736    addrlen = sizeof(pj_sockaddr_in); 
    712     status = pj_sock_getsockname(client->sock, &client->client_addr,  
     737    status = pj_sock_getsockname(client->sock, &client->alloc_addr,  
    713738                                 &addrlen); 
    714739    if (status != PJ_SUCCESS) { 
     
    716741        client->sock = PJ_INVALID_SOCKET; 
    717742        return status; 
     743    } 
     744 
     745    if (client->alloc_addr.sin_addr.s_addr == 0) { 
     746        status = pj_gethostip(&client->alloc_addr.sin_addr); 
     747        if (status != PJ_SUCCESS) { 
     748            pj_sock_close(client->sock); 
     749            client->sock = PJ_INVALID_SOCKET; 
     750            return status; 
     751        } 
    718752    } 
    719753 
     
    741775              client->obj_name, 
    742776              get_tp_type(client->sock_type), 
    743               pj_inet_ntoa(client->client_addr.sin_addr), 
    744               (int)pj_ntohs(client->client_addr.sin_port))); 
     777              pj_inet_ntoa(client->alloc_addr.sin_addr), 
     778              (int)pj_ntohs(client->alloc_addr.sin_port))); 
    745779 
    746780    return PJ_SUCCESS; 
     
    767801              client->obj_name, 
    768802              get_tp_type(client->sock_type), 
    769               pj_inet_ntoa(client->client_addr.sin_addr), 
    770               (int)pj_ntohs(client->client_addr.sin_port))); 
     803              pj_inet_ntoa(client->alloc_addr.sin_addr), 
     804              (int)pj_ntohs(client->alloc_addr.sin_port))); 
    771805    return PJ_SUCCESS; 
    772806} 
     
    796830    peer = PJ_POOL_ZALLOC_T(client->pool, struct peer); 
    797831    peer->client = client; 
    798     pj_memcpy(&peer->addr, peer_addr, sizeof(*peer_addr)); 
     832    pj_memcpy(&peer->addr, peer_addr, sizeof(peer->addr)); 
    799833 
    800834    pj_hash_set(client->pool, client->peer_htable, 
    801                 peer_addr, sizeof(*peer_addr), hval, peer); 
     835                &peer->addr, sizeof(peer->addr), hval, peer); 
    802836 
    803837    PJ_LOG(4,(THIS_FILE, "TURN client %s: peer %s:%s:%d added", 
    804838              client->obj_name, get_tp_type(client->sock_type),  
    805               pj_inet_ntoa(peer_addr->sin_addr), 
    806               (int)pj_ntohs(peer_addr->sin_port))); 
     839              pj_inet_ntoa(peer->addr.sin_addr), 
     840              (int)pj_ntohs(peer->addr.sin_port))); 
    807841 
    808842    return peer; 
     
    9761010    timeout.msec = 0; 
    9771011    pj_timer_heap_schedule(client->tu->timer_heap, &client->expiry_timer, &timeout); 
    978  
     1012    client->expiry_timer.id = PJ_TRUE; 
    9791013 
    9801014    /* Done successfully, create and send success response */ 
     
    9891023    pj_stun_msg_add_uint_attr(response->pool, response->msg, 
    9901024                              PJ_STUN_ATTR_LIFETIME, client->lifetime); 
    991     pj_stun_msg_add_ip_addr_attr(response->pool, response->msg, 
     1025    pj_stun_msg_add_sockaddr_attr(response->pool, response->msg, 
    9921026                                 PJ_STUN_ATTR_MAPPED_ADDR, PJ_FALSE, 
    9931027                                 src_addr, src_addr_len); 
    994     pj_stun_msg_add_ip_addr_attr(response->pool, response->msg, 
     1028    pj_stun_msg_add_sockaddr_attr(response->pool, response->msg, 
    9951029                                 PJ_STUN_ATTR_XOR_MAPPED_ADDR, PJ_TRUE, 
    9961030                                 src_addr, src_addr_len); 
     
    9981032    addr_len = sizeof(req_addr); 
    9991033    pj_sock_getsockname(client->sock, &req_addr, &addr_len); 
    1000     pj_stun_msg_add_ip_addr_attr(response->pool, response->msg, 
     1034    pj_stun_msg_add_sockaddr_attr(response->pool, response->msg, 
    10011035                                 PJ_STUN_ATTR_RELAY_ADDR, PJ_FALSE, 
    1002                                  &req_addr, addr_len); 
     1036                                 &client->alloc_addr, addr_len); 
    10031037 
    10041038    PJ_LOG(4,(THIS_FILE, "TURN client %s: relay allocated or refreshed, " 
     
    10111045    return pj_stun_session_send_msg(client->session, PJ_TRUE,  
    10121046                                    src_addr, src_addr_len, response); 
     1047} 
     1048 
     1049 
     1050/* 
     1051 * Handle incoming Binding request. 
     1052 * This function is called by client_handle_stun_msg() below. 
     1053 */ 
     1054static pj_status_t handle_binding_req(pj_stun_session *session, 
     1055                                      const pj_stun_msg *msg, 
     1056                                      const pj_sockaddr_t *src_addr, 
     1057                                      unsigned src_addr_len) 
     1058{ 
     1059    pj_stun_tx_data *tdata; 
     1060    pj_status_t status; 
     1061 
     1062    /* Create response */ 
     1063    status = pj_stun_session_create_response(session, msg, 0, NULL,  
     1064                                             &tdata); 
     1065    if (status != PJ_SUCCESS) 
     1066        return status; 
     1067 
     1068    /* Create MAPPED-ADDRESS attribute */ 
     1069    pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg, 
     1070                                 PJ_STUN_ATTR_MAPPED_ADDR, 
     1071                                PJ_FALSE, 
     1072                                src_addr, src_addr_len); 
     1073 
     1074    /* On the presence of magic, create XOR-MAPPED-ADDRESS attribute */ 
     1075    if (msg->hdr.magic == PJ_STUN_MAGIC) { 
     1076        status =  
     1077            pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg, 
     1078                                         PJ_STUN_ATTR_XOR_MAPPED_ADDR, 
     1079                                         PJ_TRUE, 
     1080                                         src_addr, src_addr_len); 
     1081    } 
     1082 
     1083    /* Send */ 
     1084    status = pj_stun_session_send_msg(session, PJ_TRUE,  
     1085                                      src_addr, src_addr_len, tdata); 
     1086    return status; 
    10131087} 
    10141088 
     
    10591133    } 
    10601134 
    1061     PJ_LOG(4,(THIS_FILE, "TURN client %s: active destination set to %s:%d", 
    1062                          client->obj_name, 
    1063                          pj_inet_ntoa(client->active_peer->addr.sin_addr), 
    1064                          (int)pj_ntohs(client->active_peer->addr.sin_port))); 
     1135    if (client->active_peer) { 
     1136        PJ_LOG(4,(THIS_FILE,  
     1137                  "TURN client %s: active destination set to %s:%d", 
     1138                  client->obj_name, 
     1139                  pj_inet_ntoa(client->active_peer->addr.sin_addr), 
     1140                  (int)pj_ntohs(client->active_peer->addr.sin_port))); 
     1141    } else { 
     1142        PJ_LOG(4,(THIS_FILE, "TURN client %s: active destination cleared", 
     1143                  client->obj_name)); 
     1144    } 
    10651145 
    10661146    /* Respond with successful response */ 
     
    11631243    case PJ_STUN_SEND_INDICATION: 
    11641244        status = client_handle_send_ind(client, msg); 
     1245        break; 
    11651246 
    11661247    case PJ_STUN_SET_ACTIVE_DESTINATION_REQUEST: 
    11671248        status = client_handle_sad(client, msg, 
    11681249                                   src_addr, src_addr_len); 
     1250        break; 
     1251 
    11691252    case PJ_STUN_ALLOCATE_REQUEST: 
    11701253        status = client_handle_allocate_req(client, msg, 
    11711254                                            src_addr, src_addr_len); 
     1255        break; 
     1256 
     1257    case PJ_STUN_BINDING_REQUEST: 
     1258        status = handle_binding_req(client->session, msg, 
     1259                                    src_addr, src_addr_len); 
     1260        break; 
    11721261 
    11731262    default: 
    11741263        status = client_handle_unknown_msg(client, msg, 
    11751264                                           src_addr, src_addr_len); 
     1265        break; 
    11761266    } 
    11771267 
     
    12041294    if (peer == NULL) { 
    12051295        /* Nope. Discard packet */ 
     1296        PJ_LOG(5,(THIS_FILE,  
     1297                 "TURN client %s: discarded data from %s:%d", 
     1298                 client->obj_name, 
     1299                 pj_inet_ntoa(client->pkt_src_addr.sin_addr), 
     1300                 (int)pj_ntohs(client->pkt_src_addr.sin_port))); 
    12061301        return; 
    12071302    } 
     
    12261321            return; 
    12271322 
    1228         pj_stun_msg_add_ip_addr_attr(data_ind->pool, data_ind->msg,  
    1229                                      PJ_STUN_ATTR_REMOTE_ADDR, PJ_FALSE, 
    1230                                      &client->pkt_src_addr, 
    1231                                      client->pkt_src_addr_len); 
     1323        pj_stun_msg_add_sockaddr_attr(data_ind->pool, data_ind->msg,  
     1324                                      PJ_STUN_ATTR_REMOTE_ADDR, PJ_FALSE, 
     1325                                      &client->pkt_src_addr, 
     1326                                      client->pkt_src_addr_len); 
    12321327        pj_stun_msg_add_binary_attr(data_ind->pool, data_ind->msg, 
    12331328                                    PJ_STUN_ATTR_DATA,  
  • pjproject/trunk/pjlib-util/src/pjstun-srv-test/usage.c

    r1049 r1054  
    8383        goto on_error; 
    8484 
    85     pj_memcpy(&usage->cb, cb, sizeof(*cb)); 
    86  
    8785    usage->type = type; 
    8886    status = pj_sock_socket(family, type, protocol, &usage->sock); 
     
    134132    pj_stun_server_register_usage(srv, usage); 
    135133 
     134    /* Only after everything has been initialized we copy the callback, 
     135     * to prevent callback from being called when we encounter error 
     136     * during initialiation (decendant would not expect this). 
     137     */ 
     138    pj_memcpy(&usage->cb, cb, sizeof(*cb)); 
     139 
    136140    *p_usage = usage; 
    137141    return PJ_SUCCESS; 
  • pjproject/trunk/pjlib/include/pj/hash.h

    r974 r1054  
    120120 *                  created. 
    121121 * @param ht        the hash table. 
    122  * @param key       the key. 
     122 * @param key       the key, which MUST point to buffer that remains valid 
     123 *                  for the duration of the entry. 
    123124 * @param keylen    the length of the key, or PJ_HASH_KEY_STRING to use the  
    124125 *                  string length of the key. 
  • pjproject/trunk/pjlib/src/pj/addr_resolv_sock.c

    r1025 r1054  
    5656 
    5757/* Resolve the IP address of local machine */ 
    58 pj_status_t pj_gethostip(pj_in_addr *addr) 
     58PJ_DEF(pj_status_t) pj_gethostip(pj_in_addr *addr) 
    5959{ 
    6060    const pj_str_t *hostname = pj_gethostname(); 
Note: See TracChangeset for help on using the changeset viewer.