rtp.c File Reference

Supports RTP and RTCP with Symmetric RTP support for NAT traversal. More...

#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/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include "asterisk.h"
#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/config.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/cli.h"
#include "asterisk/unaligned.h"

Include dependency graph for rtp.c:

Go to the source code of this file.

Data Structures
struct	ast_rtcp
	Structure defining an RTCP session. More...
struct	ast_rtp
struct	rtpPayloadType
Defines
#define	DEFAULT_DTMF_TIMEOUT   3000
#define	FLAG_3389_WARNING   (1 << 0)
#define	FLAG_NAT_ACTIVE   (3 << 1)
#define	FLAG_NAT_INACTIVE   (0 << 1)
#define	FLAG_NAT_INACTIVE_NOWARN   (1 << 1)
#define	MAX_RTP_PT   256
#define	MAX_TIMESTAMP_SKEW   640
#define	RTP_MTU   1200
Functions
int	ast_rtcp_fd (struct ast_rtp *rtp)
static struct ast_rtcp *	ast_rtcp_new (void)
	Initialize a new RTCP session.
struct ast_frame *	ast_rtcp_read (struct ast_rtp *rtp)
enum ast_bridge_result	ast_rtp_bridge (struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
void	ast_rtp_destroy (struct ast_rtp *rtp)
int	ast_rtp_fd (struct ast_rtp *rtp)
void	ast_rtp_get_current_formats (struct ast_rtp *rtp, int *astFormats, int *nonAstFormats)
int	ast_rtp_get_peer (struct ast_rtp *rtp, struct sockaddr_in *them)
void	ast_rtp_get_us (struct ast_rtp *rtp, struct sockaddr_in *us)
void	ast_rtp_init (void)
int	ast_rtp_lookup_code (struct ast_rtp *rtp, const int isAstFormat, const int code)
char *	ast_rtp_lookup_mime_multiple (char *buf, int size, const int capability, const int isAstFormat)
char *	ast_rtp_lookup_mime_subtype (const int isAstFormat, const int code)
struct rtpPayloadType	ast_rtp_lookup_pt (struct ast_rtp *rtp, int pt)
struct ast_rtp *	ast_rtp_new (struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
	Initializate a RTP session.
struct ast_rtp *	ast_rtp_new_with_bindaddr (struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
	Initializate a RTP session using an in_addr structure.
void	ast_rtp_offered_from_local (struct ast_rtp *rtp, int local)
int	ast_rtp_proto_register (struct ast_rtp_protocol *proto)
void	ast_rtp_proto_unregister (struct ast_rtp_protocol *proto)
void	ast_rtp_pt_clear (struct ast_rtp *rtp)
void	ast_rtp_pt_default (struct ast_rtp *rtp)
static int	ast_rtp_raw_write (struct ast_rtp *rtp, struct ast_frame *f, int codec)
struct ast_frame *	ast_rtp_read (struct ast_rtp *rtp)
void	ast_rtp_reload (void)
void	ast_rtp_reset (struct ast_rtp *rtp)
int	ast_rtp_sendcng (struct ast_rtp *rtp, int level)
int	ast_rtp_senddigit (struct ast_rtp *rtp, char digit)
void	ast_rtp_set_callback (struct ast_rtp *rtp, ast_rtp_callback callback)
void	ast_rtp_set_data (struct ast_rtp *rtp, void *data)
void	ast_rtp_set_m_type (struct ast_rtp *rtp, int pt)
void	ast_rtp_set_peer (struct ast_rtp *rtp, struct sockaddr_in *them)
void	ast_rtp_set_rtpmap_type (struct ast_rtp *rtp, int pt, char *mimeType, char *mimeSubtype)
void	ast_rtp_setnat (struct ast_rtp *rtp, int nat)
int	ast_rtp_settos (struct ast_rtp *rtp, int tos)
void	ast_rtp_stop (struct ast_rtp *rtp)
int	ast_rtp_write (struct ast_rtp *rtp, struct ast_frame *_f)
static void	calc_rxstamp (struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
static unsigned int	calc_txstamp (struct ast_rtp *rtp, struct timeval *delivery)
static struct ast_rtp_protocol *	get_proto (struct ast_channel *chan)
static struct ast_frame *	process_cisco_dtmf (struct ast_rtp *rtp, unsigned char *data, int len)
static struct ast_frame *	process_rfc2833 (struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno)
	Process RTP DTMF and events according to RFC 2833.
static struct ast_frame *	process_rfc3389 (struct ast_rtp *rtp, unsigned char *data, int len)
	Process Comfort Noise RTP.
static int	rtp_debug_test_addr (struct sockaddr_in *addr)
static int	rtp_do_debug (int fd, int argc, char *argv[])
static int	rtp_do_debug_ip (int fd, int argc, char *argv[])
static int	rtp_no_debug (int fd, int argc, char *argv[])
static int	rtp_socket (void)
static int	rtpread (int *id, int fd, short events, void *cbdata)
static struct ast_frame *	send_dtmf (struct ast_rtp *rtp)
Variables
static struct ast_cli_entry	cli_debug
static struct ast_cli_entry	cli_debug_ip
static struct ast_cli_entry	cli_no_debug
static char	debug_usage []
static int	dtmftimeout = DEFAULT_DTMF_TIMEOUT
struct {
struct rtpPayloadType   payloadType
char *   subtype
char *   type
}	mimeTypes []
static char	no_debug_usage []
static struct ast_rtp_protocol *	protos = NULL
static int	rtpdebug = 0
static struct sockaddr_in	rtpdebugaddr
static int	rtpend = 0
static int	rtpstart = 0
static struct rtpPayloadType	static_RTP_PT [MAX_RTP_PT]

---

Detailed Description

Supports RTP and RTCP with Symmetric RTP support for NAT traversal.

RTP is deffined in RFC 3550.

Definition in file rtp.c.

---

Define Documentation

#define DEFAULT_DTMF_TIMEOUT   3000

Definition at line 61 of file rtp.c.

Referenced by ast_rtp_reload().

#define FLAG_3389_WARNING   (1 << 0)

Definition at line 81 of file rtp.c.

Referenced by process_rfc3389().

#define FLAG_NAT_ACTIVE   (3 << 1)

Definition at line 82 of file rtp.c.

Referenced by ast_rtp_bridge(), ast_rtp_raw_write(), and ast_rtp_read().

#define FLAG_NAT_INACTIVE   (0 << 1)

Definition at line 83 of file rtp.c.

Referenced by ast_rtp_raw_write().

#define FLAG_NAT_INACTIVE_NOWARN   (1 << 1)

Definition at line 84 of file rtp.c.

Referenced by ast_rtp_raw_write().

#define MAX_RTP_PT   256

Definition at line 79 of file rtp.c.

Referenced by ast_rtp_get_current_formats(), ast_rtp_lookup_code(), ast_rtp_lookup_pt(), ast_rtp_pt_clear(), ast_rtp_pt_default(), ast_rtp_set_m_type(), and ast_rtp_set_rtpmap_type().

#define MAX_TIMESTAMP_SKEW   640

Definition at line 57 of file rtp.c.

Referenced by ast_rtp_raw_write(), calc_timestamp(), and calc_txpeerstamp().

#define RTP_MTU   1200

Definition at line 59 of file rtp.c.

---

Function Documentation

int ast_rtcp_fd

(

struct ast_rtp *

rtp

)

Definition at line 158 of file rtp.c.

References ast_rtp::rtcp, and ast_rtcp::s.

Referenced by sip_new().

{
   if (rtp->rtcp)
      return rtp->rtcp->s;
   return -1;
}

static struct ast_rtcp* ast_rtcp_new

(

void

)

[static, read]

Initialize a new RTCP session.

Returns:

The newly initialized RTCP session.

Definition at line 923 of file rtp.c.

References ast_log(), free, LOG_WARNING, malloc, rtp_socket(), ast_rtcp::s, and ast_rtcp::us.

Referenced by ast_rtp_new_with_bindaddr().

{
   struct ast_rtcp *rtcp;
   rtcp = malloc(sizeof(struct ast_rtcp));
   if (!rtcp)
      return NULL;
   memset(rtcp, 0, sizeof(struct ast_rtcp));
   rtcp->s = rtp_socket();
   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;
}

struct ast_frame* ast_rtcp_read

(

struct ast_rtp *

rtp

)

[read]

Definition at line 370 of file rtp.c.

References AST_FRAME_NULL, ast_inet_ntoa(), ast_log(), CRASH, LOG_DEBUG, LOG_WARNING, ast_rtp::nat, option_debug, ast_rtp::rtcp, ast_rtcp::s, and ast_rtcp::them.

Referenced by sip_rtp_read().

{
   static struct ast_frame null_frame = { AST_FRAME_NULL, };
   socklen_t len;
   int hdrlen = 8;
   int res;
   struct sockaddr_in sin;
   unsigned int rtcpdata[1024];
   char iabuf[INET_ADDRSTRLEN];
   
   if (!rtp || !rtp->rtcp)
      return &null_frame;

   len = sizeof(sin);
   
   res = recvfrom(rtp->rtcp->s, rtcpdata, sizeof(rtcpdata),
               0, (struct sockaddr *)&sin, &len);
   
   if (res < 0) {
      if (errno == EBADF)
         CRASH;
      if (errno != EAGAIN) {
         ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up now.\n", strerror(errno));
         return NULL;
      }
      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->rtcp->them, &sin, sizeof(rtp->rtcp->them));
         if (option_debug || rtpdebug)
            ast_log(LOG_DEBUG, "RTCP NAT: Got RTCP from other end. Now sending to address %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
      }
   }
   if (option_debug)
      ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
   return &null_frame;
}

enum ast_bridge_result ast_rtp_bridge	(	struct ast_channel *	c0,
		struct ast_channel *	c1,
		int	flags,
		struct ast_frame **	fo,
		struct ast_channel **	rc,
		int	timeoutms
	)

Definition at line 1539 of file rtp.c.

References ast_channel::_softhangup, AST_BRIDGE_COMPLETE, AST_BRIDGE_DTMF_CHANNEL_0, AST_BRIDGE_DTMF_CHANNEL_1, AST_BRIDGE_FAILED, AST_BRIDGE_FAILED_NOWARN, AST_BRIDGE_IGNORE_SIGS, AST_BRIDGE_RETRY, ast_check_hangup(), AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree(), ast_indicate(), ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_trylock(), ast_mutex_unlock(), ast_read(), ast_rtp_get_peer(), ast_test_flag, ast_waitfor_n(), ast_write(), FLAG_NAT_ACTIVE, ast_frame::frametype, ast_rtp_protocol::get_codec, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, inaddrcmp(), ast_channel::lock, LOG_DEBUG, LOG_WARNING, ast_channel::masq, ast_channel::masqr, ast_channel::name, option_debug, ast_rtp_protocol::set_rtp_peer, ast_frame::subclass, and ast_channel::tech_pvt.

{
   struct ast_frame *f;
   struct ast_channel *who, *cs[3];
   struct ast_rtp *p0, *p1;      /* Audio RTP Channels */
   struct ast_rtp *vp0, *vp1;    /* Video RTP channels */
   struct ast_rtp_protocol *pr0, *pr1;
   struct sockaddr_in ac0, ac1;
   struct sockaddr_in vac0, vac1;
   struct sockaddr_in t0, t1;
   struct sockaddr_in vt0, vt1;
   char iabuf[INET_ADDRSTRLEN];
   
   void *pvt0, *pvt1;
   int codec0,codec1, oldcodec0, oldcodec1;
   
   memset(&vt0, 0, sizeof(vt0));
   memset(&vt1, 0, sizeof(vt1));
   memset(&vac0, 0, sizeof(vac0));
   memset(&vac1, 0, sizeof(vac1));

   /* if need DTMF, cant native bridge */
   if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
      return AST_BRIDGE_FAILED_NOWARN;

   /* Lock channels */
   ast_mutex_lock(&c0->lock);
   while(ast_mutex_trylock(&c1->lock)) {
      ast_mutex_unlock(&c0->lock);
      usleep(1);
      ast_mutex_lock(&c0->lock);
   }

   /* Find channel driver interfaces */
   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);
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);
      return AST_BRIDGE_FAILED;
   }
   if (!pr1) {
      ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);
      return AST_BRIDGE_FAILED;
   }

   /* Get channel specific interface structures */
   pvt0 = c0->tech_pvt;
   pvt1 = c1->tech_pvt;

   /* Get audio and video interface (if native bridge is possible) */
   p0 = pr0->get_rtp_info(c0);
   if (pr0->get_vrtp_info)
      vp0 = pr0->get_vrtp_info(c0);
   else
      vp0 = NULL;
   p1 = pr1->get_rtp_info(c1);
   if (pr1->get_vrtp_info)
      vp1 = pr1->get_vrtp_info(c1);
   else
      vp1 = NULL;

   /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
   if (!p0 || !p1) {
      /* Somebody doesn't want to play... */
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);
      return AST_BRIDGE_FAILED_NOWARN;
   }
   /* Get codecs from both sides */
   if (pr0->get_codec)
      codec0 = pr0->get_codec(c0);
   else
      codec0 = 0;
   if (pr1->get_codec)
      codec1 = pr1->get_codec(c1);
   else
      codec1 = 0;
   if (pr0->get_codec && pr1->get_codec) {
      /* Hey, we can't do reinvite if both parties speak different codecs */
      if (!(codec0 & codec1)) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
         ast_mutex_unlock(&c0->lock);
         ast_mutex_unlock(&c1->lock);
         return AST_BRIDGE_FAILED_NOWARN;
      }
   }

   /* Ok, we should be able to redirect the media. Start with one channel */
   if (pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE))) 
      ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
   else {
      /* Store RTP peer */
      ast_rtp_get_peer(p1, &ac1);
      if (vp1)
         ast_rtp_get_peer(vp1, &vac1);
   }
   /* Then test the other channel */
   if (pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
      ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
   else {
      /* Store RTP peer */
      ast_rtp_get_peer(p0, &ac0);
      if (vp0)
         ast_rtp_get_peer(vp0, &vac0);
   }
   ast_mutex_unlock(&c0->lock);
   ast_mutex_unlock(&c1->lock);
   /* External RTP Bridge up, now loop and see if something happes that force us to take the
      media back to Asterisk */
   cs[0] = c0;
   cs[1] = c1;
   cs[2] = NULL;
   oldcodec0 = codec0;
   oldcodec1 = codec1;
   for (;;) {
      /* Check if something changed... */
      if ((c0->tech_pvt != pvt0)  ||
         (c1->tech_pvt != pvt1) ||
         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
            ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
            if (c0->tech_pvt == pvt0) {
               if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0)) 
                  ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
            }
            if (c1->tech_pvt == pvt1) {
               if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0)) 
                  ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
            }
            return AST_BRIDGE_RETRY;
      }
      /* Now check if they have changed address */
      ast_rtp_get_peer(p1, &t1);
      ast_rtp_get_peer(p0, &t0);
      if (pr0->get_codec)
         codec0 = pr0->get_codec(c0);
      if (pr1->get_codec)
         codec1 = pr1->get_codec(c1);
      if (vp1)
         ast_rtp_get_peer(vp1, &vt1);
      if (vp0)
         ast_rtp_get_peer(vp0, &vt0);
      if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
         if (option_debug > 1) {
            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' was %s:%d/(format %d)\n", 
               c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
         }
         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE))) 
            ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
         memcpy(&ac1, &t1, sizeof(ac1));
         memcpy(&vac1, &vt1, sizeof(vac1));
         oldcodec1 = codec1;
      }
      if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
         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);
         }
         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
            ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
         memcpy(&ac0, &t0, sizeof(ac0));
         memcpy(&vac0, &vt0, sizeof(vac0));
         oldcodec0 = codec0;
      }
      who = ast_waitfor_n(cs, 2, &timeoutms);
      if (!who) {
         if (!timeoutms) {
            if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
               ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
            if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
               ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
            return AST_BRIDGE_RETRY;
         }
         if (option_debug)
            ast_log(LOG_DEBUG, "Ooh, empty read...\n");
         /* check for hangup / whentohangup */
         if (ast_check_hangup(c0) || ast_check_hangup(c1))
            break;
         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;
         if (option_debug)
            ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
         if ((c0->tech_pvt == pvt0) && (!c0->_softhangup)) {
            if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0)) 
               ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
         }
         if ((c1->tech_pvt == pvt1) && (!c1->_softhangup)) {
            if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0)) 
               ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
         }
         return AST_BRIDGE_COMPLETE;
      } else if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
         if ((f->subclass == AST_CONTROL_HOLD) || (f->subclass == AST_CONTROL_UNHOLD) ||
             (f->subclass == AST_CONTROL_VIDUPDATE)) {
            ast_indicate(who == c0 ? c1 : c0, f->subclass);
            ast_frfree(f);
         } else {
            *fo = f;
            *rc = who;
            ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
            return AST_BRIDGE_COMPLETE;
         }
      } else {
         if ((f->frametype == AST_FRAME_DTMF) || 
            (f->frametype == AST_FRAME_VOICE) || 
            (f->frametype == AST_FRAME_VIDEO)) {
            /* 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);
            }
         }
         ast_frfree(f);
      }
      /* Swap priority not that it's a big deal at this point */
      cs[2] = cs[0];
      cs[0] = cs[1];
      cs[1] = cs[2];
      
   }

   if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
      ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
   if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
      ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);

   return AST_BRIDGE_FAILED;
}

void ast_rtp_destroy

(

struct ast_rtp *

rtp

)

Definition at line 1105 of file rtp.c.

References ast_io_remove(), ast_smoother_free(), free, ast_rtp::io, ast_rtp::ioid, ast_rtp::rtcp, ast_rtcp::s, ast_rtp::s, and ast_rtp::smoother.

Referenced by __oh323_destroy(), __sip_destroy(), cleanup_connection(), destroy_endpoint(), mgcp_hangup(), skinny_hangup(), start_rtp(), and unalloc_sub().

{
   if (rtp->smoother)
      ast_smoother_free(rtp->smoother);
   if (rtp->ioid)
      ast_io_remove(rtp->io, rtp->ioid);
   if (rtp->s > -1)
      close(rtp->s);
   if (rtp->rtcp) {
      close(rtp->rtcp->s);
      free(rtp->rtcp);
   }
   free(rtp);
}

int ast_rtp_fd

(

struct ast_rtp *

rtp

)

Definition at line 153 of file rtp.c.

References ast_rtp::s.

Referenced by __oh323_new(), mgcp_new(), sip_new(), skinny_new(), and start_rtp().

{
   return rtp->s;
}

void ast_rtp_get_current_formats	(	struct ast_rtp *	rtp,
		int *	astFormats,
		int *	nonAstFormats
	)

Definition at line 782 of file rtp.c.

References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, and MAX_RTP_PT.

Referenced by process_sdp().

                                                   {
   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;
      }
   }
}

int ast_rtp_get_peer	(	struct ast_rtp *	rtp,
		struct sockaddr_in *	them
	)

Definition at line 1057 of file rtp.c.

References ast_rtp::them.

Referenced by add_sdp(), ast_rtp_bridge(), do_monitor(), oh323_set_rtp_peer(), sip_set_rtp_peer(), and transmit_modify_with_sdp().

{
   if ((them->sin_family != AF_INET) ||
       (them->sin_port != rtp->them.sin_port) ||
       (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
      them->sin_family = AF_INET;
      them->sin_port = rtp->them.sin_port;
      them->sin_addr = rtp->them.sin_addr;
      return 1;
   }
   return 0;
}

void ast_rtp_get_us	(	struct ast_rtp *	rtp,
		struct sockaddr_in *	us
	)

Definition at line 1070 of file rtp.c.

References ast_rtp::us.

Referenced by add_sdp(), external_rtp_create(), handle_message(), and oh323_set_rtp_peer().

{
   memcpy(us, &rtp->us, sizeof(rtp->us));
}

void ast_rtp_init

(

void

)

Definition at line 1913 of file rtp.c.

References ast_cli_register(), and ast_rtp_reload().

Referenced by main().

{
   ast_cli_register(&cli_debug);
   ast_cli_register(&cli_debug_ip);
   ast_cli_register(&cli_no_debug);
   ast_rtp_reload();
}

int ast_rtp_lookup_code	(	struct ast_rtp *	rtp,
		const int	isAstFormat,
		const int	code
	)

Definition at line 822 of file rtp.c.

References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, and ast_rtp::rtp_lookup_code_cache_result.

Referenced by add_codec_to_sdp(), add_noncodec_to_sdp(), add_sdp(), ast_rtp_sendcng(), ast_rtp_senddigit(), and ast_rtp_write().

                                                                                    {

   int pt;

   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;
   }

   /* Check the dynamic list first */
   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;
      }
   }

   /* Then the static list */
   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;
}

char* ast_rtp_lookup_mime_multiple	(	char *	buf,
		int	size,
		const int	capability,
		const int	isAstFormat
	)

Definition at line 867 of file rtp.c.

References ast_rtp_lookup_mime_subtype(), AST_RTP_MAX, format, and name.

Referenced by process_sdp().

{
   int format;
   unsigned len;
   char *end = buf;
   char *start = buf;

   if (!buf || !size)
      return NULL;

   snprintf(end, size, "0x%x (", capability);

   len = strlen(end);
   end += len;
   size -= len;
   start = end;

   for (format = 1; format < AST_RTP_MAX; format <<= 1) {
      if (capability & format) {
         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format);
         snprintf(end, size, "%s|", name);
         len = strlen(end);
         end += len;
         size -= len;
      }
   }

   if (start == end)
      snprintf(start, size, "nothing)"); 
   else if (size > 1)
      *(end -1) = ')';
   
   return buf;
}

char* ast_rtp_lookup_mime_subtype	(	const int	isAstFormat,
		const int	code
	)

Definition at line 855 of file rtp.c.

References rtpPayloadType::code, mimeTypes, and payloadType.

Referenced by add_codec_to_sdp(), add_noncodec_to_sdp(), add_sdp(), ast_rtp_lookup_mime_multiple(), transmit_connect_with_sdp(), and transmit_modify_with_sdp().

                                                                         {

   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 "";
}

struct rtpPayloadType ast_rtp_lookup_pt	(	struct ast_rtp *	rtp,
		int	pt
	)			[read]

Definition at line 803 of file rtp.c.

References rtpPayloadType::code, rtpPayloadType::isAstFormat, and MAX_RTP_PT.

Referenced by ast_rtp_read(), and setup_rtp_connection().

{
   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;
}

struct ast_rtp* ast_rtp_new	(	struct sched_context *	sched,
		struct io_context *	io,
		int	rtcpenable,
		int	callbackmode
	)			[read]

Initializate a RTP session.

Parameters:

	sched
	io
	rtcpenable
	callbackmode

Returns:

A representation (structure) of an RTP session.

Definition at line 1029 of file rtp.c.

References ast_rtp_new_with_bindaddr().

Referenced by start_rtp().

{
   struct in_addr ia;

   memset(&ia, 0, sizeof(ia));
   return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
}

struct ast_rtp* ast_rtp_new_with_bindaddr	(	struct sched_context *	sched,
		struct io_context *	io,
		int	rtcpenable,
		int	callbackmode,
		struct in_addr	in
	)			[read]

Initializate a RTP session using an in_addr structure.

This fuction gets called by ast_rtp_new().

Parameters:

	sched
	io
	rtcpenable
	callbackmode
	in

Returns:

A representation (structure) of an RTP session.

Definition at line 940 of file rtp.c.

References ast_io_add(), AST_IO_IN, ast_log(), ast_rtcp_new(), ast_rtp_pt_default(), free, ast_rtp::io, ast_rtp::ioid, LOG_ERROR, malloc, ast_rtp::rtcp, rtp_socket(), rtpread(), ast_rtcp::s, ast_rtp::s, ast_rtp::sched, ast_rtp::seqno, ast_rtp::ssrc, ast_rtp::them, ast_rtcp::us, and ast_rtp::us.

Referenced by ast_rtp_new(), oh323_alloc(), sip_alloc(), and start_rtp().

{
   struct ast_rtp *rtp;
   int x;
   int first;
   int startplace;
   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;
   rtp->s = rtp_socket();
   rtp->ssrc = rand();
   rtp->seqno = rand() & 0xffff;
   if (rtp->s < 0) {
      free(rtp);
      ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
      return NULL;
   }
   if (sched && rtcpenable) {
      rtp->sched = sched;
      rtp->rtcp = ast_rtcp_new();
   }
   
   /* Select a random port number in the range of possible RTP */
   x = (rand() % (rtpend-rtpstart)) + rtpstart;
   x = x & ~1;
   /* Save it for future references. */
   startplace = x;
   /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
   for (;;) {
      /* Must be an even port number by RTP spec */
      rtp->us.sin_port = htons(x);
      rtp->us.sin_addr = addr;
      /* If there's rtcp, initialize it as well. */
      if (rtp->rtcp) {
         rtp->rtcp->us.sin_addr = addr;
         rtp->rtcp->us.sin_port = htons(x + 1);
      }
      /* Try to bind it/them. */
      if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
         break;
      if (!first) {
         /* Primary bind succeeded! Gotta recreate it */
         close(rtp->s);
         rtp->s = rtp_socket();
      }
      if (errno != EADDRINUSE) {
         /* We got an error that wasn't expected, abort! */
         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
         close(rtp->s);
         if (rtp->rtcp) {
            close(rtp->rtcp->s);
            free(rtp->rtcp);
         }
         free(rtp);
         return NULL;
      }
      /* The port was used, increment it (by two). */
      x += 2;
      /* Did we go over the limit ? */
      if (x > rtpend)
         /* then, start from the begingig. */
         x = (rtpstart + 1) & ~1;
      /* Check if we reached the place were we started. */
      if (x == startplace) {
         /* If so, there's no ports available. */
         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
         close(rtp->s);
         if (rtp->rtcp) {
            close(rtp->rtcp->s);
            free(rtp->rtcp);
         }
         free(rtp);
         return NULL;
      }
   }
   if (io && sched && callbackmode) {
      /* 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);
   }
   ast_rtp_pt_default(rtp);
   return rtp;
}

void ast_rtp_offered_from_local	(	struct ast_rtp *	rtp,
		int	local
	)

Definition at line 796 of file rtp.c.

References ast_log(), LOG_WARNING, and ast_rtp::rtp_offered_from_local.

Referenced by transmit_connect_with_sdp(), transmit_invite(), transmit_modify_with_sdp(), transmit_reinvite_with_sdp(), and transmit_response_with_sdp().

                                                                {
   if (rtp)
      rtp->rtp_offered_from_local = local;
   else
      ast_log(LOG_WARNING, "rtp structure is null\n");
}

int ast_rtp_proto_register

(

struct ast_rtp_protocol *

proto

)

Definition at line 1505 of file rtp.c.

References ast_log(), LOG_WARNING, ast_rtp_protocol::next, and ast_rtp_protocol::type.

Referenced by load_module(), and unload_module().

{
   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;
}

void ast_rtp_proto_unregister

(

struct ast_rtp_protocol *

proto

)

Definition at line 1485 of file rtp.c.

References ast_rtp_protocol::next.

Referenced by unload_module().

{
   struct ast_rtp_protocol *cur, *prev;

   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;
   }
}

void ast_rtp_pt_clear

(

struct ast_rtp *

rtp

)

Definition at line 719 of file rtp.c.

References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, and ast_rtp::rtp_lookup_code_cache_result.

Referenced by process_sdp().

{
   int i;
   if (!rtp)
      return;

   for (i = 0; i < MAX_RTP_PT; ++i) {
      rtp->current_RTP_PT[i].isAstFormat = 0;
      rtp->current_RTP_PT[i].code = 0;
   }

   rtp->rtp_lookup_code_cache_isAstFormat = 0;
   rtp->rtp_lookup_code_cache_code = 0;
   rtp->rtp_lookup_code_cache_result = 0;
}

void ast_rtp_pt_default

(

struct ast_rtp *

rtp

)

Definition at line 735 of file rtp.c.

References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, and ast_rtp::rtp_lookup_code_cache_result.

Referenced by ast_rtp_new_with_bindaddr().

{
   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;
}

static int ast_rtp_raw_write	(	struct ast_rtp *	rtp,
		struct ast_frame *	f,
		int	codec
	)			[static]

Definition at line 1256 of file rtp.c.

References AST_FORMAT_MAX_AUDIO, ast_inet_ntoa(), ast_log(), ast_set_flag, ast_test_flag, ast_verbose(), calc_txstamp(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, FLAG_NAT_ACTIVE, FLAG_NAT_INACTIVE, FLAG_NAT_INACTIVE_NOWARN, ast_rtp::lastdigitts, ast_rtp::lastovidtimestamp, ast_rtp::lastts, LOG_DEBUG, MAX_TIMESTAMP_SKEW, ast_rtp::nat, option_debug, put_unaligned_uint32(), rtp_debug_test_addr(), ast_rtp::s, ast_frame::samples, ast_rtp::seqno, ast_rtp::ssrc, ast_frame::subclass, and ast_rtp::them.

Referenced by ast_rtp_write().

{
   unsigned char *rtpheader;
   char iabuf[INET_ADDRSTRLEN];
   int hdrlen = 12;
   int res;
   unsigned int ms;
   int pred;
   int mark = 0;

   ms = calc_txstamp(rtp, &f->delivery);
   /* Default prediction */
   if (f->subclass < AST_FORMAT_MAX_AUDIO) {
      pred = rtp->lastts + f->samples;

      /* Re-calculate last TS */
      rtp->lastts = rtp->lastts + ms * 8;
      if (ast_tvzero(f->delivery)) {
         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
            and if so, go with our prediction */
         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
            rtp->lastts = pred;
         else {
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
            mark = 1;
         }
      }
   } else {
      mark = f->subclass & 0x1;
      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 */
      if (ast_tvzero(f->delivery)) {
         if (abs(rtp->lastts - pred) < 7200) {
            rtp->lastts = pred;
            rtp->lastovidtimestamp += f->samples;
         } else {
            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);
            rtp->lastovidtimestamp = rtp->lastts;
         }
      }
   }
   /* 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;

   /* Get a pointer to the header */
   rtpheader = (unsigned char *)(f->data - hdrlen);

   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)); 

   if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
      res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
      if (res <0) {
         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
            ast_log(LOG_DEBUG, "RTP Transmission error of packet %d to %s:%d: %s\n", rtp->seqno, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
         } else if ((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) {
            /* Only give this error message once if we are not RTP debugging */
            if (option_debug || rtpdebug)
               ast_log(LOG_DEBUG, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port));
            ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
         }
      }
            
      if(rtp_debug_test_addr(&rtp->them))
         ast_verbose("Sent RTP packet to %s:%d (type %d, seq %u, ts %u, len %u)\n"
               , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
   }

   rtp->seqno++;

   return 0;
}

struct ast_frame* ast_rtp_read

(

struct ast_rtp *

rtp

)

[read]

Definition at line 428 of file rtp.c.

References ast_codec_get_samples(), AST_FORMAT_MAX_AUDIO, AST_FORMAT_SLINEAR, ast_frame_byteswap_be, AST_FRAME_NULL, AST_FRAME_VIDEO, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_inet_ntoa(), ast_log(), AST_RTP_CISCO_DTMF, AST_RTP_CN, AST_RTP_DTMF, ast_rtp_lookup_pt(), ast_set_flag, ast_verbose(), calc_rxstamp(), rtpPayloadType::code, CRASH, ast_frame::data, ast_frame::datalen, ast_frame::delivery, ast_rtp::dtmfcount, ast_rtp::f, FLAG_NAT_ACTIVE, ast_frame::frametype, rtpPayloadType::isAstFormat, ast_rtp::lasteventseqn, ast_rtp::lastividtimestamp, ast_rtp::lastrxformat, ast_rtp::lastrxts, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, ast_frame::mallocd, ast_rtp::nat, ast_frame::offset, option_debug, process_cisco_dtmf(), process_rfc2833(), process_rfc3389(), ast_rtp::rawdata, ast_rtp::resp, rtp_debug_test_addr(), ast_rtp::rxseqno, ast_rtp::rxssrc, ast_rtp::s, ast_frame::samples, send_dtmf(), ast_frame::src, ast_frame::subclass, and ast_rtp::them.

Referenced by mgcp_rtp_read(), oh323_rtp_read(), rtpread(), sip_rtp_read(), and skinny_rtp_read().

{
   int res;
   struct sockaddr_in sin;
   socklen_t len;
   unsigned int seqno;
   int version;
   int payloadtype;
   int hdrlen = 12;
   int padding;
   int mark;
   int ext;
   int cc;
   int x;
   char iabuf[INET_ADDRSTRLEN];
   unsigned int ssrc;
   unsigned int timestamp;
   unsigned int *rtpheader;
   struct ast_frame *f;
   static struct ast_frame null_frame = { AST_FRAME_NULL, };
   struct rtpPayloadType rtpPT;
   
   len = sizeof(sin);
   
   /* Cache where the header will go */
   res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
               0, (struct sockaddr *)&sin, &len);


   rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
   if (res < 0) {
      if (errno == EBADF)
         CRASH;
      if (errno != EAGAIN) {
         ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up now.\n", strerror(errno));
         return NULL;
      }
      return &null_frame;
   }
   if (res < hdrlen) {
      ast_log(LOG_WARNING, "RTP Read too short\n");
      return &null_frame;
   }

   /* 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;

   if (rtp->nat) {
      /* Send to whoever sent to us */
      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));
         rtp->rxseqno = 0;
         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
         if (option_debug || rtpdebug)
            ast_log(LOG_DEBUG, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port));
      }
   }

   /* Get fields */
   seqno = ntohl(rtpheader[0]);

   /* Check RTP version */
   version = (seqno & 0xC0000000) >> 30;
   if (version != 2)
      return &null_frame;
   
   payloadtype = (seqno & 0x7f0000) >> 16;
   padding = seqno & (1 << 29);
   mark = seqno & (1 << 23);
   ext = seqno & (1 << 28);
   cc = (seqno & 0xF000000) >> 24;
   seqno &= 0xffff;
   timestamp = ntohl(rtpheader[1]);
   ssrc = ntohl(rtpheader[2]);
   
   if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
      if (option_debug || rtpdebug)
         ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n");
      mark = 1;
   }

   rtp->rxssrc = ssrc;
   
   if (padding) {
      /* Remove padding bytes */
      res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
   }
   
   if (cc) {
      /* CSRC fields present */
      hdrlen += cc*4;
   }

   if (ext) {
      /* RTP Extension present */
      hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
      hdrlen += 4;
   }

   if (res < hdrlen) {
      ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
      return &null_frame;
   }

   if(rtp_debug_test_addr(&sin))
      ast_verbose("Got RTP packet from %s:%u (type %d, seq %u, ts %u, len %d)\n"
         , 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);
   if (!rtpPT.isAstFormat) {
      /* 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_debug_test_addr(&sin)) {
            unsigned char *data;
            unsigned int event;
            unsigned int event_end;
            unsigned int duration;
            data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
            event = ntohl(*((unsigned int *)(data)));
            event >>= 24;
            event_end = ntohl(*((unsigned int *)(data)));
            event_end <<= 8;
            event_end >>= 24;
            duration = ntohl(*((unsigned int *)(data)));
            duration &= 0xFFFF;
            ast_verbose("Got rfc2833 RTP packet from %s:%d (type %d, seq %d, ts %d, len %d, mark %d, event %08x, end %d, duration %d) \n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration);
         }
         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
            f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno);
            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;
      }
   }
   rtp->f.subclass = rtpPT.code;
   if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO)
      rtp->f.frametype = AST_FRAME_VOICE;
   else
      rtp->f.frametype = AST_FRAME_VIDEO;
   rtp->lastrxformat = rtp->f.subclass;

   if (!rtp->lastrxts)
      rtp->lastrxts = timestamp;

   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;

   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) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Sending pending DTMF\n");
      return send_dtmf(rtp);
   }
   rtp->f.mallocd = 0;
   rtp->f.datalen = res - hdrlen;
   rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
   rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
   if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
      rtp->f.samples = ast_codec_get_samples(&rtp->f);
      if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
         ast_frame_byteswap_be(&rtp->f);
      calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
   } else {
      /* Video -- samples is # of samples vs. 90000 */
      if (!rtp->lastividtimestamp)
         rtp->lastividtimestamp = timestamp;
      rtp->f.samples = timestamp - rtp->lastividtimestamp;
      rtp->lastividtimestamp = timestamp;
      rtp->f.delivery.tv_sec = 0;
      rtp->f.delivery.tv_usec = 0;
      if (mark)
         rtp->f.subclass |= 0x1;
      
   }
   rtp->f.src = "RTP";
   return &rtp->f;
}

void ast_rtp_reload

(

void

)

Definition at line 1857 of file rtp.c.

References ast_config_destroy(), ast_config_load(), ast_false(), ast_log(), ast_variable_retrieve(), ast_verbose(), cfg, DEFAULT_DTMF_TIMEOUT, LOG_WARNING, option_verbose, s, and VERBOSE_PREFIX_2.

Referenced by ast_module_reload(), ast_rtp_init(), and main().

{
   struct ast_config *cfg;
   char *s;

   rtpstart = 5000;
   rtpend = 31000;
   dtmftimeout = DEFAULT_DTMF_TIMEOUT;
   cfg = ast_config_load("rtp.conf");
   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;
      }
      if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
#ifdef SO_NO_CHECK
         if (ast_false(s))
            nochecksums = 1;
         else
            nochecksums = 0;
#else
         if (ast_false(s))
            ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
#endif
      }
      if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
         dtmftimeout = atoi(s);
         if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
            ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
               dtmftimeout, DEFAULT_DTMF_TIMEOUT);
            dtmftimeout = DEFAULT_DTMF_TIMEOUT;
         };
      }
      ast_config_destroy(cfg);
   }
   if (rtpstart >= rtpend) {
      ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
      rtpstart = 5000;
      rtpend = 31000;
   }
   if (option_verbose > 1)
      ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
   
}

void ast_rtp_reset

(

struct ast_rtp *

rtp

)

Definition at line 1085 of file rtp.c.

References ast_rtp::dtmfcount, ast_rtp::dtmfduration, ast_rtp::dtmfmute, ast_rtp::lastdigitts, ast_rtp::lasteventendseqn, ast_rtp::lasteventseqn, ast_rtp::lastividtimestamp, ast_rtp::lastovidtimestamp, ast_rtp::lastrxformat, ast_rtp::lastrxts, ast_rtp::lastts, ast_rtp::lasttxformat, ast_rtp::rxcore, ast_rtp::rxseqno, ast_rtp::seqno, and ast_rtp::txcore.

{
   memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
   memset(&rtp->txcore, 0, sizeof(rtp->txcore));
   memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
   rtp->lastts = 0;
   rtp->lastdigitts = 0;
   rtp->lastrxts = 0;
   rtp->lastividtimestamp = 0;
   rtp->lastovidtimestamp = 0;
   rtp->lasteventseqn = 0;
   rtp->lasteventendseqn = 0;
   rtp->lasttxformat = 0;
   rtp->lastrxformat = 0;
   rtp->dtmfcount = 0;
   rtp->dtmfduration = 0;
   rtp->seqno = 0;
   rtp->rxseqno = 0;
}

int ast_rtp_sendcng	(	struct ast_rtp *	rtp,
		int	level
	)

Definition at line 1221 of file rtp.c.

References ast_inet_ntoa(), ast_log(), AST_RTP_CN, ast_rtp_lookup_code(), ast_tvadd(), ast_verbose(), ast_rtp::dtmfmute, ast_rtp::lastts, LOG_ERROR, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them.

Referenced by do_monitor().

{
   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;

   rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));

   /* 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;
}

int ast_rtp_senddigit	(	struct ast_rtp *	rtp,
		char	digit
	)

Definition at line 1139 of file rtp.c.

References ast_inet_ntoa(), ast_log(), AST_RTP_DTMF, ast_rtp_lookup_code(), ast_tvadd(), ast_verbose(), ast_rtp::dtmfmute, ast_rtp::lastdigitts, LOG_ERROR, LOG_WARNING, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them.

Referenced by oh323_digit(), and sip_senddigit().

{
   unsigned int *rtpheader;
   int hdrlen = 12;
   int res;
   int x;
   int payload;
   char data[256];
   char iabuf[INET_ADDRSTRLEN];

   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;
   }
   payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);

   /* If we have no peer, return immediately */ 
   if (!rtp->them.sin_addr.s_addr)
      return 0;

   rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
   
   /* 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->lastdigitts);
   rtpheader[2] = htonl(rtp->ssrc); 
   rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
   for (x = 0; x < 6; x++) {
      if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
         if (res < 0) 
            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 %u, ts %u, len %u)\n",
                   ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
                   ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
      }
      /* Sequence number of last two end packets does not get incremented */
      if (x < 3)
         rtp->seqno++;
      /* Clear marker bit and set seqno */
      rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
      /* For the last three packets, set the duration and the end bit */
      if (x == 2) {
#if 0
         /* No, this is wrong...  Do not increment lastdigitts, that's not according
            to the RFC, as best we can determine */
         rtp->lastdigitts++; /* or else the SPA3000 will click instead of beeping... */
         rtpheader[1] = htonl(rtp->lastdigitts);
#endif         
         /* Make duration 800 (100ms) */
         rtpheader[3] |= htonl((800));
         /* Set the End bit */
         rtpheader[3] |= htonl((1 << 23));
      }
   }
   /* Increment the digit timestamp by 120ms, to ensure that digits
      sent sequentially with no intervening non-digit packets do not
      get sent with the same timestamp, and that sequential digits
      have some 'dead air' in between them
   */
   rtp->lastdigitts += 960;
   /* Increment the sequence number to reflect the last packet
      that was sent
   */
   rtp->seqno++;
   return 0;
}

void ast_rtp_set_callback	(	struct ast_rtp *	rtp,
		ast_rtp_callback	callback
	)

Definition at line 170 of file rtp.c.

References ast_rtp::callback.

Referenced by start_rtp().

{
   rtp->callback = callback;
}

void ast_rtp_set_data	(	struct ast_rtp *	rtp,
		void *	data
	)

Definition at line 165 of file rtp.c.

References ast_rtp::data.

Referenced by start_rtp().

{
   rtp->data = data;
}

void ast_rtp_set_m_type	(	struct ast_rtp *	rtp,
		int	pt
	)

Definition at line 753 of file rtp.c.

References rtpPayloadType::code, ast_rtp::current_RTP_PT, and MAX_RTP_PT.

Referenced by process_sdp().

                                                     {
   if (pt < 0 || pt > MAX_RTP_PT) 
      return; /* bogus payload type */

   if (static_RTP_PT[pt].code != 0) {
      rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
   }
} 

void ast_rtp_set_peer	(	struct ast_rtp *	rtp,
		struct sockaddr_in *	them
	)

Definition at line 1046 of file rtp.c.

References ast_rtp::rtcp, ast_rtp::rxseqno, ast_rtcp::them, and ast_rtp::them.

Referenced by handle_message(), process_sdp(), and setup_rtp_connection().

{
   rtp->them.sin_port = them->sin_port;
   rtp->them.sin_addr = them->sin_addr;
   if (rtp->rtcp) {
      rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
      rtp->rtcp->them.sin_addr = them->sin_addr;
   }
   rtp->rxseqno = 0;
}

void ast_rtp_set_rtpmap_type	(	struct ast_rtp *	rtp,
		int	pt,
		char *	mimeType,
		char *	mimeSubtype
	)

Definition at line 764 of file rtp.c.

References ast_rtp::current_RTP_PT, MAX_RTP_PT, mimeTypes, subtype, and type.

Referenced by process_sdp(), and set_dtmf_payload().

                                             {
   int i;

   if (pt < 0 || pt > MAX_RTP_PT) 
         return; /* bogus payload type */

   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;
      }
   }
} 

void ast_rtp_setnat	(	struct ast_rtp *	rtp,
		int	nat
	)

Definition at line 175 of file rtp.c.

References ast_rtp::nat.

Referenced by check_user_full(), create_addr(), create_addr_from_peer(), oh323_request(), oh323_rtp_read(), sip_alloc(), and start_rtp().

{
   rtp->nat = nat;
}

int ast_rtp_settos	(	struct ast_rtp *	rtp,
		int	tos
	)

Definition at line 1037 of file rtp.c.

References ast_log(), LOG_WARNING, and ast_rtp::s.

Referenced by oh323_alloc(), and sip_alloc().

{
   int res;

   if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
      ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
   return res;
}

void ast_rtp_stop

(

struct ast_rtp *

rtp

)

Definition at line 1075 of file rtp.c.

References ast_rtp::rtcp, ast_rtcp::them, and ast_rtp::them.

Referenced by handle_request_bye(), handle_request_cancel(), handle_response(), and process_sdp().

{
   memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
   memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
   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));
   }
}

int ast_rtp_write	(	struct ast_rtp *	rtp,
		struct ast_frame *	_f
	)

Definition at line 1337 of file rtp.c.

References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G723_1, AST_FORMAT_G726, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_H261, AST_FORMAT_H263, AST_FORMAT_H263_PLUS, AST_FORMAT_ILBC, AST_FORMAT_LPC10, AST_FORMAT_SLINEAR, AST_FORMAT_SPEEX, AST_FORMAT_ULAW, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frdup(), ast_frfree(), ast_getformatname(), ast_log(), ast_rtp_lookup_code(), ast_rtp_raw_write(), ast_smoother_feed, ast_smoother_feed_be, AST_SMOOTHER_FLAG_G729, ast_smoother_free(), ast_smoother_new(), ast_smoother_read(), ast_smoother_set_flags(), ast_frame::datalen, ast_frame::frametype, ast_rtp::lasttxformat, LOG_DEBUG, LOG_WARNING, ast_frame::offset, option_debug, ast_rtp::smoother, ast_frame::subclass, and ast_rtp::them.

Referenced by mgcp_write(), oh323_write(), sip_write(), and skinny_write().

{
   struct ast_frame *f;
   int codec;
   int hdrlen = 12;
   int subclass;
   

   /* If we have no peer, return immediately */ 
   if (!rtp->them.sin_addr.s_addr)
      return 0;

   /* If there is no data length, return immediately */
   if (!_f->datalen) 
      return 0;
   
   /* Make sure we have enough space for RTP header */
   if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
      ast_log(LOG_WARNING, "RTP can only send voice\n");
      return -1;
   }

   subclass = _f->subclass;
   if (_f->frametype == AST_FRAME_VIDEO)
      subclass &= ~0x1;

   codec = ast_rtp_lookup_code(rtp, 1, subclass);
   if (codec < 0) {
      ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
      return -1;
   }

   if (rtp->lasttxformat != subclass) {
      /* New format, reset the smoother */
      if (option_debug)
         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
      rtp->lasttxformat = subclass;
      if (rtp->smoother)
         ast_smoother_free(rtp->smoother);
      rtp->smoother = NULL;
   }


   switch(subclass) {
   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;
   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);
      
      while((f = ast_smoother_read(rtp->smoother)))
         ast_rtp_raw_write(rtp, f, codec);
      break;
   case AST_FORMAT_ADPCM:
   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);
      
      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);
         if (rtp->smoother)
            ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
      }
      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;
   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;
   case AST_FORMAT_ILBC:
      if (!rtp->smoother) {
         rtp->smoother = ast_smoother_new(50);
      }
      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;
   default: 
      ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
      /* fall through to... */
   case AST_FORMAT_H261:
   case AST_FORMAT_H263:
   case AST_FORMAT_H263_PLUS:
   case AST_FORMAT_G723_1:
   case AST_FORMAT_LPC10:
   case AST_FORMAT_SPEEX:
           /* Don't buffer outgoing frames; send them one-per-packet: */
      if (_f->offset < hdrlen) {
         f = ast_frdup(_f);
      } else {
         f = _f;
      }
      ast_rtp_raw_write(rtp, f, codec);
      if (f != _f)
         ast_frfree(f);
   }
      
   return 0;
}

static void calc_rxstamp	(	struct timeval *	tv,
		struct ast_rtp *	rtp,
		unsigned int	timestamp,
		int	mark
	)			[static]

Definition at line 417 of file rtp.c.

References ast_tvadd(), ast_tvsub(), and ast_rtp::rxcore.

Referenced by ast_rtp_read(), and schedule_delivery().

{
   struct timeval ts = ast_samp2tv( timestamp, 8000);
   if (ast_tvzero(rtp->rxcore) || mark) {
      rtp->rxcore = ast_tvsub(ast_tvnow(), ts);
      /* Round to 20ms for nice, pretty timestamps */
      rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 20000;
   }
   *tv = ast_tvadd(rtp->rxcore, ts);
}

static unsigned int calc_txstamp	(	struct ast_rtp *	rtp,
		struct timeval *	delivery
	)			[static]

Definition at line 1120 of file rtp.c.

References ast_rtp::txcore.

Referenced by ast_rtp_raw_write().

{
   struct timeval t;
   long ms;
   if (ast_tvzero(rtp->txcore)) {
      rtp->txcore = ast_tvnow();
      /* Round to 20ms for nice, pretty timestamps */
      rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
   }
   /* Use previous txcore if available */
   t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
   ms = ast_tvdiff_ms(t, rtp->txcore);
   if (ms < 0)
      ms = 0;
   /* Use what we just got for next time */
   rtp->txcore = t;
   return (unsigned int) ms;
}

static struct ast_rtp_protocol* get_proto

(

struct ast_channel *

chan

)

[static, read]

Definition at line 1522 of file rtp.c.

References ast_rtp_protocol::next, ast_channel::type, and ast_rtp_protocol::type.

Referenced by ast_rtp_bridge().

{
   struct ast_rtp_protocol *cur;

   cur = protos;
   while(cur) {
      if (cur->type == chan->type) {
         return cur;
      }
      cur = cur->next;
   }
   return NULL;
}

static struct ast_frame* process_cisco_dtmf	(	struct ast_rtp *	rtp,
		unsigned char *	data,
		int	len
	)			[static, read]

Definition at line 224 of file rtp.c.

References ast_rtp::dtmfcount, ast_rtp::resp, and send_dtmf().

Referenced by ast_rtp_read().

{
   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);
   } else if (event < 17) {
      resp = 'X';
   }
   if (rtp->resp && (rtp->resp != resp)) {
      f = send_dtmf(rtp);
   }
   rtp->resp = resp;
   rtp->dtmfcount = dtmftimeout;
   return f;
}

static struct ast_frame* process_rfc2833	(	struct ast_rtp *	rtp,
		unsigned char *	data,
		int	len,
		unsigned int	seqno
	)			[static, read]

Process RTP DTMF and events according to RFC 2833.

RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".

Parameters:

	rtp
	data
	len
	seqno

Returns:

Definition at line 264 of file rtp.c.

References ast_log(), ast_rtp::dtmfcount, ast_rtp::dtmfduration, ast_rtp::lasteventendseqn, LOG_DEBUG, ast_rtp::resp, and send_dtmf().

Referenced by ast_rtp_read().

{
   unsigned int event;
   unsigned int event_end;
   unsigned int duration;
   char resp = 0;
   struct ast_frame *f = NULL;
   event = ntohl(*((unsigned int *)(data)));
   event >>= 24;
   event_end = ntohl(*((unsigned int *)(data)));
   event_end <<= 8;
   event_end >>= 24;
   duration = ntohl(*((unsigned int *)(data)));
   duration &= 0xFFFF;
   if (rtpdebug)
      ast_log(LOG_DEBUG, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
   if (event < 10) {
      resp = '0' + event;
   } else if (event < 11) {
      resp = '*';
   } else if (event < 12) {
      resp = '#';
   } else if (event < 16) {
      resp = 'A' + (event - 12);
   } else if (event < 17) {   /* Event 16: Hook flash */
      resp = 'X'; 
   }
   if (rtp->resp && (rtp->resp != resp)) {
      f = send_dtmf(rtp);
   } else if(event_end & 0x80) {
      if (rtp->resp) {
         if(rtp->lasteventendseqn != seqno) {
            f = send_dtmf(rtp);
            rtp->lasteventendseqn = seqno;
         }
         rtp->resp = 0;
      }
      resp = 0;
      duration = 0;
   } else if (rtp->resp && rtp->dtmfduration && (duration < rtp->dtmfduration)) {
      f = send_dtmf(rtp);
   }
   if (!(event_end & 0x80))
      rtp->resp = resp;
   rtp->dtmfcount = dtmftimeout;
   rtp->dtmfduration = duration;
   return f;
}

static struct ast_frame* process_rfc3389	(	struct ast_rtp *	rtp,
		unsigned char *	data,
		int	len
	)			[static, read]

Process Comfort Noise RTP.

This is incomplete at the moment.

Definition at line 319 of file rtp.c.

References AST_FRAME_CNG, AST_FRIENDLY_OFFSET, ast_inet_ntoa(), ast_log(), ast_set_flag, ast_test_flag, ast_frame::data, ast_frame::datalen, ast_frame::delivery, ast_rtp::f, FLAG_3389_WARNING, ast_frame::frametype, ast_rtp::lastrxformat, LOG_DEBUG, LOG_NOTICE, ast_frame::offset, ast_rtp::rawdata, ast_frame::samples, ast_frame::subclass, and ast_rtp::them.

Referenced by ast_rtp_read().

{
   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 20ms or anything */
   if (rtpdebug)
      ast_log(LOG_DEBUG, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);

   if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
      char iabuf[INET_ADDRSTRLEN];

      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));
      ast_set_flag(rtp, FLAG_3389_WARNING);
   }

   /* Must have at least one byte */
   if (!len)
      return NULL;
   if (len < 24) {
      rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
      rtp->f.datalen = len - 1;
      rtp->f.offset = AST_FRIENDLY_OFFSET;
      memcpy(rtp->f.data, data + 1, len - 1);
   } else {
      rtp->f.data = NULL;
      rtp->f.offset = 0;
      rtp->f.datalen = 0;
   }
   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;
   return f;
}

static int rtp_debug_test_addr

(

struct sockaddr_in *

addr

)

[inline, static]

Definition at line 211 of file rtp.c.

References rtpdebugaddr.

Referenced by ast_rtp_raw_write(), ast_rtp_read(), ast_rtp_sendcng(), and ast_rtp_senddigit().

{
   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;
}

static int rtp_do_debug	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Definition at line 1818 of file rtp.c.

References ast_cli(), RESULT_SHOWUSAGE, RESULT_SUCCESS, rtp_do_debug_ip(), and rtpdebugaddr.

{
   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_do_debug_ip	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Definition at line 1787 of file rtp.c.

References ast_cli(), ast_gethostbyname(), ast_inet_ntoa(), hp, RESULT_SHOWUSAGE, RESULT_SUCCESS, and rtpdebugaddr.

Referenced by rtp_do_debug().

{
   struct hostent *hp;
   struct ast_hostent ahp;
   char iabuf[INET_ADDRSTRLEN];
   int port = 0;
   char *p, *arg;

   if (argc != 4)
      return RESULT_SHOWUSAGE;
   arg = argv[3];
   p = strstr(arg, ":");
   if (p) {
      *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_no_debug	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Definition at line 1831 of file rtp.c.

References ast_cli(), RESULT_SHOWUSAGE, and RESULT_SUCCESS.

{
   if(argc !=3)
      return RESULT_SHOWUSAGE;
   rtpdebug = 0;
   ast_cli(fd,"RTP Debugging Disabled\n");
   return RESULT_SUCCESS;
}

static int rtp_socket

(

void

)

[static]

Definition at line 902 of file rtp.c.

References s.

Referenced by ast_rtcp_new(), and ast_rtp_new_with_bindaddr().

{
   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);
#ifdef SO_NO_CHECK
      if (nochecksums)
         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
#endif
   }
   return s;
}

static int rtpread	(	int *	id,
		int	fd,
		short	events,
		void *	cbdata
	)			[static]

Definition at line 358 of file rtp.c.

References ast_rtp_read(), ast_rtp::callback, and ast_rtp::data.

Referenced by ast_rtp_new_with_bindaddr().

{
   struct ast_rtp *rtp = cbdata;
   struct ast_frame *f;
   f = ast_rtp_read(rtp);
   if (f) {
      if (rtp->callback)
         rtp->callback(rtp, f, rtp->data);
   }
   return 1;
}

static struct ast_frame* send_dtmf

(

struct ast_rtp *

rtp

)

[static, read]

Definition at line 180 of file rtp.c.

References AST_CONTROL_FLASH, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_NULL, ast_inet_ntoa(), ast_log(), ast_frame::datalen, ast_rtp::dtmfduration, ast_rtp::dtmfmute, ast_rtp::f, ast_frame::frametype, LOG_DEBUG, ast_frame::mallocd, option_debug, ast_rtp::resp, ast_frame::samples, ast_frame::src, ast_frame::subclass, and ast_rtp::them.

Referenced by ast_rtp_read(), process_cisco_dtmf(), and process_rfc2833().

{
   static struct ast_frame null_frame = { AST_FRAME_NULL, };
   char iabuf[INET_ADDRSTRLEN];

   if (ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
      rtp->resp = 0;
      rtp->dtmfduration = 0;
      return &null_frame;
   }
   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));
   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;
   }
   rtp->f.datalen = 0;
   rtp->f.samples = 0;
   rtp->f.mallocd = 0;
   rtp->f.src = "RTP";
   rtp->resp = 0;
   rtp->dtmfduration = 0;
   return &rtp->f;
   
}

---

Variable Documentation

struct ast_cli_entry cli_debug [static]

Initial value:

{{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage }

Definition at line 1851 of file rtp.c.

struct ast_cli_entry cli_debug_ip [static]

Initial value:

{{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage }

Definition at line 1848 of file rtp.c.

struct ast_cli_entry cli_no_debug [static]

Initial value:

{{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage }

Definition at line 1854 of file rtp.c.

char debug_usage[] [static]

Initial value:

  "Usage: rtp debug [ip host[:port]]\n"
  "       Enable dumping of all RTP packets to and from host.\n"

Definition at line 1840 of file rtp.c.

int dtmftimeout = DEFAULT_DTMF_TIMEOUT [static]

Definition at line 63 of file rtp.c.

struct { ... } mimeTypes[] [static]

Referenced by ast_rtp_lookup_mime_subtype(), and ast_rtp_set_rtpmap_type().

char no_debug_usage[] [static]

Initial value:

  "Usage: rtp no debug\n"
  "       Disable all RTP debugging\n"

Definition at line 1844 of file rtp.c.

struct rtpPayloadType payloadType

Definition at line 662 of file rtp.c.

Referenced by ast_rtp_lookup_mime_subtype().

struct ast_rtp_protocol* protos = NULL [static]

Definition at line 151 of file rtp.c.

int rtpdebug = 0 [static]

Definition at line 67 of file rtp.c.

struct sockaddr_in rtpdebugaddr [static]

Definition at line 68 of file rtp.c.

Referenced by rtp_debug_test_addr(), rtp_do_debug(), and rtp_do_debug_ip().

int rtpend = 0 [static]

Definition at line 66 of file rtp.c.

int rtpstart = 0 [static]

Definition at line 65 of file rtp.c.

struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] [static]

Definition at line 690 of file rtp.c.

char* subtype

Definition at line 664 of file rtp.c.

Referenced by ast_rtp_set_rtpmap_type().

char* type

Definition at line 663 of file rtp.c.

Referenced by _build_port_config(), _fill_defaults(), _free_port_cfg(), ast_rtp_set_rtpmap_type(), ast_writestream(), build_filename(), check_header(), do_chanreads(), find_subscription_type(), load_module(), misdn_cfg_get(), misdn_cfg_get_config_string(), schedule_delivery(), subscription_type2str(), vpb_new(), and yyparse().