2002-06-16 16:06:38 +00:00
/*
* Asterisk - - A telephony toolkit for Linux .
*
* Real - time Protocol Support
2004-06-29 20:10:57 +00:00
* Supports RTP and RTCP with Symmetric RTP support for NAT
* traversal
2002-06-16 16:06:38 +00:00
*
2005-01-21 07:06:25 +00:00
* Copyright ( C ) 1999 - 2005 , Digium , Inc .
2002-06-16 16:06:38 +00:00
*
2004-06-29 20:10:57 +00:00
* Mark Spencer < markster @ digium . com >
2002-06-16 16:06:38 +00:00
*
* This program is free software , distributed under the terms of
* the GNU General Public License
*/
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <sys/time.h>
# include <signal.h>
# include <errno.h>
# include <unistd.h>
# include <netinet/in.h>
# include <sys/time.h>
# include <sys/socket.h>
# include <arpa/inet.h>
# include <fcntl.h>
2005-06-06 20:27:51 +00:00
# include "asterisk.h"
2005-06-06 22:12:19 +00:00
ASTERISK_FILE_VERSION ( __FILE__ , " $Revision$ " )
2005-06-06 20:27:51 +00:00
2005-04-21 06:02:45 +00:00
# include "asterisk/rtp.h"
# include "asterisk/frame.h"
# include "asterisk/logger.h"
# include "asterisk/options.h"
# include "asterisk/channel.h"
# include "asterisk/acl.h"
# include "asterisk/channel.h"
# include "asterisk/config.h"
# include "asterisk/lock.h"
# include "asterisk/utils.h"
# include "asterisk/cli.h"
# include "asterisk/unaligned.h"
2002-06-16 16:06:38 +00:00
2004-06-30 06:03:57 +00:00
# define MAX_TIMESTAMP_SKEW 640
2003-06-28 16:40:02 +00:00
# define RTP_MTU 1200
2004-05-05 03:56:27 +00:00
static int dtmftimeout = 3000 ; /* 3000 samples */
2002-06-16 16:06:38 +00:00
2003-05-16 02:50:46 +00:00
static int rtpstart = 0 ;
static int rtpend = 0 ;
2004-10-30 01:52:12 +00:00
static int rtpdebug = 0 ; /* Are we debugging? */
static struct sockaddr_in rtpdebugaddr ; /* Debug packets to/from this host */
2004-07-19 18:09:33 +00:00
# ifdef SO_NO_CHECK
2005-03-31 19:09:48 +00:00
static int nochecksums = 0 ;
2004-07-19 18:09:33 +00:00
# endif
2003-05-16 02:50:46 +00:00
2004-06-29 20:10:57 +00:00
/* The value of each payload format mapping: */
2003-03-12 06:00:18 +00:00
struct rtpPayloadType {
2004-10-30 01:52:12 +00:00
int isAstFormat ; /* whether the following code is an AST_FORMAT */
int code ;
2003-03-12 06:00:18 +00:00
} ;
# define MAX_RTP_PT 256
2004-04-20 19:23:08 +00:00
# define FLAG_3389_WARNING (1 << 0)
2002-06-16 16:06:38 +00:00
struct ast_rtp {
int s ;
char resp ;
struct ast_frame f ;
2003-06-28 16:40:02 +00:00
unsigned char rawdata [ 8192 + AST_FRIENDLY_OFFSET ] ;
2002-06-16 16:06:38 +00:00
unsigned int ssrc ;
unsigned int lastts ;
2005-04-04 02:13:40 +00:00
unsigned int lastdigitts ;
2002-06-16 16:06:38 +00:00
unsigned int lastrxts ;
2003-06-28 16:40:02 +00:00
unsigned int lastividtimestamp ;
unsigned int lastovidtimestamp ;
2004-11-17 19:04:48 +00:00
unsigned int lasteventseqn ;
2003-02-05 19:26:49 +00:00
int lasttxformat ;
2003-02-16 06:00:12 +00:00
int lastrxformat ;
2002-06-16 16:06:38 +00:00
int dtmfcount ;
2003-08-14 21:55:31 +00:00
unsigned int dtmfduration ;
2003-03-07 06:00:13 +00:00
int nat ;
2004-04-20 19:23:08 +00:00
int flags ;
2002-06-16 16:06:38 +00:00
struct sockaddr_in us ;
struct sockaddr_in them ;
struct timeval rxcore ;
struct timeval txcore ;
2004-03-15 16:20:01 +00:00
struct timeval dtmfmute ;
2002-08-09 17:17:54 +00:00
struct ast_smoother * smoother ;
2002-06-16 16:06:38 +00:00
int * ioid ;
unsigned short seqno ;
2004-10-19 21:07:10 +00:00
unsigned short rxseqno ;
2002-06-16 16:06:38 +00:00
struct sched_context * sched ;
struct io_context * io ;
void * data ;
ast_rtp_callback callback ;
2004-10-30 01:52:12 +00:00
struct rtpPayloadType current_RTP_PT [ MAX_RTP_PT ] ;
int rtp_lookup_code_cache_isAstFormat ; /* a cache for the result of rtp_lookup_code(): */
int rtp_lookup_code_cache_code ;
int rtp_lookup_code_cache_result ;
int rtp_offered_from_local ;
2003-06-28 16:40:02 +00:00
struct ast_rtcp * rtcp ;
} ;
struct ast_rtcp {
int s ; /* Socket */
struct sockaddr_in us ;
struct sockaddr_in them ;
2002-06-16 16:06:38 +00:00
} ;
2003-02-16 06:00:12 +00:00
static struct ast_rtp_protocol * protos = NULL ;
2003-02-12 13:59:15 +00:00
int ast_rtp_fd ( struct ast_rtp * rtp )
{
return rtp - > s ;
}
2002-06-16 16:06:38 +00:00
2003-06-28 16:40:02 +00:00
int ast_rtcp_fd ( struct ast_rtp * rtp )
{
if ( rtp - > rtcp )
return rtp - > rtcp - > s ;
return - 1 ;
}
2002-06-16 16:06:38 +00:00
void ast_rtp_set_data ( struct ast_rtp * rtp , void * data )
{
rtp - > data = data ;
}
void ast_rtp_set_callback ( struct ast_rtp * rtp , ast_rtp_callback callback )
{
rtp - > callback = callback ;
}
2003-03-07 06:00:13 +00:00
void ast_rtp_setnat ( struct ast_rtp * rtp , int nat )
{
rtp - > nat = nat ;
}
2003-02-12 13:59:15 +00:00
static struct ast_frame * send_dtmf ( struct ast_rtp * rtp )
2002-06-16 16:06:38 +00:00
{
2004-03-15 16:20:01 +00:00
struct timeval tv ;
static struct ast_frame null_frame = { AST_FRAME_NULL , } ;
2004-06-30 16:56:51 +00:00
char iabuf [ INET_ADDRSTRLEN ] ;
2004-03-15 16:20:01 +00:00
gettimeofday ( & tv , NULL ) ;
if ( ( tv . tv_sec < rtp - > dtmfmute . tv_sec ) | |
( ( tv . tv_sec = = rtp - > dtmfmute . tv_sec ) & & ( tv . tv_usec < rtp - > dtmfmute . tv_usec ) ) ) {
2004-12-28 16:43:20 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " Ignore potential DTMF echo from '%s' \n " , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) ) ;
2004-03-15 16:20:01 +00:00
rtp - > resp = 0 ;
rtp - > dtmfduration = 0 ;
return & null_frame ;
}
2004-12-28 16:43:20 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " Sending dtmf: %d (%c), at %s \n " , rtp - > resp , rtp - > resp , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) ) ;
2004-12-09 14:54:13 +00:00
if ( rtp - > resp = = ' X ' ) {
rtp - > f . frametype = AST_FRAME_CONTROL ;
rtp - > f . subclass = AST_CONTROL_FLASH ;
} else {
rtp - > f . frametype = AST_FRAME_DTMF ;
rtp - > f . subclass = rtp - > resp ;
}
2002-06-16 16:06:38 +00:00
rtp - > f . datalen = 0 ;
2003-02-05 19:26:49 +00:00
rtp - > f . samples = 0 ;
2002-06-16 16:06:38 +00:00
rtp - > f . mallocd = 0 ;
rtp - > f . src = " RTP " ;
rtp - > resp = 0 ;
2003-08-14 21:55:31 +00:00
rtp - > dtmfduration = 0 ;
2003-02-12 13:59:15 +00:00
return & rtp - > f ;
2002-06-16 16:06:38 +00:00
}
2004-10-30 01:52:12 +00:00
static inline int rtp_debug_test_addr ( struct sockaddr_in * addr )
{
if ( rtpdebug = = 0 )
return 0 ;
if ( rtpdebugaddr . sin_addr . s_addr ) {
if ( ( ( ntohs ( rtpdebugaddr . sin_port ) ! = 0 )
& & ( rtpdebugaddr . sin_port ! = addr - > sin_port ) )
| | ( rtpdebugaddr . sin_addr . s_addr ! = addr - > sin_addr . s_addr ) )
return 0 ;
}
return 1 ;
}
2003-05-02 15:37:34 +00:00
static struct ast_frame * process_cisco_dtmf ( struct ast_rtp * rtp , unsigned char * data , int len )
{
unsigned int event ;
char resp = 0 ;
struct ast_frame * f = NULL ;
event = ntohl ( * ( ( unsigned int * ) ( data ) ) ) ;
event & = 0x001F ;
#if 0
printf ( " Cisco Digit: %08x (len = %d) \n " , event , len ) ;
# endif
if ( event < 10 ) {
resp = ' 0 ' + event ;
} else if ( event < 11 ) {
resp = ' * ' ;
} else if ( event < 12 ) {
resp = ' # ' ;
} else if ( event < 16 ) {
resp = ' A ' + ( event - 12 ) ;
2004-12-09 14:54:13 +00:00
} else if ( event < 17 ) {
resp = ' X ' ;
2003-05-02 15:37:34 +00:00
}
if ( rtp - > resp & & ( rtp - > resp ! = resp ) ) {
f = send_dtmf ( rtp ) ;
}
rtp - > resp = resp ;
rtp - > dtmfcount = dtmftimeout ;
return f ;
}
2005-05-16 13:22:34 +00:00
/* process_rfc2833: Process RTP DTMF and events according to RFC 2833:
" RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals "
*/
2003-02-12 13:59:15 +00:00
static struct ast_frame * process_rfc2833 ( struct ast_rtp * rtp , unsigned char * data , int len )
2002-06-16 16:06:38 +00:00
{
unsigned int event ;
2003-08-14 21:55:31 +00:00
unsigned int event_end ;
unsigned int duration ;
2002-06-16 16:06:38 +00:00
char resp = 0 ;
2003-02-12 13:59:15 +00:00
struct ast_frame * f = NULL ;
2002-06-16 16:06:38 +00:00
event = ntohl ( * ( ( unsigned int * ) ( data ) ) ) ;
event > > = 24 ;
2003-08-14 21:55:31 +00:00
event_end = ntohl ( * ( ( unsigned int * ) ( data ) ) ) ;
event_end < < = 8 ;
event_end > > = 24 ;
duration = ntohl ( * ( ( unsigned int * ) ( data ) ) ) ;
duration & = 0xFFFF ;
2005-05-16 13:22:34 +00:00
if ( rtpdebug )
ast_log ( LOG_DEBUG , " - RTP 2833 Event: %08x (len = %d) \n " , event , len ) ;
2002-06-16 16:06:38 +00:00
if ( event < 10 ) {
resp = ' 0 ' + event ;
} else if ( event < 11 ) {
resp = ' * ' ;
} else if ( event < 12 ) {
resp = ' # ' ;
} else if ( event < 16 ) {
resp = ' A ' + ( event - 12 ) ;
2005-05-16 13:22:34 +00:00
} else if ( event < 17 ) { /* Event 16: Hook flash */
resp = ' X ' ;
2002-06-16 16:06:38 +00:00
}
if ( rtp - > resp & & ( rtp - > resp ! = resp ) ) {
2003-02-12 13:59:15 +00:00
f = send_dtmf ( rtp ) ;
2005-05-16 13:22:34 +00:00
} else if ( event_end & 0x80 ) {
2003-08-16 16:51:58 +00:00
if ( rtp - > resp ) {
f = send_dtmf ( rtp ) ;
rtp - > resp = 0 ;
}
2003-08-14 21:55:31 +00:00
resp = 0 ;
duration = 0 ;
2005-05-16 13:22:34 +00:00
} else if ( rtp - > dtmfduration & & ( duration < rtp - > dtmfduration ) ) {
2003-08-14 21:55:31 +00:00
f = send_dtmf ( rtp ) ;
}
2003-08-16 16:51:58 +00:00
if ( ! ( event_end & 0x80 ) )
rtp - > resp = resp ;
2002-06-16 16:06:38 +00:00
rtp - > dtmfcount = dtmftimeout ;
2003-08-14 21:55:31 +00:00
rtp - > dtmfduration = duration ;
2003-02-12 13:59:15 +00:00
return f ;
2002-06-16 16:06:38 +00:00
}
2005-06-02 00:49:41 +00:00
/*--- process_rfc3389: Process Comfort Noise RTP.
2005-05-16 13:22:34 +00:00
This is incomplete at the moment .
*/
2003-02-16 06:00:12 +00:00
static struct ast_frame * process_rfc3389 ( struct ast_rtp * rtp , unsigned char * data , int len )
{
struct ast_frame * f = NULL ;
/* Convert comfort noise into audio with various codecs. Unfortunately this doesn't
totally help us out becuase we don ' t have an engine to keep it going and we are not
guaranteed to have it every 20 ms or anything */
2005-05-16 13:22:34 +00:00
if ( rtpdebug )
2005-06-02 00:49:41 +00:00
ast_log ( LOG_DEBUG , " - RTP 3389 Comfort noise event: Level %d (len = %d) \n " , rtp - > lastrxformat , len ) ;
2004-04-20 19:23:08 +00:00
if ( ! ( rtp - > flags & FLAG_3389_WARNING ) ) {
2005-05-16 13:22:34 +00:00
char iabuf [ INET_ADDRSTRLEN ] ;
2005-06-02 00:50:38 +00:00
ast_log ( LOG_NOTICE , " Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s \n " , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) ) ;
2004-04-20 19:23:08 +00:00
rtp - > flags | = FLAG_3389_WARNING ;
}
2004-08-26 04:56:26 +00:00
/* Must have at least one byte */
if ( ! len )
return NULL ;
if ( len < 24 ) {
2004-09-09 02:33:14 +00:00
rtp - > f . data = rtp - > rawdata + AST_FRIENDLY_OFFSET ;
2004-08-26 04:56:26 +00:00
rtp - > f . datalen = len - 1 ;
2004-09-09 02:33:14 +00:00
rtp - > f . offset = AST_FRIENDLY_OFFSET ;
2004-08-26 04:56:26 +00:00
memcpy ( rtp - > f . data , data + 1 , len - 1 ) ;
} else {
2004-09-09 02:33:14 +00:00
rtp - > f . data = NULL ;
rtp - > f . offset = 0 ;
2004-08-26 04:56:26 +00:00
rtp - > f . datalen = 0 ;
2003-02-16 06:00:12 +00:00
}
2004-08-26 04:56:26 +00:00
rtp - > f . frametype = AST_FRAME_CNG ;
rtp - > f . subclass = data [ 0 ] & 0x7f ;
rtp - > f . datalen = len - 1 ;
rtp - > f . samples = 0 ;
rtp - > f . delivery . tv_usec = rtp - > f . delivery . tv_sec = 0 ;
f = & rtp - > f ;
2003-02-16 06:00:12 +00:00
return f ;
}
2002-06-16 16:06:38 +00:00
static int rtpread ( int * id , int fd , short events , void * cbdata )
{
struct ast_rtp * rtp = cbdata ;
2003-02-12 13:59:15 +00:00
struct ast_frame * f ;
f = ast_rtp_read ( rtp ) ;
if ( f ) {
if ( rtp - > callback )
rtp - > callback ( rtp , f , rtp - > data ) ;
}
return 1 ;
}
2003-06-28 16:40:02 +00:00
struct ast_frame * ast_rtcp_read ( struct ast_rtp * rtp )
{
static struct ast_frame null_frame = { AST_FRAME_NULL , } ;
2005-05-15 03:21:51 +00:00
socklen_t len ;
2003-06-28 16:40:02 +00:00
int hdrlen = 8 ;
int res ;
struct sockaddr_in sin ;
unsigned int rtcpdata [ 1024 ] ;
2004-06-30 16:56:51 +00:00
char iabuf [ INET_ADDRSTRLEN ] ;
2003-06-28 16:40:02 +00:00
2005-06-18 16:46:44 +00:00
if ( ! rtp | | ! rtp - > rtcp )
2003-06-28 16:40:02 +00:00
return & null_frame ;
len = sizeof ( sin ) ;
res = recvfrom ( rtp - > rtcp - > s , rtcpdata , sizeof ( rtcpdata ) ,
0 , ( struct sockaddr * ) & sin , & len ) ;
if ( res < 0 ) {
2005-05-04 04:43:30 +00:00
if ( errno ! = EAGAIN )
2004-06-29 14:22:27 +00:00
ast_log ( LOG_WARNING , " RTP Read error: %s \n " , strerror ( errno ) ) ;
2003-06-28 16:40:02 +00:00
if ( errno = = EBADF )
CRASH ;
return & null_frame ;
}
if ( res < hdrlen ) {
ast_log ( LOG_WARNING , " RTP Read too short \n " ) ;
return & null_frame ;
}
if ( rtp - > nat ) {
/* Send to whoever sent to us */
if ( ( rtp - > rtcp - > them . sin_addr . s_addr ! = sin . sin_addr . s_addr ) | |
( rtp - > rtcp - > them . sin_port ! = sin . sin_port ) ) {
memcpy ( & rtp - > them , & sin , sizeof ( rtp - > them ) ) ;
2004-10-19 21:07:10 +00:00
rtp - > rxseqno = 0 ;
2004-12-28 16:43:20 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " RTP NAT: Using address %s:%d \n " , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > rtcp - > them . sin_addr ) , ntohs ( rtp - > rtcp - > them . sin_port ) ) ;
2003-06-28 16:40:02 +00:00
}
}
2003-08-12 16:51:44 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " Got RTCP report of %d bytes \n " , res ) ;
2003-06-28 16:40:02 +00:00
return & null_frame ;
}
2004-05-01 15:18:28 +00:00
static void calc_rxstamp ( struct timeval * tv , struct ast_rtp * rtp , unsigned int timestamp , int mark )
2004-03-13 03:52:14 +00:00
{
2004-05-01 15:18:28 +00:00
if ( ( ! rtp - > rxcore . tv_sec & & ! rtp - > rxcore . tv_usec ) | | mark ) {
2004-03-13 03:52:14 +00:00
gettimeofday ( & rtp - > rxcore , NULL ) ;
2004-03-14 05:31:47 +00:00
rtp - > rxcore . tv_sec - = timestamp / 8000 ;
2004-03-13 03:52:14 +00:00
rtp - > rxcore . tv_usec - = ( timestamp % 8000 ) * 125 ;
2004-06-30 06:03:57 +00:00
/* Round to 20ms for nice, pretty timestamps */
2004-03-20 05:19:45 +00:00
rtp - > rxcore . tv_usec - = rtp - > rxcore . tv_usec % 20000 ;
2004-03-13 03:52:14 +00:00
if ( rtp - > rxcore . tv_usec < 0 ) {
/* Adjust appropriately if necessary */
rtp - > rxcore . tv_usec + = 1000000 ;
rtp - > rxcore . tv_sec - = 1 ;
}
}
tv - > tv_sec = rtp - > rxcore . tv_sec + timestamp / 8000 ;
tv - > tv_usec = rtp - > rxcore . tv_usec + ( timestamp % 8000 ) * 125 ;
if ( tv - > tv_usec > = 1000000 ) {
tv - > tv_usec - = 1000000 ;
tv - > tv_sec + = 1 ;
}
}
2003-02-12 13:59:15 +00:00
struct ast_frame * ast_rtp_read ( struct ast_rtp * rtp )
{
2002-06-16 16:06:38 +00:00
int res ;
struct sockaddr_in sin ;
2005-05-15 03:21:51 +00:00
socklen_t len ;
2002-06-16 16:06:38 +00:00
unsigned int seqno ;
2004-12-28 16:45:03 +00:00
int version ;
2002-06-16 16:06:38 +00:00
int payloadtype ;
int hdrlen = 12 ;
2005-05-14 23:41:12 +00:00
int padding ;
2003-06-28 16:40:02 +00:00
int mark ;
2004-08-31 00:16:28 +00:00
int ext ;
2004-10-19 21:07:10 +00:00
int x ;
2004-06-30 16:56:51 +00:00
char iabuf [ INET_ADDRSTRLEN ] ;
2002-06-16 16:06:38 +00:00
unsigned int timestamp ;
unsigned int * rtpheader ;
2003-02-12 13:59:15 +00:00
static struct ast_frame * f , null_frame = { AST_FRAME_NULL , } ;
2003-03-12 06:00:18 +00:00
struct rtpPayloadType rtpPT ;
2002-06-16 16:06:38 +00:00
len = sizeof ( sin ) ;
2003-06-28 16:40:02 +00:00
/* Cache where the header will go */
2003-06-28 18:35:58 +00:00
res = recvfrom ( rtp - > s , rtp - > rawdata + AST_FRIENDLY_OFFSET , sizeof ( rtp - > rawdata ) - AST_FRIENDLY_OFFSET ,
2002-06-16 16:06:38 +00:00
0 , ( struct sockaddr * ) & sin , & len ) ;
2003-03-07 06:00:13 +00:00
2003-06-28 18:35:58 +00:00
rtpheader = ( unsigned int * ) ( rtp - > rawdata + AST_FRIENDLY_OFFSET ) ;
2002-06-16 16:06:38 +00:00
if ( res < 0 ) {
2005-05-04 04:43:30 +00:00
if ( errno ! = EAGAIN )
2004-06-06 17:44:47 +00:00
ast_log ( LOG_WARNING , " RTP Read error: %s \n " , strerror ( errno ) ) ;
2002-06-16 16:06:38 +00:00
if ( errno = = EBADF )
CRASH ;
2003-02-12 13:59:15 +00:00
return & null_frame ;
2002-06-16 16:06:38 +00:00
}
if ( res < hdrlen ) {
ast_log ( LOG_WARNING , " RTP Read too short \n " ) ;
2003-02-12 13:59:15 +00:00
return & null_frame ;
2002-06-16 16:06:38 +00:00
}
2004-04-15 20:12:46 +00:00
/* Ignore if the other side hasn't been given an address
yet . */
if ( ! rtp - > them . sin_addr . s_addr | | ! rtp - > them . sin_port )
return & null_frame ;
2003-03-07 06:00:13 +00:00
if ( rtp - > nat ) {
/* Send to whoever sent to us */
2003-03-09 06:00:18 +00:00
if ( ( rtp - > them . sin_addr . s_addr ! = sin . sin_addr . s_addr ) | |
( rtp - > them . sin_port ! = sin . sin_port ) ) {
memcpy ( & rtp - > them , & sin , sizeof ( rtp - > them ) ) ;
2004-10-19 21:07:10 +00:00
rtp - > rxseqno = 0 ;
2004-06-29 12:56:46 +00:00
ast_log ( LOG_DEBUG , " RTP NAT: Using address %s:%d \n " , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) , ntohs ( rtp - > them . sin_port ) ) ;
2003-03-09 06:00:18 +00:00
}
2003-03-07 06:00:13 +00:00
}
2004-03-14 22:49:26 +00:00
2002-06-16 16:06:38 +00:00
/* Get fields */
seqno = ntohl ( rtpheader [ 0 ] ) ;
2004-12-28 16:45:03 +00:00
/* Check RTP version */
version = ( seqno & 0xC0000000 ) > > 30 ;
if ( version ! = 2 )
return & null_frame ;
2002-06-16 16:06:38 +00:00
payloadtype = ( seqno & 0x7f0000 ) > > 16 ;
2005-05-14 23:41:12 +00:00
padding = seqno & ( 1 < < 29 ) ;
2003-06-28 16:40:02 +00:00
mark = seqno & ( 1 < < 23 ) ;
2004-08-31 00:16:28 +00:00
ext = seqno & ( 1 < < 28 ) ;
2002-06-16 16:06:38 +00:00
seqno & = 0xffff ;
timestamp = ntohl ( rtpheader [ 1 ] ) ;
2005-05-14 23:41:12 +00:00
if ( padding ) {
/* Remove padding bytes */
res - = rtp - > rawdata [ AST_FRIENDLY_OFFSET + res - 1 ] ;
}
2004-08-31 00:16:28 +00:00
if ( ext ) {
/* RTP Extension present */
hdrlen + = 4 ;
2004-08-31 14:03:18 +00:00
hdrlen + = ( ntohl ( rtpheader [ 3 ] ) & 0xffff ) < < 2 ;
2004-08-31 00:16:28 +00:00
}
2003-06-28 16:40:02 +00:00
2004-08-31 05:09:20 +00:00
if ( res < hdrlen ) {
ast_log ( LOG_WARNING , " RTP Read too short (%d, expecting %d) \n " , res , hdrlen ) ;
return & null_frame ;
}
2004-10-30 01:52:12 +00:00
if ( rtp_debug_test_addr ( & sin ) )
2004-12-28 16:43:20 +00:00
ast_verbose ( " Got RTP packet from %s:%d (type %d, seq %d, ts %d, len %d) \n "
2004-10-30 01:52:12 +00:00
, ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , sin . sin_addr ) , ntohs ( sin . sin_port ) , payloadtype , seqno , timestamp , res - hdrlen ) ;
rtpPT = ast_rtp_lookup_pt ( rtp , payloadtype ) ;
2003-03-12 06:00:18 +00:00
if ( ! rtpPT . isAstFormat ) {
2004-12-28 16:43:20 +00:00
/* This is special in-band data that's not one of our codecs */
if ( rtpPT . code = = AST_RTP_DTMF ) {
/* It's special -- rfc2833 process it */
if ( rtp - > lasteventseqn < = seqno | | rtp - > resp = = 0 | | ( rtp - > lasteventseqn > = 65530 & & seqno < = 6 ) ) {
f = process_rfc2833 ( rtp , rtp - > rawdata + AST_FRIENDLY_OFFSET + hdrlen , res - hdrlen ) ;
rtp - > lasteventseqn = seqno ;
} else
f = NULL ;
if ( f )
return f ;
else
return & null_frame ;
} else if ( rtpPT . code = = AST_RTP_CISCO_DTMF ) {
/* It's really special -- process it the Cisco way */
if ( rtp - > lasteventseqn < = seqno | | rtp - > resp = = 0 | | ( rtp - > lasteventseqn > = 65530 & & seqno < = 6 ) ) {
f = process_cisco_dtmf ( rtp , rtp - > rawdata + AST_FRIENDLY_OFFSET + hdrlen , res - hdrlen ) ;
rtp - > lasteventseqn = seqno ;
} else
f = NULL ;
if ( f )
return f ;
else
return & null_frame ;
} else if ( rtpPT . code = = AST_RTP_CN ) {
/* Comfort Noise */
f = process_rfc3389 ( rtp , rtp - > rawdata + AST_FRIENDLY_OFFSET + hdrlen , res - hdrlen ) ;
if ( f )
return f ;
else
return & null_frame ;
} else {
ast_log ( LOG_NOTICE , " Unknown RTP codec %d received \n " , payloadtype ) ;
return & null_frame ;
}
2003-03-12 06:00:18 +00:00
}
rtp - > f . subclass = rtpPT . code ;
2003-06-28 16:40:02 +00:00
if ( rtp - > f . subclass < AST_FORMAT_MAX_AUDIO )
rtp - > f . frametype = AST_FRAME_VOICE ;
else
rtp - > f . frametype = AST_FRAME_VIDEO ;
2003-03-12 06:00:18 +00:00
rtp - > lastrxformat = rtp - > f . subclass ;
2002-06-16 16:06:38 +00:00
if ( ! rtp - > lastrxts )
rtp - > lastrxts = timestamp ;
2004-10-19 21:07:10 +00:00
if ( rtp - > rxseqno ) {
for ( x = rtp - > rxseqno + 1 ; x < seqno ; x + + ) {
/* Queue empty frames */
rtp - > f . mallocd = 0 ;
rtp - > f . datalen = 0 ;
rtp - > f . data = NULL ;
rtp - > f . offset = 0 ;
rtp - > f . samples = 0 ;
rtp - > f . src = " RTPMissedFrame " ;
}
}
rtp - > rxseqno = seqno ;
2002-06-16 16:06:38 +00:00
if ( rtp - > dtmfcount ) {
#if 0
printf ( " dtmfcount was %d \n " , rtp - > dtmfcount ) ;
# endif
rtp - > dtmfcount - = ( timestamp - rtp - > lastrxts ) ;
if ( rtp - > dtmfcount < 0 )
rtp - > dtmfcount = 0 ;
#if 0
if ( dtmftimeout ! = rtp - > dtmfcount )
printf ( " dtmfcount is %d \n " , rtp - > dtmfcount ) ;
# endif
}
rtp - > lastrxts = timestamp ;
/* Send any pending DTMF */
if ( rtp - > resp & & ! rtp - > dtmfcount ) {
2004-12-28 16:43:20 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " Sending pending DTMF \n " ) ;
2003-02-12 13:59:15 +00:00
return send_dtmf ( rtp ) ;
2002-06-16 16:06:38 +00:00
}
rtp - > f . mallocd = 0 ;
2003-06-28 18:35:58 +00:00
rtp - > f . datalen = res - hdrlen ;
2002-06-16 16:06:38 +00:00
rtp - > f . data = rtp - > rawdata + hdrlen + AST_FRIENDLY_OFFSET ;
rtp - > f . offset = hdrlen + AST_FRIENDLY_OFFSET ;
2003-06-28 16:40:02 +00:00
if ( rtp - > f . subclass < AST_FORMAT_MAX_AUDIO ) {
2005-05-14 23:57:44 +00:00
rtp - > f . samples = ast_codec_get_samples ( & rtp - > f ) ;
if ( rtp - > f . subclass = = AST_FORMAT_SLINEAR )
2005-04-03 22:57:18 +00:00
ast_frame_byteswap_be ( & rtp - > f ) ;
2004-05-01 15:18:28 +00:00
calc_rxstamp ( & rtp - > f . delivery , rtp , timestamp , mark ) ;
2003-06-28 16:40:02 +00:00
} else {
/* Video -- samples is # of samples vs. 90000 */
2003-06-29 03:24:39 +00:00
if ( ! rtp - > lastividtimestamp )
rtp - > lastividtimestamp = timestamp ;
2003-06-28 16:40:02 +00:00
rtp - > f . samples = timestamp - rtp - > lastividtimestamp ;
rtp - > lastividtimestamp = timestamp ;
2004-05-30 20:24:48 +00:00
rtp - > f . delivery . tv_sec = 0 ;
rtp - > f . delivery . tv_usec = 0 ;
2003-06-28 18:35:58 +00:00
if ( mark )
rtp - > f . subclass | = 0x1 ;
2002-06-16 16:06:38 +00:00
}
rtp - > f . src = " RTP " ;
2003-02-12 13:59:15 +00:00
return & rtp - > f ;
2002-06-16 16:06:38 +00:00
}
2004-06-29 20:10:57 +00:00
/* The following array defines the MIME Media type (and subtype) for each
of our codecs , or RTP - specific data type . */
2002-06-16 16:06:38 +00:00
static struct {
2003-03-12 06:00:18 +00:00
struct rtpPayloadType payloadType ;
char * type ;
char * subtype ;
} mimeTypes [ ] = {
{ { 1 , AST_FORMAT_G723_1 } , " audio " , " G723 " } ,
{ { 1 , AST_FORMAT_GSM } , " audio " , " GSM " } ,
{ { 1 , AST_FORMAT_ULAW } , " audio " , " PCMU " } ,
{ { 1 , AST_FORMAT_ALAW } , " audio " , " PCMA " } ,
2003-11-04 02:40:09 +00:00
{ { 1 , AST_FORMAT_G726 } , " audio " , " G726-32 " } ,
2003-03-12 06:00:18 +00:00
{ { 1 , AST_FORMAT_ADPCM } , " audio " , " DVI4 " } ,
{ { 1 , AST_FORMAT_SLINEAR } , " audio " , " L16 " } ,
{ { 1 , AST_FORMAT_LPC10 } , " audio " , " LPC " } ,
{ { 1 , AST_FORMAT_G729A } , " audio " , " G729 " } ,
2004-08-26 04:56:26 +00:00
{ { 1 , AST_FORMAT_SPEEX } , " audio " , " speex " } ,
2003-04-15 04:36:52 +00:00
{ { 1 , AST_FORMAT_ILBC } , " audio " , " iLBC " } ,
2003-03-13 06:00:20 +00:00
{ { 0 , AST_RTP_DTMF } , " audio " , " telephone-event " } ,
2003-05-07 15:29:20 +00:00
{ { 0 , AST_RTP_CISCO_DTMF } , " audio " , " cisco-telephone-event " } ,
2003-03-12 06:00:18 +00:00
{ { 0 , AST_RTP_CN } , " audio " , " CN " } ,
{ { 1 , AST_FORMAT_JPEG } , " video " , " JPEG " } ,
{ { 1 , AST_FORMAT_PNG } , " video " , " PNG " } ,
{ { 1 , AST_FORMAT_H261 } , " video " , " H261 " } ,
{ { 1 , AST_FORMAT_H263 } , " video " , " H263 " } ,
2005-03-05 20:57:49 +00:00
{ { 1 , AST_FORMAT_H263_PLUS } , " video " , " h263-1998 " } ,
2002-06-16 16:06:38 +00:00
} ;
2003-04-10 15:36:52 +00:00
/* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
also , our own choices for dynamic payload types . This is our master
table for transmission */
2003-03-12 06:00:18 +00:00
static struct rtpPayloadType static_RTP_PT [ MAX_RTP_PT ] = {
[ 0 ] = { 1 , AST_FORMAT_ULAW } ,
2005-03-25 21:01:11 +00:00
# ifdef USE_DEPRECATED_G726
2004-06-29 20:10:57 +00:00
[ 2 ] = { 1 , AST_FORMAT_G726 } , /* Technically this is G.721, but if Cisco can do it, so can we... */
2005-03-25 21:01:11 +00:00
# endif
2003-03-12 06:00:18 +00:00
[ 3 ] = { 1 , AST_FORMAT_GSM } ,
[ 4 ] = { 1 , AST_FORMAT_G723_1 } ,
2004-06-29 20:10:57 +00:00
[ 5 ] = { 1 , AST_FORMAT_ADPCM } , /* 8 kHz */
[ 6 ] = { 1 , AST_FORMAT_ADPCM } , /* 16 kHz */
2003-03-12 06:00:18 +00:00
[ 7 ] = { 1 , AST_FORMAT_LPC10 } ,
[ 8 ] = { 1 , AST_FORMAT_ALAW } ,
2004-06-29 20:10:57 +00:00
[ 10 ] = { 1 , AST_FORMAT_SLINEAR } , /* 2 channels */
[ 11 ] = { 1 , AST_FORMAT_SLINEAR } , /* 1 channel */
2003-03-12 06:00:18 +00:00
[ 13 ] = { 0 , AST_RTP_CN } ,
2004-06-29 20:10:57 +00:00
[ 16 ] = { 1 , AST_FORMAT_ADPCM } , /* 11.025 kHz */
[ 17 ] = { 1 , AST_FORMAT_ADPCM } , /* 22.050 kHz */
2003-03-12 06:00:18 +00:00
[ 18 ] = { 1 , AST_FORMAT_G729A } ,
2004-08-07 14:22:09 +00:00
[ 19 ] = { 0 , AST_RTP_CN } , /* Also used for CN */
2003-03-12 06:00:18 +00:00
[ 26 ] = { 1 , AST_FORMAT_JPEG } ,
[ 31 ] = { 1 , AST_FORMAT_H261 } ,
[ 34 ] = { 1 , AST_FORMAT_H263 } ,
2005-03-05 20:57:49 +00:00
[ 103 ] = { 1 , AST_FORMAT_H263_PLUS } ,
2003-04-15 20:44:53 +00:00
[ 97 ] = { 1 , AST_FORMAT_ILBC } ,
2003-03-13 06:00:20 +00:00
[ 101 ] = { 0 , AST_RTP_DTMF } ,
2003-04-10 15:36:52 +00:00
[ 110 ] = { 1 , AST_FORMAT_SPEEX } ,
2005-03-25 21:01:11 +00:00
[ 111 ] = { 1 , AST_FORMAT_G726 } ,
2004-06-29 20:10:57 +00:00
[ 121 ] = { 0 , AST_RTP_CISCO_DTMF } , /* Must be type 121 */
2003-03-12 06:00:18 +00:00
} ;
2003-03-13 06:00:20 +00:00
void ast_rtp_pt_clear ( struct ast_rtp * rtp )
{
2004-12-28 16:43:20 +00:00
int i ;
2003-03-12 06:00:18 +00:00
2004-12-28 16:43:20 +00:00
for ( i = 0 ; i < MAX_RTP_PT ; + + i ) {
rtp - > current_RTP_PT [ i ] . isAstFormat = 0 ;
rtp - > current_RTP_PT [ i ] . code = 0 ;
}
2003-03-12 06:00:18 +00:00
2004-12-28 16:43:20 +00:00
rtp - > rtp_lookup_code_cache_isAstFormat = 0 ;
rtp - > rtp_lookup_code_cache_code = 0 ;
rtp - > rtp_lookup_code_cache_result = 0 ;
2002-06-16 16:06:38 +00:00
}
2003-03-13 06:00:20 +00:00
void ast_rtp_pt_default ( struct ast_rtp * rtp )
{
2004-12-28 16:43:20 +00:00
int i ;
/* Initialize to default payload types */
for ( i = 0 ; i < MAX_RTP_PT ; + + i ) {
rtp - > current_RTP_PT [ i ] . isAstFormat = static_RTP_PT [ i ] . isAstFormat ;
rtp - > current_RTP_PT [ i ] . code = static_RTP_PT [ i ] . code ;
}
rtp - > rtp_lookup_code_cache_isAstFormat = 0 ;
rtp - > rtp_lookup_code_cache_code = 0 ;
rtp - > rtp_lookup_code_cache_result = 0 ;
2003-03-13 06:00:20 +00:00
}
2004-06-29 20:10:57 +00:00
/* Make a note of a RTP payload type that was seen in a SDP "m=" line. */
/* By default, use the well-known value for this type (although it may */
/* still be set to a different value by a subsequent "a=rtpmap:" line): */
2003-03-13 06:00:20 +00:00
void ast_rtp_set_m_type ( struct ast_rtp * rtp , int pt ) {
2004-12-28 16:43:20 +00:00
if ( pt < 0 | | pt > MAX_RTP_PT )
return ; /* bogus payload type */
2003-03-12 06:00:18 +00:00
2004-12-28 16:43:20 +00:00
if ( static_RTP_PT [ pt ] . code ! = 0 ) {
rtp - > current_RTP_PT [ pt ] = static_RTP_PT [ pt ] ;
}
2003-03-12 06:00:18 +00:00
}
2004-06-29 20:10:57 +00:00
/* Make a note of a RTP payload type (with MIME type) that was seen in */
/* a SDP "a=rtpmap:" line. */
2003-03-13 06:00:20 +00:00
void ast_rtp_set_rtpmap_type ( struct ast_rtp * rtp , int pt ,
2003-03-12 06:00:18 +00:00
char * mimeType , char * mimeSubtype ) {
2004-12-28 16:43:20 +00:00
int i ;
2003-03-12 06:00:18 +00:00
2004-12-28 16:43:20 +00:00
if ( pt < 0 | | pt > MAX_RTP_PT )
return ; /* bogus payload type */
2003-03-12 06:00:18 +00:00
2004-12-28 16:43:20 +00:00
for ( i = 0 ; i < sizeof mimeTypes / sizeof mimeTypes [ 0 ] ; + + i ) {
if ( strcasecmp ( mimeSubtype , mimeTypes [ i ] . subtype ) = = 0 & &
strcasecmp ( mimeType , mimeTypes [ i ] . type ) = = 0 ) {
rtp - > current_RTP_PT [ pt ] = mimeTypes [ i ] . payloadType ;
return ;
}
}
2003-03-12 06:00:18 +00:00
}
2004-06-29 20:10:57 +00:00
/* Return the union of all of the codecs that were set by rtp_set...() calls */
/* They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
2003-03-13 06:00:20 +00:00
void ast_rtp_get_current_formats ( struct ast_rtp * rtp ,
2003-03-12 06:00:18 +00:00
int * astFormats , int * nonAstFormats ) {
2004-12-28 16:43:20 +00:00
int pt ;
* astFormats = * nonAstFormats = 0 ;
for ( pt = 0 ; pt < MAX_RTP_PT ; + + pt ) {
if ( rtp - > current_RTP_PT [ pt ] . isAstFormat ) {
* astFormats | = rtp - > current_RTP_PT [ pt ] . code ;
} else {
* nonAstFormats | = rtp - > current_RTP_PT [ pt ] . code ;
}
}
2002-06-16 16:06:38 +00:00
}
2004-08-26 04:56:26 +00:00
void ast_rtp_offered_from_local ( struct ast_rtp * rtp , int local ) {
2004-12-28 16:43:20 +00:00
if ( rtp )
rtp - > rtp_offered_from_local = local ;
else
ast_log ( LOG_WARNING , " rtp structure is null \n " ) ;
2004-08-26 04:56:26 +00:00
}
2004-03-22 21:52:22 +00:00
struct rtpPayloadType ast_rtp_lookup_pt ( struct ast_rtp * rtp , int pt )
{
2004-12-28 16:43:20 +00:00
struct rtpPayloadType result ;
result . isAstFormat = result . code = 0 ;
if ( pt < 0 | | pt > MAX_RTP_PT )
return result ; /* bogus payload type */
/* Start with the negotiated codecs */
if ( ! rtp - > rtp_offered_from_local )
result = rtp - > current_RTP_PT [ pt ] ;
/* If it doesn't exist, check our static RTP type list, just in case */
if ( ! result . code )
result = static_RTP_PT [ pt ] ;
return result ;
2003-03-12 06:00:18 +00:00
}
2004-06-29 20:10:57 +00:00
/* Looks up an RTP code out of our *static* outbound list */
2005-04-05 23:34:56 +00:00
int ast_rtp_lookup_code ( struct ast_rtp * rtp , const int isAstFormat , const int code ) {
2003-03-12 06:00:18 +00:00
2004-12-28 16:43:20 +00:00
int pt ;
2003-04-10 15:36:52 +00:00
2004-12-28 16:43:20 +00:00
if ( isAstFormat = = rtp - > rtp_lookup_code_cache_isAstFormat & &
code = = rtp - > rtp_lookup_code_cache_code ) {
/* Use our cached mapping, to avoid the overhead of the loop below */
return rtp - > rtp_lookup_code_cache_result ;
}
2003-03-12 06:00:18 +00:00
2004-03-22 21:52:22 +00:00
/* Check the dynamic list first */
2004-12-28 16:43:20 +00:00
for ( pt = 0 ; pt < MAX_RTP_PT ; + + pt ) {
if ( rtp - > current_RTP_PT [ pt ] . code = = code & & rtp - > current_RTP_PT [ pt ] . isAstFormat = = isAstFormat ) {
rtp - > rtp_lookup_code_cache_isAstFormat = isAstFormat ;
rtp - > rtp_lookup_code_cache_code = code ;
rtp - > rtp_lookup_code_cache_result = pt ;
return pt ;
}
}
2004-03-22 21:52:22 +00:00
/* Then the static list */
2004-12-28 16:43:20 +00:00
for ( pt = 0 ; pt < MAX_RTP_PT ; + + pt ) {
if ( static_RTP_PT [ pt ] . code = = code & & static_RTP_PT [ pt ] . isAstFormat = = isAstFormat ) {
rtp - > rtp_lookup_code_cache_isAstFormat = isAstFormat ;
rtp - > rtp_lookup_code_cache_code = code ;
rtp - > rtp_lookup_code_cache_result = pt ;
return pt ;
}
}
return - 1 ;
2002-08-09 17:17:54 +00:00
}
2003-03-12 06:00:18 +00:00
2005-04-05 23:34:56 +00:00
char * ast_rtp_lookup_mime_subtype ( const int isAstFormat , const int code ) {
2004-12-28 16:43:20 +00:00
int i ;
for ( i = 0 ; i < sizeof mimeTypes / sizeof mimeTypes [ 0 ] ; + + i ) {
if ( mimeTypes [ i ] . payloadType . code = = code & & mimeTypes [ i ] . payloadType . isAstFormat = = isAstFormat ) {
return mimeTypes [ i ] . subtype ;
}
}
return " " ;
2003-03-12 06:00:18 +00:00
}
2005-04-05 23:34:56 +00:00
char * ast_rtp_lookup_mime_multiple ( char * buf , int size , const int capability , const int isAstFormat )
{
int format ;
2005-04-06 03:43:59 +00:00
unsigned len ;
char * end = buf ;
char * start = buf ;
2005-04-05 23:34:56 +00:00
if ( ! buf | | ! size )
return NULL ;
2005-04-06 03:43:59 +00:00
snprintf ( end , size , " 0x%x ( " , capability ) ;
len = strlen ( end ) ;
end + = len ;
size - = len ;
start = end ;
2005-04-05 23:34:56 +00:00
for ( format = 1 ; format < AST_RTP_MAX ; format < < = 1 ) {
if ( capability & format ) {
const char * name = ast_rtp_lookup_mime_subtype ( isAstFormat , format ) ;
2005-04-06 03:43:59 +00:00
snprintf ( end , size , " %s| " , name ) ;
len = strlen ( end ) ;
end + = len ;
size - = len ;
2005-04-05 23:34:56 +00:00
}
}
2005-04-06 03:43:59 +00:00
if ( start = = end )
snprintf ( start , size , " nothing) " ) ;
else if ( size > 1 )
* ( end - 1 ) = ' ) ' ;
2005-04-05 23:34:56 +00:00
return buf ;
}
2004-06-09 01:33:16 +00:00
static int rtp_socket ( void )
{
int s ;
long flags ;
s = socket ( AF_INET , SOCK_DGRAM , 0 ) ;
if ( s > - 1 ) {
flags = fcntl ( s , F_GETFL ) ;
fcntl ( s , F_SETFL , flags | O_NONBLOCK ) ;
2004-07-19 18:09:33 +00:00
# ifdef SO_NO_CHECK
2005-03-31 19:09:48 +00:00
if ( nochecksums )
setsockopt ( s , SOL_SOCKET , SO_NO_CHECK , & nochecksums , sizeof ( nochecksums ) ) ;
2004-07-19 18:09:33 +00:00
# endif
2004-06-09 01:33:16 +00:00
}
return s ;
}
2003-06-28 16:40:02 +00:00
static struct ast_rtcp * ast_rtcp_new ( void )
{
struct ast_rtcp * rtcp ;
rtcp = malloc ( sizeof ( struct ast_rtcp ) ) ;
if ( ! rtcp )
return NULL ;
memset ( rtcp , 0 , sizeof ( struct ast_rtcp ) ) ;
2004-06-09 01:33:16 +00:00
rtcp - > s = rtp_socket ( ) ;
2003-06-28 16:40:02 +00:00
rtcp - > us . sin_family = AF_INET ;
if ( rtcp - > s < 0 ) {
free ( rtcp ) ;
ast_log ( LOG_WARNING , " Unable to allocate socket: %s \n " , strerror ( errno ) ) ;
return NULL ;
}
return rtcp ;
}
2004-07-08 11:46:15 +00:00
struct ast_rtp * ast_rtp_new_with_bindaddr ( struct sched_context * sched , struct io_context * io , int rtcpenable , int callbackmode , struct in_addr addr )
2002-06-16 16:06:38 +00:00
{
struct ast_rtp * rtp ;
int x ;
2004-06-09 01:33:16 +00:00
int first ;
2003-05-16 02:50:46 +00:00
int startplace ;
2002-06-16 16:06:38 +00:00
rtp = malloc ( sizeof ( struct ast_rtp ) ) ;
if ( ! rtp )
return NULL ;
memset ( rtp , 0 , sizeof ( struct ast_rtp ) ) ;
rtp - > them . sin_family = AF_INET ;
rtp - > us . sin_family = AF_INET ;
2004-06-09 01:33:16 +00:00
rtp - > s = rtp_socket ( ) ;
2002-06-16 16:06:38 +00:00
rtp - > ssrc = rand ( ) ;
rtp - > seqno = rand ( ) & 0xffff ;
if ( rtp - > s < 0 ) {
free ( rtp ) ;
2004-12-28 16:43:20 +00:00
ast_log ( LOG_ERROR , " Unable to allocate socket: %s \n " , strerror ( errno ) ) ;
2002-06-16 16:06:38 +00:00
return NULL ;
}
2003-06-28 16:40:02 +00:00
if ( sched & & rtcpenable ) {
rtp - > sched = sched ;
rtp - > rtcp = ast_rtcp_new ( ) ;
}
2003-05-16 02:50:46 +00:00
/* Find us a place */
x = ( rand ( ) % ( rtpend - rtpstart ) ) + rtpstart ;
x = x & ~ 1 ;
startplace = x ;
2002-06-16 16:06:38 +00:00
for ( ; ; ) {
/* Must be an even port number by RTP spec */
rtp - > us . sin_port = htons ( x ) ;
2004-07-08 11:46:15 +00:00
rtp - > us . sin_addr = addr ;
2003-06-28 16:40:02 +00:00
if ( rtp - > rtcp )
rtp - > rtcp - > us . sin_port = htons ( x + 1 ) ;
2004-06-09 01:33:16 +00:00
if ( ! ( first = bind ( rtp - > s , ( struct sockaddr * ) & rtp - > us , sizeof ( rtp - > us ) ) ) & &
2003-09-08 16:48:07 +00:00
( ! rtp - > rtcp | | ! bind ( rtp - > rtcp - > s , ( struct sockaddr * ) & rtp - > rtcp - > us , sizeof ( rtp - > rtcp - > us ) ) ) )
2002-06-16 16:06:38 +00:00
break ;
2004-06-09 01:33:16 +00:00
if ( ! first ) {
/* Primary bind succeeded! Gotta recreate it */
close ( rtp - > s ) ;
rtp - > s = rtp_socket ( ) ;
}
2002-06-16 16:06:38 +00:00
if ( errno ! = EADDRINUSE ) {
2004-12-28 16:43:20 +00:00
ast_log ( LOG_ERROR , " Unexpected bind error: %s \n " , strerror ( errno ) ) ;
2002-06-16 16:06:38 +00:00
close ( rtp - > s ) ;
2003-06-28 16:40:02 +00:00
if ( rtp - > rtcp ) {
close ( rtp - > rtcp - > s ) ;
free ( rtp - > rtcp ) ;
}
2002-06-16 16:06:38 +00:00
free ( rtp ) ;
return NULL ;
}
2003-05-16 02:50:46 +00:00
x + = 2 ;
if ( x > rtpend )
x = ( rtpstart + 1 ) & ~ 1 ;
if ( x = = startplace ) {
2005-05-16 13:22:34 +00:00
ast_log ( LOG_ERROR , " No RTP ports remaining. Can't setup media stream for this call. \n " ) ;
2003-05-16 02:50:46 +00:00
close ( rtp - > s ) ;
2003-06-28 16:40:02 +00:00
if ( rtp - > rtcp ) {
close ( rtp - > rtcp - > s ) ;
free ( rtp - > rtcp ) ;
}
2003-05-16 02:50:46 +00:00
free ( rtp ) ;
return NULL ;
}
2002-06-16 16:06:38 +00:00
}
2003-06-28 16:40:02 +00:00
if ( io & & sched & & callbackmode ) {
2003-02-12 13:59:15 +00:00
/* Operate this one in a callback mode */
rtp - > sched = sched ;
rtp - > io = io ;
rtp - > ioid = ast_io_add ( rtp - > io , rtp - > s , rtpread , AST_IO_IN , rtp ) ;
}
2003-03-13 06:00:20 +00:00
ast_rtp_pt_default ( rtp ) ;
2002-06-16 16:06:38 +00:00
return rtp ;
}
2004-07-08 11:46:15 +00:00
struct ast_rtp * ast_rtp_new ( struct sched_context * sched , struct io_context * io , int rtcpenable , int callbackmode )
{
struct in_addr ia ;
2004-12-28 16:43:20 +00:00
2004-07-08 11:46:15 +00:00
memset ( & ia , 0 , sizeof ( ia ) ) ;
return ast_rtp_new_with_bindaddr ( sched , io , rtcpenable , callbackmode , ia ) ;
}
2003-02-05 19:26:49 +00:00
int ast_rtp_settos ( struct ast_rtp * rtp , int tos )
{
int res ;
2004-12-28 16:43:20 +00:00
2003-04-23 20:22:14 +00:00
if ( ( res = setsockopt ( rtp - > s , IPPROTO_IP , IP_TOS , & tos , sizeof ( tos ) ) ) )
2003-02-05 19:26:49 +00:00
ast_log ( LOG_WARNING , " Unable to set TOS to %d \n " , tos ) ;
return res ;
}
2002-06-16 16:06:38 +00:00
void ast_rtp_set_peer ( struct ast_rtp * rtp , struct sockaddr_in * them )
{
rtp - > them . sin_port = them - > sin_port ;
rtp - > them . sin_addr = them - > sin_addr ;
2003-06-28 16:40:02 +00:00
if ( rtp - > rtcp ) {
rtp - > rtcp - > them . sin_port = htons ( ntohs ( them - > sin_port ) + 1 ) ;
rtp - > rtcp - > them . sin_addr = them - > sin_addr ;
}
2004-10-19 21:07:10 +00:00
rtp - > rxseqno = 0 ;
2002-06-16 16:06:38 +00:00
}
2003-02-05 19:26:49 +00:00
void ast_rtp_get_peer ( struct ast_rtp * rtp , struct sockaddr_in * them )
{
them - > sin_family = AF_INET ;
them - > sin_port = rtp - > them . sin_port ;
them - > sin_addr = rtp - > them . sin_addr ;
}
2002-06-16 16:06:38 +00:00
void ast_rtp_get_us ( struct ast_rtp * rtp , struct sockaddr_in * us )
{
memcpy ( us , & rtp - > us , sizeof ( rtp - > us ) ) ;
}
2003-03-20 22:01:53 +00:00
void ast_rtp_stop ( struct ast_rtp * rtp )
{
memset ( & rtp - > them . sin_addr , 0 , sizeof ( rtp - > them . sin_addr ) ) ;
memset ( & rtp - > them . sin_port , 0 , sizeof ( rtp - > them . sin_port ) ) ;
2003-06-28 16:40:02 +00:00
if ( rtp - > rtcp ) {
memset ( & rtp - > rtcp - > them . sin_addr , 0 , sizeof ( rtp - > them . sin_addr ) ) ;
memset ( & rtp - > rtcp - > them . sin_port , 0 , sizeof ( rtp - > them . sin_port ) ) ;
}
2003-03-20 22:01:53 +00:00
}
2004-12-28 16:35:31 +00:00
void ast_rtp_reset ( struct ast_rtp * rtp )
{
memset ( & rtp - > rxcore , 0 , sizeof ( rtp - > rxcore ) ) ;
memset ( & rtp - > txcore , 0 , sizeof ( rtp - > txcore ) ) ;
memset ( & rtp - > dtmfmute , 0 , sizeof ( rtp - > dtmfmute ) ) ;
rtp - > lastts = 0 ;
2005-04-04 02:13:40 +00:00
rtp - > lastdigitts = 0 ;
2004-12-28 16:35:31 +00:00
rtp - > lastrxts = 0 ;
rtp - > lastividtimestamp = 0 ;
rtp - > lastovidtimestamp = 0 ;
rtp - > lasteventseqn = 0 ;
rtp - > lasttxformat = 0 ;
rtp - > lastrxformat = 0 ;
rtp - > dtmfcount = 0 ;
rtp - > dtmfduration = 0 ;
rtp - > seqno = 0 ;
rtp - > rxseqno = 0 ;
}
2002-06-16 16:06:38 +00:00
void ast_rtp_destroy ( struct ast_rtp * rtp )
{
2002-08-09 17:17:54 +00:00
if ( rtp - > smoother )
ast_smoother_free ( rtp - > smoother ) ;
2002-06-16 16:06:38 +00:00
if ( rtp - > ioid )
ast_io_remove ( rtp - > io , rtp - > ioid ) ;
if ( rtp - > s > - 1 )
close ( rtp - > s ) ;
2003-06-28 16:40:02 +00:00
if ( rtp - > rtcp ) {
close ( rtp - > rtcp - > s ) ;
free ( rtp - > rtcp ) ;
}
2002-06-16 16:06:38 +00:00
free ( rtp ) ;
}
2004-03-13 03:52:14 +00:00
static unsigned int calc_txstamp ( struct ast_rtp * rtp , struct timeval * delivery )
2002-06-16 16:06:38 +00:00
{
struct timeval now ;
unsigned int ms ;
if ( ! rtp - > txcore . tv_sec & & ! rtp - > txcore . tv_usec ) {
gettimeofday ( & rtp - > txcore , NULL ) ;
2004-06-30 06:03:57 +00:00
/* Round to 20ms for nice, pretty timestamps */
2004-03-20 05:22:52 +00:00
rtp - > txcore . tv_usec - = rtp - > txcore . tv_usec % 20000 ;
2002-06-16 16:06:38 +00:00
}
2004-03-13 03:52:14 +00:00
if ( delivery & & ( delivery - > tv_sec | | delivery - > tv_usec ) ) {
/* Use previous txcore */
2004-03-14 05:31:47 +00:00
ms = ( delivery - > tv_sec - rtp - > txcore . tv_sec ) * 1000 ;
2004-06-30 06:03:57 +00:00
ms + = ( 1000000 + delivery - > tv_usec - rtp - > txcore . tv_usec ) / 1000 - 1000 ;
2004-03-13 03:52:14 +00:00
rtp - > txcore . tv_sec = delivery - > tv_sec ;
rtp - > txcore . tv_usec = delivery - > tv_usec ;
} else {
gettimeofday ( & now , NULL ) ;
ms = ( now . tv_sec - rtp - > txcore . tv_sec ) * 1000 ;
2004-06-30 06:03:57 +00:00
ms + = ( 1000000 + now . tv_usec - rtp - > txcore . tv_usec ) / 1000 - 1000 ;
2004-03-13 03:52:14 +00:00
/* Use what we just got for next time */
rtp - > txcore . tv_sec = now . tv_sec ;
rtp - > txcore . tv_usec = now . tv_usec ;
}
2002-06-16 16:06:38 +00:00
return ms ;
}
2003-02-05 19:26:49 +00:00
int ast_rtp_senddigit ( struct ast_rtp * rtp , char digit )
{
unsigned int * rtpheader ;
int hdrlen = 12 ;
int res ;
int x ;
2004-07-31 20:31:11 +00:00
int payload ;
2003-02-05 19:26:49 +00:00
char data [ 256 ] ;
2004-06-30 16:56:51 +00:00
char iabuf [ INET_ADDRSTRLEN ] ;
2003-02-05 19:26:49 +00:00
if ( ( digit < = ' 9 ' ) & & ( digit > = ' 0 ' ) )
digit - = ' 0 ' ;
else if ( digit = = ' * ' )
digit = 10 ;
else if ( digit = = ' # ' )
digit = 11 ;
else if ( ( digit > = ' A ' ) & & ( digit < = ' D ' ) )
digit = digit - ' A ' + 12 ;
else if ( ( digit > = ' a ' ) & & ( digit < = ' d ' ) )
digit = digit - ' a ' + 12 ;
else {
ast_log ( LOG_WARNING , " Don't know how to represent '%c' \n " , digit ) ;
return - 1 ;
}
2004-07-31 20:31:11 +00:00
payload = ast_rtp_lookup_code ( rtp , 0 , AST_RTP_DTMF ) ;
2003-02-05 19:26:49 +00:00
/* If we have no peer, return immediately */
if ( ! rtp - > them . sin_addr . s_addr )
return 0 ;
2004-03-15 16:20:01 +00:00
gettimeofday ( & rtp - > dtmfmute , NULL ) ;
rtp - > dtmfmute . tv_usec + = ( 500 * 1000 ) ;
if ( rtp - > dtmfmute . tv_usec > 1000000 ) {
rtp - > dtmfmute . tv_usec - = 1000000 ;
rtp - > dtmfmute . tv_sec + = 1 ;
}
2003-02-05 19:26:49 +00:00
/* Get a pointer to the header */
rtpheader = ( unsigned int * ) data ;
2005-02-27 16:43:32 +00:00
rtpheader [ 0 ] = htonl ( ( 2 < < 30 ) | ( 1 < < 23 ) | ( payload < < 16 ) | ( rtp - > seqno + + ) ) ;
2005-04-04 02:13:40 +00:00
rtpheader [ 1 ] = htonl ( rtp - > lastdigitts ) ;
2003-02-05 19:26:49 +00:00
rtpheader [ 2 ] = htonl ( rtp - > ssrc ) ;
rtpheader [ 3 ] = htonl ( ( digit < < 24 ) | ( 0xa < < 16 ) | ( 0 ) ) ;
2005-01-18 14:16:04 +00:00
for ( x = 0 ; x < 6 ; x + + ) {
2003-02-05 19:26:49 +00:00
if ( rtp - > them . sin_port & & rtp - > them . sin_addr . s_addr ) {
2005-05-15 04:06:16 +00:00
res = sendto ( rtp - > s , ( void * ) rtpheader , hdrlen + 4 , 0 , ( struct sockaddr * ) & rtp - > them , sizeof ( rtp - > them ) ) ;
2005-04-04 02:13:40 +00:00
if ( res < 0 )
2005-05-15 04:06:16 +00:00
ast_log ( LOG_ERROR , " RTP Transmission error to %s:%d: %s \n " ,
ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) ,
ntohs ( rtp - > them . sin_port ) , strerror ( errno ) ) ;
if ( rtp_debug_test_addr ( & rtp - > them ) )
ast_verbose ( " Sent RTP packet to %s:%d (type %d, seq %d, ts %d, len %d) \n " ,
ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) ,
ntohs ( rtp - > them . sin_port ) , payload , rtp - > seqno , rtp - > lastdigitts , res - hdrlen ) ;
2003-02-05 19:26:49 +00:00
}
2005-04-04 02:13:40 +00:00
/* Clear marker bit and increment seqno */
2005-05-15 04:06:16 +00:00
rtpheader [ 0 ] = htonl ( ( 2 < < 30 ) | ( payload < < 16 ) | ( rtp - > seqno + + ) ) ;
2005-04-04 02:13:40 +00:00
/* For the last three packets, set the duration and the end bit */
2005-01-18 14:16:04 +00:00
if ( x = = 2 ) {
2005-06-18 17:13:01 +00:00
#if 0
/* No, this is wrong... Do not increment lastdigitts, that's not according
to the RFC , as best we can determine */
2005-05-15 04:06:16 +00:00
rtp - > lastdigitts + + ; /* or else the SPA3000 will click instead of beeping... */
2005-06-18 17:13:01 +00:00
# endif
2005-05-15 04:06:16 +00:00
rtpheader [ 1 ] = htonl ( rtp - > lastdigitts ) ;
2004-03-14 23:12:22 +00:00
/* Make duration 800 (100ms) */
rtpheader [ 3 ] | = htonl ( ( 800 ) ) ;
2005-05-15 04:06:16 +00:00
/* Set the End bit */
2003-02-05 19:26:49 +00:00
rtpheader [ 3 ] | = htonl ( ( 1 < < 23 ) ) ;
}
}
2005-04-20 16:46:25 +00:00
/* Increment the digit timestamp by 120ms, to ensure that digits
2005-04-04 02:13:40 +00:00
sent sequentially with no intervening non - digit packets do not
2005-04-20 16:46:25 +00:00
get sent with the same timestamp , and that sequential digits
have some ' dead air ' in between them
2005-04-04 02:13:40 +00:00
*/
2005-04-20 16:46:25 +00:00
rtp - > lastdigitts + = 960 ;
2003-02-05 19:26:49 +00:00
return 0 ;
}
2005-01-07 07:11:40 +00:00
int ast_rtp_sendcng ( struct ast_rtp * rtp , int level )
{
unsigned int * rtpheader ;
int hdrlen = 12 ;
int res ;
int payload ;
char data [ 256 ] ;
char iabuf [ INET_ADDRSTRLEN ] ;
level = 127 - ( level & 0x7f ) ;
payload = ast_rtp_lookup_code ( rtp , 0 , AST_RTP_CN ) ;
/* If we have no peer, return immediately */
if ( ! rtp - > them . sin_addr . s_addr )
return 0 ;
gettimeofday ( & rtp - > dtmfmute , NULL ) ;
rtp - > dtmfmute . tv_usec + = ( 500 * 1000 ) ;
if ( rtp - > dtmfmute . tv_usec > 1000000 ) {
rtp - > dtmfmute . tv_usec - = 1000000 ;
rtp - > dtmfmute . tv_sec + = 1 ;
}
/* Get a pointer to the header */
rtpheader = ( unsigned int * ) data ;
rtpheader [ 0 ] = htonl ( ( 2 < < 30 ) | ( 1 < < 23 ) | ( payload < < 16 ) | ( rtp - > seqno + + ) ) ;
rtpheader [ 1 ] = htonl ( rtp - > lastts ) ;
rtpheader [ 2 ] = htonl ( rtp - > ssrc ) ;
data [ 12 ] = level ;
if ( rtp - > them . sin_port & & rtp - > them . sin_addr . s_addr ) {
res = sendto ( rtp - > s , ( void * ) rtpheader , hdrlen + 1 , 0 , ( struct sockaddr * ) & rtp - > them , sizeof ( rtp - > them ) ) ;
if ( res < 0 )
ast_log ( LOG_ERROR , " RTP Comfort Noise Transmission error to %s:%d: %s \n " , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) , ntohs ( rtp - > them . sin_port ) , strerror ( errno ) ) ;
if ( rtp_debug_test_addr ( & rtp - > them ) )
ast_verbose ( " Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %d, len %d) \n "
, ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) , ntohs ( rtp - > them . sin_port ) , payload , rtp - > seqno , rtp - > lastts , res - hdrlen ) ;
}
return 0 ;
}
2002-08-09 17:17:54 +00:00
static int ast_rtp_raw_write ( struct ast_rtp * rtp , struct ast_frame * f , int codec )
2002-06-16 16:06:38 +00:00
{
2004-12-14 23:36:30 +00:00
unsigned char * rtpheader ;
2004-06-30 16:56:51 +00:00
char iabuf [ INET_ADDRSTRLEN ] ;
2002-06-16 16:06:38 +00:00
int hdrlen = 12 ;
int res ;
2002-08-09 17:17:54 +00:00
int ms ;
int pred ;
2003-06-28 16:40:02 +00:00
int mark = 0 ;
2002-06-16 16:06:38 +00:00
2004-03-13 03:52:14 +00:00
ms = calc_txstamp ( rtp , & f - > delivery ) ;
2002-08-09 17:17:54 +00:00
/* Default prediction */
2003-06-28 16:40:02 +00:00
if ( f - > subclass < AST_FORMAT_MAX_AUDIO ) {
2005-05-14 23:57:44 +00:00
pred = rtp - > lastts + ast_codec_get_samples ( f ) ;
2003-06-28 16:40:02 +00:00
/* Re-calculate last TS */
rtp - > lastts = rtp - > lastts + ms * 8 ;
2004-03-17 16:49:00 +00:00
if ( ! f - > delivery . tv_sec & & ! f - > delivery . tv_usec ) {
2004-03-14 05:31:47 +00:00
/* If this isn't an absolute delivery time, Check if it is close to our prediction,
and if so , go with our prediction */
2004-06-30 06:03:57 +00:00
if ( abs ( rtp - > lastts - pred ) < MAX_TIMESTAMP_SKEW )
2004-03-14 05:31:47 +00:00
rtp - > lastts = pred ;
2004-05-01 15:18:28 +00:00
else {
2004-12-28 16:43:20 +00:00
if ( option_debug > 2 )
ast_log ( LOG_DEBUG , " Difference is %d, ms is %d \n " , abs ( rtp - > lastts - pred ) , ms ) ;
2004-05-01 15:18:28 +00:00
mark = 1 ;
}
2004-03-14 05:31:47 +00:00
}
2003-06-28 16:40:02 +00:00
} else {
2003-06-28 18:35:58 +00:00
mark = f - > subclass & 0x1 ;
2003-06-28 16:40:02 +00:00
pred = rtp - > lastovidtimestamp + f - > samples ;
/* Re-calculate last TS */
rtp - > lastts = rtp - > lastts + ms * 90 ;
/* If it's close to our prediction, go for it */
2004-05-30 20:24:48 +00:00
if ( ! f - > delivery . tv_sec & & ! f - > delivery . tv_usec ) {
if ( abs ( rtp - > lastts - pred ) < 7200 ) {
rtp - > lastts = pred ;
rtp - > lastovidtimestamp + = f - > samples ;
} else {
2004-12-28 16:43:20 +00:00
if ( option_debug > 2 )
ast_log ( LOG_DEBUG , " Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d \n " , abs ( rtp - > lastts - pred ) , ms , ms * 90 , rtp - > lastts , pred , f - > samples ) ;
2004-05-30 20:24:48 +00:00
rtp - > lastovidtimestamp = rtp - > lastts ;
}
2003-06-28 16:40:02 +00:00
}
2003-06-28 18:35:58 +00:00
}
2005-04-04 02:13:40 +00:00
/* If the timestamp for non-digit packets has moved beyond the timestamp
for digits , update the digit timestamp .
*/
if ( rtp - > lastts > rtp - > lastdigitts )
rtp - > lastdigitts = rtp - > lastts ;
2003-06-28 18:35:58 +00:00
/* Get a pointer to the header */
2004-12-14 23:36:30 +00:00
rtpheader = ( unsigned char * ) ( f - > data - hdrlen ) ;
2005-03-29 04:49:24 +00:00
put_unaligned_uint32 ( rtpheader , htonl ( ( 2 < < 30 ) | ( codec < < 16 ) | ( rtp - > seqno ) | ( mark < < 23 ) ) ) ;
put_unaligned_uint32 ( rtpheader + 4 , htonl ( rtp - > lastts ) ) ;
put_unaligned_uint32 ( rtpheader + 8 , htonl ( rtp - > ssrc ) ) ;
2004-12-14 23:36:30 +00:00
2003-06-28 18:35:58 +00:00
if ( rtp - > them . sin_port & & rtp - > them . sin_addr . s_addr ) {
2003-09-08 16:48:07 +00:00
res = sendto ( rtp - > s , ( void * ) rtpheader , f - > datalen + hdrlen , 0 , ( struct sockaddr * ) & rtp - > them , sizeof ( rtp - > them ) ) ;
2003-06-28 18:35:58 +00:00
if ( res < 0 )
2004-06-29 12:56:46 +00:00
ast_log ( LOG_NOTICE , " RTP Transmission error to %s:%d: %s \n " , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) , ntohs ( rtp - > them . sin_port ) , strerror ( errno ) ) ;
2004-10-30 01:52:12 +00:00
if ( rtp_debug_test_addr ( & rtp - > them ) )
ast_verbose ( " Sent RTP packet to %s:%d (type %d, seq %d, ts %d, len %d) \n "
, ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtp - > them . sin_addr ) , ntohs ( rtp - > them . sin_port ) , codec , rtp - > seqno , rtp - > lastts , res - hdrlen ) ;
2002-06-16 16:06:38 +00:00
}
2005-03-24 22:00:23 +00:00
rtp - > seqno + + ;
2002-06-16 16:06:38 +00:00
return 0 ;
}
2002-08-09 17:17:54 +00:00
int ast_rtp_write ( struct ast_rtp * rtp , struct ast_frame * _f )
{
struct ast_frame * f ;
int codec ;
int hdrlen = 12 ;
2003-06-28 18:35:58 +00:00
int subclass ;
2002-08-09 17:17:54 +00:00
2003-02-05 19:26:49 +00:00
/* If we have no peer, return immediately */
if ( ! rtp - > them . sin_addr . s_addr )
return 0 ;
2003-04-08 21:53:46 +00:00
/* If there is no data length, return immediately */
if ( ! _f - > datalen )
return 0 ;
2002-08-09 17:17:54 +00:00
2003-02-05 19:26:49 +00:00
/* Make sure we have enough space for RTP header */
2003-06-28 16:40:02 +00:00
if ( ( _f - > frametype ! = AST_FRAME_VOICE ) & & ( _f - > frametype ! = AST_FRAME_VIDEO ) ) {
2002-08-09 17:17:54 +00:00
ast_log ( LOG_WARNING , " RTP can only send voice \n " ) ;
return - 1 ;
}
2003-06-28 18:35:58 +00:00
subclass = _f - > subclass ;
if ( _f - > frametype = = AST_FRAME_VIDEO )
subclass & = ~ 0x1 ;
2003-04-08 21:53:46 +00:00
2003-06-28 18:35:58 +00:00
codec = ast_rtp_lookup_code ( rtp , 1 , subclass ) ;
2002-08-09 17:17:54 +00:00
if ( codec < 0 ) {
2003-08-16 05:10:35 +00:00
ast_log ( LOG_WARNING , " Don't know how to send format %s packets with RTP \n " , ast_getformatname ( _f - > subclass ) ) ;
2002-08-09 17:17:54 +00:00
return - 1 ;
}
2003-06-28 18:35:58 +00:00
if ( rtp - > lasttxformat ! = subclass ) {
2003-02-05 19:26:49 +00:00
/* New format, reset the smoother */
2004-12-28 16:43:20 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " Ooh, format changed from %s to %s \n " , ast_getformatname ( rtp - > lasttxformat ) , ast_getformatname ( subclass ) ) ;
2003-06-28 18:35:58 +00:00
rtp - > lasttxformat = subclass ;
2003-02-05 19:26:49 +00:00
if ( rtp - > smoother )
ast_smoother_free ( rtp - > smoother ) ;
rtp - > smoother = NULL ;
}
2002-08-09 17:17:54 +00:00
2003-06-28 18:35:58 +00:00
switch ( subclass ) {
2005-04-03 22:57:18 +00:00
case AST_FORMAT_SLINEAR :
if ( ! rtp - > smoother ) {
rtp - > smoother = ast_smoother_new ( 320 ) ;
}
if ( ! rtp - > smoother ) {
ast_log ( LOG_WARNING , " Unable to create smoother :( \n " ) ;
return - 1 ;
}
ast_smoother_feed_be ( rtp - > smoother , _f ) ;
while ( ( f = ast_smoother_read ( rtp - > smoother ) ) )
ast_rtp_raw_write ( rtp , f , codec ) ;
break ;
2002-08-09 17:17:54 +00:00
case AST_FORMAT_ULAW :
case AST_FORMAT_ALAW :
if ( ! rtp - > smoother ) {
rtp - > smoother = ast_smoother_new ( 160 ) ;
}
if ( ! rtp - > smoother ) {
ast_log ( LOG_WARNING , " Unable to create smoother :( \n " ) ;
return - 1 ;
}
ast_smoother_feed ( rtp - > smoother , _f ) ;
2004-02-25 04:10:32 +00:00
while ( ( f = ast_smoother_read ( rtp - > smoother ) ) )
ast_rtp_raw_write ( rtp , f , codec ) ;
break ;
2004-03-05 17:32:00 +00:00
case AST_FORMAT_ADPCM :
2004-02-25 04:10:32 +00:00
case AST_FORMAT_G726 :
if ( ! rtp - > smoother ) {
rtp - > smoother = ast_smoother_new ( 80 ) ;
}
if ( ! rtp - > smoother ) {
ast_log ( LOG_WARNING , " Unable to create smoother :( \n " ) ;
return - 1 ;
}
ast_smoother_feed ( rtp - > smoother , _f ) ;
2002-08-09 17:17:54 +00:00
while ( ( f = ast_smoother_read ( rtp - > smoother ) ) )
ast_rtp_raw_write ( rtp , f , codec ) ;
break ;
case AST_FORMAT_G729A :
if ( ! rtp - > smoother ) {
rtp - > smoother = ast_smoother_new ( 20 ) ;
2004-03-14 18:01:29 +00:00
if ( rtp - > smoother )
ast_smoother_set_flags ( rtp - > smoother , AST_SMOOTHER_FLAG_G729 ) ;
2002-08-09 17:17:54 +00:00
}
if ( ! rtp - > smoother ) {
ast_log ( LOG_WARNING , " Unable to create g729 smoother :( \n " ) ;
return - 1 ;
}
ast_smoother_feed ( rtp - > smoother , _f ) ;
while ( ( f = ast_smoother_read ( rtp - > smoother ) ) )
ast_rtp_raw_write ( rtp , f , codec ) ;
break ;
2003-02-05 19:26:49 +00:00
case AST_FORMAT_GSM :
if ( ! rtp - > smoother ) {
rtp - > smoother = ast_smoother_new ( 33 ) ;
}
if ( ! rtp - > smoother ) {
ast_log ( LOG_WARNING , " Unable to create GSM smoother :( \n " ) ;
return - 1 ;
}
ast_smoother_feed ( rtp - > smoother , _f ) ;
while ( ( f = ast_smoother_read ( rtp - > smoother ) ) )
ast_rtp_raw_write ( rtp , f , codec ) ;
break ;
2003-04-15 04:36:52 +00:00
case AST_FORMAT_ILBC :
if ( ! rtp - > smoother ) {
2003-04-17 19:19:12 +00:00
rtp - > smoother = ast_smoother_new ( 50 ) ;
2003-04-15 04:36:52 +00:00
}
if ( ! rtp - > smoother ) {
ast_log ( LOG_WARNING , " Unable to create ILBC smoother :( \n " ) ;
return - 1 ;
}
ast_smoother_feed ( rtp - > smoother , _f ) ;
while ( ( f = ast_smoother_read ( rtp - > smoother ) ) )
ast_rtp_raw_write ( rtp , f , codec ) ;
break ;
2002-08-09 17:17:54 +00:00
default :
2003-08-16 05:10:35 +00:00
ast_log ( LOG_WARNING , " Not sure about sending format %s packets \n " , ast_getformatname ( subclass ) ) ;
2004-06-29 20:10:57 +00:00
/* fall through to... */
2003-06-28 16:40:02 +00:00
case AST_FORMAT_H261 :
case AST_FORMAT_H263 :
2005-03-05 20:57:49 +00:00
case AST_FORMAT_H263_PLUS :
2003-08-18 05:31:25 +00:00
case AST_FORMAT_G723_1 :
2004-09-15 18:40:07 +00:00
case AST_FORMAT_LPC10 :
2003-03-12 06:00:18 +00:00
case AST_FORMAT_SPEEX :
2004-06-29 20:10:57 +00:00
/* Don't buffer outgoing frames; send them one-per-packet: */
2002-08-09 17:17:54 +00:00
if ( _f - > offset < hdrlen ) {
f = ast_frdup ( _f ) ;
} else {
f = _f ;
}
ast_rtp_raw_write ( rtp , f , codec ) ;
}
return 0 ;
}
2003-02-16 06:00:12 +00:00
void ast_rtp_proto_unregister ( struct ast_rtp_protocol * proto )
{
struct ast_rtp_protocol * cur , * prev ;
2004-12-28 16:43:20 +00:00
2003-02-16 06:00:12 +00:00
cur = protos ;
prev = NULL ;
while ( cur ) {
if ( cur = = proto ) {
if ( prev )
prev - > next = proto - > next ;
else
protos = proto - > next ;
return ;
}
prev = cur ;
cur = cur - > next ;
}
}
int ast_rtp_proto_register ( struct ast_rtp_protocol * proto )
{
struct ast_rtp_protocol * cur ;
cur = protos ;
while ( cur ) {
if ( cur - > type = = proto - > type ) {
ast_log ( LOG_WARNING , " Tried to register same protocol '%s' twice \n " , cur - > type ) ;
return - 1 ;
}
cur = cur - > next ;
}
proto - > next = protos ;
protos = proto ;
return 0 ;
}
static struct ast_rtp_protocol * get_proto ( struct ast_channel * chan )
{
struct ast_rtp_protocol * cur ;
cur = protos ;
while ( cur ) {
if ( cur - > type = = chan - > type ) {
return cur ;
}
cur = cur - > next ;
}
return NULL ;
}
2005-05-16 13:22:34 +00:00
/* ast_rtp_bridge: Bridge calls. If possible and allowed, initiate
re - invite so the peers exchange media directly outside
of Asterisk . */
2003-02-16 06:00:12 +00:00
int ast_rtp_bridge ( struct ast_channel * c0 , struct ast_channel * c1 , int flags , struct ast_frame * * fo , struct ast_channel * * rc )
{
struct ast_frame * f ;
struct ast_channel * who , * cs [ 3 ] ;
struct ast_rtp * p0 , * p1 ;
2003-06-28 16:40:02 +00:00
struct ast_rtp * vp0 , * vp1 ;
2003-02-16 06:00:12 +00:00
struct ast_rtp_protocol * pr0 , * pr1 ;
2003-04-14 20:48:30 +00:00
struct sockaddr_in ac0 , ac1 ;
2003-06-28 16:40:02 +00:00
struct sockaddr_in vac0 , vac1 ;
2003-04-14 20:48:30 +00:00
struct sockaddr_in t0 , t1 ;
2003-06-28 16:40:02 +00:00
struct sockaddr_in vt0 , vt1 ;
2004-06-30 16:56:51 +00:00
char iabuf [ INET_ADDRSTRLEN ] ;
2003-04-14 20:48:30 +00:00
2003-02-16 06:00:12 +00:00
void * pvt0 , * pvt1 ;
int to ;
2004-05-27 04:18:46 +00:00
int codec0 , codec1 , oldcodec0 , oldcodec1 ;
2003-06-28 16:40:02 +00:00
memset ( & vt0 , 0 , sizeof ( vt0 ) ) ;
memset ( & vt1 , 0 , sizeof ( vt1 ) ) ;
memset ( & vac0 , 0 , sizeof ( vac0 ) ) ;
memset ( & vac1 , 0 , sizeof ( vac1 ) ) ;
2003-02-16 06:00:12 +00:00
/* if need DTMF, cant native bridge */
if ( flags & ( AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1 ) )
return - 2 ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & c0 - > lock ) ;
2004-08-31 21:55:19 +00:00
while ( ast_mutex_trylock ( & c1 - > lock ) ) {
ast_mutex_unlock ( & c0 - > lock ) ;
usleep ( 1 ) ;
ast_mutex_lock ( & c0 - > lock ) ;
}
2003-02-16 06:00:12 +00:00
pr0 = get_proto ( c0 ) ;
pr1 = get_proto ( c1 ) ;
if ( ! pr0 ) {
ast_log ( LOG_WARNING , " Can't find native functions for channel '%s' \n " , c0 - > name ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & c0 - > lock ) ;
ast_mutex_unlock ( & c1 - > lock ) ;
2003-02-16 06:00:12 +00:00
return - 1 ;
}
if ( ! pr1 ) {
ast_log ( LOG_WARNING , " Can't find native functions for channel '%s' \n " , c1 - > name ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & c0 - > lock ) ;
ast_mutex_unlock ( & c1 - > lock ) ;
2003-02-16 06:00:12 +00:00
return - 1 ;
}
2005-03-04 06:47:24 +00:00
pvt0 = c0 - > tech_pvt ;
pvt1 = c1 - > tech_pvt ;
2003-02-16 06:00:12 +00:00
p0 = pr0 - > get_rtp_info ( c0 ) ;
2003-06-28 16:40:02 +00:00
if ( pr0 - > get_vrtp_info )
vp0 = pr0 - > get_vrtp_info ( c0 ) ;
else
vp0 = NULL ;
2003-02-16 06:00:12 +00:00
p1 = pr1 - > get_rtp_info ( c1 ) ;
2003-06-28 16:40:02 +00:00
if ( pr1 - > get_vrtp_info )
vp1 = pr1 - > get_vrtp_info ( c1 ) ;
else
vp1 = NULL ;
2003-02-16 06:00:12 +00:00
if ( ! p0 | | ! p1 ) {
/* Somebody doesn't want to play... */
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & c0 - > lock ) ;
ast_mutex_unlock ( & c1 - > lock ) ;
2003-02-16 06:00:12 +00:00
return - 2 ;
}
2004-05-27 04:18:46 +00:00
if ( pr0 - > get_codec )
2003-11-15 00:53:33 +00:00
codec0 = pr0 - > get_codec ( c0 ) ;
2004-05-27 04:18:46 +00:00
else
codec0 = 0 ;
if ( pr1 - > get_codec )
2003-11-15 00:53:33 +00:00
codec1 = pr1 - > get_codec ( c1 ) ;
2004-05-27 04:18:46 +00:00
else
codec1 = 0 ;
if ( pr0 - > get_codec & & pr1 - > get_codec ) {
2005-05-16 13:22:34 +00:00
/* Hey, we can't do reinvite if both parties speak different codecs */
2004-02-18 21:38:46 +00:00
if ( ! ( codec0 & codec1 ) ) {
2005-05-16 13:22:34 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP. \n " , codec0 , codec1 ) ;
2003-11-25 16:26:15 +00:00
ast_mutex_unlock ( & c0 - > lock ) ;
ast_mutex_unlock ( & c1 - > lock ) ;
2003-11-15 00:53:33 +00:00
return - 2 ;
2003-11-25 16:26:15 +00:00
}
2003-11-15 00:53:33 +00:00
}
2005-05-16 13:22:34 +00:00
/* Ok, we should be able to redirect the media. Start with one channel */
2004-05-27 04:18:46 +00:00
if ( pr0 - > set_rtp_peer ( c0 , p1 , vp1 , codec1 ) )
2003-02-16 06:00:12 +00:00
ast_log ( LOG_WARNING , " Channel '%s' failed to talk to '%s' \n " , c0 - > name , c1 - > name ) ;
2003-04-14 20:48:30 +00:00
else {
/* Store RTP peer */
ast_rtp_get_peer ( p1 , & ac1 ) ;
2003-06-28 16:40:02 +00:00
if ( vp1 )
2004-05-28 00:52:45 +00:00
ast_rtp_get_peer ( vp1 , & vac1 ) ;
2003-04-14 20:48:30 +00:00
}
2005-05-16 13:22:34 +00:00
/* Then test the other channel */
2004-05-27 04:18:46 +00:00
if ( pr1 - > set_rtp_peer ( c1 , p0 , vp0 , codec0 ) )
2003-02-16 06:00:12 +00:00
ast_log ( LOG_WARNING , " Channel '%s' failed to talk back to '%s' \n " , c1 - > name , c0 - > name ) ;
2003-04-14 20:48:30 +00:00
else {
/* Store RTP peer */
ast_rtp_get_peer ( p0 , & ac0 ) ;
2003-06-28 16:40:02 +00:00
if ( vp0 )
2004-05-28 00:52:45 +00:00
ast_rtp_get_peer ( vp0 , & vac0 ) ;
2003-04-14 20:48:30 +00:00
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & c0 - > lock ) ;
ast_mutex_unlock ( & c1 - > lock ) ;
2003-02-16 06:00:12 +00:00
cs [ 0 ] = c0 ;
cs [ 1 ] = c1 ;
cs [ 2 ] = NULL ;
2004-05-27 04:18:46 +00:00
oldcodec0 = codec0 ;
oldcodec1 = codec1 ;
2003-02-16 06:00:12 +00:00
for ( ; ; ) {
2005-03-04 06:47:24 +00:00
if ( ( c0 - > tech_pvt ! = pvt0 ) | |
( c1 - > tech_pvt ! = pvt1 ) | |
2003-02-16 06:00:12 +00:00
( c0 - > masq | | c0 - > masqr | | c1 - > masq | | c1 - > masqr ) ) {
2005-02-15 15:57:52 +00:00
ast_log ( LOG_DEBUG , " Oooh, something is weird, backing out \n " ) ;
2005-03-04 06:47:24 +00:00
if ( c0 - > tech_pvt = = pvt0 ) {
2004-05-27 04:18:46 +00:00
if ( pr0 - > set_rtp_peer ( c0 , NULL , NULL , 0 ) )
2003-02-16 06:00:12 +00:00
ast_log ( LOG_WARNING , " Channel '%s' failed to revert \n " , c0 - > name ) ;
}
2005-03-04 06:47:24 +00:00
if ( c1 - > tech_pvt = = pvt1 ) {
2004-05-27 04:18:46 +00:00
if ( pr1 - > set_rtp_peer ( c1 , NULL , NULL , 0 ) )
2003-02-16 06:00:12 +00:00
ast_log ( LOG_WARNING , " Channel '%s' failed to revert back \n " , c1 - > name ) ;
}
/* Tell it to try again later */
return - 3 ;
}
to = - 1 ;
2003-04-14 20:48:30 +00:00
ast_rtp_get_peer ( p1 , & t1 ) ;
2003-07-11 21:51:06 +00:00
ast_rtp_get_peer ( p0 , & t0 ) ;
2004-05-27 04:18:46 +00:00
if ( pr0 - > get_codec )
codec0 = pr0 - > get_codec ( c0 ) ;
if ( pr1 - > get_codec )
codec1 = pr1 - > get_codec ( c1 ) ;
2003-06-28 16:40:02 +00:00
if ( vp1 )
ast_rtp_get_peer ( vp1 , & vt1 ) ;
if ( vp0 )
ast_rtp_get_peer ( vp0 , & vt0 ) ;
2004-05-27 04:18:46 +00:00
if ( inaddrcmp ( & t1 , & ac1 ) | | ( vp1 & & inaddrcmp ( & vt1 , & vac1 ) ) | | ( codec1 ! = oldcodec1 ) ) {
2004-12-28 16:43:20 +00:00
if ( option_debug ) {
ast_log ( LOG_DEBUG , " Oooh, '%s' changed end address to %s:%d (format %d) \n " ,
c1 - > name , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , t1 . sin_addr ) , ntohs ( t1 . sin_port ) , codec1 ) ;
ast_log ( LOG_DEBUG , " Oooh, '%s' changed end vaddress to %s:%d (format %d) \n " ,
c1 - > name , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , vt1 . sin_addr ) , ntohs ( vt1 . sin_port ) , codec1 ) ;
ast_log ( LOG_DEBUG , " Oooh, '%s' was %s:%d/(format %d) \n " ,
c1 - > name , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , ac1 . sin_addr ) , ntohs ( ac1 . sin_port ) , oldcodec1 ) ;
ast_log ( LOG_DEBUG , " Oooh, '%s' wasv %s:%d/(format %d) \n " ,
c1 - > name , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , vac1 . sin_addr ) , ntohs ( vac1 . sin_port ) , oldcodec1 ) ;
}
2004-05-27 04:18:46 +00:00
if ( pr0 - > set_rtp_peer ( c0 , t1 . sin_addr . s_addr ? p1 : NULL , vt1 . sin_addr . s_addr ? vp1 : NULL , codec1 ) )
2003-04-14 20:48:30 +00:00
ast_log ( LOG_WARNING , " Channel '%s' failed to update to '%s' \n " , c0 - > name , c1 - > name ) ;
memcpy ( & ac1 , & t1 , sizeof ( ac1 ) ) ;
2003-06-28 16:40:02 +00:00
memcpy ( & vac1 , & vt1 , sizeof ( vac1 ) ) ;
2004-05-27 04:18:46 +00:00
oldcodec1 = codec1 ;
2003-04-14 20:48:30 +00:00
}
2003-06-28 16:40:02 +00:00
if ( inaddrcmp ( & t0 , & ac0 ) | | ( vp0 & & inaddrcmp ( & vt0 , & vac0 ) ) ) {
2004-12-28 16:43:20 +00:00
if ( option_debug ) {
ast_log ( LOG_DEBUG , " Oooh, '%s' changed end address to %s:%d (format %d) \n " ,
c0 - > name , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , t0 . sin_addr ) , ntohs ( t0 . sin_port ) , codec0 ) ;
ast_log ( LOG_DEBUG , " Oooh, '%s' was %s:%d/(format %d) \n " ,
c0 - > name , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , ac0 . sin_addr ) , ntohs ( ac0 . sin_port ) , oldcodec0 ) ;
}
2004-05-27 04:18:46 +00:00
if ( pr1 - > set_rtp_peer ( c1 , t0 . sin_addr . s_addr ? p0 : NULL , vt0 . sin_addr . s_addr ? vp0 : NULL , codec0 ) )
2003-04-14 20:48:30 +00:00
ast_log ( LOG_WARNING , " Channel '%s' failed to update to '%s' \n " , c1 - > name , c0 - > name ) ;
memcpy ( & ac0 , & t0 , sizeof ( ac0 ) ) ;
2003-06-28 16:40:02 +00:00
memcpy ( & vac0 , & vt0 , sizeof ( vac0 ) ) ;
2004-05-27 04:18:46 +00:00
oldcodec0 = codec0 ;
2003-04-14 20:48:30 +00:00
}
2003-02-16 06:00:12 +00:00
who = ast_waitfor_n ( cs , 2 , & to ) ;
if ( ! who ) {
2004-12-28 16:43:20 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " Ooh, empty read... \n " ) ;
2005-05-16 13:22:34 +00:00
/* check for hangup / whentohangup */
2003-11-18 00:45:04 +00:00
if ( ast_check_hangup ( c0 ) | | ast_check_hangup ( c1 ) )
break ;
2003-02-16 06:00:12 +00:00
continue ;
}
f = ast_read ( who ) ;
if ( ! f | | ( ( f - > frametype = = AST_FRAME_DTMF ) & &
( ( ( who = = c0 ) & & ( flags & AST_BRIDGE_DTMF_CHANNEL_0 ) ) | |
( ( who = = c1 ) & & ( flags & AST_BRIDGE_DTMF_CHANNEL_1 ) ) ) ) ) {
* fo = f ;
* rc = who ;
2004-12-28 16:43:20 +00:00
if ( option_debug )
ast_log ( LOG_DEBUG , " Oooh, got a %s \n " , f ? " digit " : " hangup " ) ;
2005-03-04 06:47:24 +00:00
if ( ( c0 - > tech_pvt = = pvt0 ) & & ( ! c0 - > _softhangup ) ) {
2004-05-27 04:18:46 +00:00
if ( pr0 - > set_rtp_peer ( c0 , NULL , NULL , 0 ) )
2003-02-16 06:00:12 +00:00
ast_log ( LOG_WARNING , " Channel '%s' failed to revert \n " , c0 - > name ) ;
}
2005-03-04 06:47:24 +00:00
if ( ( c1 - > tech_pvt = = pvt1 ) & & ( ! c1 - > _softhangup ) ) {
2004-05-27 04:18:46 +00:00
if ( pr1 - > set_rtp_peer ( c1 , NULL , NULL , 0 ) )
2003-02-16 06:00:12 +00:00
ast_log ( LOG_WARNING , " Channel '%s' failed to revert back \n " , c1 - > name ) ;
}
/* That's all we needed */
return 0 ;
2003-03-15 06:00:16 +00:00
} else {
2003-06-28 22:50:47 +00:00
if ( ( f - > frametype = = AST_FRAME_DTMF ) | |
( f - > frametype = = AST_FRAME_VOICE ) | |
( f - > frametype = = AST_FRAME_VIDEO ) ) {
2003-03-15 06:00:16 +00:00
/* Forward voice or DTMF frames if they happen upon us */
if ( who = = c0 ) {
ast_write ( c1 , f ) ;
} else if ( who = = c1 ) {
ast_write ( c0 , f ) ;
}
}
2003-02-16 06:00:12 +00:00
ast_frfree ( f ) ;
2003-03-15 06:00:16 +00:00
}
2003-02-16 06:00:12 +00:00
/* Swap priority not that it's a big deal at this point */
cs [ 2 ] = cs [ 0 ] ;
cs [ 0 ] = cs [ 1 ] ;
cs [ 1 ] = cs [ 2 ] ;
}
return - 1 ;
}
2003-05-16 02:50:46 +00:00
2004-10-30 01:52:12 +00:00
static int rtp_do_debug_ip ( int fd , int argc , char * argv [ ] )
{
struct hostent * hp ;
struct ast_hostent ahp ;
char iabuf [ INET_ADDRSTRLEN ] ;
int port = 0 ;
char * p , * arg ;
2004-12-28 16:43:20 +00:00
2004-10-30 01:52:12 +00:00
if ( argc ! = 4 )
return RESULT_SHOWUSAGE ;
arg = argv [ 3 ] ;
p = strstr ( arg , " : " ) ;
2004-12-28 16:43:20 +00:00
if ( p ) {
2004-10-30 01:52:12 +00:00
* p = ' \0 ' ;
p + + ;
port = atoi ( p ) ;
}
hp = ast_gethostbyname ( arg , & ahp ) ;
if ( hp = = NULL )
return RESULT_SHOWUSAGE ;
rtpdebugaddr . sin_family = AF_INET ;
memcpy ( & rtpdebugaddr . sin_addr , hp - > h_addr , sizeof ( rtpdebugaddr . sin_addr ) ) ;
rtpdebugaddr . sin_port = htons ( port ) ;
if ( port = = 0 )
ast_cli ( fd , " RTP Debugging Enabled for IP: %s \n " , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtpdebugaddr . sin_addr ) ) ;
else
ast_cli ( fd , " RTP Debugging Enabled for IP: %s:%d \n " , ast_inet_ntoa ( iabuf , sizeof ( iabuf ) , rtpdebugaddr . sin_addr ) , port ) ;
rtpdebug = 1 ;
return RESULT_SUCCESS ;
}
static int rtp_do_debug ( int fd , int argc , char * argv [ ] )
{
if ( argc ! = 2 ) {
if ( argc ! = 4 )
return RESULT_SHOWUSAGE ;
return rtp_do_debug_ip ( fd , argc , argv ) ;
}
rtpdebug = 1 ;
memset ( & rtpdebugaddr , 0 , sizeof ( rtpdebugaddr ) ) ;
ast_cli ( fd , " RTP Debugging Enabled \n " ) ;
return RESULT_SUCCESS ;
}
static int rtp_no_debug ( int fd , int argc , char * argv [ ] )
{
if ( argc ! = 3 )
return RESULT_SHOWUSAGE ;
rtpdebug = 0 ;
ast_cli ( fd , " RTP Debugging Disabled \n " ) ;
return RESULT_SUCCESS ;
}
static char debug_usage [ ] =
" Usage: rtp debug [ip host[:port]] \n "
" Enable dumping of all RTP packets to and from host. \n " ;
2004-12-28 16:43:20 +00:00
2004-10-30 01:52:12 +00:00
static char no_debug_usage [ ] =
" Usage: rtp no debug \n "
" Disable all RTP debugging \n " ;
static struct ast_cli_entry cli_debug_ip =
{ { " rtp " , " debug " , " ip " , NULL } , rtp_do_debug , " Enable RTP debugging on IP " , debug_usage } ;
static struct ast_cli_entry cli_debug =
{ { " rtp " , " debug " , NULL } , rtp_do_debug , " Enable RTP debugging " , debug_usage } ;
static struct ast_cli_entry cli_no_debug =
{ { " rtp " , " no " , " debug " , NULL } , rtp_no_debug , " Disable RTP debugging " , no_debug_usage } ;
2003-05-16 02:50:46 +00:00
void ast_rtp_reload ( void )
{
struct ast_config * cfg ;
char * s ;
2004-12-28 16:43:20 +00:00
2003-05-16 02:50:46 +00:00
rtpstart = 5000 ;
rtpend = 31000 ;
2005-01-25 06:10:20 +00:00
cfg = ast_config_load ( " rtp.conf " ) ;
2003-05-16 02:50:46 +00:00
if ( cfg ) {
if ( ( s = ast_variable_retrieve ( cfg , " general " , " rtpstart " ) ) ) {
rtpstart = atoi ( s ) ;
if ( rtpstart < 1024 )
rtpstart = 1024 ;
if ( rtpstart > 65535 )
rtpstart = 65535 ;
}
if ( ( s = ast_variable_retrieve ( cfg , " general " , " rtpend " ) ) ) {
rtpend = atoi ( s ) ;
if ( rtpend < 1024 )
rtpend = 1024 ;
if ( rtpend > 65535 )
rtpend = 65535 ;
}
2004-07-17 21:08:12 +00:00
if ( ( s = ast_variable_retrieve ( cfg , " general " , " rtpchecksums " ) ) ) {
2004-07-19 18:09:33 +00:00
# ifdef SO_NO_CHECK
2005-03-31 19:09:48 +00:00
if ( ast_false ( s ) )
nochecksums = 1 ;
2004-07-17 21:08:12 +00:00
else
2005-03-31 19:09:48 +00:00
nochecksums = 0 ;
2004-07-19 18:09:33 +00:00
# else
2005-03-31 19:09:48 +00:00
if ( ast_false ( s ) )
2004-07-19 18:09:33 +00:00
ast_log ( LOG_WARNING , " Disabling RTP checksums is not supported on this operating system! \n " ) ;
# endif
2004-07-17 21:08:12 +00:00
}
2005-01-25 06:10:20 +00:00
ast_config_destroy ( cfg ) ;
2003-05-16 02:50:46 +00:00
}
if ( rtpstart > = rtpend ) {
2005-05-16 13:22:34 +00:00
ast_log ( LOG_WARNING , " Unreasonable values for RTP start/end port in rtp.conf \n " ) ;
2003-05-16 02:50:46 +00:00
rtpstart = 5000 ;
rtpend = 31000 ;
}
if ( option_verbose > 1 )
ast_verbose ( VERBOSE_PREFIX_2 " RTP Allocating from port range %d -> %d \n " , rtpstart , rtpend ) ;
2004-10-30 01:52:12 +00:00
2003-05-16 02:50:46 +00:00
}
void ast_rtp_init ( void )
{
2004-10-30 01:52:12 +00:00
ast_cli_register ( & cli_debug ) ;
ast_cli_register ( & cli_debug_ip ) ;
ast_cli_register ( & cli_no_debug ) ;
2003-05-16 02:50:46 +00:00
ast_rtp_reload ( ) ;
}