Changeset 1869


Ignore:
Timestamp:
Mar 14, 2008 5:56:11 PM (11 years ago)
Author:
bennylp
Message:

More ticket #485: initial test on TURN client/server

Location:
pjproject/trunk/pjnath
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjnath/include/pjnath/stun_auth.h

    r1374 r1869  
    278278 * @param pool          If response is to be created, then memory will 
    279279 *                      be allocated from this pool. 
     280 * @param auth_key      Optional pointer to receive authentication key to 
     281 *                      calculate MESSAGE-INTEGRITY of the response, if 
     282 *                      the response needs to be authenticated. 
    280283 * @param p_response    Optional pointer to receive the response message 
    281284 *                      then the credential in the request fails to 
     
    292295                                                  pj_stun_auth_cred *cred, 
    293296                                                  pj_pool_t *pool, 
     297                                                  pj_str_t *auth_key, 
    294298                                                  pj_stun_msg **p_response); 
    295299 
  • pjproject/trunk/pjnath/src/pjnath-test/stun.c

    r1451 r1869  
    656656 
    657657                status = pj_stun_authenticate_request(buf, len, msg,  
    658                                                       &cred, pool, NULL); 
     658                                                      &cred, pool, NULL, NULL); 
    659659                if (status != PJ_SUCCESS) { 
    660660                    char errmsg[PJ_ERR_MSG_SIZE]; 
  • pjproject/trunk/pjnath/src/pjnath/stun_auth.c

    r1479 r1869  
    122122                                                 pj_stun_auth_cred *cred, 
    123123                                                 pj_pool_t *pool, 
     124                                                 pj_str_t *auth_key, 
    124125                                                 pj_stun_msg **p_response) 
    125126{ 
     
    333334                                 NULL, &realm, &nonce, p_response); 
    334335            } 
     336            if (auth_key) { 
     337                pj_stun_create_key(pool, auth_key, &realm,  
     338                                   &auser->value, &password); 
     339            } 
    335340            return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_STALE_NONCE); 
    336341        } 
  • pjproject/trunk/pjnath/src/pjnath/stun_session.c

    r1862 r1869  
    860860{ 
    861861    pj_stun_msg *response; 
     862    pj_str_t auth_key; 
    862863    pj_status_t status; 
    863864 
     
    866867 
    867868    status = pj_stun_authenticate_request(pkt, pkt_len, msg, sess->cred, 
    868                                           tmp_pool, &response); 
     869                                          tmp_pool, &auth_key, &response); 
    869870    if (status != PJ_SUCCESS && response != NULL) { 
    870871        PJ_LOG(5,(SNAME(sess), "Message authentication failed")); 
    871         send_response(sess, tmp_pool, response, NULL, PJ_FALSE,  
     872        send_response(sess, tmp_pool, response, &auth_key, PJ_FALSE,  
    872873                      src_addr, src_addr_len); 
    873874    } 
  • pjproject/trunk/pjnath/src/pjnath/turn_session.c

    r1867 r1869  
    219219    } 
    220220 
     221    /* Attach ourself to STUN session */ 
     222    pj_stun_session_set_user_data(sess->stun, sess); 
     223 
    221224    /* Replace mutex in STUN session with a NULL mutex, since access to 
    222225     * STUN session is serialized. 
  • pjproject/trunk/pjnath/src/pjnath/turn_udp.c

    r1867 r1869  
    2020#include <pj/assert.h> 
    2121#include <pj/errno.h> 
     22#include <pj/log.h> 
    2223#include <pj/pool.h> 
    2324#include <pj/ioqueue.h> 
     
    113114    } 
    114115 
     116    /* Bind to any */ 
     117    pj_sockaddr_init(af, &udp_rel->src_addr, NULL, 0); 
     118    status = pj_sock_bind(udp_rel->sock, &udp_rel->src_addr,  
     119                          pj_sockaddr_get_len(&udp_rel->src_addr)); 
     120    if (status != PJ_SUCCESS) { 
     121        pj_turn_udp_destroy(udp_rel); 
     122        return status; 
     123    } 
     124 
    115125    /* Register to ioqeuue */ 
    116126    pj_bzero(&ioq_cb, sizeof(ioq_cb)); 
     
    256266                             pj_ssize_t bytes_read) 
    257267{ 
     268    enum { MAX_RETRY = 10 }; 
    258269    pj_turn_udp *udp_rel; 
     270    int retry = 0; 
    259271    pj_status_t status; 
    260272 
     
    271283        bytes_read = sizeof(udp_rel->pkt); 
    272284        udp_rel->src_addr_len = sizeof(udp_rel->src_addr); 
    273  
    274285        status = pj_ioqueue_recvfrom(udp_rel->key, op_key, 
    275286                                     udp_rel->pkt, &bytes_read, 0, 
     
    277288                                     &udp_rel->src_addr_len); 
    278289 
    279         if (status != PJ_EPENDING && status != PJ_SUCCESS) 
     290        if (status != PJ_EPENDING && status != PJ_SUCCESS) { 
     291            char errmsg[PJ_ERR_MSG_SIZE]; 
     292 
     293            pj_strerror(status, errmsg, sizeof(errmsg)); 
     294            PJ_LOG(4,(udp_rel->pool->obj_name, 
     295                      "ioqueue recvfrom error: %s", errmsg)); 
     296 
    280297            bytes_read = -status; 
    281  
    282     } while (status != PJ_EPENDING && status != PJ_ECANCELLED); 
     298        } 
     299 
     300    } while (status != PJ_EPENDING && status != PJ_ECANCELLED && 
     301             ++retry < MAX_RETRY); 
    283302 
    284303} 
  • pjproject/trunk/pjnath/src/pjturn-client/client_main.c

    r1867 r1869  
    133133        len = sizeof(addr); 
    134134        CHECK( pj_sock_getsockname(g.peer[i].sock, &addr, &len) ); 
    135         port = pj_sockaddr_get_port(&g.peer[i].addr); 
     135        port = pj_sockaddr_get_port(&addr); 
    136136 
    137137        CHECK( pj_gethostip(pj_AF_INET(), &g.peer[i].addr) ); 
     
    358358        pj_turn_udp_get_info(g.udp_rel, &info); 
    359359        strcpy(client_state, pj_turn_state_name(info.state)); 
    360         pj_sockaddr_print(&info.relay_addr, relay_addr, sizeof(relay_addr), 3); 
     360        if (info.state >= PJ_TURN_STATE_READY) 
     361            pj_sockaddr_print(&info.relay_addr, relay_addr, sizeof(relay_addr), 3); 
     362        else 
     363            strcpy(relay_addr, "0.0.0.0:0"); 
    361364    } else { 
    362365        strcpy(client_state, "NULL"); 
     
    372375    puts("|             CLIENT                |             PEER-0             |"); 
    373376    puts("|                                   |                                |"); 
    374     printf("| State     : %12s          | Address: %21s |\n", 
     377    printf("| State     : %-12s          | Address: %-21s |\n", 
    375378           client_state, peer0_addr); 
    376     printf("| Relay addr: %21s |                                |\n", 
     379    printf("| Relay addr: %-21s |                                |\n", 
    377380           relay_addr); 
    378381    puts("|                                   | 0  Send data to relay address  |"); 
     
    380383    puts("| S[01]  Send data to peer 0/1      |             PEER-1             |"); 
    381384    puts("| B[01]  BindChannel to peer 0/1    |                                |"); 
    382     printf("| X      Delete allocation          | Address: %21s |\n", 
     385    printf("| X      Delete allocation          | Address: %-21s |\n", 
    383386          peer1_addr); 
    384387    puts("+-----------------------------------+                                |"); 
  • pjproject/trunk/pjnath/src/pjturn-srv/auth.c

    r1852 r1869  
    5656{ 
    5757    /* Nothing to do */ 
     58} 
     59 
     60 
     61PJ_DEF(pj_status_t) pj_turn_get_cred( const pj_stun_msg *msg, 
     62                                      void *user_data, 
     63                                      pj_pool_t *pool, 
     64                                      pj_str_t *realm, 
     65                                      pj_str_t *username, 
     66                                      pj_str_t *nonce, 
     67                                      int *data_type, 
     68                                      pj_str_t *data) 
     69{ 
     70    PJ_UNUSED_ARG(msg); 
     71    PJ_UNUSED_ARG(pool); 
     72    PJ_UNUSED_ARG(user_data); 
     73 
     74    *realm = pj_str(g_realm); 
     75    *username = pj_str(g_cred[0].username); 
     76    *nonce = pj_str(THE_NONCE); 
     77    *data_type = 0; 
     78    *data = pj_str(g_cred[0].passwd); 
     79 
     80    return PJ_SUCCESS; 
    5881} 
    5982 
  • pjproject/trunk/pjnath/src/pjturn-srv/auth.h

    r1852 r1869  
    6262 
    6363/** 
     64 * Get credential. 
     65 */ 
     66PJ_DECL(pj_status_t) pj_turn_get_cred(const pj_stun_msg *msg, 
     67                                      void *user_data, 
     68                                      pj_pool_t *pool, 
     69                                      pj_str_t *realm, 
     70                                      pj_str_t *username, 
     71                                      pj_str_t *nonce, 
     72                                      int *data_type, 
     73                                      pj_str_t *data); 
     74 
     75/** 
    6476 * This function is called to get the password for the specified username. 
    6577 * This function is also used to check whether the username is valid. 
  • pjproject/trunk/pjnath/src/pjturn-srv/main.c

    r1854 r1869  
    1818 */ 
    1919#include "turn.h" 
     20#include "auth.h" 
     21 
     22#define REALM   "pjsip.org" 
    2023 
    2124int err(const char *title, pj_status_t status) 
     
    3942        return err("pj_init() error", status); 
    4043 
     44    pjlib_util_init(); 
     45    pjnath_init(); 
     46 
    4147    pj_caching_pool_init(&cp, NULL, 0); 
     48 
     49    pj_turn_auth_init(REALM); 
    4250 
    4351    status = pj_turn_srv_create(&cp.factory, &srv); 
     
    4553        return err("Error creating server", status); 
    4654 
    47     status = pj_turn_listener_create_udp(srv, pj_AF_INET(), NULL, 3478, 1, 0, &listener); 
     55    status = pj_turn_listener_create_udp(srv, pj_AF_INET(), NULL,  
     56                                         PJ_STUN_PORT, 1, 0, &listener); 
    4857    if (status != PJ_SUCCESS) 
    4958        return err("Error creating listener", status); 
  • pjproject/trunk/pjnath/src/pjturn-srv/server.c

    r1852 r1869  
    148148    srv->core.cred.data.dyn_cred.user_data = srv; 
    149149    srv->core.cred.data.dyn_cred.get_auth = &pj_turn_get_auth; 
    150     srv->core.cred.data.dyn_cred.get_cred = &pj_turn_srv_get_cred; 
     150    srv->core.cred.data.dyn_cred.get_cred = &pj_turn_get_cred; 
    151151    srv->core.cred.data.dyn_cred.get_password = &pj_turn_get_password; 
    152152    srv->core.cred.data.dyn_cred.verify_nonce = &pj_turn_verify_nonce; 
Note: See TracChangeset for help on using the changeset viewer.