Ignore:
Timestamp:
May 24, 2019 3:32:17 AM (4 years ago)
Author:
riza
Message:

Close #1017: TURN TLS transport implementation.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/pjnath/src/pjnath/turn_sock.c

    r5988 r6004  
    2020#include <pjnath/turn_sock.h> 
    2121#include <pj/activesock.h> 
     22#include <pj/ssl_sock.h> 
    2223#include <pj/assert.h> 
    2324#include <pj/errno.h> 
    … …  
    2627#include <pj/pool.h> 
    2728#include <pj/ioqueue.h> 
     29#include <pj/compat/socket.h> 
    2830 
    2931enum 
    … …  
    8587    pj_turn_tp_type      conn_type; 
    8688    pj_activesock_t     *active_sock; 
     89#if PJ_HAS_SSL_SOCK 
     90    pj_ssl_sock_t       *ssl_sock; 
     91    pj_ssl_cert_t       *cert; 
     92    pj_str_t             server_name; 
     93#endif 
     94 
    8795    pj_ioqueue_op_key_t  send_key; 
    8896 
    … …  
    123131                                           unsigned addr_len); 
    124132 
    125 static pj_bool_t on_data_read(pj_activesock_t *asock, 
     133static pj_bool_t on_data_read(pj_turn_sock *turn_sock, 
    126134                              void *data, 
    127135                              pj_size_t size, 
    128136                              pj_status_t status, 
    129137                              pj_size_t *remainder); 
    130 static pj_bool_t on_connect_complete(pj_activesock_t *asock, 
     138static pj_bool_t on_connect_complete(pj_turn_sock *turn_sock, 
    131139                                     pj_status_t status); 
    132140 
     141/* 
     142 * Activesock callback 
     143 */ 
     144static pj_bool_t on_connect_complete_asock(pj_activesock_t *asock, 
     145                                           pj_status_t status); 
     146static pj_bool_t on_data_read_asock(pj_activesock_t *asock, 
     147                                    void *data, 
     148                                    pj_size_t size, 
     149                                    pj_status_t status, 
     150                                    pj_size_t *remainder); 
     151 
     152/* 
     153 * SSL sock callback 
     154 */ 
     155static pj_bool_t on_connect_complete_ssl_sock(pj_ssl_sock_t *ssl_sock, 
     156                                              pj_status_t status); 
     157static pj_bool_t on_data_read_ssl_sock(pj_ssl_sock_t *ssl_sock, 
     158                                       void *data, 
     159                                       pj_size_t size, 
     160                                       pj_status_t status, 
     161                                       pj_size_t *remainder); 
     162   
    133163static pj_bool_t dataconn_on_data_read(pj_activesock_t *asock, 
    134164                                       void *data, 
    … …  
    152182    cfg->qos_type = PJ_QOS_TYPE_BEST_EFFORT; 
    153183    cfg->qos_ignore_error = PJ_TRUE; 
    154 } 
    155  
     184 
     185#if PJ_HAS_SSL_SOCK 
     186    pj_turn_sock_tls_cfg_default(&cfg->tls_cfg); 
     187#endif 
     188} 
     189 
     190#if PJ_HAS_SSL_SOCK 
     191 
     192PJ_DEF(void) pj_turn_sock_tls_cfg_default(pj_turn_sock_tls_cfg *tls_cfg) 
     193{ 
     194    pj_bzero(tls_cfg, sizeof(*tls_cfg)); 
     195    pj_ssl_sock_param_default(&tls_cfg->ssock_param); 
     196    tls_cfg->ssock_param.proto = PJ_TURN_TLS_DEFAULT_PROTO; 
     197} 
     198 
     199PJ_DEF(void) pj_turn_sock_tls_cfg_dup(pj_pool_t *pool, 
     200                                      pj_turn_sock_tls_cfg *dst, 
     201                                      const pj_turn_sock_tls_cfg *src) 
     202{ 
     203    pj_memcpy(dst, src, sizeof(*dst)); 
     204    pj_strdup_with_null(pool, &dst->ca_list_file, &src->ca_list_file); 
     205    pj_strdup_with_null(pool, &dst->ca_list_path, &src->ca_list_path); 
     206    pj_strdup_with_null(pool, &dst->cert_file, &src->cert_file); 
     207    pj_strdup_with_null(pool, &dst->privkey_file, &src->privkey_file); 
     208    pj_strdup_with_null(pool, &dst->password, &src->password); 
     209    pj_strdup(pool, &dst->ca_buf, &src->ca_buf); 
     210    pj_strdup(pool, &dst->cert_buf, &src->cert_buf); 
     211    pj_strdup(pool, &dst->privkey_buf, &src->privkey_buf); 
     212    pj_ssl_sock_param_copy(pool, &dst->ssock_param, &src->ssock_param); 
     213} 
     214 
     215static void wipe_buf(pj_str_t *buf) 
     216{ 
     217    volatile char *p = buf->ptr; 
     218    pj_ssize_t len = buf->slen; 
     219    while (len--) *p++ = 0; 
     220    buf->slen = 0; 
     221} 
     222 
     223PJ_DEF(void) pj_turn_sock_tls_cfg_wipe_keys(pj_turn_sock_tls_cfg *tls_cfg) 
     224{ 
     225    wipe_buf(&tls_cfg->ca_list_file); 
     226    wipe_buf(&tls_cfg->ca_list_path); 
     227    wipe_buf(&tls_cfg->cert_file); 
     228    wipe_buf(&tls_cfg->privkey_file); 
     229    wipe_buf(&tls_cfg->password); 
     230    wipe_buf(&tls_cfg->ca_buf); 
     231    wipe_buf(&tls_cfg->cert_buf); 
     232    wipe_buf(&tls_cfg->privkey_buf);  
     233} 
     234#endif 
    156235 
    157236/* 
    … …  
    176255    PJ_ASSERT_RETURN(af==pj_AF_INET() || af==pj_AF_INET6(), PJ_EINVAL); 
    177256    PJ_ASSERT_RETURN(conn_type!=PJ_TURN_TP_TCP || PJ_HAS_TCP, PJ_EINVAL); 
     257    PJ_ASSERT_RETURN(conn_type!=PJ_TURN_TP_TLS || PJ_HAS_SSL_SOCK, PJ_EINVAL); 
    178258 
    179259    if (!setting) { 
    … …  
    189269        name_tmpl = "tcprel%p"; 
    190270        break; 
     271#if PJ_HAS_SSL_SOCK 
     272    case PJ_TURN_TP_TLS: 
     273        name_tmpl = "tlsrel%p"; 
     274        break; 
     275#endif 
    191276    default: 
    192277        PJ_ASSERT_RETURN(!"Invalid TURN conn_type", PJ_EINVAL); 
    … …  
    210295    /* Copy setting (QoS parameters etc */ 
    211296    pj_memcpy(&turn_sock->setting, setting, sizeof(*setting)); 
     297#if PJ_HAS_SSL_SOCK 
     298    pj_turn_sock_tls_cfg_dup(turn_sock->pool, &turn_sock->setting.tls_cfg, 
     299                             &setting->tls_cfg); 
     300#endif 
    212301 
    213302    /* Set callback */ 
    … …  
    289378    if (turn_sock->active_sock) 
    290379        pj_activesock_close(turn_sock->active_sock); 
     380#if PJ_HAS_SSL_SOCK 
     381    if (turn_sock->ssl_sock) 
     382        pj_ssl_sock_close(turn_sock->ssl_sock); 
     383#endif 
    291384 
    292385    for (i=0; i < PJ_TURN_MAX_TCP_CONN_CNT; ++i) { 
    … …  
    475568        } 
    476569    } 
     570#if PJ_HAS_SSL_SOCK 
     571    if (turn_sock->conn_type == PJ_TURN_TP_TLS) { 
     572        pj_strdup_with_null(turn_sock->pool, &turn_sock->server_name, domain); 
     573    } 
     574#endif 
    477575 
    478576    /* Resolve server */ 
    … …  
    549647 * Notification when outgoing TCP socket has been connected. 
    550648 */ 
    551 static pj_bool_t on_connect_complete(pj_activesock_t *asock, 
     649static pj_bool_t on_connect_complete(pj_turn_sock *turn_sock, 
    552650                                     pj_status_t status) 
    553651{ 
    554     pj_turn_sock *turn_sock; 
    555  
    556     turn_sock = (pj_turn_sock*) pj_activesock_get_user_data(asock); 
    557     if (!turn_sock) 
    558         return PJ_FALSE; 
    559  
    560652    pj_grp_lock_acquire(turn_sock->grp_lock); 
    561653 
    … …  
    570662 
    571663    if (status != PJ_SUCCESS) { 
    572         sess_fail(turn_sock, "TCP connect() error", status); 
     664        if (turn_sock->conn_type == PJ_TURN_TP_UDP) 
     665            sess_fail(turn_sock, "UDP connect() error", status); 
     666        else if (turn_sock->conn_type == PJ_TURN_TP_TCP) 
     667            sess_fail(turn_sock, "TCP connect() error", status); 
     668        else if (turn_sock->conn_type == PJ_TURN_TP_TLS) 
     669            sess_fail(turn_sock, "TLS connect() error", status); 
     670 
    573671        pj_grp_lock_release(turn_sock->grp_lock); 
    574672        return PJ_FALSE; 
    … …  
    576674 
    577675    if (turn_sock->conn_type != PJ_TURN_TP_UDP) { 
    578         PJ_LOG(5,(turn_sock->obj_name, "TCP connected")); 
     676        PJ_LOG(5, (turn_sock->obj_name, "%s connected", 
     677                   turn_sock->conn_type == PJ_TURN_TP_TCP ? "TCP" : "TLS")); 
    579678    } 
    580679 
    581680    /* Kick start pending read operation */ 
    582     status = pj_activesock_start_read(asock, turn_sock->pool,  
    583                                       turn_sock->setting.max_pkt_size, 0); 
     681    if (turn_sock->conn_type != PJ_TURN_TP_TLS)  
     682        status = pj_activesock_start_read(turn_sock->active_sock,  
     683                                          turn_sock->pool, 
     684                                          turn_sock->setting.max_pkt_size,  
     685                                          0); 
     686#if PJ_HAS_SSL_SOCK 
     687    else 
     688        status = pj_ssl_sock_start_read(turn_sock->ssl_sock, turn_sock->pool, 
     689                                        turn_sock->setting.max_pkt_size, 0); 
     690#endif 
    584691 
    585692    /* Init send_key */ 
    … …  
    598705} 
    599706 
     707static pj_bool_t on_connect_complete_asock(pj_activesock_t *asock, 
     708                                           pj_status_t status) 
     709{ 
     710    pj_turn_sock *turn_sock; 
     711 
     712    turn_sock = (pj_turn_sock*)pj_activesock_get_user_data(asock); 
     713    if (!turn_sock) 
     714        return PJ_FALSE; 
     715 
     716    return on_connect_complete(turn_sock, status); 
     717} 
     718 
     719static pj_bool_t on_connect_complete_ssl_sock(pj_ssl_sock_t *ssl_sock, 
     720                                              pj_status_t status) 
     721{ 
     722    pj_turn_sock *turn_sock; 
     723 
     724    turn_sock = (pj_turn_sock*)pj_ssl_sock_get_user_data(ssl_sock); 
     725    if (!turn_sock) 
     726        return PJ_FALSE; 
     727 
     728    return on_connect_complete(turn_sock, status); 
     729} 
     730 
    600731static pj_uint16_t GETVAL16H(const pj_uint8_t *buf, unsigned pos) 
    601732{ 
    … …  
    644775 * Notification from ioqueue when incoming UDP packet is received. 
    645776 */ 
    646 static pj_bool_t on_data_read(pj_activesock_t *asock, 
     777static pj_bool_t on_data_read(pj_turn_sock *turn_sock, 
    647778                              void *data, 
    648779                              pj_size_t size, 
    … …  
    650781                              pj_size_t *remainder) 
    651782{ 
    652     pj_turn_sock *turn_sock; 
    653783    pj_bool_t ret = PJ_TRUE; 
    654784 
    655     turn_sock = (pj_turn_sock*) pj_activesock_get_user_data(asock); 
    656785    pj_grp_lock_acquire(turn_sock->grp_lock); 
    657786 
    … …  
    697826            //        "Buffer size now %lu bytes", size)); 
    698827        } 
    699     } else if (status != PJ_SUCCESS &&  
    700                turn_sock->conn_type != PJ_TURN_TP_UDP)  
    701     { 
    702         sess_fail(turn_sock, "TCP connection closed", status); 
     828    } else if (status != PJ_SUCCESS) { 
     829        if (turn_sock->conn_type == PJ_TURN_TP_UDP) 
     830            sess_fail(turn_sock, "UDP connection closed", status); 
     831        else if (turn_sock->conn_type == PJ_TURN_TP_TCP) 
     832            sess_fail(turn_sock, "TCP connection closed", status); 
     833        else if (turn_sock->conn_type == PJ_TURN_TP_TLS) 
     834            sess_fail(turn_sock, "TLS connection closed", status); 
     835 
    703836        ret = PJ_FALSE; 
    704837        goto on_return; 
    … …  
    711844} 
    712845 
     846static pj_bool_t on_data_read_asock(pj_activesock_t *asock, 
     847                                    void *data, 
     848                                    pj_size_t size, 
     849                                    pj_status_t status, 
     850                                    pj_size_t *remainder) 
     851{ 
     852    pj_turn_sock *turn_sock; 
     853 
     854    turn_sock = (pj_turn_sock*)pj_activesock_get_user_data(asock); 
     855 
     856    return on_data_read(turn_sock, data, size, status, remainder); 
     857} 
     858 
     859static pj_bool_t on_data_read_ssl_sock(pj_ssl_sock_t *ssl_sock, 
     860                                       void *data, 
     861                                       pj_size_t size, 
     862                                       pj_status_t status, 
     863                                       pj_size_t *remainder) 
     864{ 
     865    pj_turn_sock *turn_sock; 
     866 
     867    turn_sock = (pj_turn_sock*)pj_ssl_sock_get_user_data(ssl_sock); 
     868 
     869    return on_data_read(turn_sock, data, size, status, remainder); 
     870} 
     871 
     872static pj_bool_t on_data_sent_ssl_sock(pj_ssl_sock_t *ssl_sock, 
     873                                       pj_ioqueue_op_key_t *op_key, 
     874                                       pj_ssize_t bytes_sent) 
     875{ 
     876    pj_turn_sock *turn_sock; 
     877 
     878    PJ_UNUSED_ARG(op_key); 
     879 
     880    turn_sock = (pj_turn_sock*)pj_ssl_sock_get_user_data(ssl_sock); 
     881 
     882    /* Check for error/closure */ 
     883    if (bytes_sent <= 0) { 
     884        pj_status_t status; 
     885 
     886        status = (bytes_sent == 0) ? PJ_RETURN_OS_ERROR(OSERR_ENOTCONN) : 
     887            (pj_status_t)-bytes_sent; 
     888 
     889        sess_fail(turn_sock, "TLS send() error", status); 
     890 
     891        return PJ_FALSE; 
     892    } 
     893 
     894    return PJ_TRUE; 
     895} 
    713896 
    714897/* 
    … …  
    761944            } 
    762945        } 
    763     } else { 
     946    } else  if (turn_sock->conn_type == PJ_TURN_TP_TCP) { 
    764947        status = pj_activesock_send(turn_sock->active_sock, 
    765948                                    &turn_sock->send_key, pkt, &len, 0); 
     949    } 
     950#if PJ_HAS_SSL_SOCK 
     951    else if (turn_sock->conn_type == PJ_TURN_TP_TLS) { 
     952        status = pj_ssl_sock_send(turn_sock->ssl_sock, 
     953                                  &turn_sock->send_key, pkt, &len, 0); 
     954    } 
     955#endif 
     956    else { 
     957        PJ_ASSERT_RETURN(!"Invalid TURN conn_type", PJ_EINVAL); 
    766958    } 
    767959 
    … …  
    8261018    pj_turn_sock *turn_sock = (pj_turn_sock*)  
    8271019                           pj_turn_session_get_user_data(sess); 
    828     pj_status_t status; 
     1020    pj_status_t status = PJ_SUCCESS; 
    8291021 
    8301022    if (turn_sock == NULL) { 
    … …  
    8631055         * connection or ALLOCATE request failed. 
    8641056         */ 
    865         if (turn_sock->active_sock) { 
     1057        if ((turn_sock->conn_type != PJ_TURN_TP_TLS) &&  
     1058            (turn_sock->active_sock))  
     1059        { 
    8661060            pj_activesock_close(turn_sock->active_sock); 
    8671061            turn_sock->active_sock = NULL; 
    8681062        } 
    869  
     1063#if PJ_HAS_SSL_SOCK 
     1064        else if ((turn_sock->conn_type == PJ_TURN_TP_TLS) && 
     1065            (turn_sock->ssl_sock)) 
     1066        { 
     1067            pj_ssl_sock_close(turn_sock->ssl_sock); 
     1068            turn_sock->ssl_sock = NULL; 
     1069        } 
     1070#endif 
    8701071        /* Get server address from session info */ 
    8711072        pj_turn_session_get_info(sess, &info); 
    … …  
    8761077            sock_type = pj_SOCK_STREAM(); 
    8771078 
    878         /* Init socket */ 
    879         status = pj_sock_socket(turn_sock->af, sock_type, 0, &sock); 
    880         if (status != PJ_SUCCESS) { 
    881             pj_turn_sock_destroy(turn_sock); 
    882             return; 
    883         } 
    884  
    885         /* Bind socket */ 
    8861079        cfg_bind_addr = &turn_sock->setting.bound_addr; 
    8871080        max_bind_retry = MAX_BIND_RETRY; 
    … …  
    8971090            pj_sockaddr_cp(&bound_addr, cfg_bind_addr); 
    8981091        } 
    899         status = pj_sock_bind_random(sock, &bound_addr, 
    900                                      turn_sock->setting.port_range, 
    901                                      max_bind_retry); 
    902         if (status != PJ_SUCCESS) { 
    903             pj_turn_sock_destroy(turn_sock); 
    904             return; 
    905         } 
    906  
    907         /* Apply QoS, if specified */ 
    908         status = pj_sock_apply_qos2(sock, turn_sock->setting.qos_type, 
    909                                     &turn_sock->setting.qos_params,  
     1092 
     1093        if (turn_sock->conn_type != PJ_TURN_TP_TLS) { 
     1094            /* Init socket */ 
     1095            status = pj_sock_socket(turn_sock->af, sock_type, 0, &sock); 
     1096            if (status != PJ_SUCCESS) { 
     1097                pj_turn_sock_destroy(turn_sock); 
     1098                return; 
     1099            } 
     1100 
     1101            /* Bind socket */ 
     1102            status = pj_sock_bind_random(sock, &bound_addr, 
     1103                                         turn_sock->setting.port_range, 
     1104                                         max_bind_retry); 
     1105            if (status != PJ_SUCCESS) { 
     1106                pj_turn_sock_destroy(turn_sock); 
     1107                return; 
     1108            } 
     1109            /* Apply QoS, if specified */ 
     1110            status = pj_sock_apply_qos2(sock, turn_sock->setting.qos_type, 
     1111                                    &turn_sock->setting.qos_params, 
    9101112                                    (turn_sock->setting.qos_ignore_error?2:1), 
    9111113                                    turn_sock->pool->obj_name, NULL); 
    912         if (status != PJ_SUCCESS && !turn_sock->setting.qos_ignore_error) { 
    913             pj_turn_sock_destroy(turn_sock); 
    914             return; 
    915         } 
    916  
    917         /* Apply socket buffer size */ 
    918         if (turn_sock->setting.so_rcvbuf_size > 0) { 
    919             unsigned sobuf_size = turn_sock->setting.so_rcvbuf_size; 
    920             status = pj_sock_setsockopt_sobuf(sock, pj_SO_RCVBUF(), 
    921                                               PJ_TRUE, &sobuf_size); 
    922             if (status != PJ_SUCCESS) { 
    923                 PJ_PERROR(3, (turn_sock->obj_name, status, 
    924                               "Failed setting SO_RCVBUF")); 
    925             } else { 
    926                 if (sobuf_size < turn_sock->setting.so_rcvbuf_size) { 
    927                     PJ_LOG(4, (turn_sock->obj_name,  
    928                                "Warning! Cannot set SO_RCVBUF as configured," 
    929                                " now=%d, configured=%d", sobuf_size, 
    930                                turn_sock->setting.so_rcvbuf_size)); 
     1114            if (status != PJ_SUCCESS && !turn_sock->setting.qos_ignore_error)  
     1115            { 
     1116                pj_turn_sock_destroy(turn_sock); 
     1117                return; 
     1118            } 
     1119 
     1120            /* Apply socket buffer size */ 
     1121            if (turn_sock->setting.so_rcvbuf_size > 0) { 
     1122                unsigned sobuf_size = turn_sock->setting.so_rcvbuf_size; 
     1123                status = pj_sock_setsockopt_sobuf(sock, pj_SO_RCVBUF(), 
     1124                                                  PJ_TRUE, &sobuf_size); 
     1125                if (status != PJ_SUCCESS) { 
     1126                    pj_perror(3, turn_sock->obj_name, status, 
     1127                              "Failed setting SO_RCVBUF"); 
    9311128                } else { 
    932                     PJ_LOG(5, (turn_sock->obj_name, "SO_RCVBUF set to %d", 
    933                                sobuf_size)); 
     1129                    if (sobuf_size < turn_sock->setting.so_rcvbuf_size) { 
     1130                        PJ_LOG(4, (turn_sock->obj_name, 
     1131                                "Warning! Cannot set SO_RCVBUF as configured," 
     1132                                " now=%d, configured=%d", sobuf_size, 
     1133                                turn_sock->setting.so_rcvbuf_size)); 
     1134                    } else { 
     1135                        PJ_LOG(5, (turn_sock->obj_name, "SO_RCVBUF set to %d", 
     1136                                   sobuf_size)); 
     1137                    } 
    9341138                } 
    9351139            } 
    936         } 
    937         if (turn_sock->setting.so_sndbuf_size > 0) { 
    938             unsigned sobuf_size = turn_sock->setting.so_sndbuf_size; 
    939             status = pj_sock_setsockopt_sobuf(sock, pj_SO_SNDBUF(), 
    940                                               PJ_TRUE, &sobuf_size); 
    941             if (status != PJ_SUCCESS) { 
    942                 PJ_PERROR(3, (turn_sock->obj_name, status, 
    943                               "Failed setting SO_SNDBUF")); 
    944             } else { 
    945                 if (sobuf_size < turn_sock->setting.so_sndbuf_size) { 
    946                     PJ_LOG(4, (turn_sock->obj_name,  
    947                                "Warning! Cannot set SO_SNDBUF as configured," 
    948                                " now=%d, configured=%d", sobuf_size, 
    949                                turn_sock->setting.so_sndbuf_size)); 
     1140            if (turn_sock->setting.so_sndbuf_size > 0) { 
     1141                unsigned sobuf_size = turn_sock->setting.so_sndbuf_size; 
     1142                status = pj_sock_setsockopt_sobuf(sock, pj_SO_SNDBUF(), 
     1143                                                  PJ_TRUE, &sobuf_size); 
     1144                if (status != PJ_SUCCESS) { 
     1145                    pj_perror(3, turn_sock->obj_name, status, 
     1146                              "Failed setting SO_SNDBUF"); 
    9501147                } else { 
    951                     PJ_LOG(5, (turn_sock->obj_name, "SO_SNDBUF set to %d", 
    952                                sobuf_size)); 
     1148                    if (sobuf_size < turn_sock->setting.so_sndbuf_size) { 
     1149                        PJ_LOG(4, (turn_sock->obj_name, 
     1150                                "Warning! Cannot set SO_SNDBUF as configured," 
     1151                                " now=%d, configured=%d", sobuf_size, 
     1152                                turn_sock->setting.so_sndbuf_size)); 
     1153                    } else { 
     1154                        PJ_LOG(5, (turn_sock->obj_name, "SO_SNDBUF set to %d", 
     1155                                   sobuf_size)); 
     1156                    } 
    9531157                } 
    9541158            } 
    955         } 
    956  
    957         /* Create active socket */ 
    958         pj_activesock_cfg_default(&asock_cfg); 
    959         asock_cfg.grp_lock = turn_sock->grp_lock; 
    960  
    961         pj_bzero(&asock_cb, sizeof(asock_cb)); 
    962         asock_cb.on_data_read = &on_data_read; 
    963         asock_cb.on_connect_complete = &on_connect_complete; 
    964         status = pj_activesock_create(turn_sock->pool, sock, 
    965                                       sock_type, &asock_cfg, 
    966                                       turn_sock->cfg.ioqueue, &asock_cb,  
    967                                       turn_sock, 
    968                                       &turn_sock->active_sock); 
     1159 
     1160            /* Create active socket */ 
     1161            pj_activesock_cfg_default(&asock_cfg); 
     1162            asock_cfg.grp_lock = turn_sock->grp_lock; 
     1163 
     1164            pj_bzero(&asock_cb, sizeof(asock_cb)); 
     1165            asock_cb.on_data_read = &on_data_read_asock; 
     1166            asock_cb.on_connect_complete = &on_connect_complete_asock; 
     1167            status = pj_activesock_create(turn_sock->pool, sock, 
     1168                                          sock_type, &asock_cfg, 
     1169                                          turn_sock->cfg.ioqueue, &asock_cb, 
     1170                                          turn_sock, 
     1171                                          &turn_sock->active_sock); 
     1172        } 
     1173#if PJ_HAS_SSL_SOCK 
     1174        else { 
     1175            //TURN TLS 
     1176            pj_ssl_sock_param param, *ssock_param; 
     1177 
     1178            ssock_param = &turn_sock->setting.tls_cfg.ssock_param; 
     1179            pj_ssl_sock_param_default(&param); 
     1180 
     1181            pj_ssl_sock_param_copy(turn_sock->pool, &param, ssock_param); 
     1182            param.cb.on_connect_complete = &on_connect_complete_ssl_sock; 
     1183            param.cb.on_data_read = &on_data_read_ssl_sock; 
     1184            param.cb.on_data_sent = &on_data_sent_ssl_sock; 
     1185            param.ioqueue = turn_sock->cfg.ioqueue; 
     1186            param.timer_heap = turn_sock->cfg.timer_heap; 
     1187            param.grp_lock = turn_sock->grp_lock; 
     1188            param.server_name = turn_sock->server_name; 
     1189            param.user_data = turn_sock; 
     1190            param.sock_type = sock_type; 
     1191            param.sock_af = turn_sock->af; 
     1192            if (param.send_buffer_size < PJ_TURN_MAX_PKT_LEN) 
     1193                param.send_buffer_size = PJ_TURN_MAX_PKT_LEN; 
     1194            if (param.read_buffer_size < PJ_TURN_MAX_PKT_LEN) 
     1195                param.read_buffer_size = PJ_TURN_MAX_PKT_LEN; 
     1196 
     1197            param.qos_type = turn_sock->setting.qos_type; 
     1198            param.qos_ignore_error = turn_sock->setting.qos_ignore_error; 
     1199            pj_memcpy(&param.qos_params, &turn_sock->setting.qos_params, 
     1200                      sizeof(param.qos_params)); 
     1201 
     1202            if (turn_sock->setting.tls_cfg.cert_file.slen || 
     1203                turn_sock->setting.tls_cfg.ca_list_file.slen || 
     1204                turn_sock->setting.tls_cfg.ca_list_path.slen || 
     1205                turn_sock->setting.tls_cfg.privkey_file.slen) 
     1206            { 
     1207                status = pj_ssl_cert_load_from_files2( 
     1208                    turn_sock->pool, 
     1209                    &turn_sock->setting.tls_cfg.ca_list_file, 
     1210                    &turn_sock->setting.tls_cfg.ca_list_path, 
     1211                    &turn_sock->setting.tls_cfg.cert_file, 
     1212                    &turn_sock->setting.tls_cfg.privkey_file, 
     1213                    &turn_sock->setting.tls_cfg.password, 
     1214                    &turn_sock->cert); 
     1215 
     1216            } else if (turn_sock->setting.tls_cfg.ca_buf.slen || 
     1217                       turn_sock->setting.tls_cfg.cert_buf.slen || 
     1218                       turn_sock->setting.tls_cfg.privkey_buf.slen) 
     1219            { 
     1220                status = pj_ssl_cert_load_from_buffer( 
     1221                    turn_sock->pool, 
     1222                    &turn_sock->setting.tls_cfg.ca_buf, 
     1223                    &turn_sock->setting.tls_cfg.cert_buf, 
     1224                    &turn_sock->setting.tls_cfg.privkey_buf, 
     1225                    &turn_sock->setting.tls_cfg.password, 
     1226                    &turn_sock->cert); 
     1227            } 
     1228            if (status != PJ_SUCCESS) { 
     1229                pj_turn_sock_destroy(turn_sock); 
     1230                return; 
     1231            } 
     1232            if (turn_sock->cert) { 
     1233                pj_turn_sock_tls_cfg_wipe_keys(&turn_sock->setting.tls_cfg); 
     1234            } 
     1235 
     1236            status = pj_ssl_sock_create(turn_sock->pool, &param, 
     1237                                        &turn_sock->ssl_sock); 
     1238 
     1239            if (status != PJ_SUCCESS) { 
     1240                pj_turn_sock_destroy(turn_sock); 
     1241                return; 
     1242            } 
     1243 
     1244            if (turn_sock->cert) { 
     1245                status = pj_ssl_sock_set_certificate(turn_sock->ssl_sock, 
     1246                                                     turn_sock->pool, 
     1247                                                     turn_sock->cert); 
     1248 
     1249                pj_ssl_cert_wipe_keys(turn_sock->cert); 
     1250                turn_sock->cert = NULL; 
     1251            } 
     1252 
     1253        } 
     1254#endif 
     1255 
    9691256        if (status != PJ_SUCCESS) { 
    9701257            pj_turn_sock_destroy(turn_sock); 
    … …  
    9781265 
    9791266        /* Initiate non-blocking connect */ 
     1267        if (turn_sock->conn_type == PJ_TURN_TP_UDP) { 
     1268            status = PJ_SUCCESS; 
     1269        } 
    9801270#if PJ_HAS_TCP 
    981         if (turn_sock->conn_type != PJ_TURN_TP_UDP) { 
     1271        else if (turn_sock->conn_type == PJ_TURN_TP_TCP) { 
    9821272            status=pj_activesock_start_connect( 
    9831273                                        turn_sock->active_sock,  
    … …  
    9851275                                        &info.server,  
    9861276                                        pj_sockaddr_get_len(&info.server)); 
    987         } else { 
    988             status = PJ_SUCCESS; 
    989         } 
     1277        }  
     1278#endif   
     1279#if PJ_HAS_SSL_SOCK 
     1280        else if (turn_sock->conn_type == PJ_TURN_TP_TLS) { 
     1281            pj_ssl_start_connect_param connect_param; 
     1282            connect_param.pool = turn_sock->pool; 
     1283            connect_param.localaddr = &bound_addr; 
     1284            connect_param.local_port_range = turn_sock->setting.port_range; 
     1285            connect_param.remaddr = &info.server; 
     1286            connect_param.addr_len = pj_sockaddr_get_len(&info.server); 
     1287 
     1288            status = pj_ssl_sock_start_connect2(turn_sock->ssl_sock, 
     1289                                                &connect_param); 
     1290        } 
     1291#endif 
    9901292        if (status == PJ_SUCCESS) { 
    991             on_connect_complete(turn_sock->active_sock, PJ_SUCCESS); 
     1293            on_connect_complete(turn_sock, PJ_SUCCESS); 
    9921294        } else if (status != PJ_EPENDING) { 
    9931295            PJ_PERROR(3, (turn_sock->pool->obj_name, status, 
    … …  
    9981300            return; 
    9991301        } 
    1000 #else 
    1001         on_connect_complete(turn_sock->active_sock, PJ_SUCCESS); 
    1002 #endif 
    10031302 
    10041303        /* Done for now. Subsequent work will be done in  
Note: See TracChangeset for help on using the changeset viewer.