Ignore:
Timestamp:
Feb 4, 2014 10:13:56 AM (10 years ago)
Author:
bennylp
Message:

Misc (re #1630): Fixing warnings about variable set but not used with recent gcc

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4360 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
    … …  
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020#include "turn.h" 
    … …  
    6363                                pj_turn_relay_res *relay); 
    6464static void destroy_relay(pj_turn_relay_res *relay); 
    65 static void on_rx_from_peer(pj_ioqueue_key_t *key,  
    66                             pj_ioqueue_op_key_t *op_key,  
     65static void on_rx_from_peer(pj_ioqueue_key_t *key, 
     66                            pj_ioqueue_op_key_t *op_key, 
    6767                            pj_ssize_t bytes_read); 
    6868static pj_status_t stun_on_send_msg(pj_stun_session *sess, 
    … …  
    125125    /* Check if we can satisfy the bandwidth */ 
    126126    if (cfg->bandwidth > MAX_CLIENT_BANDWIDTH) { 
    127         pj_stun_session_respond(sess, rdata,  
     127        pj_stun_session_respond(sess, rdata, 
    128128                                PJ_STUN_SC_ALLOCATION_QUOTA_REACHED, 
    129129                                "Invalid bandwidth", NULL, PJ_TRUE, 
    … …  
    137137    if (attr_req_tp == NULL) { 
    138138        pj_stun_session_respond(sess, rdata, PJ_STUN_SC_BAD_REQUEST, 
    139                                 "Missing REQUESTED-TRANSPORT attribute",  
     139                                "Missing REQUESTED-TRANSPORT attribute", 
    140140                                NULL, PJ_TRUE, src_addr, src_addr_len); 
    141141        return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_BAD_REQUEST); 
    … …  
    157157    if (attr_res_token) { 
    158158        /* We don't support RESERVATION-TOKEN for now */ 
    159         pj_stun_session_respond(sess, rdata,  
     159        pj_stun_session_respond(sess, rdata, 
    160160                                PJ_STUN_SC_BAD_REQUEST, 
    161                                 "RESERVATION-TOKEN is not supported", NULL,  
     161                                "RESERVATION-TOKEN is not supported", NULL, 
    162162                                PJ_TRUE, src_addr, src_addr_len); 
    163163        return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_BAD_REQUEST); 
    … …  
    171171        if (cfg->lifetime < MIN_LIFETIME) { 
    172172            pj_stun_session_respond(sess, rdata, PJ_STUN_SC_BAD_REQUEST, 
    173                                     "LIFETIME too short", NULL,  
     173                                    "LIFETIME too short", NULL, 
    174174                                    PJ_TRUE, src_addr, src_addr_len); 
    175175            return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_BAD_REQUEST); 
    … …  
    207207    /* Add LIFETIME. */ 
    208208    pj_stun_msg_add_uint_attr(tdata->pool, tdata->msg, 
    209                               PJ_STUN_ATTR_LIFETIME,  
     209                              PJ_STUN_ATTR_LIFETIME, 
    210210                              (unsigned)alloc->relay.lifetime); 
    211211 
    … …  
    223223                                  &alloc->hkey.clt_addr, 
    224224                                  pj_sockaddr_get_len(&alloc->hkey.clt_addr)); 
    225      
     225 
    226226    /* Send the response */ 
    227227    return pj_stun_session_send_msg(srv_sess, transport, PJ_TRUE, 
    228                                     PJ_FALSE, &alloc->hkey.clt_addr,  
     228                                    PJ_FALSE, &alloc->hkey.clt_addr, 
    229229                                    pj_sockaddr_get_len(&alloc->hkey.clt_addr), 
    230230                                    tdata); 
    … …  
    256256 
    257257    /* Lookup the password */ 
    258     status = pj_turn_get_password(NULL, NULL, &realm->value,  
    259                                   &user->value, alloc->pool,  
    260                                   &alloc->cred.data.static_cred.data_type,  
     258    status = pj_turn_get_password(NULL, NULL, &realm->value, 
     259                                  &user->value, alloc->pool, 
     260                                  &alloc->cred.data.static_cred.data_type, 
    261261                                  &alloc->cred.data.static_cred.data); 
    262262    if (status != PJ_SUCCESS) 
    … …  
    315315    pj_memcpy(&alloc->hkey.clt_addr, src_addr, src_addr_len); 
    316316 
    317     status = pj_lock_create_recursive_mutex(pool, alloc->obj_name,  
     317    status = pj_lock_create_recursive_mutex(pool, alloc->obj_name, 
    318318                                            &alloc->lock); 
    319319    if (status != PJ_SUCCESS) { 
    … …  
    328328 
    329329    /* Print info */ 
    330     pj_ansi_strcpy(alloc->info,  
     330    pj_ansi_strcpy(alloc->info, 
    331331                   pj_turn_tp_type_name(transport->listener->tp_type)); 
    332332    alloc->info[3] = ':'; 
    … …  
    372372 
    373373    /* Done */ 
    374     pj_sockaddr_print(&alloc->relay.hkey.addr, str_tmp,  
     374    pj_sockaddr_print(&alloc->relay.hkey.addr, str_tmp, 
    375375                      sizeof(str_tmp), 3); 
    376     PJ_LOG(4,(alloc->obj_name, "Client %s created, relay addr=%s:%s",  
     376    PJ_LOG(4,(alloc->obj_name, "Client %s created, relay addr=%s:%s", 
    377377              alloc->info, pj_turn_tp_type_name(req.tp_type), str_tmp)); 
    378378 
    … …  
    384384    /* Send reply to the ALLOCATE request */ 
    385385    pj_strerror(status, str_tmp, sizeof(str_tmp)); 
    386     pj_stun_session_respond(srv_sess, rdata, PJ_STUN_SC_BAD_REQUEST, str_tmp,  
     386    pj_stun_session_respond(srv_sess, rdata, PJ_STUN_SC_BAD_REQUEST, str_tmp, 
    387387                            transport, PJ_TRUE, src_addr, src_addr_len); 
    388388 
    … …  
    397397{ 
    398398    if (relay->timer.id) { 
    399         pj_timer_heap_cancel(relay->allocation->server->core.timer_heap,  
     399        pj_timer_heap_cancel(relay->allocation->server->core.timer_heap, 
    400400                             &relay->timer); 
    401401        relay->timer.id = PJ_FALSE; 
    … …  
    483483 
    484484/* Initiate shutdown sequence for this allocation and start destroy timer. 
    485  * Once allocation is marked as shutting down, any packets will be  
    486  * rejected/discarded  
     485 * Once allocation is marked as shutting down, any packets will be 
     486 * rejected/discarded 
    487487 */ 
    488488static void alloc_shutdown(pj_turn_allocation *alloc) 
    … …  
    502502         */ 
    503503        return; 
    504     }  
     504    } 
    505505 
    506506    pj_assert(alloc->relay.timer.id == TIMER_ID_NONE); 
    … …  
    531531    pj_assert(alloc->relay.timer.id != TIMER_ID_DESTROY); 
    532532    if (alloc->relay.timer.id != 0) { 
    533         pj_timer_heap_cancel(alloc->server->core.timer_heap,  
     533        pj_timer_heap_cancel(alloc->server->core.timer_heap, 
    534534                             &alloc->relay.timer); 
    535535        alloc->relay.timer.id = TIMER_ID_NONE; 
    … …  
    540540 
    541541    alloc->relay.timer.id = TIMER_ID_TIMEOUT; 
    542     status = pj_timer_heap_schedule(alloc->server->core.timer_heap,  
     542    status = pj_timer_heap_schedule(alloc->server->core.timer_heap, 
    543543                                    &alloc->relay.timer, &delay); 
    544544    if (status != PJ_SUCCESS) { 
    … …  
    566566        e->id = TIMER_ID_NONE; 
    567567 
    568         PJ_LOG(4,(alloc->obj_name,  
    569                   "Client %s refresh timed-out, shutting down..",  
     568        PJ_LOG(4,(alloc->obj_name, 
     569                  "Client %s refresh timed-out, shutting down..", 
    570570                  alloc->info)); 
    571571 
    … …  
    575575        e->id = TIMER_ID_NONE; 
    576576 
    577         PJ_LOG(4,(alloc->obj_name, "Client %s destroying..",  
     577        PJ_LOG(4,(alloc->obj_name, "Client %s destroying..", 
    578578                  alloc->info)); 
    579579 
    … …  
    601601 
    602602    pj_bzero(relay, sizeof(*relay)); 
    603      
     603 
    604604    relay->allocation = alloc; 
    605605    relay->tp.sock = PJ_INVALID_SOCKET; 
    606      
     606 
    607607    /* TODO: get the requested address family from somewhere */ 
    608608    af = alloc->transport->listener->addr.addr.sa_family; 
    … …  
    622622    /* Lifetime and timeout */ 
    623623    relay->lifetime = req->lifetime; 
    624     pj_timer_entry_init(&relay->timer, TIMER_ID_NONE, relay,  
     624    pj_timer_entry_init(&relay->timer, TIMER_ID_NONE, relay, 
    625625                        &relay_timeout_cb); 
    626626    resched_timeout(alloc); 
    627      
     627 
    628628    /* Transport type */ 
    629629    relay->hkey.tp_type = req->tp_type; 
    … …  
    677677        pj_sockaddr_init(af, &bound_addr, NULL, port); 
    678678 
    679         status = pj_sock_bind(relay->tp.sock, &bound_addr,  
     679        status = pj_sock_bind(relay->tp.sock, &bound_addr, 
    680680                              pj_sockaddr_get_len(&bound_addr)); 
    681681        if (status == PJ_SUCCESS) 
    … …  
    685685    if (status != PJ_SUCCESS) { 
    686686        /* Unable to allocate port */ 
    687         PJ_LOG(4,(THIS_FILE, "Unable to allocate relay, giving up: err %d",  
     687        PJ_LOG(4,(THIS_FILE, "Unable to allocate relay, giving up: err %d", 
    688688                  status)); 
    689689        pj_sock_close(relay->tp.sock); 
    … …  
    696696    status = pj_sock_getsockname(relay->tp.sock, &relay->hkey.addr, &namelen); 
    697697    if (status != PJ_SUCCESS) { 
    698         PJ_LOG(4,(THIS_FILE, "pj_sock_getsockname() failed: err %d",  
     698        PJ_LOG(4,(THIS_FILE, "pj_sock_getsockname() failed: err %d", 
    699699                  status)); 
    700700        pj_sock_close(relay->tp.sock); 
    … …  
    703703    } 
    704704    if (!pj_sockaddr_has_addr(&relay->hkey.addr)) { 
    705         pj_sockaddr_copy_addr(&relay->hkey.addr,  
     705        pj_sockaddr_copy_addr(&relay->hkey.addr, 
    706706                              &alloc->transport->listener->addr); 
    707707    } 
    … …  
    719719                                      relay, &icb, &relay->tp.key); 
    720720    if (status != PJ_SUCCESS) { 
    721         PJ_LOG(4,(THIS_FILE, "pj_ioqueue_register_sock() failed: err %d",  
     721        PJ_LOG(4,(THIS_FILE, "pj_ioqueue_register_sock() failed: err %d", 
    722722                  status)); 
    723723        pj_sock_close(relay->tp.sock); 
    … …  
    737737static void send_reply_err(pj_turn_allocation *alloc, 
    738738                           const pj_stun_rx_data *rdata, 
    739                            pj_bool_t cache,  
     739                           pj_bool_t cache, 
    740740                           int code, const char *errmsg) 
    741741{ 
    742742    pj_status_t status; 
    743743 
    744     status = pj_stun_session_respond(alloc->sess, rdata, code, errmsg, NULL,  
     744    status = pj_stun_session_respond(alloc->sess, rdata, code, errmsg, NULL, 
    745745                                     cache, &alloc->hkey.clt_addr, 
    746746                                     pj_sockaddr_get_len(&alloc->hkey.clt_addr.addr)); 
    … …  
    787787    } 
    788788 
    789     status = pj_stun_session_send_msg(alloc->sess, NULL, PJ_TRUE,  
    790                                       PJ_FALSE, &alloc->hkey.clt_addr,   
    791                                       pj_sockaddr_get_len(&alloc->hkey.clt_addr),  
     789    status = pj_stun_session_send_msg(alloc->sess, NULL, PJ_TRUE, 
     790                                      PJ_FALSE, &alloc->hkey.clt_addr, 
     791                                      pj_sockaddr_get_len(&alloc->hkey.clt_addr), 
    792792                                      tdata); 
    793793    if (status != PJ_SUCCESS) { 
    … …  
    807807    perm = PJ_POOL_ZALLOC_T(alloc->pool, pj_turn_permission); 
    808808    pj_memcpy(&perm->hkey.peer_addr, peer_addr, addr_len); 
    809      
     809 
    810810    perm->allocation = alloc; 
    811811    perm->channel = PJ_TURN_INVALID_CHANNEL; 
    … …  
    815815 
    816816    /* Register to hash table (only the address part!) */ 
    817     pj_hash_set(alloc->pool, alloc->peer_table,  
    818                 pj_sockaddr_get_addr(&perm->hkey.peer_addr),  
     817    pj_hash_set(alloc->pool, alloc->peer_table, 
     818                pj_sockaddr_get_addr(&perm->hkey.peer_addr), 
    819819                pj_sockaddr_get_addr_len(&perm->hkey.peer_addr), 0, perm); 
    820820 
    … …  
    835835 
    836836    /* Remove from permission hash table */ 
    837     pj_hash_set(NULL, alloc->peer_table,  
    838                 pj_sockaddr_get_addr(&perm->hkey.peer_addr),  
     837    pj_hash_set(NULL, alloc->peer_table, 
     838                pj_sockaddr_get_addr(&perm->hkey.peer_addr), 
    839839                pj_sockaddr_get_addr_len(&perm->hkey.peer_addr), 0, NULL); 
    840840 
    841841    /* Remove from channel hash table, if assigned a channel number */ 
    842842    if (perm->channel != PJ_TURN_INVALID_CHANNEL) { 
    843         pj_hash_set(NULL, alloc->ch_table, &perm->channel,  
     843        pj_hash_set(NULL, alloc->ch_table, &perm->channel, 
    844844                    sizeof(perm->channel), 0, NULL); 
    845845    } 
    … …  
    859859 
    860860    /* Lookup in peer hash table */ 
    861     perm = (pj_turn_permission*)  
    862            pj_hash_get(alloc->peer_table,  
     861    perm = (pj_turn_permission*) 
     862           pj_hash_get(alloc->peer_table, 
    863863                       pj_sockaddr_get_addr(peer_addr), 
    864                        pj_sockaddr_get_addr_len(peer_addr),  
     864                       pj_sockaddr_get_addr_len(peer_addr), 
    865865                       NULL); 
    866866    return perm ? check_permission_expiry(perm) : NULL; 
    … …  
    881881} 
    882882 
    883 /* Update permission because of data from client to peer.  
     883/* Update permission because of data from client to peer. 
    884884 * Return PJ_TRUE is permission is found. 
    885885 */ 
    … …  
    917917         * callbacks. 
    918918         * 
    919          * Note: currently it is necessary to specify the  
     919         * Note: currently it is necessary to specify the 
    920920         * PJ_STUN_NO_FINGERPRINT_CHECK otherwise the FINGERPRINT 
    921921         * attribute inside STUN Send Indication message will mess up 
    … …  
    930930        status = pj_stun_session_on_rx_pkt(alloc->sess, pkt->pkt, pkt->len, 
    931931                                           options, NULL, &parsed_len, 
    932                                            &pkt->src.clt_addr,  
     932                                           &pkt->src.clt_addr, 
    933933                                           pkt->src_addr_len); 
    934934 
    … …  
    963963        if (alloc->transport->listener->tp_type == PJ_TURN_TP_UDP) { 
    964964            if (pkt->len < pj_ntohs(cd->length)+sizeof(*cd)) { 
    965                 PJ_LOG(4,(alloc->obj_name,  
     965                PJ_LOG(4,(alloc->obj_name, 
    966966                          "ChannelData from %s discarded: UDP size error", 
    967967                          alloc->info)); 
    … …  
    976976        if (!perm) { 
    977977            /* Discard */ 
    978             PJ_LOG(4,(alloc->obj_name,  
     978            PJ_LOG(4,(alloc->obj_name, 
    979979                      "ChannelData from %s discarded: ch#0x%x not found", 
    980980                      alloc->info, pj_ntohs(cd->ch_number))); 
    … …  
    999999 
    10001000/* 
    1001  * Handle incoming packet from peer. This function is called by  
     1001 * Handle incoming packet from peer. This function is called by 
    10021002 * on_rx_from_peer(). 
    10031003 */ 
    … …  
    10101010 
    10111011    /* Lookup permission */ 
    1012     perm = lookup_permission_by_addr(alloc, src_addr,  
     1012    perm = lookup_permission_by_addr(alloc, src_addr, 
    10131013                                     pj_sockaddr_get_len(src_addr)); 
    10141014    if (perm == NULL) { 
    … …  
    10501050        pj_status_t status; 
    10511051 
    1052         status = pj_stun_session_create_ind(alloc->sess,  
     1052        status = pj_stun_session_create_ind(alloc->sess, 
    10531053                                            PJ_STUN_DATA_INDICATION, &tdata); 
    10541054        if (status != PJ_SUCCESS) { 
    … …  
    10571057        } 
    10581058 
    1059         pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg,  
     1059        pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg, 
    10601060                                      PJ_STUN_ATTR_XOR_PEER_ADDR, PJ_TRUE, 
    10611061                                      src_addr, pj_sockaddr_get_len(src_addr)); 
    10621062        pj_stun_msg_add_binary_attr(tdata->pool, tdata->msg, 
    1063                                     PJ_STUN_ATTR_DATA,  
     1063                                    PJ_STUN_ATTR_DATA, 
    10641064                                    (const pj_uint8_t*)pkt, len); 
    10651065 
    1066         pj_stun_session_send_msg(alloc->sess, NULL, PJ_FALSE,  
    1067                                  PJ_FALSE, &alloc->hkey.clt_addr,  
    1068                                  pj_sockaddr_get_len(&alloc->hkey.clt_addr),  
     1066        pj_stun_session_send_msg(alloc->sess, NULL, PJ_FALSE, 
     1067                                 PJ_FALSE, &alloc->hkey.clt_addr, 
     1068                                 pj_sockaddr_get_len(&alloc->hkey.clt_addr), 
    10691069                                 tdata); 
    10701070    } 
    … …  
    10741074 * ioqueue notification on RX packets from the relay socket. 
    10751075 */ 
    1076 static void on_rx_from_peer(pj_ioqueue_key_t *key,  
    1077                             pj_ioqueue_op_key_t *op_key,  
     1076static void on_rx_from_peer(pj_ioqueue_key_t *key, 
     1077                            pj_ioqueue_op_key_t *op_key, 
    10781078                            pj_ssize_t bytes_read) 
    10791079{ 
    … …  
    10971097        status = pj_ioqueue_recvfrom(key, op_key, 
    10981098                                     rel->tp.rx_pkt, &bytes_read, 0, 
    1099                                      &rel->tp.src_addr,  
     1099                                     &rel->tp.src_addr, 
    11001100                                     &rel->tp.src_addr_len); 
    11011101 
    … …  
    11571157    if (alloc->relay.lifetime == 0) { 
    11581158        /* Reject with 437 if we're shutting down */ 
    1159         send_reply_err(alloc, rdata, PJ_TRUE,  
     1159        send_reply_err(alloc, rdata, PJ_TRUE, 
    11601160                       PJ_STUN_SC_ALLOCATION_MISMATCH, NULL); 
    11611161        return PJ_SUCCESS; 
    … …  
    11631163 
    11641164    if (msg->hdr.type == PJ_STUN_REFRESH_REQUEST) { 
    1165         /*  
    1166          * Handle REFRESH request  
     1165        /* 
     1166         * Handle REFRESH request 
    11671167         */ 
    11681168        pj_stun_lifetime_attr *lifetime; 
    … …  
    11761176        bandwidth = (pj_stun_bandwidth_attr*) 
    11771177                    pj_stun_msg_find_attr(msg, PJ_STUN_ATTR_BANDWIDTH, 0); 
     1178 
     1179        /* TODO: process bandwidth */ 
     1180        PJ_UNUSED_ARG(bandwidth); 
    11781181 
    11791182        if (lifetime && lifetime->value==0) { 
    … …  
    11871190 
    11881191            /* Shutdown allocation */ 
    1189             PJ_LOG(4,(alloc->obj_name,  
     1192            PJ_LOG(4,(alloc->obj_name, 
    11901193                      "Client %s request to dealloc, shutting down", 
    11911194                      alloc->info)); 
    … …  
    11971200             * This is a refresh request. 
    11981201             */ 
    1199              
     1202 
    12001203            /* Update lifetime */ 
    12011204            if (lifetime) { 
    … …  
    12271230 
    12281231        if (!ch_attr || !peer_attr) { 
    1229             send_reply_err(alloc, rdata, PJ_TRUE,  
     1232            send_reply_err(alloc, rdata, PJ_TRUE, 
    12301233                           PJ_STUN_SC_BAD_REQUEST, NULL); 
    12311234            return PJ_SUCCESS; 
    … …  
    12351238        p1 = lookup_permission_by_chnum(alloc, PJ_STUN_GET_CH_NB(ch_attr->value)); 
    12361239 
    1237         /* If permission is found, this is supposed to be a channel bind  
     1240        /* If permission is found, this is supposed to be a channel bind 
    12381241         * refresh. Make sure it's for the same peer. 
    12391242         */ 
    … …  
    12411244            if (pj_sockaddr_cmp(&p1->hkey.peer_addr, &peer_attr->sockaddr)) { 
    12421245                /* Address mismatch. Send 400 */ 
    1243                 send_reply_err(alloc, rdata, PJ_TRUE,  
    1244                                PJ_STUN_SC_BAD_REQUEST,  
     1246                send_reply_err(alloc, rdata, PJ_TRUE, 
     1247                               PJ_STUN_SC_BAD_REQUEST, 
    12451248                               "Peer address mismatch"); 
    12461249                return PJ_SUCCESS; 
    … …  
    12631266                                       pj_sockaddr_get_len(&peer_attr->sockaddr)); 
    12641267        if (p2 && p2->channel != PJ_TURN_INVALID_CHANNEL) { 
    1265             send_reply_err(alloc, rdata, PJ_TRUE, PJ_STUN_SC_BAD_REQUEST,  
     1268            send_reply_err(alloc, rdata, PJ_TRUE, PJ_STUN_SC_BAD_REQUEST, 
    12661269                           "Peer address already assigned a channel number"); 
    12671270            return PJ_SUCCESS; 
    … …  
    12811284        /* Register to hash table */ 
    12821285        pj_assert(sizeof(p2->channel==2)); 
    1283         pj_hash_set(alloc->pool, alloc->ch_table, &p2->channel,  
     1286        pj_hash_set(alloc->pool, alloc->ch_table, &p2->channel, 
    12841287                    sizeof(p2->channel), 0, p2); 
    12851288 
    … …  
    13681371    /* Relay the data to peer */ 
    13691372    len = data_attr->length; 
    1370     pj_sock_sendto(alloc->relay.tp.sock, data_attr->data,  
     1373    pj_sock_sendto(alloc->relay.tp.sock, data_attr->data, 
    13711374                   &len, 0, &peer_attr->sockaddr, 
    13721375                   pj_sockaddr_get_len(&peer_attr->sockaddr)); 
Note: See TracChangeset for help on using the changeset viewer.