src/srtp.c

00001 /*
00002   The oRTP library is an RTP (Realtime Transport Protocol - rfc3550) stack.
00003   Copyright (C) 2001  Simon MORLAT simon.morlat@linphone.org
00004 
00005   This library is free software; you can redistribute it and/or
00006   modify it under the terms of the GNU Lesser General Public
00007   License as published by the Free Software Foundation; either
00008   version 2.1 of the License, or (at your option) any later version.
00009 
00010   This library is distributed in the hope that it will be useful,
00011   but WITHOUT ANY WARRANTY; without even the implied warranty of
00012   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013   Lesser General Public License for more details.
00014 
00015   You should have received a copy of the GNU Lesser General Public
00016   License along with this library; if not, write to the Free Software
00017   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018 */
00019 
00020 #if defined(WIN32) || defined(_WIN32_WCE)
00021 #include "ortp-config-win32.h"
00022 #else
00023 #include "ortp-config.h"
00024 #endif
00025 #include "ortp/ortp.h"
00026 
00027 #ifdef HAVE_SRTP
00028 
00029 #undef PACKAGE_NAME 
00030 #undef PACKAGE_STRING
00031 #undef PACKAGE_TARNAME 
00032 #undef PACKAGE_VERSION
00033 
00034 #include "ortp/srtp.h"
00035 
00036 #define SRTP_PAD_BYTES 64 /*?? */
00037 
00038 static int  srtp_sendto(RtpTransport *t, mblk_t *m, int flags, const struct sockaddr *to, socklen_t tolen){
00039         srtp_t srtp=(srtp_t)t->data;
00040         int slen;
00041         /* enlarge the buffer for srtp to write its data */
00042         msgpullup(m,msgdsize(m)+SRTP_PAD_BYTES);
00043         slen=m->b_wptr-m->b_rptr;
00044         if (srtp_protect(srtp,m->b_rptr,&slen)==err_status_ok){
00045                 return sendto(t->session->rtp.socket,m->b_rptr,slen,flags,to,tolen);
00046         }
00047         ortp_error("srtp_protect() failed");
00048         return -1;
00049 }
00050 
00051 static int srtp_recvfrom(RtpTransport *t, mblk_t *m, int flags, struct sockaddr *from, socklen_t *fromlen){
00052         srtp_t srtp=(srtp_t)t->data;
00053         int err;
00054         int slen;
00055         err=recvfrom(t->session->rtp.socket,m->b_wptr,m->b_datap->db_lim-m->b_datap->db_base,flags,from,fromlen);
00056         if (err>0){
00057 
00058                 /* keep NON-RTP data unencrypted */
00059                 rtp_header_t *rtp;
00060                 if (err>=RTP_FIXED_HEADER_SIZE)
00061                 {
00062                         rtp = (rtp_header_t*)m->b_wptr;
00063                         if (rtp->version!=2)
00064                         {
00065                                 return err;
00066                         }
00067                 }
00068 
00069                 slen=err;
00070                 if (srtp_unprotect(srtp,m->b_wptr,&slen)==err_status_ok)
00071                         return slen;
00072                 else {
00073                         ortp_error("srtp_unprotect() failed");
00074                         return -1;
00075                 }
00076         }
00077         return err;
00078 }
00079 
00080 static int  srtcp_sendto(RtpTransport *t, mblk_t *m, int flags, const struct sockaddr *to, socklen_t tolen){
00081         srtp_t srtp=(srtp_t)t->data;
00082         int slen;
00083         /* enlarge the buffer for srtp to write its data */
00084         msgpullup(m,msgdsize(m)+SRTP_PAD_BYTES);
00085         slen=m->b_wptr-m->b_rptr;
00086         if (srtp_protect_rtcp(srtp,m->b_rptr,&slen)==err_status_ok){
00087                 return sendto(t->session->rtcp.socket,m->b_rptr,slen,flags,to,tolen);
00088         }
00089         ortp_error("srtp_protect_rtcp() failed");
00090         return -1;
00091 }
00092 
00093 static int srtcp_recvfrom(RtpTransport *t, mblk_t *m, int flags, struct sockaddr *from, socklen_t *fromlen){
00094         srtp_t srtp=(srtp_t)t->data;
00095         int err;
00096         int slen;
00097         err=recvfrom(t->session->rtcp.socket,m->b_wptr,m->b_datap->db_lim-m->b_datap->db_base,flags,from,fromlen);
00098         if (err>0){
00099                 slen=err;
00100                 if (srtp_unprotect_rtcp(srtp,m->b_wptr,&slen)==err_status_ok)
00101                         return slen;
00102                 else {
00103                         ortp_error("srtp_unprotect_rtcp() failed");
00104                         return -1;
00105                 }
00106         }
00107         return err;
00108 }
00109 
00110 ortp_socket_t 
00111 srtp_getsocket(RtpTransport *t)
00112 {
00113   return t->session->rtp.socket;
00114 }
00115 
00116 ortp_socket_t 
00117 srtcp_getsocket(RtpTransport *t)
00118 {
00119   return t->session->rtcp.socket;
00120 }
00121 
00130 int srtp_transport_new(srtp_t srtp, RtpTransport **rtpt, RtpTransport **rtcpt ){
00131         if (rtpt) {
00132                 (*rtpt)=ortp_new(RtpTransport,1);
00133                 (*rtpt)->data=srtp;
00134                 (*rtpt)->t_getsocket=srtp_getsocket;
00135                 (*rtpt)->t_sendto=srtp_sendto;
00136                 (*rtpt)->t_recvfrom=srtp_recvfrom;
00137         }
00138         if (rtcpt) {
00139                 (*rtcpt)=ortp_new(RtpTransport,1);
00140                 (*rtcpt)->data=srtp;
00141                 (*rtcpt)->t_getsocket=srtcp_getsocket;
00142                 (*rtcpt)->t_sendto=srtcp_sendto;
00143                 (*rtcpt)->t_recvfrom=srtcp_recvfrom;
00144         }
00145         return 0;
00146 }
00147 
00148 err_status_t ortp_srtp_init(void)
00149 {
00150         return srtp_init();
00151 }
00152 
00153 err_status_t ortp_srtp_create(srtp_t *session, const srtp_policy_t *policy)
00154 {
00155         int i;
00156         i = srtp_create(session, policy);
00157         return i;
00158 }
00159 
00160 err_status_t ortp_srtp_dealloc(srtp_t session)
00161 {
00162         return srtp_dealloc(session);
00163 }
00164 
00165 err_status_t ortp_srtp_add_stream(srtp_t session, const srtp_policy_t *policy)
00166 {
00167         return srtp_add_stream(session, policy);
00168 }
00169 
00170 bool_t ortp_srtp_supported(void){
00171         return TRUE;
00172 }
00173 
00174 #else
00175 
00176 int srtp_transport_new(void *i, RtpTransport **rtpt, RtpTransport **rtcpt ){
00177         ortp_error("srtp_transport_new: oRTP has not been compiled with SRTP support.");
00178         return -1;
00179 }
00180 
00181 bool_t ortp_srtp_supported(void){
00182         return FALSE;
00183 }
00184 
00185 int ortp_srtp_create(void *i, const void *policy)
00186 {
00187         return -1;
00188 }
00189 
00190 int ortp_srtp_dealloc(void *session)
00191 {
00192         return -1;
00193 }
00194 
00195 int ortp_srtp_add_stream(void *session, const void *policy)
00196 {
00197         return -1;
00198 }
00199 
00200 #endif
00201 

Generated on Fri Feb 15 00:08:47 2008 for oRTP by  doxygen 1.5.4