Changeset 1763


Ignore:
Timestamp:
Feb 1, 2008 2:47:31 PM (11 years ago)
Author:
bennylp
Message:

More ticket #61: removed const from rtp and rtcp callback function declaration to allow in-place packet modification

Location:
pjproject/trunk/pjmedia
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjmedia/include/pjmedia/transport.h

    r1748 r1763  
    242242                          unsigned addr_len, 
    243243                          void (*rtp_cb)(void *user_data, 
    244                                          const void *pkt, 
     244                                         void *pkt, 
    245245                                         pj_ssize_t size), 
    246246                          void (*rtcp_cb)(void *user_data, 
    247                                           const void *pkt, 
     247                                          void *pkt, 
    248248                                          pj_ssize_t size)); 
    249249 
     
    424424                                                unsigned addr_len, 
    425425                                                void (*rtp_cb)(void *user_data, 
    426                                                                const void *pkt, 
     426                                                               void *pkt, 
    427427                                                               pj_ssize_t), 
    428428                                                void (*rtcp_cb)(void *usr_data, 
    429                                                                 const void*pkt, 
     429                                                                void*pkt, 
    430430                                                                pj_ssize_t)) 
    431431{ 
  • pjproject/trunk/pjmedia/include/pjmedia/transport_srtp.h

    r1748 r1763  
    226226 
    227227/** 
     228 * This is a utility function to decrypt SRTP packet using SRTP transport. 
     229 * This function is not part of SRTP transport's API, but it can be used 
     230 * to decrypt SRTP packets from non-network (for example, from a saved file) 
     231 * without having to use the transport framework. See pcaputil.c in the 
     232 * samples collection on how to use this function. 
     233 * 
     234 * @param tp            The SRTP transport. 
     235 * @param is_rtp        Set to non-zero if the packet is SRTP, otherwise set 
     236 *                      to zero if the packet is SRTCP. 
     237 * @param pkt           On input, it contains SRTP or SRTCP packet. On 
     238 *                      output, it contains the decrypted RTP/RTCP packet. 
     239 * @param pkt_len       On input, specify the length of the buffer. On 
     240 *                      output, it will be filled with the actual length 
     241 *                      of decrypted packet. 
     242 * 
     243 * @return              PJ_SUCCESS on success. 
     244 */ 
     245PJ_DECL(pj_status_t) pjmedia_transport_srtp_decrypt_pkt(pjmedia_transport *tp, 
     246                                                        pj_bool_t is_rtp, 
     247                                                        void *pkt, 
     248                                                        int *pkt_len); 
     249 
     250 
     251/** 
    228252 * Query member transport of SRTP. 
    229253 * 
  • pjproject/trunk/pjmedia/src/pjmedia/transport_ice.c

    r1735 r1763  
    4141 
    4242    void               (*rtp_cb)(void*, 
    43                                  const void*, 
     43                                 void*, 
    4444                                 pj_ssize_t); 
    4545    void               (*rtcp_cb)(void*, 
    46                                   const void*, 
     46                                  void*, 
    4747                                  pj_ssize_t); 
    4848}; 
     
    6060                                       unsigned addr_len, 
    6161                                       void (*rtp_cb)(void*, 
    62                                                       const void*, 
     62                                                      void*, 
    6363                                                      pj_ssize_t), 
    6464                                       void (*rtcp_cb)(void*, 
    65                                                        const void*, 
     65                                                       void*, 
    6666                                                       pj_ssize_t)); 
    6767static void        transport_detach   (pjmedia_transport *tp, 
     
    675675                                      unsigned addr_len, 
    676676                                      void (*rtp_cb)(void*, 
    677                                                      const void*, 
     677                                                     void*, 
    678678                                                     pj_ssize_t), 
    679679                                      void (*rtcp_cb)(void*, 
    680                                                       const void*, 
     680                                                      void*, 
    681681                                                      pj_ssize_t)) 
    682682{ 
  • pjproject/trunk/pjmedia/src/pjmedia/transport_srtp.c

    r1760 r1763  
    8484    pj_lock_t           *mutex; 
    8585    char                 tx_buffer[MAX_BUFFER_LEN]; 
    86     char                 rx_buffer[MAX_BUFFER_LEN]; 
    8786 
    8887    pjmedia_srtp_setting setting; 
     
    103102    void                *user_data; 
    104103    void                (*rtp_cb)( void *user_data, 
    105                                    const void *pkt, 
     104                                   void *pkt, 
    106105                                   pj_ssize_t size); 
    107106    void                (*rtcp_cb)(void *user_data, 
    108                                    const void *pkt, 
     107                                   void *pkt, 
    109108                                   pj_ssize_t size); 
    110109         
     
    118117 * This callback is called by transport when incoming rtp is received 
    119118 */ 
    120 static void srtp_rtp_cb( void *user_data, const void *pkt, pj_ssize_t size); 
     119static void srtp_rtp_cb( void *user_data, void *pkt, pj_ssize_t size); 
    121120 
    122121/* 
    123122 * This callback is called by transport when incoming rtcp is received 
    124123 */ 
    125 static void srtp_rtcp_cb( void *user_data, const void *pkt, pj_ssize_t size); 
     124static void srtp_rtcp_cb( void *user_data, void *pkt, pj_ssize_t size); 
    126125 
    127126 
     
    137136                                       unsigned addr_len, 
    138137                                       void (*rtp_cb)(void*, 
    139                                                       const void*, 
     138                                                      void*, 
    140139                                                      pj_ssize_t), 
    141140                                       void (*rtcp_cb)(void*, 
    142                                                        const void*, 
     141                                                       void*, 
    143142                                                       pj_ssize_t)); 
    144143static void        transport_detach   (pjmedia_transport *tp, 
     
    358357    /* Initialize base pjmedia_transport */ 
    359358    pj_memcpy(srtp->base.name, pool->obj_name, PJ_MAX_OBJ_NAME); 
    360     srtp->base.type = tp->type; 
     359    if (tp) 
     360        srtp->base.type = tp->type; 
     361    else 
     362        srtp->base.type = PJMEDIA_TRANSPORT_TYPE_UDP; 
    361363    srtp->base.op = &transport_srtp_op; 
    362364 
     
    565567                                    const pj_sockaddr_t *rem_rtcp, 
    566568                                    unsigned addr_len, 
    567                                     void (*rtp_cb) (void*, const void*, 
     569                                    void (*rtp_cb) (void*, void*, 
    568570                                                    pj_ssize_t), 
    569                                     void (*rtcp_cb)(void*, const void*, 
     571                                    void (*rtcp_cb)(void*, void*, 
    570572                                                    pj_ssize_t)) 
    571573{ 
     
    591593    transport_srtp *srtp = (transport_srtp*) tp; 
    592594 
    593     PJ_ASSERT_ON_FAIL(tp && srtp->real_tp, return); 
    594  
    595595    PJ_UNUSED_ARG(strm); 
    596     pjmedia_transport_detach(srtp->real_tp, srtp); 
     596    PJ_ASSERT_ON_FAIL(tp, return); 
     597 
     598    if (srtp->real_tp) { 
     599        pjmedia_transport_detach(srtp->real_tp, srtp); 
     600    } 
    597601 
    598602    /* Clear up application infos from transport */ 
     
    688692    pjmedia_transport_detach(tp, NULL); 
    689693     
    690     if (srtp->setting.close_member_tp) { 
     694    if (srtp->setting.close_member_tp && srtp->real_tp) { 
    691695        pjmedia_transport_close(srtp->real_tp); 
    692696    } 
     
    705709 * This callback is called by transport when incoming rtp is received 
    706710 */ 
    707 static void srtp_rtp_cb( void *user_data, const void *pkt, pj_ssize_t size) 
     711static void srtp_rtp_cb( void *user_data, void *pkt, pj_ssize_t size) 
    708712{ 
    709713    transport_srtp *srtp = (transport_srtp *) user_data; 
     
    716720    } 
    717721 
    718     if (size < 0 || size > sizeof(srtp->rx_buffer) || !srtp->session_inited) { 
     722    if (size < 0 || !srtp->session_inited) { 
    719723        return; 
    720724    } 
    721725 
     726    /* Make sure buffer is 32bit aligned */ 
     727    PJ_ASSERT_ON_FAIL( (((long)pkt) & 0x03)==0, return ); 
     728 
    722729    pj_lock_acquire(srtp->mutex); 
    723     pj_memcpy(srtp->rx_buffer, pkt, size); 
    724  
    725     err = srtp_unprotect(srtp->srtp_rx_ctx, srtp->rx_buffer, &len); 
     730 
     731    err = srtp_unprotect(srtp->srtp_rx_ctx, (pj_uint8_t*)pkt, &len); 
    726732     
    727733    if (err == err_status_ok) { 
    728         srtp->rtp_cb(srtp->user_data, srtp->rx_buffer, len); 
     734        srtp->rtp_cb(srtp->user_data, pkt, len); 
    729735    } else { 
    730736        PJ_LOG(5,(srtp->pool->obj_name,  
     
    739745 * This callback is called by transport when incoming rtcp is received 
    740746 */ 
    741 static void srtp_rtcp_cb( void *user_data, const void *pkt, pj_ssize_t size) 
     747static void srtp_rtcp_cb( void *user_data, void *pkt, pj_ssize_t size) 
    742748{ 
    743749    transport_srtp *srtp = (transport_srtp *) user_data; 
     
    750756    } 
    751757 
    752     if (size < 0 || size > sizeof(srtp->rx_buffer) || !srtp->session_inited) { 
     758    if (size < 0 || !srtp->session_inited) { 
    753759        return; 
    754760    } 
    755761 
     762    /* Make sure buffer is 32bit aligned */ 
     763    PJ_ASSERT_ON_FAIL( (((long)pkt) & 0x03)==0, return ); 
     764 
    756765    pj_lock_acquire(srtp->mutex); 
    757     pj_memcpy(srtp->rx_buffer, pkt, size); 
    758  
    759     err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, srtp->rx_buffer, &len); 
     766 
     767    err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, (pj_uint8_t*)pkt, &len); 
    760768 
    761769    if (err == err_status_ok) { 
    762         srtp->rtcp_cb(srtp->user_data, srtp->rx_buffer, len); 
     770        srtp->rtcp_cb(srtp->user_data, pkt, len); 
    763771    } else { 
    764772        PJ_LOG(5,(srtp->pool->obj_name,  
     
    12651273} 
    12661274 
     1275/* Utility */ 
     1276PJ_DEF(pj_status_t) pjmedia_transport_srtp_decrypt_pkt(pjmedia_transport *tp, 
     1277                                                       pj_bool_t is_rtp, 
     1278                                                       void *pkt, 
     1279                                                       int *pkt_len) 
     1280{ 
     1281    transport_srtp *srtp = (transport_srtp *)tp; 
     1282    err_status_t err; 
     1283 
     1284    if (srtp->bypass_srtp) 
     1285        return PJ_SUCCESS; 
     1286 
     1287    PJ_ASSERT_RETURN(*pkt_len>0, PJ_EINVAL); 
     1288    PJ_ASSERT_RETURN(srtp->session_inited, PJ_EINVALIDOP); 
     1289 
     1290    /* Make sure buffer is 32bit aligned */ 
     1291    PJ_ASSERT_ON_FAIL( (((long)pkt) & 0x03)==0, return PJ_EINVAL); 
     1292 
     1293    pj_lock_acquire(srtp->mutex); 
     1294 
     1295    if (is_rtp) 
     1296        err = srtp_unprotect(srtp->srtp_rx_ctx, pkt, pkt_len); 
     1297    else 
     1298        err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, pkt, pkt_len); 
     1299     
     1300    if (err != err_status_ok) { 
     1301        PJ_LOG(5,(srtp->pool->obj_name,  
     1302                  "Failed to unprotect SRTP, pkt size=%d, err=%s",  
     1303                  *pkt_len, get_libsrtp_errstr(err))); 
     1304    } 
     1305 
     1306    pj_lock_release(srtp->mutex); 
     1307 
     1308    return (err==err_status_ok) ? PJ_SUCCESS : PJMEDIA_ERRNO_FROM_LIBSRTP(err); 
     1309} 
     1310 
    12671311#endif 
    12681312 
  • pjproject/trunk/pjmedia/src/pjmedia/transport_udp.c

    r1748 r1763  
    5656    int                 addr_len;       /**< Length of addresses.           */ 
    5757    void  (*rtp_cb)(    void*,          /**< To report incoming RTP.        */ 
    58                         const void*, 
     58                        void*, 
    5959                        pj_ssize_t); 
    6060    void  (*rtcp_cb)(   void*,          /**< To report incoming RTCP.       */ 
    61                         const void*, 
     61                        void*, 
    6262                        pj_ssize_t); 
    6363 
     
    106106                                       unsigned addr_len, 
    107107                                       void (*rtp_cb)(void*, 
    108                                                       const void*, 
     108                                                      void*, 
    109109                                                      pj_ssize_t), 
    110110                                       void (*rtcp_cb)(void*, 
    111                                                        const void*, 
     111                                                       void*, 
    112112                                                       pj_ssize_t)); 
    113113static void        transport_detach   (pjmedia_transport *tp, 
     
    420420 
    421421    do { 
    422         void (*cb)(void*,const void*,pj_ssize_t); 
     422        void (*cb)(void*,void*,pj_ssize_t); 
    423423        void *user_data; 
    424424 
     
    524524 
    525525    do { 
    526         void (*cb)(void*,const void*,pj_ssize_t); 
     526        void (*cb)(void*,void*,pj_ssize_t); 
    527527        void *user_data; 
    528528 
     
    588588                                       unsigned addr_len, 
    589589                                       void (*rtp_cb)(void*, 
    590                                                       const void*, 
     590                                                      void*, 
    591591                                                      pj_ssize_t), 
    592592                                       void (*rtcp_cb)(void*, 
    593                                                        const void*, 
     593                                                       void*, 
    594594                                                       pj_ssize_t)) 
    595595{ 
Note: See TracChangeset for help on using the changeset viewer.