Ignore:
Timestamp:
Sep 23, 2019 7:25:41 AM (3 years ago)
Author:
ming
Message:

Fixed #2229: Limitations in ICE data sending

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjnath/src/pjnath/turn_sock.c

    r6039 r6071  
    9494 
    9595    pj_ioqueue_op_key_t  send_key; 
     96    pj_ioqueue_op_key_t  int_send_key; 
     97    unsigned             pkt_len; 
     98    unsigned             body_len; 
    9699 
    97100    /* Data connection, when peer_conn_type==PJ_TURN_TP_TCP (RFC 6062) */ 
     
    109112                                    const pj_sockaddr_t *dst_addr, 
    110113                                    unsigned dst_addr_len); 
     114static pj_status_t turn_on_stun_send_pkt(pj_turn_session *sess, 
     115                                         const pj_uint8_t *pkt, 
     116                                         unsigned pkt_len, 
     117                                         const pj_sockaddr_t *dst_addr, 
     118                                         unsigned dst_addr_len); 
    111119static void turn_on_channel_bound(pj_turn_session *sess, 
    112120                                  const pj_sockaddr_t *peer_addr, 
     
    136144                              pj_status_t status, 
    137145                              pj_size_t *remainder); 
     146static pj_bool_t on_data_sent(pj_turn_sock *turn_sock, 
     147                              pj_ioqueue_op_key_t *send_key, 
     148                              pj_ssize_t sent); 
    138149static pj_bool_t on_connect_complete(pj_turn_sock *turn_sock, 
    139150                                     pj_status_t status); 
     
    149160                                    pj_status_t status, 
    150161                                    pj_size_t *remainder); 
     162static pj_bool_t on_data_sent_asock(pj_activesock_t *asock, 
     163                                     pj_ioqueue_op_key_t *send_key, 
     164                                     pj_ssize_t sent); 
    151165 
    152166/* 
     
    168182                                       pj_status_t status, 
    169183                                       pj_size_t *remainder); 
     184static pj_bool_t dataconn_on_data_sent(pj_activesock_t *asock, 
     185                                       pj_ioqueue_op_key_t *send_key, 
     186                                       pj_ssize_t sent); 
    170187static pj_bool_t dataconn_on_connect_complete(pj_activesock_t *asock, 
    171188                                              pj_status_t status); 
     
    328345    pj_bzero(&sess_cb, sizeof(sess_cb)); 
    329346    sess_cb.on_send_pkt = &turn_on_send_pkt; 
     347    sess_cb.on_stun_send_pkt = &turn_on_stun_send_pkt; 
    330348    sess_cb.on_channel_bound = &turn_on_channel_bound; 
    331349    sess_cb.on_rx_data = &turn_on_rx_data; 
     
    628646        return PJ_EINVALIDOP; 
    629647 
     648    /* TURN session may add some headers to the packet, so we need 
     649     * to store our actual data length to be sent here. 
     650     */ 
     651    turn_sock->body_len = pkt_len; 
    630652    return pj_turn_session_sendto(turn_sock->sess, pkt, pkt_len,  
    631653                                  addr, addr_len); 
     
    694716    /* Init send_key */ 
    695717    pj_ioqueue_op_key_init(&turn_sock->send_key, sizeof(turn_sock->send_key)); 
     718    pj_ioqueue_op_key_init(&turn_sock->int_send_key, 
     719                           sizeof(turn_sock->int_send_key)); 
    696720 
    697721    /* Send Allocate request */ 
     
    861885} 
    862886 
     887static pj_bool_t on_data_sent(pj_turn_sock *turn_sock, 
     888                              pj_ioqueue_op_key_t *send_key, 
     889                              pj_ssize_t sent) 
     890{ 
     891    unsigned header_len, sent_size; 
     892 
     893    /* Don't report to callback if this is internal message. */ 
     894    if (send_key == &turn_sock->int_send_key) { 
     895        return PJ_TRUE; 
     896    } 
     897 
     898    if (turn_sock->cb.on_data_sent) { 
     899        /* Remove the length of packet header from sent size. */ 
     900        header_len = turn_sock->pkt_len - turn_sock->body_len; 
     901        sent_size = (sent > header_len)? (sent - header_len) : 0; 
     902        (*turn_sock->cb.on_data_sent)(turn_sock, sent_size); 
     903    } 
     904 
     905    return PJ_TRUE; 
     906} 
     907 
     908 
     909static pj_bool_t on_data_sent_asock(pj_activesock_t *asock, 
     910                                     pj_ioqueue_op_key_t *send_key, 
     911                                     pj_ssize_t sent) 
     912{ 
     913    pj_turn_sock *turn_sock; 
     914 
     915    turn_sock = (pj_turn_sock*)pj_activesock_get_user_data(asock); 
     916 
     917    return on_data_sent(turn_sock, send_key, sent); 
     918} 
     919 
     920 
    863921#if PJ_HAS_SSL_SOCK 
    864922static pj_bool_t on_data_read_ssl_sock(pj_ssl_sock_t *ssl_sock, 
     
    897955    } 
    898956 
    899     return PJ_TRUE; 
     957    return on_data_sent(turn_sock, op_key, bytes_sent); 
    900958} 
    901959#endif 
    902960 
    903 /* 
    904  * Callback from TURN session to send outgoing packet. 
    905  */ 
    906 static pj_status_t turn_on_send_pkt(pj_turn_session *sess, 
    907                                     const pj_uint8_t *pkt, 
    908                                     unsigned pkt_len, 
    909                                     const pj_sockaddr_t *dst_addr, 
    910                                     unsigned dst_addr_len) 
     961 
     962static pj_status_t send_pkt(pj_turn_session *sess, 
     963                            pj_bool_t internal, 
     964                            const pj_uint8_t *pkt, 
     965                            unsigned pkt_len, 
     966                            const pj_sockaddr_t *dst_addr, 
     967                            unsigned dst_addr_len) 
    911968{ 
    912969    pj_turn_sock *turn_sock = (pj_turn_sock*)  
     
    914971    pj_ssize_t len = pkt_len; 
    915972    pj_status_t status = PJ_SUCCESS; 
     973    pj_ioqueue_key_t *send_key = &turn_sock->send_key; 
    916974 
    917975    if (turn_sock == NULL || turn_sock->is_destroying) { 
     
    922980    } 
    923981 
     982    if (internal) 
     983        send_key = &turn_sock->int_send_key; 
     984    turn_sock->pkt_len = pkt_len; 
     985 
    924986    if (turn_sock->conn_type == PJ_TURN_TP_UDP) { 
    925987        status = pj_activesock_sendto(turn_sock->active_sock, 
    926                                       &turn_sock->send_key, pkt, &len, 0, 
     988                                      send_key, pkt, &len, 0, 
    927989                                      dst_addr, dst_addr_len); 
    928990    } else if (turn_sock->alloc_param.peer_conn_type == PJ_TURN_TP_TCP) { 
     
    932994            /* Destination address is TURN server */ 
    933995            status = pj_activesock_send(turn_sock->active_sock, 
    934                                         &turn_sock->send_key, pkt, &len, 0); 
     996                                        send_key, pkt, &len, 0); 
    935997        } else { 
    936998            /* Destination address is peer, lookup data connection */ 
     
    9521014    } else  if (turn_sock->conn_type == PJ_TURN_TP_TCP) { 
    9531015        status = pj_activesock_send(turn_sock->active_sock, 
    954                                     &turn_sock->send_key, pkt, &len, 0); 
     1016                                    send_key, pkt, &len, 0); 
    9551017    } 
    9561018#if PJ_HAS_SSL_SOCK 
    9571019    else if (turn_sock->conn_type == PJ_TURN_TP_TLS) { 
    9581020        status = pj_ssl_sock_send(turn_sock->ssl_sock, 
    959                                   &turn_sock->send_key, pkt, &len, 0); 
     1021                                  send_key, pkt, &len, 0); 
    9601022    } 
    9611023#endif 
     
    9691031 
    9701032    return status; 
     1033} 
     1034 
     1035 
     1036/* 
     1037 * Callback from TURN session to send outgoing packet. 
     1038 */ 
     1039static pj_status_t turn_on_send_pkt(pj_turn_session *sess, 
     1040                                    const pj_uint8_t *pkt, 
     1041                                    unsigned pkt_len, 
     1042                                    const pj_sockaddr_t *dst_addr, 
     1043                                    unsigned dst_addr_len) 
     1044{ 
     1045    return send_pkt(sess, PJ_FALSE, pkt, pkt_len, 
     1046                    dst_addr, dst_addr_len); 
     1047} 
     1048 
     1049static pj_status_t turn_on_stun_send_pkt(pj_turn_session *sess, 
     1050                                         const pj_uint8_t *pkt, 
     1051                                         unsigned pkt_len, 
     1052                                         const pj_sockaddr_t *dst_addr, 
     1053                                         unsigned dst_addr_len) 
     1054{ 
     1055    return send_pkt(sess, PJ_TRUE, pkt, pkt_len, 
     1056                    dst_addr, dst_addr_len); 
    9711057} 
    9721058 
     
    11701256            pj_bzero(&asock_cb, sizeof(asock_cb)); 
    11711257            asock_cb.on_data_read = &on_data_read_asock; 
     1258            asock_cb.on_data_sent = &on_data_sent_asock; 
    11721259            asock_cb.on_connect_complete = &on_connect_complete_asock; 
    11731260            status = pj_activesock_create(turn_sock->pool, sock, 
     
    13991486} 
    14001487 
     1488static pj_bool_t dataconn_on_data_sent(pj_activesock_t *asock, 
     1489                                       pj_ioqueue_op_key_t *send_key, 
     1490                                       pj_ssize_t sent) 
     1491{ 
     1492    tcp_data_conn_t *conn = (tcp_data_conn_t*) 
     1493                            pj_activesock_get_user_data(asock); 
     1494    pj_turn_sock *turn_sock = conn->turn_sock; 
     1495 
     1496    return on_data_sent(turn_sock, send_key, sent); 
     1497} 
     1498 
    14011499static pj_bool_t dataconn_on_connect_complete(pj_activesock_t *asock, 
    14021500                                              pj_status_t status) 
     
    15771675    pj_bzero(&asock_cb, sizeof(asock_cb)); 
    15781676    asock_cb.on_data_read = &dataconn_on_data_read; 
     1677    asock_cb.on_data_sent = &dataconn_on_data_sent; 
    15791678    asock_cb.on_connect_complete = &dataconn_on_connect_complete; 
    15801679    status = pj_activesock_create(pool, sock, 
Note: See TracChangeset for help on using the changeset viewer.