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/pjmedia/src/pjmedia/transport_srtp.c

    r4723 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 
    … …  
    4646#define MAX_KEY_LEN                 128 
    4747 
    48 /* Initial value of probation counter. When probation counter > 0,  
     48/* Initial value of probation counter. When probation counter > 0, 
    4949 * it means SRTP is in probation state, and it may restart when 
    5050 * srtp_unprotect() returns err_status_replay_* 
    … …  
    7777 
    7878    /* cipher AES_CM, auth HMAC_SHA1, auth tag len = 10 octets */ 
    79     {"AES_CM_128_HMAC_SHA1_80", AES_128_ICM, 30, HMAC_SHA1, 20, 10, 10,  
     79    {"AES_CM_128_HMAC_SHA1_80", AES_128_ICM, 30, HMAC_SHA1, 20, 10, 10, 
    8080        sec_serv_conf_and_auth}, 
    8181 
    … …  
    8484        sec_serv_conf_and_auth}, 
    8585 
    86     /*  
     86    /* 
    8787     * F8_128_HMAC_SHA1_8 not supported by libsrtp? 
    8888     * {"F8_128_HMAC_SHA1_8", NULL_CIPHER, 0, NULL_AUTH, 0, 0, 0, sec_serv_none} 
    … …  
    125125                                   void *pkt, 
    126126                                   pj_ssize_t size); 
    127          
     127 
    128128    /* Transport information */ 
    129129    pjmedia_transport   *member_tp; /**< Underlying transport.       */ 
    … …  
    131131    /* SRTP usage policy of peer. This field is updated when media is starting. 
    132132     * This is useful when SRTP is in optional mode and peer is using mandatory 
    133      * mode, so when local is about to reinvite/update, it should offer  
     133     * mode, so when local is about to reinvite/update, it should offer 
    134134     * RTP/SAVP instead of offering RTP/AVP. 
    135135     */ 
    136136    pjmedia_srtp_use     peer_use; 
    137137 
    138     /* When probation counter > 0, it means SRTP is in probation state,  
     138    /* When probation counter > 0, it means SRTP is in probation state, 
    139139     * and it may restart when srtp_unprotect() returns err_status_replay_* 
    140140     */ 
    … …  
    206206 
    207207 
    208 static pjmedia_transport_op transport_srtp_op =  
     208static pjmedia_transport_op transport_srtp_op = 
    209209{ 
    210210    &transport_get_info, 
    … …  
    239239        "couldn't deallocate properly",     /* err_status_dealloc_fail  = 4  */ 
    240240        "couldn't initialize",              /* err_status_init_fail     = 5  */ 
    241         "can't process as much data as requested",  
     241        "can't process as much data as requested", 
    242242                                            /* err_status_terminus      = 6  */ 
    243243        "authentication failure",           /* err_status_auth_fail     = 7  */ 
    244244        "cipher failure",                   /* err_status_cipher_fail   = 8  */ 
    245245        "replay check failed (bad index)",  /* err_status_replay_fail   = 9  */ 
    246         "replay check failed (index too old)",  
     246        "replay check failed (index too old)", 
    247247                                            /* err_status_replay_old    = 10 */ 
    248248        "algorithm failed test routine",    /* err_status_algo_fail     = 11 */ 
    249249        "unsupported operation",            /* err_status_no_such_op    = 12 */ 
    250250        "no appropriate context found",     /* err_status_no_ctx        = 13 */ 
    251         "unable to perform desired validation",  
     251        "unable to perform desired validation", 
    252252                                            /* err_status_cant_check    = 14 */ 
    253253        "can't use key any more",           /* err_status_key_expired   = 15 */ 
    … …  
    286286 
    287287        err = srtp_init(); 
    288         if (err != err_status_ok) {  
    289             PJ_LOG(4, (THIS_FILE, "Failed to initialize libsrtp: %s",  
     288        if (err != err_status_ok) { 
     289            PJ_LOG(4, (THIS_FILE, "Failed to initialize libsrtp: %s", 
    290290                       get_libsrtp_errstr(err))); 
    291291            return PJMEDIA_ERRNO_FROM_LIBSRTP(err); 
    … …  
    294294        if (pjmedia_endpt_atexit(endpt, pjmedia_srtp_deinit_lib) != PJ_SUCCESS) 
    295295        { 
    296             /* There will be memory leak when it fails to schedule libsrtp  
     296            /* There will be memory leak when it fails to schedule libsrtp 
    297297             * deinitialization, however the memory leak could be harmless, 
    298              * since in modern OS's memory used by an application is released  
     298             * since in modern OS's memory used by an application is released 
    299299             * when the application terminates. 
    300300             */ 
    … …  
    307307    PJ_UNUSED_ARG(endpt); 
    308308#endif 
    309      
     309 
    310310    return PJ_SUCCESS; 
    311311} 
    … …  
    338338#endif 
    339339    if (err != err_status_ok) { 
    340         PJ_LOG(4, (THIS_FILE, "Failed to deinitialize libsrtp: %s",  
     340        PJ_LOG(4, (THIS_FILE, "Failed to deinitialize libsrtp: %s", 
    341341                   get_libsrtp_errstr(err))); 
    342342    } 
    … …  
    350350    int i; 
    351351    int cs_cnt = sizeof(crypto_suites)/sizeof(crypto_suites[0]); 
    352      
     352 
    353353    /* treat unspecified crypto_name as crypto 'NULL' */ 
    354354    if (crypto_name->slen == 0) 
    … …  
    421421 
    422422    /* Check crypto availability */ 
    423     if (opt && opt->crypto_count == 0 &&  
     423    if (opt && opt->crypto_count == 0 && 
    424424        opt->use == PJMEDIA_SRTP_MANDATORY) 
    425425        return PJMEDIA_SRTP_ESDPREQCRYPTO; 
    … …  
    435435 
    436436            /* check key length */ 
    437             if (opt->crypto[i].key.slen &&  
    438                 opt->crypto[i].key.slen <  
     437            if (opt->crypto[i].key.slen && 
     438                opt->crypto[i].key.slen < 
    439439                (pj_ssize_t)crypto_suites[cs_idx].cipher_key_len) 
    440440                return PJMEDIA_SRTP_EINKEYLEN; 
    … …  
    506506 */ 
    507507PJ_DEF(pj_status_t) pjmedia_transport_srtp_start( 
    508                            pjmedia_transport *tp,  
     508                           pjmedia_transport *tp, 
    509509                           const pjmedia_srtp_crypto *tx, 
    510510                           const pjmedia_srtp_crypto *rx) 
    … …  
    518518    int              cr_rx_idx = 0; 
    519519    int              au_rx_idx = 0; 
    520     int              crypto_suites_cnt; 
    521520    pj_status_t      status = PJ_SUCCESS; 
    522521 
    … …  
    528527        pjmedia_transport_srtp_stop(tp); 
    529528    } 
    530  
    531     crypto_suites_cnt = sizeof(crypto_suites)/sizeof(crypto_suites[0]); 
    532529 
    533530    /* Get encryption and authentication method */ 
    … …  
    545542 
    546543    /* Check whether the crypto-suite requested is supported */ 
    547     if (cr_tx_idx == -1 || cr_rx_idx == -1 || au_tx_idx == -1 ||  
     544    if (cr_tx_idx == -1 || cr_rx_idx == -1 || au_tx_idx == -1 || 
    548545        au_rx_idx == -1) 
    549546    { 
    … …  
    648645        else 
    649646            b64[b64_len] = '\0'; 
    650          
     647 
    651648        PJ_LOG(5, (srtp->pool->obj_name, "TX: %s key=%s", 
    652649                   srtp->tx_policy.name.ptr, b64)); 
    … …  
    700697    err = srtp_dealloc(p_srtp->srtp_rx_ctx); 
    701698    if (err != err_status_ok) { 
    702         PJ_LOG(4, (p_srtp->pool->obj_name,  
     699        PJ_LOG(4, (p_srtp->pool->obj_name, 
    703700                   "Failed to dealloc RX SRTP context: %s", 
    704701                   get_libsrtp_errstr(err))); 
    … …  
    706703    err = srtp_dealloc(p_srtp->srtp_tx_ctx); 
    707704    if (err != err_status_ok) { 
    708         PJ_LOG(4, (p_srtp->pool->obj_name,  
     705        PJ_LOG(4, (p_srtp->pool->obj_name, 
    709706                   "Failed to dealloc TX SRTP context: %s", 
    710707                   get_libsrtp_errstr(err))); 
    … …  
    753750    info->spc_info[spc_info_idx].type = PJMEDIA_TRANSPORT_TYPE_SRTP; 
    754751    info->spc_info[spc_info_idx].cbsize = sizeof(srtp_info); 
    755     pj_memcpy(&info->spc_info[spc_info_idx].buffer, &srtp_info,  
     752    pj_memcpy(&info->spc_info[spc_info_idx].buffer, &srtp_info, 
    756753              sizeof(srtp_info)); 
    757754 
    … …  
    782779 
    783780    /* Attach itself to transport */ 
    784     status = pjmedia_transport_attach(srtp->member_tp, srtp, rem_addr,  
     781    status = pjmedia_transport_attach(srtp->member_tp, srtp, rem_addr, 
    785782                                      rem_rtcp, addr_len, &srtp_rtp_cb, 
    786783                                      &srtp_rtcp_cb); 
    … …  
    842839 
    843840    if (err == err_status_ok) { 
    844         status = pjmedia_transport_send_rtp(srtp->member_tp,  
     841        status = pjmedia_transport_send_rtp(srtp->member_tp, 
    845842                                            srtp->rtp_tx_buffer, len); 
    846843    } else { 
    847844        status = PJMEDIA_ERRNO_FROM_LIBSRTP(err); 
    848845    } 
    849      
     846 
    850847    return status; 
    851848} 
    … …  
    870867 
    871868    if (srtp->bypass_srtp) { 
    872         return pjmedia_transport_send_rtcp2(srtp->member_tp, addr, addr_len,  
     869        return pjmedia_transport_send_rtcp2(srtp->member_tp, addr, addr_len, 
    873870                                            pkt, size); 
    874871    } 
    … …  
    903900{ 
    904901    transport_srtp *srtp = (transport_srtp *) tp; 
    905      
     902 
    906903    PJ_ASSERT_RETURN(tp, PJ_EINVAL); 
    907904 
    … …  
    965962    } 
    966963    err = srtp_unprotect(srtp->srtp_rx_ctx, (pj_uint8_t*)pkt, &len); 
    967     if (srtp->probation_cnt > 0 &&  
    968         (err == err_status_replay_old || err == err_status_replay_fail))  
     964    if (srtp->probation_cnt > 0 && 
     965        (err == err_status_replay_old || err == err_status_replay_fail)) 
    969966    { 
    970967        /* Handle such condition that stream is updated (RTP seq is reinited 
    971          * & SRTP is restarted), but some old packets are still coming  
     968         * & SRTP is restarted), but some old packets are still coming 
    972969         * so SRTP is learning wrong RTP seq. While the newly inited RTP seq 
    973          * comes, SRTP thinks the RTP seq is replayed, so srtp_unprotect()  
     970         * comes, SRTP thinks the RTP seq is replayed, so srtp_unprotect() 
    974971         * will return err_status_replay_*. Restarting SRTP can resolve this. 
    975972         */ 
    … …  
    982979                                              &tx, &rx); 
    983980        if (status != PJ_SUCCESS) { 
    984             PJ_LOG(5,(srtp->pool->obj_name, "Failed to restart SRTP, err=%s",  
     981            PJ_LOG(5,(srtp->pool->obj_name, "Failed to restart SRTP, err=%s", 
    985982                      get_libsrtp_errstr(err))); 
    986983        } else if (!srtp->bypass_srtp) { 
    … …  
    990987 
    991988    if (err != err_status_ok) { 
    992         PJ_LOG(5,(srtp->pool->obj_name,  
    993                   "Failed to unprotect SRTP, pkt size=%d, err=%s",  
     989        PJ_LOG(5,(srtp->pool->obj_name, 
     990                  "Failed to unprotect SRTP, pkt size=%d, err=%s", 
    994991                  size, get_libsrtp_errstr(err))); 
    995992    } else { 
    … …  
    10361033    err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, (pj_uint8_t*)pkt, &len); 
    10371034    if (err != err_status_ok) { 
    1038         PJ_LOG(5,(srtp->pool->obj_name,  
     1035        PJ_LOG(5,(srtp->pool->obj_name, 
    10391036                  "Failed to unprotect SRTCP, pkt size=%d, err=%s", 
    10401037                  size, get_libsrtp_errstr(err))); 
    … …  
    10561053 */ 
    10571054static pj_status_t generate_crypto_attr_value(pj_pool_t *pool, 
    1058                                               char *buffer, int *buffer_len,  
     1055                                              char *buffer, int *buffer_len, 
    10591056                                              pjmedia_srtp_crypto *crypto, 
    10601057                                              int tag) 
    … …  
    10881085            key_ok = PJ_TRUE; 
    10891086 
    1090             err = crypto_get_random((unsigned char*)key,  
     1087            err = crypto_get_random((unsigned char*)key, 
    10911088                                     crypto_suites[cs_idx].cipher_key_len); 
    10921089            if (err != err_status_ok) { 
    … …  
    11001097        } while (!key_ok); 
    11011098        crypto->key.ptr = (char*) 
    1102                           pj_pool_zalloc(pool,  
     1099                          pj_pool_zalloc(pool, 
    11031100                                         crypto_suites[cs_idx].cipher_key_len); 
    11041101        pj_memcpy(crypto->key.ptr, key, crypto_suites[cs_idx].cipher_key_len); 
    … …  
    11181115 
    11191116    b64_key[b64_key_len] = '\0'; 
    1120      
     1117 
    11211118    PJ_ASSERT_RETURN(*buffer_len >= (crypto->name.slen + \ 
    11221119                     b64_key_len + 16), PJ_ETOOSMALL); 
    … …  
    11241121    /* Print the crypto attribute value. */ 
    11251122    print_len = pj_ansi_snprintf(buffer, *buffer_len, "%d %s inline:%s", 
    1126                                    tag,  
     1123                                   tag, 
    11271124                                   crypto_suites[cs_idx].name, 
    11281125                                   b64_key); 
    … …  
    12061203    crypto->key.ptr = (char*) pj_pool_zalloc(pool, MAX_KEY_LEN); 
    12071204    itmp = MAX_KEY_LEN; 
    1208     status = pj_base64_decode(&tmp, (pj_uint8_t*)crypto->key.ptr,  
     1205    status = pj_base64_decode(&tmp, (pj_uint8_t*)crypto->key.ptr, 
    12091206                              &itmp); 
    12101207    if (status != PJ_SUCCESS) { 
    … …  
    12271224 
    12281225    PJ_ASSERT_RETURN(tp, PJ_EINVAL); 
    1229      
     1226 
    12301227    pj_bzero(&srtp->rx_policy_neg, sizeof(srtp->rx_policy_neg)); 
    12311228    pj_bzero(&srtp->tx_policy_neg, sizeof(srtp->tx_policy_neg)); 
    … …  
    12751272 
    12761273PROPAGATE_MEDIA_CREATE: 
    1277     return pjmedia_transport_media_create(srtp->member_tp, sdp_pool,  
     1274    return pjmedia_transport_media_create(srtp->member_tp, sdp_pool, 
    12781275                                          member_tp_option, sdp_remote, 
    12791276                                          media_index); 
    … …  
    12971294 
    12981295    PJ_ASSERT_RETURN(tp && sdp_pool && sdp_local, PJ_EINVAL); 
    1299      
     1296 
    13001297    pj_bzero(&srtp->rx_policy_neg, sizeof(srtp->rx_policy_neg)); 
    13011298    pj_bzero(&srtp->tx_policy_neg, sizeof(srtp->tx_policy_neg)); 
    … …  
    13071304 
    13081305    /* Bypass if media transport is not RTP/AVP or RTP/SAVP */ 
    1309     if (pj_stricmp(&m_loc->desc.transport, &ID_RTP_AVP)  != 0 &&  
     1306    if (pj_stricmp(&m_loc->desc.transport, &ID_RTP_AVP)  != 0 && 
    13101307        pj_stricmp(&m_loc->desc.transport, &ID_RTP_SAVP) != 0) 
    13111308        goto BYPASS_SRTP; 
    … …  
    13181315     */ 
    13191316    /* 
    1320     if (pjmedia_sdp_media_find_attr(m_loc, &ID_INACTIVE, NULL) ||  
     1317    if (pjmedia_sdp_media_find_attr(m_loc, &ID_INACTIVE, NULL) || 
    13211318        (m_rem && pjmedia_sdp_media_find_attr(m_rem, &ID_INACTIVE, NULL))) 
    13221319        goto BYPASS_SRTP; 
    13231320    */ 
    13241321 
    1325     /* Check remote media transport & set local media transport  
     1322    /* Check remote media transport & set local media transport 
    13261323     * based on SRTP usage option. 
    13271324     */ 
    … …  
    13331330                goto BYPASS_SRTP; 
    13341331            case PJMEDIA_SRTP_OPTIONAL: 
    1335                 m_loc->desc.transport =  
     1332                m_loc->desc.transport = 
    13361333                                (srtp->peer_use == PJMEDIA_SRTP_MANDATORY)? 
    13371334                                ID_RTP_SAVP : ID_RTP_AVP; 
    … …  
    13561353                if (buffer_len) { 
    13571354                    pj_strset(&attr_value, buffer, buffer_len); 
    1358                     attr = pjmedia_sdp_attr_create(srtp->pool, ID_CRYPTO.ptr,  
     1355                    attr = pjmedia_sdp_attr_create(srtp->pool, ID_CRYPTO.ptr, 
    13591356                                                   &attr_value); 
    13601357                    m_loc->attr[m_loc->attr_count++] = attr; 
    … …  
    14011398                has_crypto_attr = PJ_TRUE; 
    14021399 
    1403                 status = parse_attr_crypto(srtp->pool, m_rem->attr[i],  
     1400                status = parse_attr_crypto(srtp->pool, m_rem->attr[i], 
    14041401                                           &tmp_rx_crypto, &tags[cr_attr_count]); 
    14051402                if (status != PJ_SUCCESS) 
    14061403                    return status; 
    1407           
     1404 
    14081405                /* Check duplicated tag */ 
    14091406                for (j=0; j<cr_attr_count; ++j) { 
    … …  
    14171414                    /* lets see if the crypto-suite offered is supported */ 
    14181415                    for (j=0; j<srtp->setting.crypto_count; ++j) 
    1419                         if (pj_stricmp(&tmp_rx_crypto.name,  
     1416                        if (pj_stricmp(&tmp_rx_crypto.name, 
    14201417                                       &srtp->setting.crypto[j].name) == 0) 
    14211418                        { 
    … …  
    14341431                            //          hex_test_key, 
    14351432                            //          strlen(hex_test_key)); 
    1436                             //pj_strset(test_key, raw_test_key,  
     1433                            //pj_strset(test_key, raw_test_key, 
    14371434                            //    crypto_suites[cs_idx].cipher_key_len); 
    14381435                            /* EO Force to use test key */ 
    14391436 
    1440                             if (tmp_rx_crypto.key.slen !=  
     1437                            if (tmp_rx_crypto.key.slen != 
    14411438                                (int)crypto_suites[cs_idx].cipher_key_len) 
    14421439                                return PJMEDIA_SRTP_EINKEYLEN; 
    … …  
    14591456                case PJMEDIA_SRTP_OPTIONAL: 
    14601457                    /* bypass SRTP when no crypto-attr and remote uses RTP/AVP */ 
    1461                     if (!has_crypto_attr &&  
     1458                    if (!has_crypto_attr && 
    14621459                        pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP) == 0) 
    14631460                        goto BYPASS_SRTP; 
    14641461                    /* bypass SRTP when nothing match and remote uses RTP/AVP */ 
    1465                     else if (matched_idx == -1 &&  
     1462                    else if (matched_idx == -1 && 
    14661463                        pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP) == 0) 
    14671464                        goto BYPASS_SRTP; 
    … …  
    14851482            } 
    14861483 
    1487             /* we have to generate crypto answer,  
     1484            /* we have to generate crypto answer, 
    14881485             * with srtp->tx_policy_neg matched the offer 
    14891486             * and rem_tag contains matched offer tag. 
    … …  
    14971494 
    14981495            srtp->tx_policy_neg = srtp->setting.crypto[matched_idx]; 
    1499              
     1496 
    15001497            /* If buffer_len==0, just skip the crypto attribute. */ 
    15011498            if (buffer_len) { 
    15021499                pj_strset(&attr_value, buffer, buffer_len); 
    1503                 attr = pjmedia_sdp_attr_create(sdp_pool, ID_CRYPTO.ptr,  
     1500                attr = pjmedia_sdp_attr_create(sdp_pool, ID_CRYPTO.ptr, 
    15041501                                               &attr_value); 
    15051502                m_loc->attr[m_loc->attr_count++] = attr; 
    … …  
    15081505            /* At this point, we get valid rx_policy_neg & tx_policy_neg. */ 
    15091506        } 
    1510              
     1507 
    15111508    } 
    15121509    goto PROPAGATE_MEDIA_CREATE; 
    … …  
    15191516 
    15201517PROPAGATE_MEDIA_CREATE: 
    1521     return pjmedia_transport_encode_sdp(srtp->member_tp, sdp_pool,  
     1518    return pjmedia_transport_encode_sdp(srtp->member_tp, sdp_pool, 
    15221519                                        sdp_local, sdp_remote, media_index); 
    15231520} 
    … …  
    15481545    /* For answerer side, this function will just have to start SRTP */ 
    15491546 
    1550     /* Check remote media transport & set local media transport  
     1547    /* Check remote media transport & set local media transport 
    15511548     * based on SRTP usage option. 
    15521549     */ 
    … …  
    15611558            // Regardless the answer's transport type (RTP/AVP or RTP/SAVP), 
    15621559            // the answer must be processed through in optional mode. 
    1563             // Please note that at this point transport type is ensured to be  
     1560            // Please note that at this point transport type is ensured to be 
    15641561            // RTP/AVP or RTP/SAVP, see transport_media_create() 
    15651562            //if (pj_stricmp(&m_rem->desc.transport, &m_loc->desc.transport)) { 
    … …  
    15741571        } 
    15751572    } 
    1576      
     1573 
    15771574    if (srtp->offerer_side) { 
    15781575        /* find supported crypto-suite, get the tag, and assign policy_local */ 
    … …  
    15931590            has_crypto_attr = PJ_TRUE; 
    15941591 
    1595             status = parse_attr_crypto(srtp->pool, m_rem->attr[i],  
     1592            status = parse_attr_crypto(srtp->pool, m_rem->attr[i], 
    15961593                                       &tmp_tx_crypto, &rem_tag); 
    15971594            if (status != PJ_SUCCESS) 
    … …  
    16061603 
    16071604            /* match the crypto name */ 
    1608             if (pj_stricmp(&tmp_tx_crypto.name,  
     1605            if (pj_stricmp(&tmp_tx_crypto.name, 
    16091606                &srtp->setting.crypto[rem_tag-1].name) != 0) 
    16101607            { 
    … …  
    16341631 
    16351632    /* Make sure we have the SRTP policies */ 
    1636     if (srtp_crypto_empty(&srtp->tx_policy_neg) ||  
     1633    if (srtp_crypto_empty(&srtp->tx_policy_neg) || 
    16371634        srtp_crypto_empty(&srtp->rx_policy_neg)) 
    16381635    { 
    … …  
    16711668 
    16721669PROPAGATE_MEDIA_START: 
    1673     return pjmedia_transport_media_start(srtp->member_tp, pool,  
     1670    return pjmedia_transport_media_start(srtp->member_tp, pool, 
    16741671                                         sdp_local, sdp_remote, 
    16751672                                         media_index); 
    … …  
    16851682    status = pjmedia_transport_media_stop(srtp->member_tp); 
    16861683    if (status != PJ_SUCCESS) 
    1687         PJ_LOG(4, (srtp->pool->obj_name,  
     1684        PJ_LOG(4, (srtp->pool->obj_name, 
    16881685                   "SRTP failed stop underlying media transport.")); 
    16891686 
    … …  
    17201717    else 
    17211718        err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, pkt, pkt_len); 
    1722      
     1719 
    17231720    if (err != err_status_ok) { 
    1724         PJ_LOG(5,(srtp->pool->obj_name,  
    1725                   "Failed to unprotect SRTP, pkt size=%d, err=%s",  
     1721        PJ_LOG(5,(srtp->pool->obj_name, 
     1722                  "Failed to unprotect SRTP, pkt size=%d, err=%s", 
    17261723                  *pkt_len, get_libsrtp_errstr(err))); 
    17271724    } 
Note: See TracChangeset for help on using the changeset viewer.