Sat Nov 1 06:28:39 2008

Asterisk developer's documentation

---

rtp.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! 
 * \file 
 *
 * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
 *
 * \author Mark Spencer <markster@digium.com>
 * 
 * \note RTP is defined in RFC 3550.
 */

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 143337 $")

#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>

#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"
#include "asterisk/utils.h"

#define MAX_TIMESTAMP_SKEW 640

#define RTP_SEQ_MOD     (1<<16)  /*!< A sequence number can't be more than 16 bits */
#define RTCP_DEFAULT_INTERVALMS   5000 /*!< Default milli-seconds between RTCP reports we send */
#define RTCP_MIN_INTERVALMS       500  /*!< Min milli-seconds between RTCP reports we send */
#define RTCP_MAX_INTERVALMS       60000   /*!< Max milli-seconds between RTCP reports we send */

#define RTCP_PT_FUR     192
#define RTCP_PT_SR      200
#define RTCP_PT_RR      201
#define RTCP_PT_SDES    202
#define RTCP_PT_BYE     203
#define RTCP_PT_APP     204

#define RTP_MTU      1200

#define DEFAULT_DTMF_TIMEOUT 3000   /*!< samples */

static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;

static int rtpstart;       /*!< First port for RTP sessions (set in rtp.conf) */
static int rtpend;         /*!< Last port for RTP sessions (set in rtp.conf) */
static int rtpdebug;       /*!< Are we debugging? */
static int rtcpdebug;         /*!< Are we debugging RTCP? */
static int rtcpstats;         /*!< Are we debugging RTCP? */
static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
static int stundebug;         /*!< Are we debugging stun? */
static struct sockaddr_in rtpdebugaddr;   /*!< Debug packets to/from this host */
static struct sockaddr_in rtcpdebugaddr;  /*!< Debug RTCP packets to/from this host */
#ifdef SO_NO_CHECK
static int nochecksums;
#endif

/* Uncomment this to enable more intense native bridging, but note: this is currently buggy */
/* #define P2P_INTENSE */

/*!
 * \brief Structure representing a RTP session.
 *
 * RTP session is defined on page 9 of RFC 3550: "An association among a set of participants communicating with RTP.  A participant may be involved in multiple RTP sessions at the same time [...]"
 *
 */
/*! \brief The value of each payload format mapping: */
struct rtpPayloadType {
   int isAstFormat;  /*!< whether the following code is an AST_FORMAT */
   int code;
};


/*! \brief RTP session description */
struct ast_rtp {
   int s;
   struct ast_frame f;
   unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
   unsigned int ssrc;      /*!< Synchronization source, RFC 3550, page 10. */
   unsigned int themssrc;     /*!< Their SSRC */
   unsigned int rxssrc;
   unsigned int lastts;
   unsigned int lastrxts;
   unsigned int lastividtimestamp;
   unsigned int lastovidtimestamp;
   unsigned int lasteventseqn;
   int lastrxseqno;                /*!< Last received sequence number */
   unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
   unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
   unsigned int rxcount;           /*!< How many packets have we received? */
   unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
   unsigned int txcount;           /*!< How many packets have we sent? */
   unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
   unsigned int cycles;            /*!< Shifted count of sequence number cycles */
   double rxjitter;                /*!< Interarrival jitter at the moment */
   double rxtransit;               /*!< Relative transit time for previous packet */
   int lasttxformat;
   int lastrxformat;

   int rtptimeout;         /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
   int rtpholdtimeout;     /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
   int rtpkeepalive;    /*!< Send RTP comfort noice packets for keepalive */

   /* DTMF Reception Variables */
   char resp;
   unsigned int lastevent;
   int dtmfcount;
   unsigned int dtmfsamples;
   /* DTMF Transmission Variables */
   unsigned int lastdigitts;
   char sending_digit;  /*!< boolean - are we sending digits */
   char send_digit;  /*!< digit we are sending */
   int send_payload;
   int send_duration;
   int nat;
   unsigned int flags;
   struct sockaddr_in us;     /*!< Socket representation of the local endpoint. */
   struct sockaddr_in them;   /*!< Socket representation of the remote endpoint. */
   struct timeval rxcore;
   struct timeval txcore;
   double drxcore;                 /*!< The double representation of the first received packet */
   struct timeval lastrx;          /*!< timeval when we last received a packet */
   struct timeval dtmfmute;
   struct ast_smoother *smoother;
   int *ioid;
   unsigned short seqno;      /*!< Sequence number, RFC 3550, page 13. */
   unsigned short rxseqno;
   struct sched_context *sched;
   struct io_context *io;
   void *data;
   ast_rtp_callback callback;
   ast_mutex_t bridge_lock;
   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;
   struct ast_rtcp *rtcp;
   struct ast_codec_pref pref;
   struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
   int set_marker_bit:1;           /*!< Whether to set the marker bit or not */
};

/* Forward declarations */
static int ast_rtcp_write(const void *data);
static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw);
static int ast_rtcp_write_sr(const void *data);
static int ast_rtcp_write_rr(const void *data);
static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp);
static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp);
int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit);

#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 FLAG_HAS_DTMF         (1 << 3)
#define FLAG_P2P_SENT_MARK              (1 << 4)
#define FLAG_P2P_NEED_DTMF              (1 << 5)
#define FLAG_CALLBACK_MODE              (1 << 6)
#define FLAG_DTMF_COMPENSATE            (1 << 7)
#define FLAG_HAS_STUN                   (1 << 8)

/*!
 * \brief Structure defining an RTCP session.
 * 
 * The concept "RTCP session" is not defined in RFC 3550, but since 
 * this structure is analogous to ast_rtp, which tracks a RTP session, 
 * it is logical to think of this as a RTCP session.
 *
 * RTCP packet is defined on page 9 of RFC 3550.
 * 
 */
struct ast_rtcp {
   int s;            /*!< Socket */
   struct sockaddr_in us;     /*!< Socket representation of the local endpoint. */
   struct sockaddr_in them;   /*!< Socket representation of the remote endpoint. */
   unsigned int soc;    /*!< What they told us */
   unsigned int spc;    /*!< What they told us */
   unsigned int themrxlsr;    /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
   struct timeval rxlsr;      /*!< Time when we got their last SR */
   struct timeval txlsr;      /*!< Time when we sent or last SR*/
   unsigned int expected_prior;  /*!< no. packets in previous interval */
   unsigned int received_prior;  /*!< no. packets received in previous interval */
   int schedid;         /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
   unsigned int rr_count;     /*!< number of RRs we've sent, not including report blocks in SR's */
   unsigned int sr_count;     /*!< number of SRs we've sent */
   unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
   double accumulated_transit;   /*!< accumulated a-dlsr-lsr */
   double rtt;       /*!< Last reported rtt */
   unsigned int reported_jitter; /*!< The contents of their last jitter entry in the RR */
   unsigned int reported_lost;   /*!< Reported lost packets in their RR */
   char quality[AST_MAX_USER_FIELD];
   double maxrxjitter;
   double minrxjitter;
   double maxrtt;
   double minrtt;
   int sendfur;
};


typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;

/* XXX Maybe stun belongs in another file if it ever has use outside of RTP */
struct stun_header {
   unsigned short msgtype;
   unsigned short msglen;
   stun_trans_id  id;
   unsigned char ies[0];
} __attribute__((packed));

struct stun_attr {
   unsigned short attr;
   unsigned short len;
   unsigned char value[0];
} __attribute__((packed));

struct stun_addr {
   unsigned char unused;
   unsigned char family;
   unsigned short port;
   unsigned int addr;
} __attribute__((packed));

#define STUN_IGNORE     (0)
#define STUN_ACCEPT     (1)

#define STUN_BINDREQ 0x0001
#define STUN_BINDRESP   0x0101
#define STUN_BINDERR 0x0111
#define STUN_SECREQ  0x0002
#define STUN_SECRESP 0x0102
#define STUN_SECERR  0x0112

#define STUN_MAPPED_ADDRESS   0x0001
#define STUN_RESPONSE_ADDRESS 0x0002
#define STUN_CHANGE_REQUEST   0x0003
#define STUN_SOURCE_ADDRESS   0x0004
#define STUN_CHANGED_ADDRESS  0x0005
#define STUN_USERNAME      0x0006
#define STUN_PASSWORD      0x0007
#define STUN_MESSAGE_INTEGRITY   0x0008
#define STUN_ERROR_CODE    0x0009
#define STUN_UNKNOWN_ATTRIBUTES  0x000a
#define STUN_REFLECTED_FROM   0x000b

static const char *stun_msg2str(int msg)
{
   switch(msg) {
   case STUN_BINDREQ:
      return "Binding Request";
   case STUN_BINDRESP:
      return "Binding Response";
   case STUN_BINDERR:
      return "Binding Error Response";
   case STUN_SECREQ:
      return "Shared Secret Request";
   case STUN_SECRESP:
      return "Shared Secret Response";
   case STUN_SECERR:
      return "Shared Secret Error Response";
   }
   return "Non-RFC3489 Message";
}

static const char *stun_attr2str(int msg)
{
   switch(msg) {
   case STUN_MAPPED_ADDRESS:
      return "Mapped Address";
   case STUN_RESPONSE_ADDRESS:
      return "Response Address";
   case STUN_CHANGE_REQUEST:
      return "Change Request";
   case STUN_SOURCE_ADDRESS:
      return "Source Address";
   case STUN_CHANGED_ADDRESS:
      return "Changed Address";
   case STUN_USERNAME:
      return "Username";
   case STUN_PASSWORD:
      return "Password";
   case STUN_MESSAGE_INTEGRITY:
      return "Message Integrity";
   case STUN_ERROR_CODE:
      return "Error Code";
   case STUN_UNKNOWN_ATTRIBUTES:
      return "Unknown Attributes";
   case STUN_REFLECTED_FROM:
      return "Reflected From";
   }
   return "Non-RFC3489 Attribute";
}

struct stun_state {
   const char *username;
   const char *password;
};

static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
{
   if (stundebug)
      ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
         stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
   switch(ntohs(attr->attr)) {
   case STUN_USERNAME:
      state->username = (const char *) (attr->value);
      break;
   case STUN_PASSWORD:
      state->password = (const char *) (attr->value);
      break;
   default:
      if (stundebug)
         ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n", 
            stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
   }
   return 0;
}

static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
{
   int size = sizeof(**attr) + strlen(s);
   if (*left > size) {
      (*attr)->attr = htons(attrval);
      (*attr)->len = htons(strlen(s));
      memcpy((*attr)->value, s, strlen(s));
      (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
      *len += size;
      *left -= size;
   }
}

static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
{
   int size = sizeof(**attr) + 8;
   struct stun_addr *addr;
   if (*left > size) {
      (*attr)->attr = htons(attrval);
      (*attr)->len = htons(8);
      addr = (struct stun_addr *)((*attr)->value);
      addr->unused = 0;
      addr->family = 0x01;
      addr->port = sin->sin_port;
      addr->addr = sin->sin_addr.s_addr;
      (*attr) = (struct stun_attr *)((*attr)->value + 8);
      *len += size;
      *left -= size;
   }
}

static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
{
   return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
      (struct sockaddr *)dst, sizeof(*dst));
}

static void stun_req_id(struct stun_header *req)
{
   int x;
   for (x=0;x<4;x++)
      req->id.id[x] = ast_random();
}

size_t ast_rtp_alloc_size(void)
{
   return sizeof(struct ast_rtp);
}

void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
{
   struct stun_header *req;
   unsigned char reqdata[1024];
   int reqlen, reqleft;
   struct stun_attr *attr;

   req = (struct stun_header *)reqdata;
   stun_req_id(req);
   reqlen = 0;
   reqleft = sizeof(reqdata) - sizeof(struct stun_header);
   req->msgtype = 0;
   req->msglen = 0;
   attr = (struct stun_attr *)req->ies;
   if (username)
      append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
   req->msglen = htons(reqlen);
   req->msgtype = htons(STUN_BINDREQ);
   stun_send(rtp->s, suggestion, req);
}

static int stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, size_t len)
{
   struct stun_header *resp, *hdr = (struct stun_header *)data;
   struct stun_attr *attr;
   struct stun_state st;
   int ret = STUN_IGNORE;  
   unsigned char respdata[1024];
   int resplen, respleft;
   
   if (len < sizeof(struct stun_header)) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Runt STUN packet (only %zd, wanting at least %zd)\n", len, sizeof(struct stun_header));
      return -1;
   }
   if (stundebug)
      ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), ntohs(hdr->msglen));
   if (ntohs(hdr->msglen) > len - sizeof(struct stun_header)) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Scrambled STUN packet length (got %d, expecting %zd)\n", ntohs(hdr->msglen), len - sizeof(struct stun_header));
   } else
      len = ntohs(hdr->msglen);
   data += sizeof(struct stun_header);
   memset(&st, 0, sizeof(st));
   while(len) {
      if (len < sizeof(struct stun_attr)) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Runt Attribute (got %zd, expecting %zd)\n", len, sizeof(struct stun_attr));
         break;
      }
      attr = (struct stun_attr *)data;
      if ((ntohs(attr->len) + sizeof(struct stun_attr)) > len) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", (int) (ntohs(attr->len) + sizeof(struct stun_attr)), (int) len);
         break;
      }
      if (stun_process_attr(&st, attr)) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
         break;
      }
      /* Clear attribute in case previous entry was a string */
      attr->attr = 0;
      data += ntohs(attr->len) + sizeof(struct stun_attr);
      len -= ntohs(attr->len) + sizeof(struct stun_attr);
   }
   /* Null terminate any string */
   *data = '\0';
   resp = (struct stun_header *)respdata;
   resplen = 0;
   respleft = sizeof(respdata) - sizeof(struct stun_header);
   resp->id = hdr->id;
   resp->msgtype = 0;
   resp->msglen = 0;
   attr = (struct stun_attr *)resp->ies;
   if (!len) {
      switch(ntohs(hdr->msgtype)) {
      case STUN_BINDREQ:
         if (stundebug)
            ast_verbose("STUN Bind Request, username: %s\n", 
               st.username ? st.username : "<none>");
         if (st.username)
            append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
         append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
         resp->msglen = htons(resplen);
         resp->msgtype = htons(STUN_BINDRESP);
         stun_send(s, src, resp);
         ret = STUN_ACCEPT;
         break;
      default:
         if (stundebug)
            ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
      }
   }
   return ret;
}

/*! \brief List of current sessions */
static AST_LIST_HEAD_STATIC(protos, ast_rtp_protocol);

static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
{
   unsigned int sec, usec, frac;
   sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
   usec = tv.tv_usec;
   frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
   *msw = sec;
   *lsw = frac;
}

int ast_rtp_fd(struct ast_rtp *rtp)
{
   return rtp->s;
}

int ast_rtcp_fd(struct ast_rtp *rtp)
{
   if (rtp->rtcp)
      return rtp->rtcp->s;
   return -1;
}

unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
{
   unsigned int interval;
   /*! \todo XXX Do a more reasonable calculation on this one
   * Look in RFC 3550 Section A.7 for an example*/
   interval = rtcpinterval;
   return interval;
}

/* \brief Put RTP timeout timers on hold during another transaction, like T.38 */
void ast_rtp_set_rtptimers_onhold(struct ast_rtp *rtp)
{
   rtp->rtptimeout = (-1) * rtp->rtptimeout;
   rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout;
}

/*! \brief Set rtp timeout */
void ast_rtp_set_rtptimeout(struct ast_rtp *rtp, int timeout)
{
   rtp->rtptimeout = timeout;
}

/*! \brief Set rtp hold timeout */
void ast_rtp_set_rtpholdtimeout(struct ast_rtp *rtp, int timeout)
{
   rtp->rtpholdtimeout = timeout;
}

/*! \brief set RTP keepalive interval */
void ast_rtp_set_rtpkeepalive(struct ast_rtp *rtp, int period)
{
   rtp->rtpkeepalive = period;
}

/*! \brief Get rtp timeout */
int ast_rtp_get_rtptimeout(struct ast_rtp *rtp)
{
   if (rtp->rtptimeout < 0)   /* We're not checking, but remembering the setting (during T.38 transmission) */
      return 0;
   return rtp->rtptimeout;
}

/*! \brief Get rtp hold timeout */
int ast_rtp_get_rtpholdtimeout(struct ast_rtp *rtp)
{
   if (rtp->rtptimeout < 0)   /* We're not checking, but remembering the setting (during T.38 transmission) */
      return 0;
   return rtp->rtpholdtimeout;
}

/*! \brief Get RTP keepalive interval */
int ast_rtp_get_rtpkeepalive(struct ast_rtp *rtp)
{
   return rtp->rtpkeepalive;
}

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

void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
{
   rtp->nat = nat;
}

int ast_rtp_getnat(struct ast_rtp *rtp)
{
   return ast_test_flag(rtp, FLAG_NAT_ACTIVE);
}

void ast_rtp_setdtmf(struct ast_rtp *rtp, int dtmf)
{
   ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF);
}

void ast_rtp_setdtmfcompensate(struct ast_rtp *rtp, int compensate)
{
   ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE);
}

void ast_rtp_setstun(struct ast_rtp *rtp, int stun_enable)
{
   ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN);
}

static struct ast_frame *send_dtmf(struct ast_rtp *rtp, enum ast_frame_type type)
{
   if (((ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && type == AST_FRAME_DTMF_END) ||
        (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(rtp->them.sin_addr));
      rtp->resp = 0;
      rtp->dtmfsamples = 0;
      return &ast_null_frame;
   }
   if (option_debug)
      ast_log(LOG_DEBUG, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(rtp->them.sin_addr));
   if (rtp->resp == 'X') {
      rtp->f.frametype = AST_FRAME_CONTROL;
      rtp->f.subclass = AST_CONTROL_FLASH;
   } else {
      rtp->f.frametype = type;
      rtp->f.subclass = rtp->resp;
   }
   rtp->f.datalen = 0;
   rtp->f.samples = 0;
   rtp->f.mallocd = 0;
   rtp->f.src = "RTP";
   return &rtp->f;
   
}

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

static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
{
   if (rtcpdebug == 0)
      return 0;
   if (rtcpdebugaddr.sin_addr.s_addr) {
      if (((ntohs(rtcpdebugaddr.sin_port) != 0)
         && (rtcpdebugaddr.sin_port != addr->sin_port))
         || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
      return 0;
   }
   return 1;
}


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 (option_debug > 2 || rtpdebug)
      ast_log(LOG_DEBUG, "Cisco DTMF Digit: %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) {
      resp = 'X';
   }
   if (rtp->resp && (rtp->resp != resp)) {
      f = send_dtmf(rtp, AST_FRAME_DTMF_END);
   }
   rtp->resp = resp;
   rtp->dtmfcount = dtmftimeout;
   return f;
}

/*! 
 * \brief Process RTP DTMF and events according to RFC 2833.
 * 
 * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
 * 
 * \param rtp
 * \param data
 * \param len
 * \param seqno
 * \returns
 */
static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp)
{
   unsigned int event;
   unsigned int event_end;
   unsigned int samples;
   char resp = 0;
   struct ast_frame *f = NULL;

   /* Figure out event, event end, and samples */
   event = ntohl(*((unsigned int *)(data)));
   event >>= 24;
   event_end = ntohl(*((unsigned int *)(data)));
   event_end <<= 8;
   event_end >>= 24;
   samples = ntohl(*((unsigned int *)(data)));
   samples &= 0xFFFF;

   /* Print out debug if turned on */
   if (rtpdebug || option_debug > 2)
      ast_log(LOG_DEBUG, "- RTP 2833 Event: %08x (len = %d)\n", event, len);

   /* Figure out what digit was pressed */
   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'; 
   } else {
      /* Not a supported event */
      ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
      return &ast_null_frame;
   }

   if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
      if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
         rtp->resp = resp;
         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
         f->len = 0;
         rtp->lastevent = timestamp;
      }
   } else {
      if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
         rtp->resp = resp;
         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
      } else if ((event_end & 0x80) && (rtp->lastevent != seqno) && rtp->resp) {
         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
         f->len = ast_tvdiff_ms(ast_samp2tv(samples, 8000), ast_tv(0, 0)); /* XXX hard coded 8kHz */
         rtp->resp = 0;
         rtp->lastevent = seqno;
      }
   }

   rtp->dtmfcount = dtmftimeout;
   rtp->dtmfsamples = samples;

   return f;
}

/*!
 * \brief Process Comfort Noise RTP.
 * 
 * This is incomplete at the moment.
 * 
*/
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 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))) {
      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(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;