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