Ignore:
Timestamp:
Apr 9, 2008 9:38:12 AM (16 years ago)
Author:
bennylp
Message:

More ticket #485: huge changeset to support TURN TCP. Please see ticket #485 for the details

File:
1 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/pjnath/src/pjturn-srv/allocation.c

    r1879 r1913  
    6666                            pj_ssize_t bytes_read); 
    6767static pj_status_t stun_on_send_msg(pj_stun_session *sess, 
     68                                    void *token, 
    6869                                    const void *pkt, 
    6970                                    pj_size_t pkt_size, 
    … …  
    7475                                      unsigned pkt_len, 
    7576                                      const pj_stun_rx_data *rdata, 
     77                                      void *token, 
    7678                                      const pj_sockaddr_t *src_addr, 
    7779                                      unsigned src_addr_len); 
    … …  
    8082                                         unsigned pkt_len, 
    8183                                         const pj_stun_msg *msg, 
     84                                         void *token, 
    8285                                         const pj_sockaddr_t *src_addr, 
    8386                                         unsigned src_addr_len); 
    … …  
    124127        pj_stun_session_respond(sess, rdata,  
    125128                                PJ_STUN_SC_ALLOCATION_QUOTA_REACHED, 
    126                                 "Invalid bandwidth", PJ_TRUE, 
     129                                "Invalid bandwidth", NULL, PJ_TRUE, 
    127130                                src_addr, src_addr_len); 
    128131        return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_ALLOCATION_QUOTA_REACHED); 
    … …  
    135138        pj_stun_session_respond(sess, rdata, PJ_STUN_SC_BAD_REQUEST, 
    136139                                "Missing REQUESTED-TRANSPORT attribute",  
    137                                 PJ_TRUE, src_addr, src_addr_len); 
     140                                NULL, PJ_TRUE, src_addr, src_addr_len); 
    138141        return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_BAD_REQUEST); 
    139142    } 
    … …  
    144147    if (cfg->tp_type != PJ_TURN_TP_UDP) { 
    145148        pj_stun_session_respond(sess, rdata, PJ_STUN_SC_UNSUPP_TRANSPORT_PROTO, 
    146                                 NULL, PJ_TRUE, src_addr, src_addr_len); 
     149                                NULL, NULL, PJ_TRUE, src_addr, src_addr_len); 
    147150        return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_UNSUPP_TRANSPORT_PROTO); 
    148151    } 
    … …  
    156159        pj_stun_session_respond(sess, rdata,  
    157160                                PJ_STUN_SC_BAD_REQUEST, 
    158                                 "RESERVATION-TOKEN is not supported", PJ_TRUE,  
    159                                 src_addr, src_addr_len); 
     161                                "RESERVATION-TOKEN is not supported", NULL,  
     162                                PJ_TRUE, src_addr, src_addr_len); 
    160163        return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_BAD_REQUEST); 
    161164    } 
    … …  
    168171        pj_stun_session_respond(sess, rdata,  
    169172                                PJ_STUN_SC_BAD_REQUEST, 
    170                                 "REQUESTED-PROPS is not supported", PJ_TRUE,  
    171                                 src_addr, src_addr_len); 
     173                                "REQUESTED-PROPS is not supported",  
     174                                NULL, PJ_TRUE, src_addr, src_addr_len); 
    172175        return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_BAD_REQUEST); 
    173176    } 
    … …  
    180183        if (cfg->lifetime < MIN_LIFETIME) { 
    181184            pj_stun_session_respond(sess, rdata, PJ_STUN_SC_BAD_REQUEST, 
    182                                     "LIFETIME too short", PJ_TRUE,  
    183                                     src_addr, src_addr_len); 
     185                                    "LIFETIME too short", NULL,  
     186                                    PJ_TRUE, src_addr, src_addr_len); 
    184187            return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_BAD_REQUEST); 
    185188        } 
    … …  
    197200static pj_status_t send_allocate_response(pj_turn_allocation *alloc, 
    198201                                          pj_stun_session *srv_sess, 
     202                                          pj_turn_transport *transport, 
    199203                                          const pj_stun_rx_data *rdata) 
    200204{ 
    … …  
    233237     
    234238    /* Send the response */ 
    235     return pj_stun_session_send_msg(srv_sess, PJ_TRUE, 
    236                                     &alloc->hkey.clt_addr,  
     239    return pj_stun_session_send_msg(srv_sess, transport, PJ_TRUE, 
     240                                    PJ_FALSE, &alloc->hkey.clt_addr,  
    237241                                    pj_sockaddr_get_len(&alloc->hkey.clt_addr), 
    238242                                    tdata); 
    … …  
    284288 * Create new allocation. 
    285289 */ 
    286 PJ_DEF(pj_status_t) pj_turn_allocation_create(pj_turn_listener *listener, 
     290PJ_DEF(pj_status_t) pj_turn_allocation_create(pj_turn_transport *transport, 
    287291                                              const pj_sockaddr_t *src_addr, 
    288292                                              unsigned src_addr_len, 
    … …  
    291295                                              pj_turn_allocation **p_alloc) 
    292296{ 
    293     pj_turn_srv *srv = listener->server; 
     297    pj_turn_srv *srv = transport->listener->server; 
    294298    const pj_stun_msg *msg = rdata->msg; 
    295299    pj_pool_t *pool; 
    … …  
    311315    alloc->pool = pool; 
    312316    alloc->obj_name = pool->obj_name; 
    313     alloc->listener = listener; 
    314     alloc->clt_sock = PJ_INVALID_SOCKET; 
    315317    alloc->relay.tp.sock = PJ_INVALID_SOCKET; 
     318    alloc->server = transport->listener->server; 
    316319 
    317320    alloc->bandwidth = req.bandwidth; 
    318321 
    319     alloc->hkey.tp_type = listener->tp_type; 
     322    /* Set transport */ 
     323    alloc->transport = transport; 
     324    pj_turn_transport_add_ref(transport, alloc); 
     325 
     326    alloc->hkey.tp_type = transport->listener->tp_type; 
    320327    pj_memcpy(&alloc->hkey.clt_addr, src_addr, src_addr_len); 
    321328 
    … …  
    333340 
    334341    /* Print info */ 
    335     pj_ansi_strcpy(alloc->info, pj_turn_tp_type_name(listener->tp_type)); 
     342    pj_ansi_strcpy(alloc->info,  
     343                   pj_turn_tp_type_name(transport->listener->tp_type)); 
    336344    alloc->info[3] = ':'; 
    337345    pj_sockaddr_print(src_addr, alloc->info+4, sizeof(alloc->info)-4, 3); 
    … …  
    371379 
    372380    /* Respond to ALLOCATE request */ 
    373     status = send_allocate_response(alloc, srv_sess, rdata); 
     381    status = send_allocate_response(alloc, srv_sess, transport, rdata); 
    374382    if (status != PJ_SUCCESS) 
    375383        goto on_error; 
    … …  
    389397    pj_strerror(status, str_tmp, sizeof(str_tmp)); 
    390398    pj_stun_session_respond(srv_sess, rdata, PJ_STUN_SC_BAD_REQUEST, str_tmp,  
    391                             PJ_TRUE, src_addr, src_addr_len); 
     399                            transport, PJ_TRUE, src_addr, src_addr_len); 
    392400 
    393401    /* Cleanup */ 
    … …  
    401409{ 
    402410    if (relay->timer.id) { 
    403         pj_timer_heap_cancel(relay->allocation->listener->server->core.timer_heap,  
     411        pj_timer_heap_cancel(relay->allocation->server->core.timer_heap,  
    404412                             &relay->timer); 
    405413        relay->timer.id = PJ_FALSE; 
    … …  
    428436 
    429437    /* Unregister this allocation */ 
    430     pj_turn_srv_unregister_allocation(alloc->listener->server, alloc); 
     438    pj_turn_srv_unregister_allocation(alloc->server, alloc); 
    431439 
    432440    /* Destroy relay */ 
    … …  
    436444    if (alloc->lock) { 
    437445        pj_lock_acquire(alloc->lock); 
     446    } 
     447 
     448    /* Unreference transport */ 
     449    if (alloc->transport) { 
     450        pj_turn_transport_dec_ref(alloc->transport, alloc); 
     451        alloc->transport = NULL; 
    438452    } 
    439453 
    … …  
    466480 
    467481 
     482/* 
     483 * Handle transport closure. 
     484 */ 
     485PJ_DEF(void) pj_turn_allocation_on_transport_closed( pj_turn_allocation *alloc, 
     486                                                     pj_turn_transport *tp) 
     487{ 
     488    PJ_LOG(5,(alloc->obj_name, "Transport %s unexpectedly closed, destroying " 
     489              "allocation %s", tp->info, alloc->info)); 
     490    pj_turn_transport_dec_ref(tp, alloc); 
     491    alloc->transport = NULL; 
     492    destroy_allocation(alloc); 
     493} 
     494 
     495 
    468496/* Initiate shutdown sequence for this allocation and start destroy timer. 
    469497 * Once allocation is marked as shutting down, any packets will be  
    … …  
    477505    if (alloc->relay.timer.id == TIMER_ID_TIMEOUT) { 
    478506        /* Cancel existing shutdown timer */ 
    479         pj_timer_heap_cancel(alloc->listener->server->core.timer_heap, 
     507        pj_timer_heap_cancel(alloc->server->core.timer_heap, 
    480508                             &alloc->relay.timer); 
    481509        alloc->relay.timer.id = TIMER_ID_NONE; 
    … …  
    499527    /* Schedule destroy timer */ 
    500528    alloc->relay.timer.id = TIMER_ID_DESTROY; 
    501     pj_timer_heap_schedule(alloc->listener->server->core.timer_heap, 
     529    pj_timer_heap_schedule(alloc->server->core.timer_heap, 
    502530                           &alloc->relay.timer, &destroy_delay); 
    503531} 
    … …  
    515543    pj_assert(alloc->relay.timer.id != TIMER_ID_DESTROY); 
    516544    if (alloc->relay.timer.id != 0) { 
    517         pj_timer_heap_cancel(alloc->listener->server->core.timer_heap, 
     545        pj_timer_heap_cancel(alloc->server->core.timer_heap,  
    518546                             &alloc->relay.timer); 
    519547        alloc->relay.timer.id = TIMER_ID_NONE; 
    … …  
    524552 
    525553    alloc->relay.timer.id = TIMER_ID_TIMEOUT; 
    526     status = pj_timer_heap_schedule(alloc->listener->server->core.timer_heap, 
     554    status = pj_timer_heap_schedule(alloc->server->core.timer_heap,  
    527555                                    &alloc->relay.timer, &delay); 
    528556    if (status != PJ_SUCCESS) { 
    … …  
    590618     
    591619    /* TODO: get the requested address family from somewhere */ 
    592     af = alloc->listener->addr.addr.sa_family; 
     620    af = alloc->transport->listener->addr.addr.sa_family; 
    593621 
    594622    /* Save realm */ 
    … …  
    687715    } 
    688716    if (!pj_sockaddr_has_addr(&relay->hkey.addr)) { 
    689         pj_sockaddr_copy_addr(&relay->hkey.addr, &alloc->listener->addr); 
     717        pj_sockaddr_copy_addr(&relay->hkey.addr,  
     718                              &alloc->transport->listener->addr); 
    690719    } 
    691720    if (!pj_sockaddr_has_addr(&relay->hkey.addr)) { 
    … …  
    725754    pj_status_t status; 
    726755 
    727     status = pj_stun_session_respond(alloc->sess, rdata, code, errmsg, cache, 
    728                                      &alloc->hkey.clt_addr, 
     756    status = pj_stun_session_respond(alloc->sess, rdata, code, errmsg, NULL,  
     757                                     cache, &alloc->hkey.clt_addr, 
    729758                                     pj_sockaddr_get_len(&alloc->hkey.clt_addr.addr)); 
    730759    if (status != PJ_SUCCESS) { 
    … …  
    770799    } 
    771800 
    772     status = pj_stun_session_send_msg(alloc->sess, PJ_TRUE,  
    773                                       &alloc->hkey.clt_addr,   
     801    status = pj_stun_session_send_msg(alloc->sess, NULL, PJ_TRUE,  
     802                                      PJ_FALSE, &alloc->hkey.clt_addr,   
    774803                                      pj_sockaddr_get_len(&alloc->hkey.clt_addr),  
    775804                                      tdata); 
    … …  
    791820    pj_memcpy(&perm->hkey.peer_addr, peer_addr, addr_len); 
    792821     
    793     if (alloc->listener->tp_type == PJ_TURN_TP_UDP) { 
    794         perm->sock = alloc->listener->sock; 
    795     } else { 
    796         pj_assert(!"TCP is not supported yet"); 
    797         return NULL; 
    798     } 
    799  
    800822    perm->allocation = alloc; 
    801823    perm->channel = PJ_TURN_INVALID_CHANNEL; 
    … …  
    901923         */ 
    902924        unsigned options = PJ_STUN_CHECK_PACKET; 
    903         if (pkt->listener->tp_type == PJ_TURN_TP_UDP) 
     925        unsigned parsed_len = 0; 
     926 
     927        if (pkt->transport->listener->tp_type == PJ_TURN_TP_UDP) 
    904928            options |= PJ_STUN_IS_DATAGRAM; 
    905929 
    906930        status = pj_stun_session_on_rx_pkt(alloc->sess, pkt->pkt, pkt->len, 
    907                                            options, NULL, 
     931                                           options, NULL, &parsed_len, 
    908932                                           &pkt->src.clt_addr,  
    909933                                           pkt->src_addr_len); 
     934 
     935        if (pkt->transport->listener->tp_type == PJ_TURN_TP_UDP) { 
     936            pkt->len = 0; 
     937        } else if (parsed_len > 0) { 
     938            if (parsed_len == pkt->len) { 
     939                pkt->len = 0; 
     940            } else { 
     941                pj_memmove(pkt->pkt, pkt->pkt+parsed_len, 
     942                           pkt->len - parsed_len); 
     943                pkt->len -= parsed_len; 
     944            } 
     945        } 
     946 
    910947        if (status != PJ_SUCCESS) { 
    911948            alloc_err(alloc, "Error handling STUN packet", status); 
    … …  
    924961 
    925962        /* For UDP check the packet length */ 
    926         if (alloc->listener->tp_type == PJ_TURN_TP_UDP) { 
     963        if (alloc->transport->listener->tp_type == PJ_TURN_TP_UDP) { 
    927964            if (pkt->len < pj_ntohs(cd->length)+sizeof(*cd)) { 
    928965                PJ_LOG(4,(alloc->obj_name,  
    … …  
    10041041 
    10051042        /* Send to client */ 
    1006         pj_turn_listener_sendto(alloc->listener, rel->tp.tx_pkt, 
    1007                                len+sizeof(pj_turn_channel_data), 0, 
    1008                                &alloc->hkey.clt_addr, 
    1009                                pj_sockaddr_get_len(&alloc->hkey.clt_addr)); 
     1043        alloc->transport->sendto(alloc->transport, rel->tp.tx_pkt, 
     1044                                 len+sizeof(pj_turn_channel_data), 0, 
     1045                                 &alloc->hkey.clt_addr, 
     1046                                 pj_sockaddr_get_len(&alloc->hkey.clt_addr)); 
    10101047    } else { 
    10111048        /* Send Data Indication */ 
    … …  
    10271064                                    (const pj_uint8_t*)pkt, len); 
    10281065 
    1029         pj_stun_session_send_msg(alloc->sess, PJ_FALSE,  
    1030                                  &alloc->hkey.clt_addr,  
     1066        pj_stun_session_send_msg(alloc->sess, NULL, PJ_FALSE,  
     1067                                 PJ_FALSE, &alloc->hkey.clt_addr,  
    10311068                                 pj_sockaddr_get_len(&alloc->hkey.clt_addr),  
    10321069                                 tdata); 
    … …  
    10771114 */ 
    10781115static pj_status_t stun_on_send_msg(pj_stun_session *sess, 
     1116                                    void *token, 
    10791117                                    const void *pkt, 
    10801118                                    pj_size_t pkt_size, 
    … …  
    10841122    pj_turn_allocation *alloc; 
    10851123 
     1124    PJ_UNUSED_ARG(token); 
     1125 
    10861126    alloc = (pj_turn_allocation*) pj_stun_session_get_user_data(sess); 
    10871127 
    1088     return pj_turn_listener_sendto(alloc->listener, pkt, pkt_size, 0, 
    1089                                   dst_addr, addr_len); 
     1128    return alloc->transport->sendto(alloc->transport, pkt, pkt_size, 0, 
     1129                                    dst_addr, addr_len); 
    10901130} 
    10911131 
    … …  
    10991139                                      unsigned pkt_len, 
    11001140                                      const pj_stun_rx_data *rdata, 
     1141                                      void *token, 
    11011142                                      const pj_sockaddr_t *src_addr, 
    11021143                                      unsigned src_addr_len) 
    … …  
    11071148    PJ_UNUSED_ARG(pkt); 
    11081149    PJ_UNUSED_ARG(pkt_len); 
     1150    PJ_UNUSED_ARG(token); 
    11091151    PJ_UNUSED_ARG(src_addr); 
    11101152    PJ_UNUSED_ARG(src_addr_len); 
    … …  
    12751317                                         unsigned pkt_len, 
    12761318                                         const pj_stun_msg *msg, 
     1319                                         void *token, 
    12771320                                         const pj_sockaddr_t *src_addr, 
    12781321                                         unsigned src_addr_len) 
    … …  
    12821325    pj_turn_allocation *alloc; 
    12831326    pj_turn_permission *perm; 
     1327    pj_ssize_t len; 
    12841328 
    12851329    PJ_UNUSED_ARG(pkt); 
    12861330    PJ_UNUSED_ARG(pkt_len); 
     1331    PJ_UNUSED_ARG(token); 
    12871332    PJ_UNUSED_ARG(src_addr); 
    12881333    PJ_UNUSED_ARG(src_addr_len); 
    … …  
    13211366        return PJ_SUCCESS; 
    13221367 
    1323     /* Relay the data to client */ 
    1324     if (alloc->hkey.tp_type == PJ_TURN_TP_UDP) { 
    1325         pj_ssize_t len = data_attr->length; 
    1326         pj_sock_sendto(alloc->listener->sock, data_attr->data,  
    1327                        &len, 0, &peer_attr->sockaddr, 
    1328                        pj_sockaddr_get_len(&peer_attr->sockaddr)); 
    1329     } else { 
    1330         pj_assert(!"TCP is not supported"); 
    1331     } 
     1368    /* Relay the data to peer */ 
     1369    len = data_attr->length; 
     1370    pj_sock_sendto(alloc->relay.tp.sock, data_attr->data,  
     1371                   &len, 0, &peer_attr->sockaddr, 
     1372                   pj_sockaddr_get_len(&peer_attr->sockaddr)); 
    13321373 
    13331374    return PJ_SUCCESS; 
Note: See TracChangeset for help on using the changeset viewer.