res/res_rtp_asterisk.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2008, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*!
  20  * \file
  21  *
  22  * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
  23  *
  24  * \author Mark Spencer <markster@digium.com>
  25  *
  26  * \note RTP is defined in RFC 3550.
  27  */
  28
  29 #include "asterisk.h"
  30
  31 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  32
  33 #include <sys/time.h>
  34 #include <signal.h>
  35 #include <fcntl.h>
  36 #include <math.h>
  37
  38 #include "asterisk/stun.h"
  39 #include "asterisk/pbx.h"
  40 #include "asterisk/frame.h"
  41 #include "asterisk/channel.h"
  42 #include "asterisk/acl.h"
  43 #include "asterisk/config.h"
  44 #include "asterisk/lock.h"
  45 #include "asterisk/utils.h"
  46 #include "asterisk/netsock.h"
  47 #include "asterisk/cli.h"
  48 #include "asterisk/manager.h"
  49 #include "asterisk/unaligned.h"
  50 #include "asterisk/module.h"
  51 #include "asterisk/rtp_engine.h"
  52
  53 #define MAX_TIMESTAMP_SKEW      640
  54
  55 #define RTP_SEQ_MOD     (1<<16) /*!< A sequence number can't be more than 16 bits */
  56 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
  57 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
  58 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
  59
  60 #define DEFAULT_RTP_START 5000 /*!< Default port number to start allocating RTP ports from */
  61 #define DEFAULT_RTP_END 31000  /*!< Default maximum port number to end allocating RTP ports at */
  62
  63 #define MINIMUM_RTP_PORT 1024 /*!< Minimum port number to accept */
  64 #define MAXIMUM_RTP_PORT 65535 /*!< Maximum port number to accept */
  65
  66 #define RTCP_PT_FUR     192
  67 #define RTCP_PT_SR      200
  68 #define RTCP_PT_RR      201
  69 #define RTCP_PT_SDES    202
  70 #define RTCP_PT_BYE     203
  71 #define RTCP_PT_APP     204
  72
  73 #define RTP_MTU         1200
  74
  75 #define DEFAULT_DTMF_TIMEOUT (150 * (8000 / 1000))      /*!< samples */
  76
  77 #define ZFONE_PROFILE_ID 0x505a
  78
  79 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
  80
  81 static int rtpstart = DEFAULT_RTP_START;                        /*!< First port for RTP sessions (set in rtp.conf) */
  82 static int rtpend = DEFAULT_RTP_END;                    /*!< Last port for RTP sessions (set in rtp.conf) */
  83 static int rtpdebug;                    /*!< Are we debugging? */
  84 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
  85 static int rtcpstats;                   /*!< Are we debugging RTCP? */
  86 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
  87 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
  88 static struct sockaddr_in rtcpdebugaddr;        /*!< Debug RTCP packets to/from this host */
  89 #ifdef SO_NO_CHECK
  90 static int nochecksums;
  91 #endif
  92 static int strictrtp;
  93
  94 enum strict_rtp_state {
  95         STRICT_RTP_OPEN = 0, /*! No RTP packets should be dropped, all sources accepted */
  96         STRICT_RTP_LEARN,    /*! Accept next packet as source */
  97         STRICT_RTP_CLOSED,   /*! Drop all RTP packets not coming from source that was learned */
  98 };
  99
 100 #define FLAG_3389_WARNING               (1 << 0)
 101 #define FLAG_NAT_ACTIVE                 (3 << 1)
 102 #define FLAG_NAT_INACTIVE               (0 << 1)
 103 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
 104 #define FLAG_NEED_MARKER_BIT            (1 << 3)
 105 #define FLAG_DTMF_COMPENSATE            (1 << 4)
 106
 107 /*! \brief RTP session description */
 108 struct ast_rtp {
 109         int s;
 110         struct ast_frame f;
 111         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
 112         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
 113         unsigned int themssrc;          /*!< Their SSRC */
 114         unsigned int rxssrc;
 115         unsigned int lastts;
 116         unsigned int lastrxts;
 117         unsigned int lastividtimestamp;
 118         unsigned int lastovidtimestamp;
 119         unsigned int lastitexttimestamp;
 120         unsigned int lastotexttimestamp;
 121         unsigned int lasteventseqn;
 122         int lastrxseqno;                /*!< Last received sequence number */
 123         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
 124         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
 125         unsigned int rxcount;           /*!< How many packets have we received? */
 126         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
 127         unsigned int txcount;           /*!< How many packets have we sent? */
 128         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
 129         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
 130         double rxjitter;                /*!< Interarrival jitter at the moment */
 131         double rxtransit;               /*!< Relative transit time for previous packet */
 132         int lasttxformat;
 133         int lastrxformat;
 134
 135         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
 136         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
 137         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
 138
 139         /* DTMF Reception Variables */
 140         char resp;
 141         unsigned int lastevent;
 142         unsigned int dtmf_duration;     /*!< Total duration in samples since the digit start event */
 143         unsigned int dtmf_timeout;      /*!< When this timestamp is reached we consider END frame lost and forcibly abort digit */
 144         unsigned int dtmfsamples;
 145         /* DTMF Transmission Variables */
 146         unsigned int lastdigitts;
 147         char sending_digit;     /*!< boolean - are we sending digits */
 148         char send_digit;        /*!< digit we are sending */
 149         int send_payload;
 150         int send_duration;
 151         unsigned int flags;
 152         struct timeval rxcore;
 153         struct timeval txcore;
 154         double drxcore;                 /*!< The double representation of the first received packet */
 155         struct timeval lastrx;          /*!< timeval when we last received a packet */
 156         struct timeval dtmfmute;
 157         struct ast_smoother *smoother;
 158         int *ioid;
 159         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
 160         unsigned short rxseqno;
 161         struct sched_context *sched;
 162         struct io_context *io;
 163         void *data;
 164         struct ast_rtcp *rtcp;
 165         struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
 166
 167         enum strict_rtp_state strict_rtp_state; /*!< Current state that strict RTP protection is in */
 168         struct sockaddr_in strict_rtp_address;  /*!< Remote address information for strict RTP purposes */
 169         struct sockaddr_in alt_rtp_address; /*!<Alternate remote address information */
 170
 171         struct rtp_red *red;
 172 };
 173
 174 /*!
 175  * \brief Structure defining an RTCP session.
 176  *
 177  * The concept "RTCP session" is not defined in RFC 3550, but since
 178  * this structure is analogous to ast_rtp, which tracks a RTP session,
 179  * it is logical to think of this as a RTCP session.
 180  *
 181  * RTCP packet is defined on page 9 of RFC 3550.
 182  *
 183  */
 184 struct ast_rtcp {
 185         int rtcp_info;
 186         int s;                          /*!< Socket */
 187         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
 188         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
 189         unsigned int soc;               /*!< What they told us */
 190         unsigned int spc;               /*!< What they told us */
 191         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
 192         struct timeval rxlsr;           /*!< Time when we got their last SR */
 193         struct timeval txlsr;           /*!< Time when we sent or last SR*/
 194         unsigned int expected_prior;    /*!< no. packets in previous interval */
 195         unsigned int received_prior;    /*!< no. packets received in previous interval */
 196         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
 197         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
 198         unsigned int sr_count;          /*!< number of SRs we've sent */
 199         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
 200         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
 201         double rtt;                     /*!< Last reported rtt */
 202         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
 203         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
 204
 205         double reported_maxjitter;
 206         double reported_minjitter;
 207         double reported_normdev_jitter;
 208         double reported_stdev_jitter;
 209         unsigned int reported_jitter_count;
 210
 211         double reported_maxlost;
 212         double reported_minlost;
 213         double reported_normdev_lost;
 214         double reported_stdev_lost;
 215
 216         double rxlost;
 217         double maxrxlost;
 218         double minrxlost;
 219         double normdev_rxlost;
 220         double stdev_rxlost;
 221         unsigned int rxlost_count;
 222
 223         double maxrxjitter;
 224         double minrxjitter;
 225         double normdev_rxjitter;
 226         double stdev_rxjitter;
 227         unsigned int rxjitter_count;
 228         double maxrtt;
 229         double minrtt;
 230         double normdevrtt;
 231         double stdevrtt;
 232         unsigned int rtt_count;
 233 };
 234
 235 struct rtp_red {
 236         struct ast_frame t140;  /*!< Primary data  */
 237         struct ast_frame t140red;   /*!< Redundant t140*/
 238         unsigned char pt[AST_RED_MAX_GENERATION];  /*!< Payload types for redundancy data */
 239         unsigned char ts[AST_RED_MAX_GENERATION]; /*!< Time stamps */
 240         unsigned char len[AST_RED_MAX_GENERATION]; /*!< length of each generation */
 241         int num_gen; /*!< Number of generations */
 242         int schedid; /*!< Timer id */
 243         int ti; /*!< How long to buffer data before send */
 244         unsigned char t140red_data[64000];
 245         unsigned char buf_data[64000]; /*!< buffered primary data */
 246         int hdrlen;
 247         long int prev_ts;
 248 };
 249
 250 /* Forward Declarations */
 251 static int ast_rtp_new(struct ast_rtp_instance *instance, struct sched_context *sched, struct sockaddr_in *sin, void *data);
 252 static int ast_rtp_destroy(struct ast_rtp_instance *instance);
 253 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit);
 254 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit);
 255 static void ast_rtp_new_source(struct ast_rtp_instance *instance);
 256 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame);
 257 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp);
 258 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value);
 259 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp);
 260 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin);
 261 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin);
 262 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations);
 263 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame);
 264 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1);
 265 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat);
 266 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1);
 267 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct sockaddr_in *suggestion, const char *username);
 268 static void ast_rtp_stop(struct ast_rtp_instance *instance);
 269
 270 /* RTP Engine Declaration */
 271 static struct ast_rtp_engine asterisk_rtp_engine = {
 272         .name = "asterisk",
 273         .new = ast_rtp_new,
 274         .destroy = ast_rtp_destroy,
 275         .dtmf_begin = ast_rtp_dtmf_begin,
 276         .dtmf_end = ast_rtp_dtmf_end,
 277         .new_source = ast_rtp_new_source,
 278         .write = ast_rtp_write,
 279         .read = ast_rtp_read,
 280         .prop_set = ast_rtp_prop_set,
 281         .fd = ast_rtp_fd,
 282         .remote_address_set = ast_rtp_remote_address_set,
 283         .alt_remote_address_set = ast_rtp_alt_remote_address_set,
 284         .red_init = rtp_red_init,
 285         .red_buffer = rtp_red_buffer,
 286         .local_bridge = ast_rtp_local_bridge,
 287         .get_stat = ast_rtp_get_stat,
 288         .dtmf_compatible = ast_rtp_dtmf_compatible,
 289         .stun_request = ast_rtp_stun_request,
 290         .stop = ast_rtp_stop,
 291 };
 292
 293 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
 294 {
 295         if (!rtpdebug) {
 296                 return 0;
 297         }
 298
 299         if (rtpdebugaddr.sin_addr.s_addr) {
 300                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
 301                      && (rtpdebugaddr.sin_port != addr->sin_port))
 302                     || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
 303                         return 0;
 304         }
 305
 306         return 1;
 307 }
 308
 309 static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
 310 {
 311         if (!rtcpdebug) {
 312                 return 0;
 313         }
 314
 315         if (rtcpdebugaddr.sin_addr.s_addr) {
 316                 if (((ntohs(rtcpdebugaddr.sin_port) != 0)
 317                      && (rtcpdebugaddr.sin_port != addr->sin_port))
 318                     || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
 319                         return 0;
 320         }
 321
 322         return 1;
 323 }
 324
 325 static int rtp_get_rate(int subclass)
 326 {
 327         return (subclass == AST_FORMAT_G722) ? 8000 : ast_format_rate(subclass);
 328 }
 329
 330 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
 331 {
 332         unsigned int interval;
 333         /*! \todo XXX Do a more reasonable calculation on this one
 334          * Look in RFC 3550 Section A.7 for an example*/
 335         interval = rtcpinterval;
 336         return interval;
 337 }
 338
 339 /*! \brief Calculate normal deviation */
 340 static double normdev_compute(double normdev, double sample, unsigned int sample_count)
 341 {
 342         normdev = normdev * sample_count + sample;
 343         sample_count++;
 344
 345         return normdev / sample_count;
 346 }
 347
 348 static double stddev_compute(double stddev, double sample, double normdev, double normdev_curent, unsigned int sample_count)
 349 {
 350 /*
 351                 for the formula check http://www.cs.umd.edu/~austinjp/constSD.pdf
 352                 return sqrt( (sample_count*pow(stddev,2) + sample_count*pow((sample-normdev)/(sample_count+1),2) + pow(sample-normdev_curent,2)) / (sample_count+1));
 353                 we can compute the sigma^2 and that way we would have to do the sqrt only 1 time at the end and would save another pow 2 compute
 354                 optimized formula
 355 */
 356 #define SQUARE(x) ((x) * (x))
 357
 358         stddev = sample_count * stddev;
 359         sample_count++;
 360
 361         return stddev +
 362                 ( sample_count * SQUARE( (sample - normdev) / sample_count ) ) +
 363                 ( SQUARE(sample - normdev_curent) / sample_count );
 364
 365 #undef SQUARE
 366 }
 367
 368 static int create_new_socket(const char *type)
 369 {
 370         int sock = socket(AF_INET, SOCK_DGRAM, 0);
 371
 372         if (sock < 0) {
 373                 if (!type) {
 374                         type = "RTP/RTCP";
 375                 }
 376                 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
 377         } else {
 378                 long flags = fcntl(sock, F_GETFL);
 379                 fcntl(sock, F_SETFL, flags | O_NONBLOCK);
 380 #ifdef SO_NO_CHECK
 381                 if (nochecksums) {
 382                         setsockopt(sock, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
 383                 }
 384 #endif
 385         }
 386
 387         return sock;
 388 }
 389
 390 static int ast_rtp_new(struct ast_rtp_instance *instance, struct sched_context *sched, struct sockaddr_in *sin, void *data)
 391 {
 392         struct ast_rtp *rtp = NULL;
 393         int x, startplace;
 394
 395         /* Create a new RTP structure to hold all of our data */
 396         if (!(rtp = ast_calloc(1, sizeof(*rtp)))) {
 397                 return -1;
 398         }
 399
 400         /* Set default parameters on the newly created RTP structure */
 401         rtp->ssrc = ast_random();
 402         rtp->seqno = ast_random() & 0xffff;
 403         rtp->strict_rtp_state = (strictrtp ? STRICT_RTP_LEARN : STRICT_RTP_OPEN);
 404
 405         /* Create a new socket for us to listen on and use */
 406         if ((rtp->s = create_new_socket("RTP")) < 0) {
 407                 ast_debug(1, "Failed to create a new socket for RTP instance '%p'\n", instance);
 408                 ast_free(rtp);
 409                 return -1;
 410         }
 411
 412         /* Now actually find a free RTP port to use */
 413         x = (rtpend == rtpstart) ? rtpstart : (ast_random() % (rtpend - rtpstart)) + rtpstart;
 414         x = x & ~1;
 415         startplace = x;
 416
 417         for (;;) {
 418                 sin->sin_port = htons(x);
 419                 /* Try to bind, this will tell us whether the port is available or not */
 420                 if (!bind(rtp->s, (struct sockaddr *)sin, sizeof(*sin))) {
 421                         ast_debug(1, "Allocated port %d for RTP instance '%p'\n", x, instance);
 422                         ast_rtp_instance_set_local_address(instance, sin);
 423                         break;
 424                 }
 425
 426                 x += 2;
 427                 if (x > rtpend) {
 428                         x = (rtpstart + 1) & ~1;
 429                 }
 430
 431                 /* See if we ran out of ports or if the bind actually failed because of something other than the address being in use */
 432                 if (x == startplace || errno != EADDRINUSE) {
 433                         ast_log(LOG_ERROR, "Oh dear... we couldn't allocate a port for RTP instance '%p'\n", instance);
 434                         return -1;
 435                 }
 436         }
 437
 438         /* Record any information we may need */
 439         rtp->sched = sched;
 440
 441         /* Associate the RTP structure with the RTP instance and be done */
 442         ast_rtp_instance_set_data(instance, rtp);
 443
 444         return 0;
 445 }
 446
 447 static int ast_rtp_destroy(struct ast_rtp_instance *instance)
 448 {
 449         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
 450
 451         /* Destroy the smoother that was smoothing out audio if present */
 452         if (rtp->smoother) {
 453                 ast_smoother_free(rtp->smoother);
 454         }
 455
 456         /* Close our own socket so we no longer get packets */
 457         if (rtp->s > -1) {
 458                 close(rtp->s);
 459         }
 460
 461         /* Destroy RTCP if it was being used */
 462         if (rtp->rtcp) {
 463                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
 464                 close(rtp->rtcp->s);
 465                 ast_free(rtp->rtcp);
 466         }
 467
 468         /* Destroy RED if it was being used */
 469         if (rtp->red) {
 470                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
 471                 ast_free(rtp->red);
 472         }
 473
 474         /* Finally destroy ourselves */
 475         ast_free(rtp);
 476
 477         return 0;
 478 }
 479
 480 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit)
 481 {
 482         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
 483         struct sockaddr_in remote_address = { 0, };
 484         int hdrlen = 12, res = 0, i = 0, payload = 101;
 485         char data[256];
 486         unsigned int *rtpheader = (unsigned int*)data;
 487
 488         ast_rtp_instance_get_remote_address(instance, &remote_address);
 489
 490         /* If we have no remote address information bail out now */
 491         if (!remote_address.sin_addr.s_addr || !remote_address.sin_port) {
 492                 return -1;
 493         }
 494
 495         /* Convert given digit into what we want to transmit */
 496         if ((digit <= '9') && (digit >= '0')) {
 497                 digit -= '0';
 498         } else if (digit == '*') {
 499                 digit = 10;
 500         } else if (digit == '#') {
 501                 digit = 11;
 502         } else if ((digit >= 'A') && (digit <= 'D')) {
 503                 digit = digit - 'A' + 12;
 504         } else if ((digit >= 'a') && (digit <= 'd')) {
 505                 digit = digit - 'a' + 12;
 506         } else {
 507                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
 508                 return -1;
 509         }
 510
 511         /* Grab the payload that they expect the RFC2833 packet to be received in */
 512         payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 0, AST_RTP_DTMF);
 513
 514         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
 515         rtp->send_duration = 160;
 516         rtp->lastdigitts = rtp->lastts + rtp->send_duration;
 517
 518         /* Create the actual packet that we will be sending */
 519         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
 520         rtpheader[1] = htonl(rtp->lastdigitts);
 521         rtpheader[2] = htonl(rtp->ssrc);
 522
 523         /* Actually send the packet */
 524         for (i = 0; i < 2; i++) {
 525                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
 526                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &remote_address, sizeof(remote_address));
 527                 if (res < 0) {
 528                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
 529                                 ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), strerror(errno));
 530                 }
 531                 if (rtp_debug_test_addr(&remote_address)) {
 532                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
 533                                     ast_inet_ntoa(remote_address.sin_addr),
 534                                     ntohs(remote_address.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
 535                 }
 536                 rtp->seqno++;
 537                 rtp->send_duration += 160;
 538                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
 539         }
 540
 541         /* Record that we are in the process of sending a digit and information needed to continue doing so */
 542         rtp->sending_digit = 1;
 543         rtp->send_digit = digit;
 544         rtp->send_payload = payload;
 545
 546         return 0;
 547 }
 548
 549 static int ast_rtp_dtmf_continuation(struct ast_rtp_instance *instance)
 550 {
 551         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
 552         struct sockaddr_in remote_address = { 0, };
 553         int hdrlen = 12, res = 0;
 554         char data[256];
 555         unsigned int *rtpheader = (unsigned int*)data;
 556
 557         ast_rtp_instance_get_remote_address(instance, &remote_address);
 558
 559         /* Make sure we know where the other side is so we can send them the packet */
 560         if (!remote_address.sin_addr.s_addr || !remote_address.sin_port) {
 561                 return -1;
 562         }
 563
 564         /* Actually create the packet we will be sending */
 565         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
 566         rtpheader[1] = htonl(rtp->lastdigitts);
 567         rtpheader[2] = htonl(rtp->ssrc);
 568         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
 569         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
 570
 571         /* Boom, send it on out */
 572         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &remote_address, sizeof(remote_address));
 573         if (res < 0) {
 574                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
 575                         ast_inet_ntoa(remote_address.sin_addr),
 576                         ntohs(remote_address.sin_port), strerror(errno));
 577         }
 578
 579         if (rtp_debug_test_addr(&remote_address)) {
 580                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
 581                             ast_inet_ntoa(remote_address.sin_addr),
 582                             ntohs(remote_address.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
 583         }
 584
 585         /* And now we increment some values for the next time we swing by */
 586         rtp->seqno++;
 587         rtp->send_duration += 160;
 588
 589         return 0;
 590 }
 591
 592 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit)
 593 {
 594         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
 595         struct sockaddr_in remote_address = { 0, };
 596         int hdrlen = 12, res = 0, i = 0;
 597         char data[256];
 598         unsigned int *rtpheader = (unsigned int*)data;
 599
 600         ast_rtp_instance_get_remote_address(instance, &remote_address);
 601
 602         /* Make sure we know where the remote side is so we can send them the packet we construct */
 603         if (!remote_address.sin_addr.s_addr || !remote_address.sin_port) {
 604                 return -1;
 605         }
 606
 607         /* Convert the given digit to the one we are going to send */
 608         if ((digit <= '9') && (digit >= '0')) {
 609                 digit -= '0';
 610         } else if (digit == '*') {
 611                 digit = 10;
 612         } else if (digit == '#') {
 613                 digit = 11;
 614         } else if ((digit >= 'A') && (digit <= 'D')) {
 615                 digit = digit - 'A' + 12;
 616         } else if ((digit >= 'a') && (digit <= 'd')) {
 617                 digit = digit - 'a' + 12;
 618         } else {
 619                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
 620                 return -1;
 621         }
 622
 623         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
 624
 625         /* Construct the packet we are going to send */
 626         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
 627         rtpheader[1] = htonl(rtp->lastdigitts);
 628         rtpheader[2] = htonl(rtp->ssrc);
 629         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
 630         rtpheader[3] |= htonl((1 << 23));
 631         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
 632
 633         /* Send it 3 times, that's the magical number */
 634         for (i = 0; i < 3; i++) {
 635                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &remote_address, sizeof(remote_address));
 636                 if (res < 0) {
 637                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
 638                                 ast_inet_ntoa(remote_address.sin_addr),
 639                                 ntohs(remote_address.sin_port), strerror(errno));
 640                 }
 641                 if (rtp_debug_test_addr(&remote_address)) {
 642                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
 643                                     ast_inet_ntoa(remote_address.sin_addr),
 644                                     ntohs(remote_address.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
 645                 }
 646         }
 647
 648         /* Oh and we can't forget to turn off the stuff that says we are sending DTMF */
 649         rtp->lastts += rtp->send_duration;
 650         rtp->sending_digit = 0;
 651         rtp->send_digit = 0;
 652
 653         return 0;
 654 }
 655
 656 static void ast_rtp_new_source(struct ast_rtp_instance *instance)
 657 {
 658         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
 659
 660         /* We simply set this bit so that the next packet sent will have the marker bit turned on */
 661         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
 662
 663         if (!ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_CONSTANT_SSRC)) {
 664                 ast_log(LOG_ERROR, "Changing ssrc\n");
 665                 rtp->ssrc = ast_random();
 666         }
 667
 668         return;
 669 }
 670
 671 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
 672 {
 673         struct timeval t;
 674         long ms;
 675
 676         if (ast_tvzero(rtp->txcore)) {
 677                 rtp->txcore = ast_tvnow();
 678                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
 679         }
 680
 681         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
 682         if ((ms = ast_tvdiff_ms(t, rtp->txcore)) < 0) {
 683                 ms = 0;
 684         }
 685         rtp->txcore = t;
 686
 687         return (unsigned int) ms;
 688 }
 689
 690 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
 691 {
 692         unsigned int sec, usec, frac;
 693         sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
 694         usec = tv.tv_usec;
 695         frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
 696         *msw = sec;
 697         *lsw = frac;
 698 }
 699
 700 /*! \brief Send RTCP recipient's report */
 701 static int ast_rtcp_write_rr(const void *data)
 702 {
 703         struct ast_rtp *rtp = (struct ast_rtp *)data;
 704         int res;
 705         int len = 32;
 706         unsigned int lost;
 707         unsigned int extended;
 708         unsigned int expected;
 709         unsigned int expected_interval;
 710         unsigned int received_interval;
 711         int lost_interval;
 712         struct timeval now;
 713         unsigned int *rtcpheader;
 714         char bdata[1024];
 715         struct timeval dlsr;
 716         int fraction;
 717
 718         double rxlost_current;
 719
 720         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
 721                 return 0;
 722
 723         if (!rtp->rtcp->them.sin_addr.s_addr) {
 724                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
 725                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
 726                 return 0;
 727         }
 728
 729         extended = rtp->cycles + rtp->lastrxseqno;
 730         expected = extended - rtp->seedrxseqno + 1;
 731         lost = expected - rtp->rxcount;
 732         expected_interval = expected - rtp->rtcp->expected_prior;
 733         rtp->rtcp->expected_prior = expected;
 734         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
 735         rtp->rtcp->received_prior = rtp->rxcount;
 736         lost_interval = expected_interval - received_interval;
 737
 738         if (lost_interval <= 0)
 739                 rtp->rtcp->rxlost = 0;
 740         else rtp->rtcp->rxlost = rtp->rtcp->rxlost;
 741         if (rtp->rtcp->rxlost_count == 0)
 742                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
 743         if (lost_interval < rtp->rtcp->minrxlost)
 744                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
 745         if (lost_interval > rtp->rtcp->maxrxlost)
 746                 rtp->rtcp->maxrxlost = rtp->rtcp->rxlost;
 747
 748         rxlost_current = normdev_compute(rtp->rtcp->normdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->rxlost_count);
 749         rtp->rtcp->stdev_rxlost = stddev_compute(rtp->rtcp->stdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->normdev_rxlost, rxlost_current, rtp->rtcp->rxlost_count);
 750         rtp->rtcp->normdev_rxlost = rxlost_current;
 751         rtp->rtcp->rxlost_count++;
 752
 753         if (expected_interval == 0 || lost_interval <= 0)
 754                 fraction = 0;
 755         else
 756                 fraction = (lost_interval << 8) / expected_interval;
 757         gettimeofday(&now, NULL);
 758         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
 759         rtcpheader = (unsigned int *)bdata;
 760         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
 761         rtcpheader[1] = htonl(rtp->ssrc);
 762         rtcpheader[2] = htonl(rtp->themssrc);
 763         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
 764         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
 765         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
 766         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
 767         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
 768
 769         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos
 770           it can change mid call, and SDES can't) */
 771         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
 772         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
 773         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
 774         len += 12;
 775
 776         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
 777
 778         if (res < 0) {
 779                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
 780                 /* Remove the scheduler */
 781                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
 782                 return 0;
 783         }
 784
 785         rtp->rtcp->rr_count++;
 786         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
 787                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
 788                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n"
 789                         "  IA jitter: %.4f\n"
 790                         "  Their last SR: %u\n"
 791                             "  DLSR: %4.4f (sec)\n\n",
 792                             ast_inet_ntoa(rtp->rtcp->them.sin_addr),
 793                             ntohs(rtp->rtcp->them.sin_port),
 794                             rtp->ssrc, rtp->themssrc, fraction, lost,
 795                             rtp->rxjitter,
 796                             rtp->rtcp->themrxlsr,
 797                             (double)(ntohl(rtcpheader[7])/65536.0));
 798         }
 799
 800         return res;
 801 }
 802
 803 /*! \brief Send RTCP sender's report */
 804 static int ast_rtcp_write_sr(const void *data)
 805 {
 806         struct ast_rtp *rtp = (struct ast_rtp *)data;
 807         int res;
 808         int len = 0;
 809         struct timeval now;
 810         unsigned int now_lsw;
 811         unsigned int now_msw;
 812         unsigned int *rtcpheader;
 813         unsigned int lost;
 814         unsigned int extended;
 815         unsigned int expected;
 816         unsigned int expected_interval;
 817         unsigned int received_interval;
 818         int lost_interval;
 819         int fraction;
 820         struct timeval dlsr;
 821         char bdata[512];
 822
 823         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
 824         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
 825                 return 0;
 826
 827         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
 828                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
 829                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
 830                 return 0;
 831         }
 832
 833         gettimeofday(&now, NULL);
 834         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
 835         rtcpheader = (unsigned int *)bdata;
 836         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
 837         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
 838         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
 839         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
 840         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
 841         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
 842         len += 28;
 843
 844         extended = rtp->cycles + rtp->lastrxseqno;
 845         expected = extended - rtp->seedrxseqno + 1;
 846         if (rtp->rxcount > expected)
 847                 expected += rtp->rxcount - expected;
 848         lost = expected - rtp->rxcount;
 849         expected_interval = expected - rtp->rtcp->expected_prior;
 850         rtp->rtcp->expected_prior = expected;
 851         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
 852         rtp->rtcp->received_prior = rtp->rxcount;
 853         lost_interval = expected_interval - received_interval;
 854         if (expected_interval == 0 || lost_interval <= 0)
 855                 fraction = 0;
 856         else
 857                 fraction = (lost_interval << 8) / expected_interval;
 858         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
 859         rtcpheader[7] = htonl(rtp->themssrc);
 860         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
 861         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
 862         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
 863         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
 864         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
 865         len += 24;
 866
 867         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
 868
 869         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */
 870         /* it can change mid call, and SDES can't) */
 871         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
 872         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
 873         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
 874         len += 12;
 875
 876         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
 877         if (res < 0) {
 878                 ast_log(LOG_ERROR, "RTCP SR transmission error to %s:%d, rtcp halted %s\n",ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port), strerror(errno));
 879                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
 880                 return 0;
 881         }
 882
 883         /* FIXME Don't need to get a new one */
 884         gettimeofday(&rtp->rtcp->txlsr, NULL);
 885         rtp->rtcp->sr_count++;
 886
 887         rtp->rtcp->lastsrtxcount = rtp->txcount;
 888
 889         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
 890                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
 891                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
 892                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
 893                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
 894                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
 895                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
 896                 ast_verbose("  Report block:\n");
 897                 ast_verbose("  Fraction lost: %u\n", fraction);
 898                 ast_verbose("  Cumulative loss: %u\n", lost);
 899                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
 900                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
 901                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
 902         }
 903         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To %s:%d\r\n"
 904                                             "OurSSRC: %u\r\n"
 905                                             "SentNTP: %u.%010u\r\n"
 906                                             "SentRTP: %u\r\n"
 907                                             "SentPackets: %u\r\n"
 908                                             "SentOctets: %u\r\n"
 909                                             "ReportBlock:\r\n"
 910                                             "FractionLost: %u\r\n"
 911                                             "CumulativeLoss: %u\r\n"
 912                                             "IAJitter: %.4f\r\n"
 913                                             "TheirLastSR: %u\r\n"
 914                       "DLSR: %4.4f (sec)\r\n",
 915                       ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
 916                       rtp->ssrc,
 917                       (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
 918                       rtp->lastts,
 919                       rtp->txcount,
 920                       rtp->txoctetcount,
 921                       fraction,
 922                       lost,
 923                       rtp->rxjitter,
 924                       rtp->rtcp->themrxlsr,
 925                       (double)(ntohl(rtcpheader[12])/65536.0));
 926         return res;
 927 }
 928
 929 /*! \brief Write and RTCP packet to the far end
 930  * \note Decide if we are going to send an SR (with Reception Block) or RR
 931  * RR is sent if we have not sent any rtp packets in the previous interval */
 932 static int ast_rtcp_write(const void *data)
 933 {
 934         struct ast_rtp *rtp = (struct ast_rtp *)data;
 935         int res;
 936
 937         if (!rtp || !rtp->rtcp)
 938                 return 0;
 939
 940         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
 941                 res = ast_rtcp_write_sr(data);
 942         else
 943                 res = ast_rtcp_write_rr(data);
 944
 945         return res;
 946 }
 947
 948 static int ast_rtp_raw_write(struct ast_rtp_instance *instance, struct ast_frame *frame, int codec)
 949 {
 950         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
 951         int pred, mark = 0;
 952         unsigned int ms = calc_txstamp(rtp, &frame->delivery);
 953         struct sockaddr_in remote_address = { 0, };
 954         int rate = rtp_get_rate(frame->subclass) / 1000;
 955
 956         if (frame->subclass == AST_FORMAT_G722) {
 957                 frame->samples /= 2;
 958         }
 959
 960         if (rtp->sending_digit) {
 961                 return 0;
 962         }
 963
 964         if (frame->frametype == AST_FRAME_VOICE) {
 965                 pred = rtp->lastts + frame->samples;
 966
 967                 /* Re-calculate last TS */
 968                 rtp->lastts = rtp->lastts + ms * rate;
 969                 if (ast_tvzero(frame->delivery)) {
 970                         /* If this isn't an absolute delivery time, Check if it is close to our prediction,
 971                            and if so, go with our prediction */
 972                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW) {
 973                                 rtp->lastts = pred;
 974                         } else {
 975                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
 976                                 mark = 1;
 977                         }
 978                 }
 979         } else if (frame->frametype == AST_FRAME_VIDEO) {
 980                 mark = frame->subclass & 0x1;
 981                 pred = rtp->lastovidtimestamp + frame->samples;
 982                 /* Re-calculate last TS */
 983                 rtp->lastts = rtp->lastts + ms * 90;
 984                 /* If it's close to our prediction, go for it */
 985                 if (ast_tvzero(frame->delivery)) {
 986                         if (abs(rtp->lastts - pred) < 7200) {
 987                                 rtp->lastts = pred;
 988                                 rtp->lastovidtimestamp += frame->samples;
 989                         } else {
 990                                 ast_debug(3, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, frame->samples);
 991                                 rtp->lastovidtimestamp = rtp->lastts;
 992                         }
 993                 }
 994         } else {
 995                 pred = rtp->lastotexttimestamp + frame->samples;
 996                 /* Re-calculate last TS */
 997                 rtp->lastts = rtp->lastts + ms;
 998                 /* If it's close to our prediction, go for it */
 999                 if (ast_tvzero(frame->delivery)) {
1000                         if (abs(rtp->lastts - pred) < 7200) {
1001                                 rtp->lastts = pred;
1002                                 rtp->lastotexttimestamp += frame->samples;
1003                         } else {
1004                                 ast_debug(3, "Difference is %d, ms is %d, pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, rtp->lastts, pred, frame->samples);
1005                                 rtp->lastotexttimestamp = rtp->lastts;
1006                         }
1007                 }
1008         }
1009
1010         /* If we have been explicitly told to set the marker bit then do so */
1011         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
1012                 mark = 1;
1013                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
1014         }
1015
1016         /* If the timestamp for non-digt packets has moved beyond the timestamp for digits, update the digit timestamp */
1017         if (rtp->lastts > rtp->lastdigitts) {
1018                 rtp->lastdigitts = rtp->lastts;
1019         }
1020
1021         if (ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO)) {
1022                 rtp->lastts = frame->ts * rate;
1023         }
1024
1025         ast_rtp_instance_get_remote_address(instance, &remote_address);
1026
1027         /* If we know the remote address construct a packet and send it out */
1028         if (remote_address.sin_port && remote_address.sin_addr.s_addr) {
1029                 int hdrlen = 12, res;
1030                 unsigned char *rtpheader = (unsigned char *)(frame->data.ptr - hdrlen);
1031
1032                 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1033                 put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1034                 put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
1035
1036                 if ((res = sendto(rtp->s, (void *)rtpheader, frame->datalen + hdrlen, 0, (struct sockaddr *)&remote_address, sizeof(remote_address))) < 0) {
1037                         if (!ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT) || (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT) && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1038                                 ast_debug(1, "RTP Transmission error of packet %d to %s:%d: %s\n", rtp->seqno, ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), strerror(errno));
1039                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
1040                                 /* Only give this error message once if we are not RTP debugging */
1041                                 if (option_debug || rtpdebug)
1042                                         ast_debug(0, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port));
1043                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
1044                         }
1045                 } else {
1046                         rtp->txcount++;
1047                         rtp->txoctetcount += (res - hdrlen);
1048
1049                         if (rtp->rtcp && rtp->rtcp->schedid < 1) {
1050                                 ast_debug(1, "Starting RTCP transmission on RTP instance '%p'\n", instance);
1051                                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1052                         }
1053                 }
1054
1055                 if (rtp_debug_test_addr(&remote_address)) {
1056                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1057                                     ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), codec, rtp->seqno, rtp->lastts, res - hdrlen);
1058                 }
1059         }
1060
1061         rtp->seqno++;
1062
1063         return 0;
1064 }
1065
1066 static struct ast_frame *red_t140_to_red(struct rtp_red *red) {
1067         unsigned char *data = red->t140red.data.ptr;
1068         int len = 0;
1069         int i;
1070
1071         /* replace most aged generation */
1072         if (red->len[0]) {
1073                 for (i = 1; i < red->num_gen+1; i++)
1074                         len += red->len[i];
1075
1076                 memmove(&data[red->hdrlen], &data[red->hdrlen+red->len[0]], len);
1077         }
1078
1079         /* Store length of each generation and primary data length*/
1080         for (i = 0; i < red->num_gen; i++)
1081                 red->len[i] = red->len[i+1];
1082         red->len[i] = red->t140.datalen;
1083
1084         /* write each generation length in red header */
1085         len = red->hdrlen;
1086         for (i = 0; i < red->num_gen; i++)
1087                 len += data[i*4+3] = red->len[i];
1088
1089         /* add primary data to buffer */
1090         memcpy(&data[len], red->t140.data.ptr, red->t140.datalen);
1091         red->t140red.datalen = len + red->t140.datalen;
1092
1093         /* no primary data and no generations to send */
1094         if (len == red->hdrlen && !red->t140.datalen)
1095                 return NULL;
1096
1097         /* reset t.140 buffer */
1098         red->t140.datalen = 0;
1099
1100         return &red->t140red;
1101 }
1102
1103 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
1104 {
1105         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1106         struct sockaddr_in remote_address = { 0, };
1107         int codec, subclass;
1108
1109         ast_rtp_instance_get_remote_address(instance, &remote_address);
1110
1111         /* If we don't actually know the remote address don't even bother doing anything */
1112         if (!remote_address.sin_addr.s_addr) {
1113                 ast_debug(1, "No remote address on RTP instance '%p' so dropping frame\n", instance);
1114                 return 0;
1115         }
1116
1117         /* If there is no data length we can't very well send the packet */
1118         if (!frame->datalen) {
1119                 ast_debug(1, "Received frame with no data for RTP instance '%p' so dropping frame\n", instance);
1120                 return 0;
1121         }
1122
1123         /* If the packet is not one our RTP stack supports bail out */
1124         if (frame->frametype != AST_FRAME_VOICE && frame->frametype != AST_FRAME_VIDEO && frame->frametype != AST_FRAME_TEXT) {
1125                 ast_log(LOG_WARNING, "RTP can only send voice, video, and text\n");
1126                 return -1;
1127         }
1128
1129         if (rtp->red) {
1130                 /* return 0; */
1131                 /* no primary data or generations to send */
1132                 if ((frame = red_t140_to_red(rtp->red)) == NULL)
1133                         return 0;
1134         }
1135
1136         /* Grab the subclass and look up the payload we are going to use */
1137         subclass = frame->subclass;
1138         if (frame->frametype == AST_FRAME_VIDEO) {
1139                 subclass &= ~0x1;
1140         }
1141         if ((codec = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 1, subclass)) < 0) {
1142                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(frame->subclass));
1143                 return -1;
1144         }
1145
1146         /* Oh dear, if the format changed we will have to set up a new smoother */
1147         if (rtp->lasttxformat != subclass) {
1148                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1149                 rtp->lasttxformat = subclass;
1150                 if (rtp->smoother) {
1151                         ast_smoother_free(rtp->smoother);
1152                         rtp->smoother = NULL;
1153                 }
1154         }
1155
1156         /* If no smoother is present see if we have to set one up */
1157         if (!rtp->smoother) {
1158                 struct ast_format_list fmt = ast_codec_pref_getsize(&ast_rtp_instance_get_codecs(instance)->pref, subclass);
1159
1160                 switch (subclass) {
1161                 case AST_FORMAT_SPEEX:
1162                 case AST_FORMAT_G723_1:
1163                 case AST_FORMAT_SIREN7:
1164                 case AST_FORMAT_SIREN14:
1165                         /* these are all frame-based codecs and cannot be safely run through
1166                            a smoother */
1167                         break;
1168                 default:
1169                         if (fmt.inc_ms) {
1170                                 if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
1171                                         ast_log(LOG_WARNING, "Unable to create smoother: format %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
1172                                         return -1;
1173                                 }
1174                                 if (fmt.flags) {
1175                                         ast_smoother_set_flags(rtp->smoother, fmt.flags);
1176                                 }
1177                                 ast_debug(1, "Created smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
1178                         }
1179                 }
1180         }
1181
1182         /* Feed audio frames into the actual function that will create a frame and send it */
1183         if (rtp->smoother) {
1184                 struct ast_frame *f;
1185
1186                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
1187                         ast_smoother_feed_be(rtp->smoother, frame);
1188                 } else {
1189                         ast_smoother_feed(rtp->smoother, frame);
1190                 }
1191
1192                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data.ptr)) {
1193                                 ast_rtp_raw_write(instance, f, codec);
1194                 }
1195         } else {
1196                 int hdrlen = 12;
1197                 struct ast_frame *f = NULL;
1198
1199                 if (frame->offset < hdrlen) {
1200                         f = ast_frdup(frame);
1201                 } else {
1202                         f = frame;
1203                 }
1204                 if (f->data.ptr) {
1205                         ast_rtp_raw_write(instance, f, codec);
1206                 }
1207                 if (f != frame) {
1208                         ast_frfree(f);
1209                 }
1210
1211         }
1212
1213         return 0;
1214 }
1215
1216 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1217 {
1218         struct timeval now;
1219         double transit;
1220         double current_time;
1221         double d;
1222         double dtv;
1223         double prog;
1224         int rate = rtp_get_rate(rtp->f.subclass);
1225
1226         double normdev_rxjitter_current;
1227         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1228                 gettimeofday(&rtp->rxcore, NULL);
1229                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1230                 /* map timestamp to a real time */
1231                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1232                 rtp->rxcore.tv_sec -= timestamp / rate;
1233                 rtp->rxcore.tv_usec -= (timestamp % rate) * 125;
1234                 /* Round to 0.1ms for nice, pretty timestamps */
1235                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1236                 if (rtp->rxcore.tv_usec < 0) {
1237                         /* Adjust appropriately if necessary */
1238                         rtp->rxcore.tv_usec += 1000000;
1239                         rtp->rxcore.tv_sec -= 1;
1240                 }
1241         }
1242
1243         gettimeofday(&now,NULL);
1244         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1245         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / rate;
1246         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % rate) * 125;
1247         if (tv->tv_usec >= 1000000) {
1248                 tv->tv_usec -= 1000000;
1249                 tv->tv_sec += 1;
1250         }
1251         prog = (double)((timestamp-rtp->seedrxts)/(float)(rate));
1252         dtv = (double)rtp->drxcore + (double)(prog);
1253         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1254         transit = current_time - dtv;
1255         d = transit - rtp->rxtransit;
1256         rtp->rxtransit = transit;
1257         if (d<0)
1258                 d=-d;
1259         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1260
1261         if (rtp->rtcp) {
1262                 if (rtp->rxjitter > rtp->rtcp->maxrxjitter)
1263                         rtp->rtcp->maxrxjitter = rtp->rxjitter;
1264                 if (rtp->rtcp->rxjitter_count == 1)
1265                         rtp->rtcp->minrxjitter = rtp->rxjitter;
1266                 if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1267                         rtp->rtcp->minrxjitter = rtp->rxjitter;
1268
1269                 normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
1270                 rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
1271
1272                 rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
1273                 rtp->rtcp->rxjitter_count++;
1274         }
1275 }
1276
1277 static struct ast_frame *send_dtmf(struct ast_rtp_instance *instance, enum ast_frame_type type, int compensate)
1278 {
1279         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1280         struct sockaddr_in remote_address = { 0, };
1281
1282         ast_rtp_instance_get_remote_address(instance, &remote_address);
1283
1284         if (((compensate && type == AST_FRAME_DTMF_END) || (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
1285                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(remote_address.sin_addr));
1286                 rtp->resp = 0;
1287                 rtp->dtmfsamples = 0;
1288                 return &ast_null_frame;
1289         }
1290         ast_debug(1, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(remote_address.sin_addr));
1291         if (rtp->resp == 'X') {
1292                 rtp->f.frametype = AST_FRAME_CONTROL;
1293                 rtp->f.subclass = AST_CONTROL_FLASH;
1294         } else {
1295                 rtp->f.frametype = type;
1296                 rtp->f.subclass = rtp->resp;
1297         }
1298         rtp->f.datalen = 0;
1299         rtp->f.samples = 0;
1300         rtp->f.mallocd = 0;
1301         rtp->f.src = "RTP";
1302
1303         return &rtp->f;
1304 }
1305
1306 static struct ast_frame *process_dtmf_rfc2833(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct sockaddr_in *sin, int payloadtype, int mark)
1307 {
1308         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1309         struct sockaddr_in remote_address = { 0, };
1310         unsigned int event, event_end, samples;
1311         char resp = 0;
1312         struct ast_frame *f = NULL;
1313
1314         ast_rtp_instance_get_remote_address(instance, &remote_address);
1315
1316         /* Figure out event, event end, and samples */
1317         event = ntohl(*((unsigned int *)(data)));
1318         event >>= 24;
1319         event_end = ntohl(*((unsigned int *)(data)));
1320         event_end <<= 8;
1321         event_end >>= 24;
1322         samples = ntohl(*((unsigned int *)(data)));
1323         samples &= 0xFFFF;
1324
1325         if (rtp_debug_test_addr(&remote_address)) {
1326                 ast_verbose("Got  RTP RFC2833 from   %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n", ast_inet_ntoa(remote_address.sin_addr),
1327                             ntohs(remote_address.sin_port), payloadtype, seqno, timestamp, len, (mark?1:0), event, ((event_end & 0x80)?1:0), samples);
1328         }
1329
1330         /* Print out debug if turned on */
1331         if (rtpdebug || option_debug > 2)
1332                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
1333
1334         /* Figure out what digit was pressed */
1335         if (event < 10) {
1336                 resp = '0' + event;
1337         } else if (event < 11) {
1338                 resp = '*';
1339         } else if (event < 12) {
1340                 resp = '#';
1341         } else if (event < 16) {
1342                 resp = 'A' + (event - 12);
1343         } else if (event < 17) {        /* Event 16: Hook flash */
1344                 resp = 'X';
1345         } else {
1346                 /* Not a supported event */
1347                 ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
1348                 return &ast_null_frame;
1349         }
1350
1351         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
1352                 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
1353                         rtp->resp = resp;
1354                         rtp->dtmf_timeout = 0;
1355                         f = send_dtmf(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
1356                         f->len = 0;
1357                         rtp->lastevent = timestamp;
1358                 }
1359         } else {
1360                 /*  The duration parameter measures the complete
1361                     duration of the event (from the beginning) - RFC2833.
1362                     Account for the fact that duration is only 16 bits long
1363                     (about 8 seconds at 8000 Hz) and can wrap is digit
1364                     is hold for too long. */
1365                 unsigned int new_duration = rtp->dtmf_duration;
1366                 unsigned int last_duration = new_duration & 0xFFFF;
1367
1368                 if (last_duration > 64000 && samples < last_duration) {
1369                         new_duration += 0xFFFF + 1;
1370                 }
1371                 new_duration = (new_duration & ~0xFFFF) | samples;
1372
1373                 if (event_end & 0x80) {
1374                         /* End event */
1375                         if ((rtp->lastevent != seqno) && rtp->resp) {
1376                                 rtp->dtmf_duration = new_duration;
1377                                 f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
1378                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass)), ast_tv(0, 0));
1379                                 rtp->resp = 0;
1380                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
1381                         }
1382                 } else {
1383                         /* Begin/continuation */
1384
1385                         if (rtp->resp && rtp->resp != resp) {
1386                                 /* Another digit already began. End it */
1387                                 f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
1388                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass)), ast_tv(0, 0));
1389                                 rtp->resp = 0;
1390                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
1391                         }
1392
1393                         if (rtp->resp) {
1394                                 /* Digit continues */
1395                                 rtp->dtmf_duration = new_duration;
1396                         } else {
1397                                 /* New digit began */
1398                                 rtp->resp = resp;
1399                                 f = send_dtmf(instance, AST_FRAME_DTMF_BEGIN, 0);
1400                                 rtp->dtmf_duration = samples;
1401                         }
1402
1403                         rtp->dtmf_timeout = timestamp + rtp->dtmf_duration + dtmftimeout;
1404                 }
1405
1406                 rtp->lastevent = seqno;
1407         }
1408
1409         rtp->dtmfsamples = samples;
1410
1411         return f;
1412 }
1413
1414 static struct ast_frame *process_dtmf_cisco(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct sockaddr_in *sin, int payloadtype, int mark)
1415 {
1416         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1417         unsigned int event, flags, power;
1418         char resp = 0;
1419         unsigned char seq;
1420         struct ast_frame *f = NULL;
1421
1422         if (len < 4) {
1423                 return NULL;
1424         }
1425
1426         /*      The format of Cisco RTP DTMF packet looks like next:
1427                 +0                              - sequence number of DTMF RTP packet (begins from 1,
1428                                                   wrapped to 0)
1429                 +1                              - set of flags
1430                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
1431                                                   or repeated digit without audio???
1432                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
1433                                                   then falls to 0 at its end)
1434                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
1435                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
1436                 by each new packet and thus provides some redudancy.
1437
1438                 Sample of Cisco RTP DTMF packet is (all data in hex):
1439                         19 07 00 02 12 02 20 02
1440                 showing end of DTMF digit '2'.
1441
1442                 The packets
1443                         27 07 00 02 0A 02 20 02
1444                         28 06 20 02 00 02 0A 02
1445                 shows begin of new digit '2' with very short pause (20 ms) after
1446                 previous digit '2'. Bit +1.0 flips at begin of new digit.
1447
1448                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
1449                 so its uses the same sequencing and timestamping rules as replaced
1450                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
1451                 on audio framing parameters. Marker bit isn't used within stream of
1452                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
1453                 are not sequential at borders between DTMF and audio streams,
1454         */
1455
1456         seq = data[0];
1457         flags = data[1];
1458         power = data[2];
1459         event = data[3] & 0x1f;
1460
1461         if (option_debug > 2 || rtpdebug)
1462                 ast_debug(0, "Cisco DTMF Digit: %02x (len=%d, seq=%d, flags=%02x, power=%d, history count=%d)\n", event, len, seq, flags, power, (len - 4) / 2);
1463         if (event < 10) {
1464                 resp = '0' + event;
1465         } else if (event < 11) {
1466                 resp = '*';
1467         } else if (event < 12) {
1468                 resp = '#';
1469         } else if (event < 16) {
1470                 resp = 'A' + (event - 12);
1471         } else if (event < 17) {
1472                 resp = 'X';
1473         }
1474         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
1475                 rtp->resp = resp;
1476                 /* Why we should care on DTMF compensation at reception? */
1477                 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
1478                         f = send_dtmf(instance, AST_FRAME_DTMF_BEGIN, 0);
1479                         rtp->dtmfsamples = 0;
1480                 }
1481         } else if ((rtp->resp == resp) && !power) {
1482                 f = send_dtmf(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
1483                 f->samples = rtp->dtmfsamples * (rtp_get_rate(f->subclass) / 1000);
1484                 rtp->resp = 0;
1485         } else if (rtp->resp == resp)
1486                 rtp->dtmfsamples += 20 * (rtp_get_rate(f->subclass) / 1000);
1487         rtp->dtmf_timeout = 0;
1488
1489         return f;
1490 }
1491
1492 static struct ast_frame *process_cn_rfc3389(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct sockaddr_in *sin, int payloadtype, int mark)
1493 {
1494         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1495
1496         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
1497            totally help us out becuase we don't have an engine to keep it going and we are not
1498            guaranteed to have it every 20ms or anything */
1499         if (rtpdebug)
1500                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
1501
1502         if (ast_test_flag(rtp, FLAG_3389_WARNING)) {
1503                 struct sockaddr_in remote_address = { 0, };
1504
1505                 ast_rtp_instance_get_remote_address(instance, &remote_address);
1506
1507                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
1508                         ast_inet_ntoa(remote_address.sin_addr));
1509                 ast_set_flag(rtp, FLAG_3389_WARNING);
1510         }
1511
1512         /* Must have at least one byte */
1513         if (!len)
1514                 return NULL;
1515         if (len < 24) {
1516                 rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
1517                 rtp->f.datalen = len - 1;
1518                 rtp->f.offset = AST_FRIENDLY_OFFSET;
1519                 memcpy(rtp->f.data.ptr, data + 1, len - 1);
1520         } else {
1521                 rtp->f.data.ptr = NULL;
1522                 rtp->f.offset = 0;
1523                 rtp->f.datalen = 0;
1524         }
1525         rtp->f.frametype = AST_FRAME_CNG;
1526         rtp->f.subclass = data[0] & 0x7f;
1527         rtp->f.datalen = len - 1;
1528         rtp->f.samples = 0;
1529         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
1530
1531         return &rtp->f;
1532 }
1533
1534 static struct ast_frame *ast_rtcp_read(struct ast_rtp_instance *instance)
1535 {
1536         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1537         struct sockaddr_in sin;
1538         socklen_t len = sizeof(sin);
1539         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
1540         unsigned int *rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
1541         int res, packetwords, position = 0;
1542         struct ast_frame *f = &ast_null_frame;
1543
1544         /* Read in RTCP data from the socket */
1545         if ((res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0) {
1546                 ast_assert(errno != EBADF);
1547                 if (errno != EAGAIN) {
1548                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
1549                         return NULL;
1550                 }
1551                 return &ast_null_frame;
1552         }
1553
1554         packetwords = res / 4;
1555
1556         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
1557                 /* Send to whoever sent to us */
1558                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1559                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
1560                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1561                         if (option_debug || rtpdebug)
1562                                 ast_debug(0, "RTCP NAT: Got RTCP from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1563                 }
1564         }
1565
1566         ast_debug(1, "Got RTCP report of %d bytes\n", res);
1567
1568         while (position < packetwords) {
1569                 int i, pt, rc;
1570                 unsigned int length, dlsr, lsr, msw, lsw, comp;
1571                 struct timeval now;
1572                 double rttsec, reported_jitter, reported_normdev_jitter_current, normdevrtt_current, reported_lost, reported_normdev_lost_current;
1573                 uint64_t rtt = 0;
1574
1575                 i = position;
1576                 length = ntohl(rtcpheader[i]);
1577                 pt = (length & 0xff0000) >> 16;
1578                 rc = (length & 0x1f000000) >> 24;
1579                 length &= 0xffff;
1580
1581                 if ((i + length) > packetwords) {
1582                         if (option_debug || rtpdebug)
1583                                 ast_log(LOG_DEBUG, "RTCP Read too short\n");
1584                         return &ast_null_frame;
1585                 }
1586
1587                 if (rtcp_debug_test_addr(&sin)) {
1588                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
1589                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
1590                         ast_verbose("Reception reports: %d\n", rc);
1591                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
1592                 }
1593
1594                 i += 2; /* Advance past header and ssrc */
1595
1596                 switch (pt) {
1597                 case RTCP_PT_SR:
1598                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
1599                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
1600                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
1601                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
1602
1603                         if (rtcp_debug_test_addr(&sin)) {
1604                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
1605                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
1606                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
1607                         }
1608                         i += 5;
1609                         if (rc < 1)
1610                                 break;
1611                         /* Intentional fall through */
1612                 case RTCP_PT_RR:
1613                         /* Don't handle multiple reception reports (rc > 1) yet */
1614                         /* Calculate RTT per RFC */
1615                         gettimeofday(&now, NULL);
1616                         timeval2ntp(now, &msw, &lsw);
1617                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
1618                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
1619                                 lsr = ntohl(rtcpheader[i + 4]);
1620                                 dlsr = ntohl(rtcpheader[i + 5]);
1621                                 rtt = comp - lsr - dlsr;
1622
1623                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
1624                                    sess->ee_delay = (eedelay * 1000) / 65536; */
1625                                 if (rtt < 4294) {
1626                                         rtt = (rtt * 1000000) >> 16;
1627                                 } else {
1628                                         rtt = (rtt * 1000) >> 16;
1629                                         rtt *= 1000;
1630                                 }
1631                                 rtt = rtt / 1000.;
1632                                 rttsec = rtt / 1000.;
1633                                 rtp->rtcp->rtt = rttsec;
1634
1635                                 if (comp - dlsr >= lsr) {
1636                                         rtp->rtcp->accumulated_transit += rttsec;
1637
1638                                         if (rtp->rtcp->rtt_count == 0)
1639                                                 rtp->rtcp->minrtt = rttsec;
1640
1641                                         if (rtp->rtcp->maxrtt<rttsec)
1642                                                 rtp->rtcp->maxrtt = rttsec;
1643                                         if (rtp->rtcp->minrtt>rttsec)
1644                                                 rtp->rtcp->minrtt = rttsec;
1645
1646                                         normdevrtt_current = normdev_compute(rtp->rtcp->normdevrtt, rttsec, rtp->rtcp->rtt_count);
1647
1648                                         rtp->rtcp->stdevrtt = stddev_compute(rtp->rtcp->stdevrtt, rttsec, rtp->rtcp->normdevrtt, normdevrtt_current, rtp->rtcp->rtt_count);
1649
1650                                         rtp->rtcp->normdevrtt = normdevrtt_current;
1651
1652                                         rtp->rtcp->rtt_count++;
1653                                 } else if (rtcp_debug_test_addr(&sin)) {
1654                                         ast_verbose("Internal RTCP NTP clock skew detected: "
1655                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
1656                                                     "diff=%d\n",
1657                                                     lsr, comp, dlsr, dlsr / 65536,
1658                                                     (dlsr % 65536) * 1000 / 65536,
1659                                                     dlsr - (comp - lsr));
1660                                 }
1661                         }
1662
1663                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1664                         reported_jitter = (double) rtp->rtcp->reported_jitter;
1665
1666                         if (rtp->rtcp->reported_jitter_count == 0)
1667                                 rtp->rtcp->reported_minjitter = reported_jitter;
1668
1669                         if (reported_jitter < rtp->rtcp->reported_minjitter)
1670                                 rtp->rtcp->reported_minjitter = reported_jitter;
1671
1672                         if (reported_jitter > rtp->rtcp->reported_maxjitter)
1673                                 rtp->rtcp->reported_maxjitter = reported_jitter;
1674
1675                         reported_normdev_jitter_current = normdev_compute(rtp->rtcp->reported_normdev_jitter, reported_jitter, rtp->rtcp->reported_jitter_count);
1676
1677                         rtp->rtcp->reported_stdev_jitter = stddev_compute(rtp->rtcp->reported_stdev_jitter, reported_jitter, rtp->rtcp->reported_normdev_jitter, reported_normdev_jitter_current, rtp->rtcp->reported_jitter_count);
1678
1679                         rtp->rtcp->reported_normdev_jitter = reported_normdev_jitter_current;
1680
1681                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1682
1683                         reported_lost = (double) rtp->rtcp->reported_lost;
1684
1685                         /* using same counter as for jitter */
1686                         if (rtp->rtcp->reported_jitter_count == 0)
1687                                 rtp->rtcp->reported_minlost = reported_lost;
1688
1689                         if (reported_lost < rtp->rtcp->reported_minlost)
1690                                 rtp->rtcp->reported_minlost = reported_lost;
1691
1692                         if (reported_lost > rtp->rtcp->reported_maxlost)
1693                                 rtp->rtcp->reported_maxlost = reported_lost;
1694                         reported_normdev_lost_current = normdev_compute(rtp->rtcp->reported_normdev_lost, reported_lost, rtp->rtcp->reported_jitter_count);
1695
1696                         rtp->rtcp->reported_stdev_lost = stddev_compute(rtp->rtcp->reported_stdev_lost, reported_lost, rtp->rtcp->reported_normdev_lost, reported_normdev_lost_current, rtp->rtcp->reported_jitter_count);
1697
1698                         rtp->rtcp->reported_normdev_lost = reported_normdev_lost_current;
1699
1700                         rtp->rtcp->reported_jitter_count++;
1701
1702                         if (rtcp_debug_test_addr(&sin)) {
1703                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1704                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1705                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1706                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1707                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1708                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1709                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1710                                 if (rtt)
1711                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
1712                         }
1713                         if (rtt) {
1714                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1715                                                                     "PT: %d(%s)\r\n"
1716                                                                     "ReceptionReports: %d\r\n"
1717                                                                     "SenderSSRC: %u\r\n"
1718                                                                     "FractionLost: %ld\r\n"
1719                                                                     "PacketsLost: %d\r\n"
1720                                                                     "HighestSequence: %ld\r\n"
1721                                                                     "SequenceNumberCycles: %ld\r\n"
1722                                                                     "IAJitter: %u\r\n"
1723                                                                     "LastSR: %lu.%010lu\r\n"
1724                                                                     "DLSR: %4.4f(sec)\r\n"
1725                                               "RTT: %llu(sec)\r\n",
1726                                               ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1727                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1728                                               rc,
1729                                               rtcpheader[i + 1],
1730                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1731                                               rtp->rtcp->reported_lost,
1732                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1733                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1734                                               rtp->rtcp->reported_jitter,
1735                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1736                                               ntohl(rtcpheader[i + 5])/65536.0,
1737                                               (unsigned long long)rtt);
1738                         } else {
1739                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1740                                                                     "PT: %d(%s)\r\n"
1741                                                                     "ReceptionReports: %d\r\n"
1742                                                                     "SenderSSRC: %u\r\n"
1743                                                                     "FractionLost: %ld\r\n"
1744                                                                     "PacketsLost: %d\r\n"
1745                                                                     "HighestSequence: %ld\r\n"
1746                                                                     "SequenceNumberCycles: %ld\r\n"
1747                                                                     "IAJitter: %u\r\n"
1748                                                                     "LastSR: %lu.%010lu\r\n"
1749                                               "DLSR: %4.4f(sec)\r\n",
1750                                               ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1751                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1752                                               rc,
1753                                               rtcpheader[i + 1],
1754                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1755                                               rtp->rtcp->reported_lost,
1756                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1757                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1758                                               rtp->rtcp->reported_jitter,
1759                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
1760                                               ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1761                                               ntohl(rtcpheader[i + 5])/65536.0);
1762                         }
1763                         break;
1764                 case RTCP_PT_FUR:
1765                         if (rtcp_debug_test_addr(&sin))
1766                                 ast_verbose("Received an RTCP Fast Update Request\n");
1767                         rtp->f.frametype = AST_FRAME_CONTROL;
1768                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
1769                         rtp->f.datalen = 0;
1770                         rtp->f.samples = 0;
1771                         rtp->f.mallocd = 0;
1772                         rtp->f.src = "RTP";
1773                         f = &rtp->f;
1774                         break;
1775                 case RTCP_PT_SDES:
1776                         if (rtcp_debug_test_addr(&sin))
1777                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1778                         break;
1779                 case RTCP_PT_BYE:
1780                         if (rtcp_debug_test_addr(&sin))
1781                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1782                         break;
1783                 default:
1784                         ast_debug(1, "Unknown RTCP packet (pt=%d) received from %s:%d\n", pt, ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1785                         break;
1786                 }
1787                 position += (length + 1);
1788         }
1789
1790         rtp->rtcp->rtcp_info = 1;
1791
1792         return f;
1793 }
1794
1795 static int bridge_p2p_rtp_write(struct ast_rtp_instance *instance, unsigned int *rtpheader, int len, int hdrlen)
1796 {
1797         struct ast_rtp_instance *instance1 = ast_rtp_instance_get_bridged(instance);
1798         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance), *bridged = ast_rtp_instance_get_data(instance1);
1799         int res = 0, payload = 0, bridged_payload = 0, mark;
1800         struct ast_rtp_payload_type payload_type;
1801         int reconstruct = ntohl(rtpheader[0]);
1802         struct sockaddr_in remote_address = { 0, };
1803
1804         /* Get fields from packet */
1805         payload = (reconstruct & 0x7f0000) >> 16;
1806         mark = (((reconstruct & 0x800000) >> 23) != 0);
1807
1808         /* Check what the payload value should be */
1809         payload_type = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payload);
1810
1811         /* Otherwise adjust bridged payload to match */
1812         bridged_payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance1), payload_type.asterisk_format, payload_type.code);
1813
1814         /* If the payload coming in is not one of the negotiated ones then send it to the core, this will cause formats to change and the bridge to break */
1815         if (!(ast_rtp_instance_get_codecs(instance1)->payloads[bridged_payload].code)) {
1816                 return -1;
1817         }
1818
1819         /* If the marker bit has been explicitly set turn it on */
1820         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
1821                 mark = 1;
1822                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
1823         }
1824
1825         /* Reconstruct part of the packet */
1826         reconstruct &= 0xFF80FFFF;
1827         reconstruct |= (bridged_payload << 16);
1828         reconstruct |= (mark << 23);
1829         rtpheader[0] = htonl(reconstruct);
1830
1831         ast_rtp_instance_get_remote_address(instance1, &remote_address);
1832
1833         /* Send the packet back out */
1834         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&remote_address, sizeof(remote_address));
1835         if (res < 0) {
1836                 if (!ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_NAT) || (ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_NAT) && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1837                         ast_debug(1, "RTP Transmission error of packet to %s:%d: %s\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), strerror(errno));
1838                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1839                         if (option_debug || rtpdebug)
1840                                 ast_debug(0, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port));
1841                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1842                 }
1843                 return 0;
1844         } else if (rtp_debug_test_addr(&remote_address)) {
1845                 ast_verbose("Sent RTP P2P packet to %s:%u (type %-2.2d, len %-6.6u)\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), bridged_payload, len - hdrlen);
1846         }
1847
1848         return 0;
1849 }
1850
1851 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp)
1852 {
1853         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1854         struct sockaddr_in sin;
1855         socklen_t len = sizeof(sin);
1856         int res, hdrlen = 12, version, payloadtype, padding, mark, ext, cc, prev_seqno;
1857         unsigned int *rtpheader = (unsigned int*)(rtp->rawdata + AST_FRIENDLY_OFFSET), seqno, ssrc, timestamp;
1858         struct ast_rtp_payload_type payload;
1859         struct sockaddr_in remote_address = { 0, };
1860
1861         /* If this is actually RTCP let's hop on over and handle it */
1862         if (rtcp) {
1863                 if (rtp->rtcp) {
1864                         return ast_rtcp_read(instance);
1865                 }
1866                 return &ast_null_frame;
1867         }
1868
1869         /* If we are currently sending DTMF to the remote party send a continuation packet */
1870         if (rtp->sending_digit) {
1871                 ast_rtp_dtmf_continuation(instance);
1872         }
1873
1874         /* Actually read in the data from the socket */
1875         if ((res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr*)&sin, &len)) < 0) {
1876                 ast_assert(errno != EBADF);
1877                 if (errno != EAGAIN) {
1878                         ast_log(LOG_WARNING, "RTP Read error: %s. Hanging up.\n", strerror(errno));
1879                         return NULL;
1880                 }
1881                 return &ast_null_frame;
1882         }
1883
1884         /* Make sure the data that was read in is actually enough to make up an RTP packet */
1885         if (res < hdrlen) {
1886                 ast_log(LOG_WARNING, "RTP Read too short\n");
1887                 return &ast_null_frame;
1888         }
1889
1890         /* If strict RTP protection is enabled see if we need to learn the remote address or if we need to drop the packet */
1891         if (rtp->strict_rtp_state == STRICT_RTP_LEARN) {
1892                 memcpy(&rtp->strict_rtp_address, &sin, sizeof(rtp->strict_rtp_address));
1893                 rtp->strict_rtp_state = STRICT_RTP_CLOSED;
1894         } else if (rtp->strict_rtp_state == STRICT_RTP_CLOSED) {
1895                 if ((rtp->strict_rtp_address.sin_addr.s_addr != sin.sin_addr.s_addr) || (rtp->strict_rtp_address.sin_port != sin.sin_port)) {
1896                         /* Hmm, not the strict addres. Perhaps we're getting audio from the alternate? */
1897                         if ((rtp->alt_rtp_address.sin_addr.s_addr == sin.sin_addr.s_addr) && (rtp->alt_rtp_address.sin_port == sin.sin_port)) {
1898                                 /* ooh, we did! You're now the new expected address, son! */
1899                                 rtp->strict_rtp_address = sin;
1900                         } else  {
1901                                 ast_debug(1, "Received RTP packet from %s:%d, dropping due to strict RTP protection. Expected it to be from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), ast_inet_ntoa(rtp->strict_rtp_address.sin_addr), ntohs(rtp->strict_rtp_address.sin_port));
1902                                 return &ast_null_frame;
1903                         }
1904                 }
1905         }
1906
1907         /* Get fields and verify this is an RTP packet */
1908         seqno = ntohl(rtpheader[0]);
1909
1910         ast_rtp_instance_get_remote_address(instance, &remote_address);
1911
1912         if (!(version = (seqno & 0xC0000000) >> 30)) {
1913                 if ((ast_stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == AST_STUN_ACCEPT) &&
1914                     (!remote_address.sin_port && !remote_address.sin_addr.s_addr)) {
1915                         ast_rtp_instance_set_remote_address(instance, &sin);
1916                 }
1917                 return &ast_null_frame;
1918         }
1919
1920         /* If symmetric RTP is enabled see if the remote side is not what we expected and change where we are sending audio */
1921         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
1922                 if ((remote_address.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1923                     (remote_address.sin_port != sin.sin_port)) {
1924                         ast_rtp_instance_set_remote_address(instance, &sin);
1925                         memcpy(&remote_address, &sin, sizeof(remote_address));
1926                         if (rtp->rtcp) {
1927                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1928                                 rtp->rtcp->them.sin_port = htons(ntohs(sin.sin_port)+1);
1929                         }
1930                         rtp->rxseqno = 0;
1931                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1932                         if (option_debug || rtpdebug)
1933                                 ast_debug(0, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port));
1934                 }
1935         }
1936
1937         /* If we are directly bridged to another instance send the audio directly out */
1938         if (ast_rtp_instance_get_bridged(instance) && !bridge_p2p_rtp_write(instance, rtpheader, res, hdrlen)) {
1939                 return &ast_null_frame;
1940         }
1941
1942         /* If the version is not what we expected by this point then just drop the packet */
1943         if (version != 2) {
1944                 return &ast_null_frame;
1945         }
1946
1947         /* Pull out the various other fields we will need */
1948         payloadtype = (seqno & 0x7f0000) >> 16;
1949         padding = seqno & (1 << 29);
1950         mark = seqno & (1 << 23);
1951         ext = seqno & (1 << 28);
1952         cc = (seqno & 0xF000000) >> 24;
1953         seqno &= 0xffff;
1954         timestamp = ntohl(rtpheader[1]);
1955         ssrc = ntohl(rtpheader[2]);
1956
1957         /* Force a marker bit if the SSRC changes */
1958         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1959                 if (option_debug || rtpdebug) {
1960                         ast_debug(1, "Forcing Marker bit, because SSRC has changed\n");
1961                 }
1962                 mark = 1;
1963         }
1964
1965         /* Remove any padding bytes that may be present */
1966         if (padding) {
1967                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1968         }
1969
1970         /* Skip over any CSRC fields */
1971         if (cc) {
1972                 hdrlen += cc * 4;
1973         }
1974
1975         /* Look for any RTP extensions, currently we do not support any */
1976         if (ext) {
1977                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
1978                 hdrlen += 4;
1979                 if (option_debug) {
1980                         int profile;
1981                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1982                         if (profile == 0x505a)
1983                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1984                         else
1985                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
1986                 }
1987         }
1988
1989         /* Make sure after we potentially mucked with the header length that it is once again valid */
1990         if (res < hdrlen) {
1991                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d\n", res, hdrlen);
1992                 return &ast_null_frame;
1993         }
1994
1995         rtp->rxcount++;
1996         if (rtp->rxcount == 1) {
1997                 rtp->seedrxseqno = seqno;
1998         }
1999
2000         /* Do not schedule RR if RTCP isn't run */
2001         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
2002                 /* Schedule transmission of Receiver Report */
2003                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2004         }
2005         if ((int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
2006                 rtp->cycles += RTP_SEQ_MOD;
2007
2008         prev_seqno = rtp->lastrxseqno;
2009         rtp->lastrxseqno = seqno;
2010
2011         if (!rtp->themssrc) {
2012                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
2013         }
2014
2015         if (rtp_debug_test_addr(&sin)) {
2016                 ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2017                             ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
2018         }
2019
2020         payload = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payloadtype);
2021
2022         /* If the payload is not actually an Asterisk one but a special one pass it off to the respective handler */
2023         if (!payload.asterisk_format) {
2024                 struct ast_frame *f = NULL;
2025                 if (payload.code == AST_RTP_DTMF) {
2026                         f = process_dtmf_rfc2833(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2027                 } else if (payload.code == AST_RTP_CISCO_DTMF) {
2028                         f = process_dtmf_cisco(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2029                 } else if (payload.code == AST_RTP_CN) {
2030                         f = process_cn_rfc3389(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2031                 } else {
2032                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(remote_address.sin_addr));
2033                 }
2034
2035                 return f ? f : &ast_null_frame;
2036         }
2037
2038         rtp->lastrxformat = rtp->f.subclass = payload.code;
2039         rtp->f.frametype = (rtp->f.subclass & AST_FORMAT_AUDIO_MASK) ? AST_FRAME_VOICE : (rtp->f.subclass & AST_FORMAT_VIDEO_MASK) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
2040
2041         rtp->rxseqno = seqno;
2042
2043         if (rtp->dtmf_timeout && rtp->dtmf_timeout < timestamp) {
2044                 rtp->dtmf_timeout = 0;
2045
2046                 if (rtp->resp) {
2047                         struct ast_frame *f;
2048                         f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
2049                         f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass)), ast_tv(0, 0));
2050                         rtp->resp = 0;
2051                         rtp->dtmf_timeout = rtp->dtmf_duration = 0;
2052                         return f;
2053                 }
2054         }
2055
2056         rtp->lastrxts = timestamp;
2057
2058         rtp->f.src = "RTP";
2059         rtp->f.mallocd = 0;
2060         rtp->f.datalen = res - hdrlen;
2061         rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
2062         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
2063         rtp->f.seqno = seqno;
2064
2065         if (rtp->f.subclass == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
2066                 unsigned char *data = rtp->f.data.ptr;
2067
2068                 memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
2069                 rtp->f.datalen +=3;
2070                 *data++ = 0xEF;
2071                 *data++ = 0xBF;
2072                 *data = 0xBD;
2073         }
2074
2075         if (rtp->f.subclass == AST_FORMAT_T140RED) {
2076                 unsigned char *data = rtp->f.data.ptr;
2077                 unsigned char *header_end;
2078                 int num_generations;
2079                 int header_length;
2080                 int len;
2081                 int diff =(int)seqno - (prev_seqno+1); /* if diff = 0, no drop*/
2082                 int x;
2083
2084                 rtp->f.subclass = AST_FORMAT_T140;
2085                 header_end = memchr(data, ((*data) & 0x7f), rtp->f.datalen);
2086                 if (header_end == NULL) {
2087                         return &ast_null_frame;
2088                 }
2089                 header_end++;
2090
2091                 header_length = header_end - data;
2092                 num_generations = header_length / 4;
2093                 len = header_length;
2094
2095                 if (!diff) {
2096                         for (x = 0; x < num_generations; x++)
2097                                 len += data[x * 4 + 3];
2098
2099                         if (!(rtp->f.datalen - len))
2100                                 return &ast_null_frame;
2101
2102                         rtp->f.data.ptr += len;
2103                         rtp->f.datalen -= len;
2104                 } else if (diff > num_generations && diff < 10) {
2105                         len -= 3;
2106                         rtp->f.data.ptr += len;
2107                         rtp->f.datalen -= len;
2108
2109                         data = rtp->f.data.ptr;
2110                         *data++ = 0xEF;
2111                         *data++ = 0xBF;
2112                         *data = 0xBD;
2113                 } else {
2114                         for ( x = 0; x < num_generations - diff; x++)
2115                                 len += data[x * 4 + 3];
2116
2117                         rtp->f.data.ptr += len;
2118                         rtp->f.datalen -= len;
2119                 }
2120         }
2121
2122         if (rtp->f.subclass & AST_FORMAT_AUDIO_MASK) {
2123                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
2124                 if (rtp->f.subclass == AST_FORMAT_SLINEAR)
2125                         ast_frame_byteswap_be(&rtp->f);
2126                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
2127                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
2128                 ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
2129                 rtp->f.ts = timestamp / (rtp_get_rate(rtp->f.subclass) / 1000);
2130                 rtp->f.len = rtp->f.samples / ((ast_format_rate(rtp->f.subclass) / 1000));
2131         } else if (rtp->f.subclass & AST_FORMAT_VIDEO_MASK) {
2132                 /* Video -- samples is # of samples vs. 90000 */
2133                 if (!rtp->lastividtimestamp)
2134                         rtp->lastividtimestamp = timestamp;
2135                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
2136                 rtp->lastividtimestamp = timestamp;
2137                 rtp->f.delivery.tv_sec = 0;
2138                 rtp->f.delivery.tv_usec = 0;
2139                 /* Pass the RTP marker bit as bit 0 in the subclass field.
2140                  * This is ok because subclass is actually a bitmask, and
2141                  * the low bits represent audio formats, that are not
2142                  * involved here since we deal with video.
2143                  */
2144                 if (mark)
2145                         rtp->f.subclass |= 0x1;
2146         } else {
2147                 /* TEXT -- samples is # of samples vs. 1000 */
2148                 if (!rtp->lastitexttimestamp)
2149                         rtp->lastitexttimestamp = timestamp;
2150                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
2151                 rtp->lastitexttimestamp = timestamp;
2152                 rtp->f.delivery.tv_sec = 0;
2153                 rtp->f.delivery.tv_usec = 0;
2154         }
2155
2156         return &rtp->f;
2157 }
2158
2159 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
2160 {
2161         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2162
2163         if (property == AST_RTP_PROPERTY_RTCP) {
2164                 if (rtp->rtcp) {
2165                         ast_debug(1, "Ignoring duplicate RTCP property on RTP instance '%p'\n", instance);
2166                         return;
2167                 }
2168                 if (!(rtp->rtcp = ast_calloc(1, sizeof(*rtp->rtcp)))) {
2169                         return;
2170                 }
2171                 if ((rtp->rtcp->s = create_new_socket("RTCP")) < 0) {
2172                         ast_debug(1, "Failed to create a new socket for RTCP on instance '%p'\n", instance);
2173                         ast_free(rtp->rtcp);
2174                         rtp->rtcp = NULL;
2175                         return;
2176                 }
2177
2178                 /* Grab the IP address and port we are going to use */
2179                 ast_rtp_instance_get_local_address(instance, &rtp->rtcp->us);
2180                 rtp->rtcp->us.sin_port = htons(ntohs(rtp->rtcp->us.sin_port) + 1);
2181
2182                 /* Try to actually bind to the IP address and port we are going to use for RTCP, if this fails we have to bail out */
2183                 if (bind(rtp->rtcp->s, (struct sockaddr*)&rtp->rtcp->us, sizeof(rtp->rtcp->us))) {
2184                         ast_debug(1, "Failed to setup RTCP on RTP instance '%p'\n", instance);
2185                         close(rtp->rtcp->s);
2186                         ast_free(rtp->rtcp);
2187                         rtp->rtcp = NULL;
2188                         return;
2189                 }
2190
2191                 ast_debug(1, "Setup RTCP on RTP instance '%p'\n", instance);
2192                 rtp->rtcp->schedid = -1;
2193
2194                 return;
2195         }
2196
2197         return;
2198 }
2199
2200 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp)
2201 {
2202         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2203
2204         return rtcp ? (rtp->rtcp ? rtp->rtcp->s : -1) : rtp->s;
2205 }
2206
2207 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin)
2208 {
2209         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2210
2211         if (rtp->rtcp) {
2212                 ast_debug(1, "Setting RTCP address on RTP instance '%p'\n", instance);
2213                 memcpy(&rtp->rtcp->them, sin, sizeof(rtp->rtcp->them));
2214                 rtp->rtcp->them.sin_port = htons(ntohs(sin->sin_port) + 1);
2215         }
2216
2217         rtp->rxseqno = 0;
2218
2219         if (strictrtp) {
2220                 rtp->strict_rtp_state = STRICT_RTP_LEARN;
2221         }
2222
2223         return;
2224 }
2225
2226 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin)
2227 {
2228         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2229
2230         /* No need to futz with rtp->rtcp here because ast_rtcp_read is already able to adjust if receiving
2231          * RTCP from an "unexpected" source
2232          */
2233         rtp->alt_rtp_address = *sin;
2234
2235         return;
2236 }
2237
2238 /*! \brief Write t140 redundacy frame
2239  * \param data primary data to be buffered
2240  */
2241 static int red_write(const void *data)
2242 {
2243         struct ast_rtp_instance *instance = (struct ast_rtp_instance*) data;
2244         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2245
2246         ast_rtp_write(instance, &rtp->red->t140);
2247
2248         return 1;
2249 }
2250
2251 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
2252 {
2253         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2254         int x;
2255
2256         if (!(rtp->red = ast_calloc(1, sizeof(*rtp->red)))) {
2257                 return -1;
2258         }
2259
2260         rtp->red->t140.frametype = AST_FRAME_TEXT;
2261         rtp->red->t140.subclass = AST_FORMAT_T140RED;
2262         rtp->red->t140.data.ptr = &rtp->red->buf_data;
2263
2264         rtp->red->t140.ts = 0;
2265         rtp->red->t140red = rtp->red->t140;
2266         rtp->red->t140red.data.ptr = &rtp->red->t140red_data;
2267         rtp->red->t140red.datalen = 0;
2268         rtp->red->ti = buffer_time;
2269         rtp->red->num_gen = generations;
2270         rtp->red->hdrlen = generations * 4 + 1;
2271         rtp->red->prev_ts = 0;
2272
2273         for (x = 0; x < generations; x++) {
2274                 rtp->red->pt[x] = payloads[x];
2275                 rtp->red->pt[x] |= 1 << 7; /* mark redundant generations pt */
2276                 rtp->red->t140red_data[x*4] = rtp->red->pt[x];
2277         }
2278         rtp->red->t140red_data[x*4] = rtp->red->pt[x] = payloads[x]; /* primary pt */
2279         rtp->red->schedid = ast_sched_add(rtp->sched, generations, red_write, instance);
2280
2281         rtp->red->t140.datalen = 0;
2282
2283         return 0;
2284 }
2285
2286 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
2287 {
2288         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2289
2290         if (frame->datalen > -1) {
2291                 struct rtp_red *red = rtp->red;
2292                 memcpy(&red->buf_data[red->t140.datalen], frame->data.ptr, frame->datalen);
2293                 red->t140.datalen += frame->datalen;
2294                 red->t140.ts = frame->ts;
2295         }
2296
2297         return 0;
2298 }
2299
2300 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1)
2301 {
2302         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance0);
2303
2304         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2305
2306         return 0;
2307 }
2308
2309 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
2310 {
2311         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2312
2313         if (!rtp->rtcp) {
2314                 return -1;
2315         }
2316
2317         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXCOUNT, -1, stats->txcount, rtp->txcount);
2318         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXCOUNT, -1, stats->rxcount, rtp->rxcount);
2319
2320         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->txploss, rtp->rtcp->reported_lost);
2321         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->rxploss, rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2322         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_maxrxploss, rtp->rtcp->reported_maxlost);
2323         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_minrxploss, rtp->rtcp->reported_minlost);
2324         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_normdevrxploss, rtp->rtcp->reported_normdev_lost);
2325         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_stdevrxploss, rtp->rtcp->reported_stdev_lost);
2326         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_maxrxploss, rtp->rtcp->maxrxlost);
2327         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_minrxploss, rtp->rtcp->minrxlost);
2328         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_normdevrxploss, rtp->rtcp->normdev_rxlost);
2329         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_stdevrxploss, rtp->rtcp->stdev_rxlost);
2330         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_LOSS);
2331
2332         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->txjitter, rtp->rxjitter);
2333         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->rxjitter, rtp->rtcp->reported_jitter / (unsigned int) 65536.0);
2334         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_maxjitter, rtp->rtcp->reported_maxjitter);
2335         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_minjitter, rtp->rtcp->reported_minjitter);
2336         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_normdevjitter, rtp->rtcp->reported_normdev_jitter);
2337         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_stdevjitter, rtp->rtcp->reported_stdev_jitter);
2338         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_maxjitter, rtp->rtcp->maxrxjitter);
2339         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_minjitter, rtp->rtcp->minrxjitter);
2340         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_normdevjitter, rtp->rtcp->normdev_rxjitter);
2341         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_stdevjitter, rtp->rtcp->stdev_rxjitter);
2342         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_JITTER);
2343
2344         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->rtt, rtp->rtcp->rtt);
2345         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MAX_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->maxrtt, rtp->rtcp->maxrtt);
2346         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MIN_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->minrtt, rtp->rtcp->minrtt);
2347         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_NORMDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->normdevrtt, rtp->rtcp->normdevrtt);
2348         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_STDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->stdevrtt, rtp->rtcp->stdevrtt);
2349         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_RTT);
2350
2351         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_SSRC, -1, stats->local_ssrc, rtp->ssrc);
2352         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_SSRC, -1, stats->remote_ssrc, rtp->themssrc);
2353
2354         return 0;
2355 }
2356
2357 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1)
2358 {
2359         /* If both sides are not using the same method of DTMF transmission
2360          * (ie: one is RFC2833, other is INFO... then we can not do direct media.
2361          * --------------------------------------------------
2362          * | DTMF Mode |  HAS_DTMF  |  Accepts Begin Frames |
2363          * |-----------|------------|-----------------------|
2364          * | Inband    | False      | True                  |
2365          * | RFC2833   | True       | True                  |
2366          * | SIP INFO  | False      | False                 |
2367          * --------------------------------------------------
2368          */
2369         return (((ast_rtp_instance_get_prop(instance0, AST_RTP_PROPERTY_DTMF) != ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_DTMF)) ||
2370                  (!chan0->tech->send_digit_begin != !chan1->tech->send_digit_begin)) ? 0 : 1);
2371 }
2372
2373 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct sockaddr_in *suggestion, const char *username)
2374 {
2375         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2376
2377         ast_stun_request(rtp->s, suggestion, username, NULL);
2378 }
2379
2380 static void ast_rtp_stop(struct ast_rtp_instance *instance)
2381 {
2382         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2383         struct sockaddr_in sin = { 0, };
2384
2385         if (rtp->rtcp) {
2386                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2387         }
2388         if (rtp->red) {
2389                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
2390                 free(rtp->red);
2391                 rtp->red = NULL;
2392         }
2393
2394         ast_rtp_instance_set_remote_address(instance, &sin);
2395         if (rtp->rtcp) {
2396                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2397                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2398         }
2399
2400         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2401 }
2402
2403 static char *rtp_do_debug_ip(struct ast_cli_args *a)
2404 {
2405         struct hostent *hp;
2406         struct ast_hostent ahp;
2407         int port = 0;
2408         char *p, *arg = ast_strdupa(a->argv[4]);
2409
2410         p = strstr(arg, ":");
2411         if (p) {
2412                 *p = '\0';
2413                 p++;
2414                 port = atoi(p);
2415         }
2416         hp = ast_gethostbyname(arg, &ahp);
2417         if (hp == NULL) {
2418                 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
2419                 return CLI_FAILURE;
2420         }
2421         rtpdebugaddr.sin_family = AF_INET;
2422         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
2423         rtpdebugaddr.sin_port = htons(port);
2424         if (port == 0)
2425                 ast_cli(a->fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
2426         else
2427                 ast_cli(a->fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
2428         rtpdebug = 1;
2429         return CLI_SUCCESS;
2430 }
2431
2432 static char *rtcp_do_debug_ip(struct ast_cli_args *a)
2433 {
2434         struct hostent *hp;
2435         struct ast_hostent ahp;
2436         int port = 0;
2437         char *p, *arg = ast_strdupa(a->argv[3]);
2438
2439         p = strstr(arg, ":");
2440         if (p) {
2441                 *p = '\0';
2442                 p++;
2443                 port = atoi(p);
2444         }
2445         hp = ast_gethostbyname(arg, &ahp);
2446         if (hp == NULL) {
2447                 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
2448                 return CLI_FAILURE;
2449         }
2450         rtcpdebugaddr.sin_family = AF_INET;
2451         memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
2452         rtcpdebugaddr.sin_port = htons(port);
2453         if (port == 0)
2454                 ast_cli(a->fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
2455         else
2456                 ast_cli(a->fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
2457         rtcpdebug = 1;
2458         return CLI_SUCCESS;
2459 }
2460
2461 static char *handle_cli_rtp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2462 {
2463         switch (cmd) {
2464         case CLI_INIT:
2465                 e->command = "rtp set debug {on|off|ip}";
2466                 e->usage =
2467                         "Usage: rtp set debug {on|off|ip host[:port]}\n"
2468                         "       Enable/Disable dumping of all RTP packets. If 'ip' is\n"
2469                         "       specified, limit the dumped packets to those to and from\n"
2470                         "       the specified 'host' with optional port.\n";
2471                 return NULL;
2472         case CLI_GENERATE:
2473                 return NULL;
2474         }
2475
2476         if (a->argc == e->args) { /* set on or off */
2477                 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
2478                         rtpdebug = 1;
2479                         memset(&rtpdebugaddr, 0, sizeof(rtpdebugaddr));
2480                         ast_cli(a->fd, "RTP Debugging Enabled\n");
2481                         return CLI_SUCCESS;
2482                 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
2483                         rtpdebug = 0;
2484                         ast_cli(a->fd, "RTP Debugging Disabled\n");
2485                         return CLI_SUCCESS;
2486                 }
2487         } else if (a->argc == e->args +1) { /* ip */
2488                 return rtp_do_debug_ip(a);
2489         }
2490
2491         return CLI_SHOWUSAGE;   /* default, failure */
2492 }
2493
2494 static char *handle_cli_rtcp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2495 {
2496         switch (cmd) {
2497         case CLI_INIT:
2498                 e->command = "rtcp set debug {on|off|ip}";
2499                 e->usage =
2500                         "Usage: rtcp set debug {on|off|ip host[:port]}\n"
2501                         "       Enable/Disable dumping of all RTCP packets. If 'ip' is\n"
2502                         "       specified, limit the dumped packets to those to and from\n"
2503                         "       the specified 'host' with optional port.\n";
2504                 return NULL;
2505         case CLI_GENERATE:
2506                 return NULL;
2507         }
2508
2509         if (a->argc == e->args) { /* set on or off */
2510                 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
2511                         rtcpdebug = 1;
2512                         memset(&rtcpdebugaddr, 0, sizeof(rtcpdebugaddr));
2513                         ast_cli(a->fd, "RTCP Debugging Enabled\n");
2514                         return CLI_SUCCESS;
2515                 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
2516                         rtcpdebug = 0;
2517                         ast_cli(a->fd, "RTCP Debugging Disabled\n");
2518                         return CLI_SUCCESS;
2519                 }
2520         } else if (a->argc == e->args +1) { /* ip */
2521                 return rtcp_do_debug_ip(a);
2522         }
2523
2524         return CLI_SHOWUSAGE;   /* default, failure */
2525 }
2526
2527 static char *handle_cli_rtcp_set_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2528 {
2529         switch (cmd) {
2530         case CLI_INIT:
2531                 e->command = "rtcp set stats {on|off}";
2532                 e->usage =
2533                         "Usage: rtcp set stats {on|off}\n"
2534                         "       Enable/Disable dumping of RTCP stats.\n";
2535                 return NULL;
2536         case CLI_GENERATE:
2537                 return NULL;
2538         }
2539
2540         if (a->argc != e->args)
2541                 return CLI_SHOWUSAGE;
2542
2543         if (!strncasecmp(a->argv[e->args-1], "on", 2))
2544                 rtcpstats = 1;
2545         else if (!strncasecmp(a->argv[e->args-1], "off", 3))
2546                 rtcpstats = 0;
2547         else
2548                 return CLI_SHOWUSAGE;
2549
2550         ast_cli(a->fd, "RTCP Stats %s\n", rtcpstats ? "Enabled" : "Disabled");
2551         return CLI_SUCCESS;
2552 }
2553
2554 static struct ast_cli_entry cli_rtp[] = {
2555         AST_CLI_DEFINE(handle_cli_rtp_set_debug,  "Enable/Disable RTP debugging"),
2556         AST_CLI_DEFINE(handle_cli_rtcp_set_debug, "Enable/Disable RTCP debugging"),
2557         AST_CLI_DEFINE(handle_cli_rtcp_set_stats, "Enable/Disable RTCP stats"),
2558 };
2559
2560 static int rtp_reload(int reload)
2561 {
2562         struct ast_config *cfg;
2563         const char *s;
2564         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
2565
2566         cfg = ast_config_load2("rtp.conf", "rtp", config_flags);
2567         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
2568                 return 0;
2569         }
2570
2571         rtpstart = DEFAULT_RTP_START;
2572         rtpend = DEFAULT_RTP_END;
2573         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2574         strictrtp = STRICT_RTP_OPEN;
2575         if (cfg) {
2576                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
2577                         rtpstart = atoi(s);
2578                         if (rtpstart < MINIMUM_RTP_PORT)
2579                                 rtpstart = MINIMUM_RTP_PORT;
2580                         if (rtpstart > MAXIMUM_RTP_PORT)
2581                                 rtpstart = MAXIMUM_RTP_PORT;
2582                 }
2583                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
2584                         rtpend = atoi(s);
2585                         if (rtpend < MINIMUM_RTP_PORT)
2586                                 rtpend = MINIMUM_RTP_PORT;
2587                         if (rtpend > MAXIMUM_RTP_PORT)
2588                                 rtpend = MAXIMUM_RTP_PORT;
2589                 }
2590                 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
2591                         rtcpinterval = atoi(s);
2592                         if (rtcpinterval == 0)
2593                                 rtcpinterval = 0; /* Just so we're clear... it's zero */
2594                         if (rtcpinterval < RTCP_MIN_INTERVALMS)
2595                                 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
2596                         if (rtcpinterval > RTCP_MAX_INTERVALMS)
2597                                 rtcpinterval = RTCP_MAX_INTERVALMS;
2598                 }
2599                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
2600 #ifdef SO_NO_CHECK
2601                         nochecksums = ast_false(s) ? 1 : 0;
2602 #else
2603                         if (ast_false(s))
2604                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
2605 #endif
2606                 }
2607                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
2608                         dtmftimeout = atoi(s);
2609                         if ((dtmftimeout < 0) || (dtmftimeout > 64000)) {
2610                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
2611                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
2612                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2613                         };
2614                 }
2615                 if ((s = ast_variable_retrieve(cfg, "general", "strictrtp"))) {
2616                         strictrtp = ast_true(s);
2617                 }
2618                 ast_config_destroy(cfg);
2619         }
2620         if (rtpstart >= rtpend) {
2621                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
2622                 rtpstart = DEFAULT_RTP_START;
2623                 rtpend = DEFAULT_RTP_END;
2624         }
2625         ast_verb(2, "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
2626         return 0;
2627 }
2628
2629 static int reload_module(void)
2630 {
2631         rtp_reload(1);
2632         return 0;
2633 }
2634
2635 static int load_module(void)
2636 {
2637         if (ast_rtp_engine_register(&asterisk_rtp_engine)) {
2638                 return AST_MODULE_LOAD_DECLINE;
2639         }
2640
2641         if (ast_cli_register_multiple(cli_rtp, ARRAY_LEN(cli_rtp))) {
2642                 ast_rtp_engine_unregister(&asterisk_rtp_engine);
2643                 return AST_MODULE_LOAD_DECLINE;
2644         }
2645
2646         rtp_reload(0);
2647
2648         return AST_MODULE_LOAD_SUCCESS;
2649 }
2650
2651 static int unload_module(void)
2652 {
2653         ast_rtp_engine_unregister(&asterisk_rtp_engine);
2654         ast_cli_unregister_multiple(cli_rtp, ARRAY_LEN(cli_rtp));
2655
2656         return 0;
2657 }
2658
2659 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Asterisk RTP Stack",
2660                 .load = load_module,
2661                 .unload = unload_module,
2662                 .reload = reload_module,
2663                 );