3e24e25bb904d046a7d216493ac4a610b44a3f5b
[asterisk/asterisk.git] / main / rtp.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! 
20  * \file 
21  *
22  * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
23  *
24  * \author Mark Spencer <markster@digium.com>
25  * 
26  * \note RTP is defined in RFC 3550.
27  */
28
29 #include "asterisk.h"
30
31 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
32
33 #include <sys/time.h>
34 #include <signal.h>
35 #include <fcntl.h>
36 #include <math.h> 
37
38 #include "asterisk/rtp.h"
39 #include "asterisk/pbx.h"
40 #include "asterisk/frame.h"
41 #include "asterisk/channel.h"
42 #include "asterisk/acl.h"
43 #include "asterisk/config.h"
44 #include "asterisk/lock.h"
45 #include "asterisk/utils.h"
46 #include "asterisk/netsock.h"
47 #include "asterisk/cli.h"
48 #include "asterisk/manager.h"
49 #include "asterisk/unaligned.h"
50
51 #define MAX_TIMESTAMP_SKEW      640
52
53 #define RTP_SEQ_MOD     (1<<16)         /*!< A sequence number can't be more than 16 bits */
54 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
55 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
56 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
57
58 #define RTCP_PT_FUR     192
59 #define RTCP_PT_SR      200
60 #define RTCP_PT_RR      201
61 #define RTCP_PT_SDES    202
62 #define RTCP_PT_BYE     203
63 #define RTCP_PT_APP     204
64
65 #define RTP_MTU         1200
66
67 #define DEFAULT_DTMF_TIMEOUT 3000       /*!< samples */
68
69 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
70
71 static int rtpstart = 5000;     /*!< First port for RTP sessions (set in rtp.conf) */
72 static int rtpend = 31000;      /*!< Last port for RTP sessions (set in rtp.conf) */
73 static int rtpdebug;                    /*!< Are we debugging? */
74 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
75 static int rtcpstats;                   /*!< Are we debugging RTCP? */
76 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
77 static int stundebug;                   /*!< Are we debugging stun? */
78 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
79 static struct sockaddr_in rtcpdebugaddr;        /*!< Debug RTCP packets to/from this host */
80 #ifdef SO_NO_CHECK
81 static int nochecksums;
82 #endif
83 static int strictrtp;
84
85 enum strict_rtp_state {
86         STRICT_RTP_OPEN = 0, /*! No RTP packets should be dropped, all sources accepted */
87         STRICT_RTP_LEARN,    /*! Accept next packet as source */
88         STRICT_RTP_CLOSED,   /*! Drop all RTP packets not coming from source that was learned */
89 };
90
91 /* Uncomment this to enable more intense native bridging, but note: this is currently buggy */
92 /* #define P2P_INTENSE */
93
94 /*!
95  * \brief Structure representing a RTP session.
96  *
97  * RTP session is defined on page 9 of RFC 3550: "An association among a set of participants communicating with RTP.  A participant may be involved in multiple RTP sessions at the same time [...]"
98  *
99  */
100
101 /*! \brief RTP session description */
102 struct ast_rtp {
103         int s;
104         struct ast_frame f;
105         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
106         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
107         unsigned int themssrc;          /*!< Their SSRC */
108         unsigned int rxssrc;
109         unsigned int lastts;
110         unsigned int lastrxts;
111         unsigned int lastividtimestamp;
112         unsigned int lastovidtimestamp;
113         unsigned int lastitexttimestamp;
114         unsigned int lastotexttimestamp;
115         unsigned int lasteventseqn;
116         int lastrxseqno;                /*!< Last received sequence number */
117         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
118         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
119         unsigned int rxcount;           /*!< How many packets have we received? */
120         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
121         unsigned int txcount;           /*!< How many packets have we sent? */
122         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
123         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
124         double rxjitter;                /*!< Interarrival jitter at the moment */
125         double rxtransit;               /*!< Relative transit time for previous packet */
126         int lasttxformat;
127         int lastrxformat;
128
129         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
130         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
131         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
132
133         /* DTMF Reception Variables */
134         char resp;
135         unsigned int lastevent;
136         int dtmfcount;
137         unsigned int dtmfsamples;
138         /* DTMF Transmission Variables */
139         unsigned int lastdigitts;
140         char sending_digit;     /*!< boolean - are we sending digits */
141         char send_digit;        /*!< digit we are sending */
142         int send_payload;
143         int send_duration;
144         int nat;
145         unsigned int flags;
146         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
147         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
148         struct timeval rxcore;
149         struct timeval txcore;
150         double drxcore;                 /*!< The double representation of the first received packet */
151         struct timeval lastrx;          /*!< timeval when we last received a packet */
152         struct timeval dtmfmute;
153         struct ast_smoother *smoother;
154         int *ioid;
155         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
156         unsigned short rxseqno;
157         struct sched_context *sched;
158         struct io_context *io;
159         void *data;
160         ast_rtp_callback callback;
161 #ifdef P2P_INTENSE
162         ast_mutex_t bridge_lock;
163 #endif
164         struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
165         int rtp_lookup_code_cache_isAstFormat; /*!< a cache for the result of rtp_lookup_code(): */
166         int rtp_lookup_code_cache_code;
167         int rtp_lookup_code_cache_result;
168         struct ast_rtcp *rtcp;
169         struct ast_codec_pref pref;
170         struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
171
172         enum strict_rtp_state strict_rtp_state; /*!< Current state that strict RTP protection is in */
173         struct sockaddr_in strict_rtp_address;  /*!< Remote address information for strict RTP purposes */
174
175         int set_marker_bit:1;           /*!< Whether to set the marker bit or not */
176         struct rtp_red *red;
177 };
178
179 static struct ast_frame *red_t140_to_red(struct rtp_red *red);
180 static int red_write(const void *data);
181  
182 struct rtp_red {
183         struct ast_frame t140;  /*!< Primary data  */
184         struct ast_frame t140red;   /*!< Redundant t140*/
185         unsigned char pt[RED_MAX_GENERATION];  /*!< Payload types for redundancy data */
186         unsigned char ts[RED_MAX_GENERATION]; /*!< Time stamps */
187         unsigned char len[RED_MAX_GENERATION]; /*!< length of each generation */
188         int num_gen; /*!< Number of generations */
189         int schedid; /*!< Timer id */
190         int ti; /*!< How long to buffer data before send */
191         unsigned char t140red_data[64000];  
192         unsigned char buf_data[64000]; /*!< buffered primary data */
193         int hdrlen; 
194         long int prev_ts;
195 };
196
197 /* Forward declarations */
198 static int ast_rtcp_write(const void *data);
199 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw);
200 static int ast_rtcp_write_sr(const void *data);
201 static int ast_rtcp_write_rr(const void *data);
202 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp);
203 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp);
204 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit);
205
206 #define FLAG_3389_WARNING               (1 << 0)
207 #define FLAG_NAT_ACTIVE                 (3 << 1)
208 #define FLAG_NAT_INACTIVE               (0 << 1)
209 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
210 #define FLAG_HAS_DTMF                   (1 << 3)
211 #define FLAG_P2P_SENT_MARK              (1 << 4)
212 #define FLAG_P2P_NEED_DTMF              (1 << 5)
213 #define FLAG_CALLBACK_MODE              (1 << 6)
214 #define FLAG_DTMF_COMPENSATE            (1 << 7)
215 #define FLAG_HAS_STUN                   (1 << 8)
216
217 /*!
218  * \brief Structure defining an RTCP session.
219  * 
220  * The concept "RTCP session" is not defined in RFC 3550, but since 
221  * this structure is analogous to ast_rtp, which tracks a RTP session, 
222  * it is logical to think of this as a RTCP session.
223  *
224  * RTCP packet is defined on page 9 of RFC 3550.
225  * 
226  */
227 struct ast_rtcp {
228         int rtcp_info;
229         int s;                          /*!< Socket */
230         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
231         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
232         unsigned int soc;               /*!< What they told us */
233         unsigned int spc;               /*!< What they told us */
234         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
235         struct timeval rxlsr;           /*!< Time when we got their last SR */
236         struct timeval txlsr;           /*!< Time when we sent or last SR*/
237         unsigned int expected_prior;    /*!< no. packets in previous interval */
238         unsigned int received_prior;    /*!< no. packets received in previous interval */
239         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
240         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
241         unsigned int sr_count;          /*!< number of SRs we've sent */
242         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
243         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
244         double rtt;                     /*!< Last reported rtt */
245         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
246         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
247         char quality[AST_MAX_USER_FIELD];
248         char quality_jitter[AST_MAX_USER_FIELD];
249         char quality_loss[AST_MAX_USER_FIELD];
250         char quality_rtt[AST_MAX_USER_FIELD];
251
252         double reported_maxjitter;
253         double reported_minjitter;
254         double reported_normdev_jitter;
255         double reported_stdev_jitter;
256         unsigned int reported_jitter_count;
257
258         double reported_maxlost;
259         double reported_minlost;
260         double reported_normdev_lost;
261         double reported_stdev_lost;
262
263         double rxlost;
264         double maxrxlost;
265         double minrxlost;
266         double normdev_rxlost;
267         double stdev_rxlost;
268         unsigned int rxlost_count;
269
270         double maxrxjitter;
271         double minrxjitter;
272         double normdev_rxjitter;
273         double stdev_rxjitter;
274         unsigned int rxjitter_count;
275         double maxrtt;
276         double minrtt;
277         double normdevrtt;
278         double stdevrtt;
279         unsigned int rtt_count;
280         int sendfur;
281 };
282
283 /*!
284  * \brief STUN support code
285  *
286  * This code provides some support for doing STUN transactions.
287  * Eventually it should be moved elsewhere as other protocols
288  * than RTP can benefit from it - e.g. SIP.
289  * STUN is described in RFC3489 and it is based on the exchange
290  * of UDP packets between a client and one or more servers to
291  * determine the externally visible address (and port) of the client
292  * once it has gone through the NAT boxes that connect it to the
293  * outside.
294  * The simplest request packet is just the header defined in
295  * struct stun_header, and from the response we may just look at
296  * one attribute, STUN_MAPPED_ADDRESS, that we find in the response.
297  * By doing more transactions with different server addresses we
298  * may determine more about the behaviour of the NAT boxes, of
299  * course - the details are in the RFC.
300  *
301  * All STUN packets start with a simple header made of a type,
302  * length (excluding the header) and a 16-byte random transaction id.
303  * Following the header we may have zero or more attributes, each
304  * structured as a type, length and a value (whose format depends
305  * on the type, but often contains addresses).
306  * Of course all fields are in network format.
307  */
308
309 typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
310
311 struct stun_header {
312         unsigned short msgtype;
313         unsigned short msglen;
314         stun_trans_id  id;
315         unsigned char ies[0];
316 } __attribute__((packed));
317
318 struct stun_attr {
319         unsigned short attr;
320         unsigned short len;
321         unsigned char value[0];
322 } __attribute__((packed));
323
324 /*
325  * The format normally used for addresses carried by STUN messages.
326  */
327 struct stun_addr {
328         unsigned char unused;
329         unsigned char family;
330         unsigned short port;
331         unsigned int addr;
332 } __attribute__((packed));
333
334 #define STUN_IGNORE             (0)
335 #define STUN_ACCEPT             (1)
336
337 /*! \brief STUN message types
338  * 'BIND' refers to transactions used to determine the externally
339  * visible addresses. 'SEC' refers to transactions used to establish
340  * a session key for subsequent requests.
341  * 'SEC' functionality is not supported here.
342  */
343  
344 #define STUN_BINDREQ    0x0001
345 #define STUN_BINDRESP   0x0101
346 #define STUN_BINDERR    0x0111
347 #define STUN_SECREQ     0x0002
348 #define STUN_SECRESP    0x0102
349 #define STUN_SECERR     0x0112
350
351 /*! \brief Basic attribute types in stun messages.
352  * Messages can also contain custom attributes (codes above 0x7fff)
353  */
354 #define STUN_MAPPED_ADDRESS     0x0001
355 #define STUN_RESPONSE_ADDRESS   0x0002
356 #define STUN_CHANGE_REQUEST     0x0003
357 #define STUN_SOURCE_ADDRESS     0x0004
358 #define STUN_CHANGED_ADDRESS    0x0005
359 #define STUN_USERNAME           0x0006
360 #define STUN_PASSWORD           0x0007
361 #define STUN_MESSAGE_INTEGRITY  0x0008
362 #define STUN_ERROR_CODE         0x0009
363 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
364 #define STUN_REFLECTED_FROM     0x000b
365
366 /*! \brief helper function to print message names */
367 static const char *stun_msg2str(int msg)
368 {
369         switch (msg) {
370         case STUN_BINDREQ:
371                 return "Binding Request";
372         case STUN_BINDRESP:
373                 return "Binding Response";
374         case STUN_BINDERR:
375                 return "Binding Error Response";
376         case STUN_SECREQ:
377                 return "Shared Secret Request";
378         case STUN_SECRESP:
379                 return "Shared Secret Response";
380         case STUN_SECERR:
381                 return "Shared Secret Error Response";
382         }
383         return "Non-RFC3489 Message";
384 }
385
386 /*! \brief helper function to print attribute names */
387 static const char *stun_attr2str(int msg)
388 {
389         switch (msg) {
390         case STUN_MAPPED_ADDRESS:
391                 return "Mapped Address";
392         case STUN_RESPONSE_ADDRESS:
393                 return "Response Address";
394         case STUN_CHANGE_REQUEST:
395                 return "Change Request";
396         case STUN_SOURCE_ADDRESS:
397                 return "Source Address";
398         case STUN_CHANGED_ADDRESS:
399                 return "Changed Address";
400         case STUN_USERNAME:
401                 return "Username";
402         case STUN_PASSWORD:
403                 return "Password";
404         case STUN_MESSAGE_INTEGRITY:
405                 return "Message Integrity";
406         case STUN_ERROR_CODE:
407                 return "Error Code";
408         case STUN_UNKNOWN_ATTRIBUTES:
409                 return "Unknown Attributes";
410         case STUN_REFLECTED_FROM:
411                 return "Reflected From";
412         }
413         return "Non-RFC3489 Attribute";
414 }
415
416 /*! \brief here we store credentials extracted from a message */
417 struct stun_state {
418         const char *username;
419         const char *password;
420 };
421
422 static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
423 {
424         if (stundebug)
425                 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
426                             stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
427         switch (ntohs(attr->attr)) {
428         case STUN_USERNAME:
429                 state->username = (const char *) (attr->value);
430                 break;
431         case STUN_PASSWORD:
432                 state->password = (const char *) (attr->value);
433                 break;
434         default:
435                 if (stundebug)
436                         ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n", 
437                                     stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
438         }
439         return 0;
440 }
441
442 /*! \brief append a string to an STUN message */
443 static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
444 {
445         int size = sizeof(**attr) + strlen(s);
446         if (*left > size) {
447                 (*attr)->attr = htons(attrval);
448                 (*attr)->len = htons(strlen(s));
449                 memcpy((*attr)->value, s, strlen(s));
450                 (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
451                 *len += size;
452                 *left -= size;
453         }
454 }
455
456 /*! \brief append an address to an STUN message */
457 static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sock_in, int *len, int *left)
458 {
459         int size = sizeof(**attr) + 8;
460         struct stun_addr *addr;
461         if (*left > size) {
462                 (*attr)->attr = htons(attrval);
463                 (*attr)->len = htons(8);
464                 addr = (struct stun_addr *)((*attr)->value);
465                 addr->unused = 0;
466                 addr->family = 0x01;
467                 addr->port = sock_in->sin_port;
468                 addr->addr = sock_in->sin_addr.s_addr;
469                 (*attr) = (struct stun_attr *)((*attr)->value + 8);
470                 *len += size;
471                 *left -= size;
472         }
473 }
474
475 /*! \brief wrapper to send an STUN message */
476 static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
477 {
478         return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
479                       (struct sockaddr *)dst, sizeof(*dst));
480 }
481
482 /*! \brief helper function to generate a random request id */
483 static void stun_req_id(struct stun_header *req)
484 {
485         int x;
486         for (x = 0; x < 4; x++)
487                 req->id.id[x] = ast_random();
488 }
489
490 size_t ast_rtp_alloc_size(void)
491 {
492         return sizeof(struct ast_rtp);
493 }
494
495 /*! \brief callback type to be invoked on stun responses. */
496 typedef int (stun_cb_f)(struct stun_attr *attr, void *arg);
497
498 /*! \brief handle an incoming STUN message.
499  *
500  * Do some basic sanity checks on packet size and content,
501  * try to extract a bit of information, and possibly reply.
502  * At the moment this only processes BIND requests, and returns
503  * the externally visible address of the request.
504  * If a callback is specified, invoke it with the attribute.
505  */
506 static int stun_handle_packet(int s, struct sockaddr_in *src,
507         unsigned char *data, size_t len, stun_cb_f *stun_cb, void *arg)
508 {
509         struct stun_header *hdr = (struct stun_header *)data;
510         struct stun_attr *attr;
511         struct stun_state st;
512         int ret = STUN_IGNORE;  
513         int x;
514
515         /* On entry, 'len' is the length of the udp payload. After the
516          * initial checks it becomes the size of unprocessed options,
517          * while 'data' is advanced accordingly.
518          */
519         if (len < sizeof(struct stun_header)) {
520                 ast_debug(1, "Runt STUN packet (only %d, wanting at least %d)\n", (int) len, (int) sizeof(struct stun_header));
521                 return -1;
522         }
523         len -= sizeof(struct stun_header);
524         data += sizeof(struct stun_header);
525         x = ntohs(hdr->msglen); /* len as advertised in the message */
526         if (stundebug)
527                 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), x);
528         if (x > len) {
529                 ast_debug(1, "Scrambled STUN packet length (got %d, expecting %d)\n", x, (int)len);
530         } else
531                 len = x;
532         memset(&st, 0, sizeof(st));
533         while (len) {
534                 if (len < sizeof(struct stun_attr)) {
535                         ast_debug(1, "Runt Attribute (got %d, expecting %d)\n", (int)len, (int) sizeof(struct stun_attr));
536                         break;
537                 }
538                 attr = (struct stun_attr *)data;
539                 /* compute total attribute length */
540                 x = ntohs(attr->len) + sizeof(struct stun_attr);
541                 if (x > len) {
542                         ast_debug(1, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", x, (int)len);
543                         break;
544                 }
545                 if (stun_cb)
546                         stun_cb(attr, arg);
547                 if (stun_process_attr(&st, attr)) {
548                         ast_debug(1, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
549                         break;
550                 }
551                 /* Clear attribute id: in case previous entry was a string,
552                  * this will act as the terminator for the string.
553                  */
554                 attr->attr = 0;
555                 data += x;
556                 len -= x;
557         }
558         /* Null terminate any string.
559          * XXX NOTE, we write past the size of the buffer passed by the
560          * caller, so this is potentially dangerous. The only thing that
561          * saves us is that usually we read the incoming message in a
562          * much larger buffer in the struct ast_rtp
563          */
564         *data = '\0';
565
566         /* Now prepare to generate a reply, which at the moment is done
567          * only for properly formed (len == 0) STUN_BINDREQ messages.
568          */
569         if (len == 0) {
570                 unsigned char respdata[1024];
571                 struct stun_header *resp = (struct stun_header *)respdata;
572                 int resplen = 0;        /* len excluding header */
573                 int respleft = sizeof(respdata) - sizeof(struct stun_header);
574
575                 resp->id = hdr->id;
576                 resp->msgtype = 0;
577                 resp->msglen = 0;
578                 attr = (struct stun_attr *)resp->ies;
579                 switch (ntohs(hdr->msgtype)) {
580                 case STUN_BINDREQ:
581                         if (stundebug)
582                                 ast_verbose("STUN Bind Request, username: %s\n", 
583                                             st.username ? st.username : "<none>");
584                         if (st.username)
585                                 append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
586                         append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
587                         resp->msglen = htons(resplen);
588                         resp->msgtype = htons(STUN_BINDRESP);
589                         stun_send(s, src, resp);
590                         ret = STUN_ACCEPT;
591                         break;
592                 default:
593                         if (stundebug)
594                                 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
595                 }
596         }
597         return ret;
598 }
599
600 /*! \brief Extract the STUN_MAPPED_ADDRESS from the stun response.
601  * This is used as a callback for stun_handle_response
602  * when called from ast_stun_request.
603  */
604 static int stun_get_mapped(struct stun_attr *attr, void *arg)
605 {
606         struct stun_addr *addr = (struct stun_addr *)(attr + 1);
607         struct sockaddr_in *sa = (struct sockaddr_in *)arg;
608
609         if (ntohs(attr->attr) != STUN_MAPPED_ADDRESS || ntohs(attr->len) != 8)
610                 return 1;       /* not us. */
611         sa->sin_port = addr->port;
612         sa->sin_addr.s_addr = addr->addr;
613         return 0;
614 }
615
616 /*! \brief Generic STUN request
617  * Send a generic stun request to the server specified,
618  * possibly waiting for a reply and filling the 'reply' field with
619  * the externally visible address. Note that in this case the request
620  * will be blocking.
621  * (Note, the interface may change slightly in the future).
622  *
623  * \param s the socket used to send the request
624  * \param dst the address of the STUN server
625  * \param username if non null, add the username in the request
626  * \param answer if non null, the function waits for a response and
627  *    puts here the externally visible address.
628  * \return 0 on success, other values on error.
629  */
630 int ast_stun_request(int s, struct sockaddr_in *dst,
631         const char *username, struct sockaddr_in *answer)
632 {
633         struct stun_header *req;
634         unsigned char reqdata[1024];
635         int reqlen, reqleft;
636         struct stun_attr *attr;
637         int res = 0;
638         int retry;
639         
640         req = (struct stun_header *)reqdata;
641         stun_req_id(req);
642         reqlen = 0;
643         reqleft = sizeof(reqdata) - sizeof(struct stun_header);
644         req->msgtype = 0;
645         req->msglen = 0;
646         attr = (struct stun_attr *)req->ies;
647         if (username)
648                 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
649         req->msglen = htons(reqlen);
650         req->msgtype = htons(STUN_BINDREQ);
651         for (retry = 0; retry < 3; retry++) {   /* XXX make retries configurable */
652                 /* send request, possibly wait for reply */
653                 unsigned char reply_buf[1024];
654                 fd_set rfds;
655                 struct timeval to = { 3, 0 };   /* timeout, make it configurable */
656                 struct sockaddr_in src;
657                 socklen_t srclen;
658
659                 res = stun_send(s, dst, req);
660                 if (res < 0) {
661                         ast_log(LOG_WARNING, "ast_stun_request send #%d failed error %d, retry\n",
662                                 retry, res);
663                         continue;
664                 }
665                 if (answer == NULL)
666                         break;
667                 FD_ZERO(&rfds);
668                 FD_SET(s, &rfds);
669                 res = ast_select(s + 1, &rfds, NULL, NULL, &to);
670                 if (res <= 0)   /* timeout or error */
671                         continue;
672                 memset(&src, '\0', sizeof(src));
673                 srclen = sizeof(src);
674                 /* XXX pass -1 in the size, because stun_handle_packet might
675                  * write past the end of the buffer.
676                  */
677                 res = recvfrom(s, reply_buf, sizeof(reply_buf) - 1,
678                         0, (struct sockaddr *)&src, &srclen);
679                 if (res < 0) {
680                         ast_log(LOG_WARNING, "ast_stun_request recvfrom #%d failed error %d, retry\n",
681                                 retry, res);
682                         continue;
683                 }
684                 memset(answer, '\0', sizeof(struct sockaddr_in));
685                 stun_handle_packet(s, &src, reply_buf, res,
686                         stun_get_mapped, answer);
687                 res = 0; /* signal regular exit */
688                 break;
689         }
690         return res;
691 }
692
693 /*! \brief send a STUN BIND request to the given destination.
694  * Optionally, add a username if specified.
695  */
696 void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
697 {
698         ast_stun_request(rtp->s, suggestion, username, NULL);
699 }
700
701 /*! \brief List of current sessions */
702 static AST_RWLIST_HEAD_STATIC(protos, ast_rtp_protocol);
703
704 static void timeval2ntp(struct timeval when, unsigned int *msw, unsigned int *lsw)
705 {
706         unsigned int sec, usec, frac;
707         sec = when.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
708         usec = when.tv_usec;
709         frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
710         *msw = sec;
711         *lsw = frac;
712 }
713
714 int ast_rtp_fd(struct ast_rtp *rtp)
715 {
716         return rtp->s;
717 }
718
719 int ast_rtcp_fd(struct ast_rtp *rtp)
720 {
721         if (rtp->rtcp)
722                 return rtp->rtcp->s;
723         return -1;
724 }
725
726 unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
727 {
728         unsigned int interval;
729         /*! \todo XXX Do a more reasonable calculation on this one
730          * Look in RFC 3550 Section A.7 for an example*/
731         interval = rtcpinterval;
732         return interval;
733 }
734
735 /* \brief Put RTP timeout timers on hold during another transaction, like T.38 */
736 void ast_rtp_set_rtptimers_onhold(struct ast_rtp *rtp)
737 {
738         rtp->rtptimeout = (-1) * rtp->rtptimeout;
739         rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout;
740 }
741
742 /*! \brief Set rtp timeout */
743 void ast_rtp_set_rtptimeout(struct ast_rtp *rtp, int timeout)
744 {
745         rtp->rtptimeout = timeout;
746 }
747
748 /*! \brief Set rtp hold timeout */
749 void ast_rtp_set_rtpholdtimeout(struct ast_rtp *rtp, int timeout)
750 {
751         rtp->rtpholdtimeout = timeout;
752 }
753
754 /*! \brief set RTP keepalive interval */
755 void ast_rtp_set_rtpkeepalive(struct ast_rtp *rtp, int period)
756 {
757         rtp->rtpkeepalive = period;
758 }
759
760 /*! \brief Get rtp timeout */
761 int ast_rtp_get_rtptimeout(struct ast_rtp *rtp)
762 {
763         if (rtp->rtptimeout < 0)        /* We're not checking, but remembering the setting (during T.38 transmission) */
764                 return 0;
765         return rtp->rtptimeout;
766 }
767
768 /*! \brief Get rtp hold timeout */
769 int ast_rtp_get_rtpholdtimeout(struct ast_rtp *rtp)
770 {
771         if (rtp->rtptimeout < 0)        /* We're not checking, but remembering the setting (during T.38 transmission) */
772                 return 0;
773         return rtp->rtpholdtimeout;
774 }
775
776 /*! \brief Get RTP keepalive interval */
777 int ast_rtp_get_rtpkeepalive(struct ast_rtp *rtp)
778 {
779         return rtp->rtpkeepalive;
780 }
781
782 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
783 {
784         rtp->data = data;
785 }
786
787 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
788 {
789         rtp->callback = callback;
790 }
791
792 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
793 {
794         rtp->nat = nat;
795 }
796
797 int ast_rtp_getnat(struct ast_rtp *rtp)
798 {
799         return ast_test_flag(rtp, FLAG_NAT_ACTIVE);
800 }
801
802 void ast_rtp_setdtmf(struct ast_rtp *rtp, int dtmf)
803 {
804         ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF);
805 }
806
807 void ast_rtp_setdtmfcompensate(struct ast_rtp *rtp, int compensate)
808 {
809         ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE);
810 }
811
812 void ast_rtp_setstun(struct ast_rtp *rtp, int stun_enable)
813 {
814         ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN);
815 }
816
817 static void rtp_bridge_lock(struct ast_rtp *rtp)
818 {
819 #ifdef P2P_INTENSE
820         ast_mutex_lock(&rtp->bridge_lock);
821 #endif
822         return;
823 }
824
825 static void rtp_bridge_unlock(struct ast_rtp *rtp)
826 {
827 #ifdef P2P_INTENSE
828         ast_mutex_unlock(&rtp->bridge_lock);
829 #endif
830         return;
831 }
832
833 /*! \brief Calculate normal deviation */
834 static double normdev_compute(double normdev, double sample, unsigned int sample_count)
835 {
836         normdev = normdev * sample_count + sample;
837         sample_count++;
838
839         return normdev / sample_count;
840 }
841
842 static double stddev_compute(double stddev, double sample, double normdev, double normdev_curent, unsigned int sample_count)
843 {
844 /*
845                 for the formula check http://www.cs.umd.edu/~austinjp/constSD.pdf
846                 return sqrt( (sample_count*pow(stddev,2) + sample_count*pow((sample-normdev)/(sample_count+1),2) + pow(sample-normdev_curent,2)) / (sample_count+1));
847                 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
848                 optimized formula
849 */
850 #define SQUARE(x) ((x) * (x))
851
852         stddev = sample_count * stddev;
853         sample_count++;
854
855         return stddev + 
856                ( sample_count * SQUARE( (sample - normdev) / sample_count ) ) + 
857                ( SQUARE(sample - normdev_curent) / sample_count );
858
859 #undef SQUARE
860 }
861
862 static struct ast_frame *send_dtmf(struct ast_rtp *rtp, enum ast_frame_type type)
863 {
864         if (((ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && type == AST_FRAME_DTMF_END) ||
865              (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
866                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(rtp->them.sin_addr));
867                 rtp->resp = 0;
868                 rtp->dtmfsamples = 0;
869                 return &ast_null_frame;
870         }
871         ast_debug(1, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(rtp->them.sin_addr));
872         if (rtp->resp == 'X') {
873                 rtp->f.frametype = AST_FRAME_CONTROL;
874                 rtp->f.subclass = AST_CONTROL_FLASH;
875         } else {
876                 rtp->f.frametype = type;
877                 rtp->f.subclass = rtp->resp;
878         }
879         rtp->f.datalen = 0;
880         rtp->f.samples = 0;
881         rtp->f.mallocd = 0;
882         rtp->f.src = "RTP";
883         return &rtp->f;
884         
885 }
886
887 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
888 {
889         if (rtpdebug == 0)
890                 return 0;
891         if (rtpdebugaddr.sin_addr.s_addr) {
892                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
893                      && (rtpdebugaddr.sin_port != addr->sin_port))
894                     || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
895                         return 0;
896         }
897         return 1;
898 }
899
900 static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
901 {
902         if (rtcpdebug == 0)
903                 return 0;
904         if (rtcpdebugaddr.sin_addr.s_addr) {
905                 if (((ntohs(rtcpdebugaddr.sin_port) != 0)
906                      && (rtcpdebugaddr.sin_port != addr->sin_port))
907                     || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
908                         return 0;
909         }
910         return 1;
911 }
912
913
914 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
915 {
916         unsigned int event;
917         char resp = 0;
918         struct ast_frame *f = NULL;
919         unsigned char seq;
920         unsigned int flags;
921         unsigned int power;
922
923         /* We should have at least 4 bytes in RTP data */
924         if (len < 4)
925                 return f;
926
927         /*      The format of Cisco RTP DTMF packet looks like next:
928                 +0                              - sequence number of DTMF RTP packet (begins from 1,
929                                                   wrapped to 0)
930                 +1                              - set of flags
931                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
932                                                   or repeated digit without audio???
933                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
934                                                   then falls to 0 at its end)
935                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
936                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
937                 by each new packet and thus provides some redudancy.
938                 
939                 Sample of Cisco RTP DTMF packet is (all data in hex):
940                         19 07 00 02 12 02 20 02
941                 showing end of DTMF digit '2'.
942
943                 The packets
944                         27 07 00 02 0A 02 20 02
945                         28 06 20 02 00 02 0A 02
946                 shows begin of new digit '2' with very short pause (20 ms) after
947                 previous digit '2'. Bit +1.0 flips at begin of new digit.
948                 
949                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
950                 so its uses the same sequencing and timestamping rules as replaced
951                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
952                 on audio framing parameters. Marker bit isn't used within stream of
953                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
954                 are not sequential at borders between DTMF and audio streams,
955         */
956
957         seq = data[0];
958         flags = data[1];
959         power = data[2];
960         event = data[3] & 0x1f;
961
962         if (option_debug > 2 || rtpdebug)
963                 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);
964         if (event < 10) {
965                 resp = '0' + event;
966         } else if (event < 11) {
967                 resp = '*';
968         } else if (event < 12) {
969                 resp = '#';
970         } else if (event < 16) {
971                 resp = 'A' + (event - 12);
972         } else if (event < 17) {
973                 resp = 'X';
974         }
975         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
976                 rtp->resp = resp;
977                 /* Why we should care on DTMF compensation at reception? */
978                 if (!ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
979                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
980                         rtp->dtmfsamples = 0;
981                 }
982         } else if ((rtp->resp == resp) && !power) {
983                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
984                 f->samples = rtp->dtmfsamples * 8;
985                 rtp->resp = 0;
986         } else if (rtp->resp == resp)
987                 rtp->dtmfsamples += 20 * 8;
988         rtp->dtmfcount = dtmftimeout;
989         return f;
990 }
991
992 /*! 
993  * \brief Process RTP DTMF and events according to RFC 2833.
994  * 
995  * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
996  * 
997  * \param rtp
998  * \param data
999  * \param len
1000  * \param seqno
1001  * \param timestamp
1002  * \returns
1003  */
1004 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp)
1005 {
1006         unsigned int event;
1007         unsigned int event_end;
1008         unsigned int samples;
1009         char resp = 0;
1010         struct ast_frame *f = NULL;
1011
1012         /* Figure out event, event end, and samples */
1013         event = ntohl(*((unsigned int *)(data)));
1014         event >>= 24;
1015         event_end = ntohl(*((unsigned int *)(data)));
1016         event_end <<= 8;
1017         event_end >>= 24;
1018         samples = ntohl(*((unsigned int *)(data)));
1019         samples &= 0xFFFF;
1020
1021         /* Print out debug if turned on */
1022         if (rtpdebug || option_debug > 2)
1023                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
1024
1025         /* Figure out what digit was pressed */
1026         if (event < 10) {
1027                 resp = '0' + event;
1028         } else if (event < 11) {
1029                 resp = '*';
1030         } else if (event < 12) {
1031                 resp = '#';
1032         } else if (event < 16) {
1033                 resp = 'A' + (event - 12);
1034         } else if (event < 17) {        /* Event 16: Hook flash */
1035                 resp = 'X';     
1036         } else {
1037                 /* Not a supported event */
1038                 ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
1039                 return &ast_null_frame;
1040         }
1041
1042         if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
1043                 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
1044                         rtp->resp = resp;
1045                         rtp->dtmfcount = 0;
1046                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
1047                         f->len = 0;
1048                         rtp->lastevent = timestamp;
1049                 }
1050         } else {
1051                 if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
1052                         rtp->resp = resp;
1053                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
1054                         rtp->dtmfcount = dtmftimeout;
1055                 } else if ((event_end & 0x80) && (rtp->lastevent != seqno) && rtp->resp) {
1056                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
1057                         f->len = ast_tvdiff_ms(ast_samp2tv(samples, 8000), ast_tv(0, 0)); /* XXX hard coded 8kHz */
1058                         rtp->resp = 0;
1059                         rtp->dtmfcount = 0;
1060                         rtp->lastevent = seqno;
1061                 }
1062         }
1063
1064         rtp->dtmfsamples = samples;
1065
1066         return f;
1067 }
1068
1069 /*!
1070  * \brief Process Comfort Noise RTP.
1071  * 
1072  * This is incomplete at the moment.
1073  * 
1074 */
1075 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
1076 {
1077         struct ast_frame *f = NULL;
1078         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
1079            totally help us out becuase we don't have an engine to keep it going and we are not
1080            guaranteed to have it every 20ms or anything */
1081         if (rtpdebug)
1082                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
1083
1084         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
1085                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
1086                         ast_inet_ntoa(rtp->them.sin_addr));
1087                 ast_set_flag(rtp, FLAG_3389_WARNING);
1088         }
1089         
1090         /* Must have at least one byte */
1091         if (!len)
1092                 return NULL;
1093         if (len < 24) {
1094                 rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
1095                 rtp->f.datalen = len - 1;
1096                 rtp->f.offset = AST_FRIENDLY_OFFSET;
1097                 memcpy(rtp->f.data.ptr, data + 1, len - 1);
1098         } else {
1099                 rtp->f.data.ptr = NULL;
1100                 rtp->f.offset = 0;
1101                 rtp->f.datalen = 0;
1102         }
1103         rtp->f.frametype = AST_FRAME_CNG;
1104         rtp->f.subclass = data[0] & 0x7f;
1105         rtp->f.datalen = len - 1;
1106         rtp->f.samples = 0;
1107         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
1108         f = &rtp->f;
1109         return f;
1110 }
1111
1112 static int rtpread(int *id, int fd, short events, void *cbdata)
1113 {
1114         struct ast_rtp *rtp = cbdata;
1115         struct ast_frame *f;
1116         f = ast_rtp_read(rtp);
1117         if (f) {
1118                 if (rtp->callback)
1119                         rtp->callback(rtp, f, rtp->data);
1120         }
1121         return 1;
1122 }
1123
1124 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
1125 {
1126         socklen_t len;
1127         int position, i, packetwords;
1128         int res;
1129         struct sockaddr_in sock_in;
1130         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
1131         unsigned int *rtcpheader;
1132         int pt;
1133         struct timeval now;
1134         unsigned int length;
1135         int rc;
1136         double rttsec;
1137         uint64_t rtt = 0;
1138         unsigned int dlsr;
1139         unsigned int lsr;
1140         unsigned int msw;
1141         unsigned int lsw;
1142         unsigned int comp;
1143         struct ast_frame *f = &ast_null_frame;
1144         
1145         double reported_jitter;
1146         double reported_normdev_jitter_current;
1147         double normdevrtt_current;
1148         double reported_lost;
1149         double reported_normdev_lost_current;
1150
1151         if (!rtp || !rtp->rtcp)
1152                 return &ast_null_frame;
1153
1154         len = sizeof(sock_in);
1155         
1156         res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
1157                                         0, (struct sockaddr *)&sock_in, &len);
1158         rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
1159         
1160         if (res < 0) {
1161                 ast_assert(errno != EBADF);
1162                 if (errno != EAGAIN) {
1163                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
1164                         return NULL;
1165                 }
1166                 return &ast_null_frame;
1167         }
1168
1169         packetwords = res / 4;
1170         
1171         if (rtp->nat) {
1172                 /* Send to whoever sent to us */
1173                 if ((rtp->rtcp->them.sin_addr.s_addr != sock_in.sin_addr.s_addr) ||
1174                     (rtp->rtcp->them.sin_port != sock_in.sin_port)) {
1175                         memcpy(&rtp->rtcp->them, &sock_in, sizeof(rtp->rtcp->them));
1176                         if (option_debug || rtpdebug)
1177                                 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));
1178                 }
1179         }
1180
1181         ast_debug(1, "Got RTCP report of %d bytes\n", res);
1182
1183         /* Process a compound packet */
1184         position = 0;
1185         while (position < packetwords) {
1186                 i = position;
1187                 length = ntohl(rtcpheader[i]);
1188                 pt = (length & 0xff0000) >> 16;
1189                 rc = (length & 0x1f000000) >> 24;
1190                 length &= 0xffff;
1191  
1192                 if ((i + length) > packetwords) {
1193                         if (option_debug || rtpdebug)
1194                                 ast_log(LOG_DEBUG, "RTCP Read too short\n");
1195                         return &ast_null_frame;
1196                 }
1197                 
1198                 if (rtcp_debug_test_addr(&sock_in)) {
1199                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.sin_port));
1200                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
1201                         ast_verbose("Reception reports: %d\n", rc);
1202                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
1203                 }
1204  
1205                 i += 2; /* Advance past header and ssrc */
1206                 
1207                 switch (pt) {
1208                 case RTCP_PT_SR:
1209                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
1210                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
1211                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
1212                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
1213  
1214                         if (rtcp_debug_test_addr(&sock_in)) {
1215                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
1216                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
1217                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
1218                         }
1219                         i += 5;
1220                         if (rc < 1)
1221                                 break;
1222                         /* Intentional fall through */
1223                 case RTCP_PT_RR:
1224                         /* Don't handle multiple reception reports (rc > 1) yet */
1225                         /* Calculate RTT per RFC */
1226                         gettimeofday(&now, NULL);
1227                         timeval2ntp(now, &msw, &lsw);
1228                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
1229                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
1230                                 lsr = ntohl(rtcpheader[i + 4]);
1231                                 dlsr = ntohl(rtcpheader[i + 5]);
1232                                 rtt = comp - lsr - dlsr;
1233
1234                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
1235                                    sess->ee_delay = (eedelay * 1000) / 65536; */
1236                                 if (rtt < 4294) {
1237                                     rtt = (rtt * 1000000) >> 16;
1238                                 } else {
1239                                     rtt = (rtt * 1000) >> 16;
1240                                     rtt *= 1000;
1241                                 }
1242                                 rtt = rtt / 1000.;
1243                                 rttsec = rtt / 1000.;
1244                                 rtp->rtcp->rtt = rttsec;
1245
1246                                 if (comp - dlsr >= lsr) {
1247                                         rtp->rtcp->accumulated_transit += rttsec;
1248
1249                                         if (rtp->rtcp->rtt_count == 0) 
1250                                                 rtp->rtcp->minrtt = rttsec;
1251
1252                                         if (rtp->rtcp->maxrtt<rttsec)
1253                                                 rtp->rtcp->maxrtt = rttsec;
1254
1255                                         if (rtp->rtcp->minrtt>rttsec)
1256                                                 rtp->rtcp->minrtt = rttsec;
1257
1258                                         normdevrtt_current = normdev_compute(rtp->rtcp->normdevrtt, rttsec, rtp->rtcp->rtt_count);
1259
1260                                         rtp->rtcp->stdevrtt = stddev_compute(rtp->rtcp->stdevrtt, rttsec, rtp->rtcp->normdevrtt, normdevrtt_current, rtp->rtcp->rtt_count);
1261
1262                                         rtp->rtcp->normdevrtt = normdevrtt_current;
1263
1264                                         rtp->rtcp->rtt_count++;
1265                                 } else if (rtcp_debug_test_addr(&sock_in)) {
1266                                         ast_verbose("Internal RTCP NTP clock skew detected: "
1267                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
1268                                                            "diff=%d\n",
1269                                                            lsr, comp, dlsr, dlsr / 65536,
1270                                                            (dlsr % 65536) * 1000 / 65536,
1271                                                            dlsr - (comp - lsr));
1272                                 }
1273                         }
1274
1275                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1276                         reported_jitter = (double) rtp->rtcp->reported_jitter;
1277
1278                         if (rtp->rtcp->reported_jitter_count == 0) 
1279                                 rtp->rtcp->reported_minjitter = reported_jitter;
1280
1281                         if (reported_jitter < rtp->rtcp->reported_minjitter) 
1282                                 rtp->rtcp->reported_minjitter = reported_jitter;
1283
1284                         if (reported_jitter > rtp->rtcp->reported_maxjitter) 
1285                                 rtp->rtcp->reported_maxjitter = reported_jitter;
1286
1287                         reported_normdev_jitter_current = normdev_compute(rtp->rtcp->reported_normdev_jitter, reported_jitter, rtp->rtcp->reported_jitter_count);
1288
1289                         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);
1290
1291                         rtp->rtcp->reported_normdev_jitter = reported_normdev_jitter_current;
1292
1293                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1294
1295                         reported_lost = (double) rtp->rtcp->reported_lost;
1296
1297                         /* using same counter as for jitter */
1298                         if (rtp->rtcp->reported_jitter_count == 0)
1299                                 rtp->rtcp->reported_minlost = reported_lost;
1300
1301                         if (reported_lost < rtp->rtcp->reported_minlost)
1302                                 rtp->rtcp->reported_minlost = reported_lost;
1303
1304                         if (reported_lost > rtp->rtcp->reported_maxlost) 
1305                                 rtp->rtcp->reported_maxlost = reported_lost;
1306
1307                         reported_normdev_lost_current = normdev_compute(rtp->rtcp->reported_normdev_lost, reported_lost, rtp->rtcp->reported_jitter_count);
1308
1309                         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);
1310
1311                         rtp->rtcp->reported_normdev_lost = reported_normdev_lost_current;
1312
1313                         rtp->rtcp->reported_jitter_count++;
1314
1315                         if (rtcp_debug_test_addr(&sock_in)) {
1316                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1317                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1318                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1319                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1320                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1321                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1322                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1323                                 if (rtt)
1324                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
1325                         }
1326
1327                         if (rtt) {
1328                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From: %s:%d\r\n"
1329                                                                     "PT: %d(%s)\r\n"
1330                                                                     "ReceptionReports: %d\r\n"
1331                                                                     "SenderSSRC: %u\r\n"
1332                                                                     "FractionLost: %ld\r\n"
1333                                                                     "PacketsLost: %d\r\n"
1334                                                                     "HighestSequence: %ld\r\n"
1335                                                                     "SequenceNumberCycles: %ld\r\n"
1336                                                                     "IAJitter: %u\r\n"
1337                                                                     "LastSR: %lu.%010lu\r\n"
1338                                                                     "DLSR: %4.4f(sec)\r\n"
1339                                                                     "RTT: %llu(sec)\r\n",
1340                                                                     ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.sin_port),
1341                                                                     pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1342                                                                     rc,
1343                                                                     rtcpheader[i + 1],
1344                                                                     (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1345                                                                     rtp->rtcp->reported_lost,
1346                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1347                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1348                                                                     rtp->rtcp->reported_jitter,
1349                                                                     (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1350                                                                     ntohl(rtcpheader[i + 5])/65536.0,
1351                                                                     (unsigned long long)rtt);
1352                         } else {
1353                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From: %s:%d\r\n"
1354                                                                     "PT: %d(%s)\r\n"
1355                                                                     "ReceptionReports: %d\r\n"
1356                                                                     "SenderSSRC: %u\r\n"
1357                                                                     "FractionLost: %ld\r\n"
1358                                                                     "PacketsLost: %d\r\n"
1359                                                                     "HighestSequence: %ld\r\n"
1360                                                                     "SequenceNumberCycles: %ld\r\n"
1361                                                                     "IAJitter: %u\r\n"
1362                                                                     "LastSR: %lu.%010lu\r\n"
1363                                                                     "DLSR: %4.4f(sec)\r\n",
1364                                                                     ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.sin_port),
1365                                                                     pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1366                                                                     rc,
1367                                                                     rtcpheader[i + 1],
1368                                                                     (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1369                                                                     rtp->rtcp->reported_lost,
1370                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1371                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1372                                                                     rtp->rtcp->reported_jitter,
1373                                                                     (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
1374                                                                     ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1375                                                                     ntohl(rtcpheader[i + 5])/65536.0);
1376                         }
1377                         break;
1378                 case RTCP_PT_FUR:
1379                         if (rtcp_debug_test_addr(&sock_in))
1380                                 ast_verbose("Received an RTCP Fast Update Request\n");
1381                         rtp->f.frametype = AST_FRAME_CONTROL;
1382                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
1383                         rtp->f.datalen = 0;
1384                         rtp->f.samples = 0;
1385                         rtp->f.mallocd = 0;
1386                         rtp->f.src = "RTP";
1387                         f = &rtp->f;
1388                         break;
1389                 case RTCP_PT_SDES:
1390                         if (rtcp_debug_test_addr(&sock_in))
1391                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1392                         break;
1393                 case RTCP_PT_BYE:
1394                         if (rtcp_debug_test_addr(&sock_in))
1395                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1396                         break;
1397                 default:
1398                         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));
1399                         break;
1400                 }
1401                 position += (length + 1);
1402         }
1403         rtp->rtcp->rtcp_info = 1;       
1404         return f;
1405 }
1406
1407 static void calc_rxstamp(struct timeval *when, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1408 {
1409         struct timeval now;
1410         double transit;
1411         double current_time;
1412         double d;
1413         double dtv;
1414         double prog;
1415         
1416         double normdev_rxjitter_current;
1417         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1418                 gettimeofday(&rtp->rxcore, NULL);
1419                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1420                 /* map timestamp to a real time */
1421                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1422                 rtp->rxcore.tv_sec -= timestamp / 8000;
1423                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
1424                 /* Round to 0.1ms for nice, pretty timestamps */
1425                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1426                 if (rtp->rxcore.tv_usec < 0) {
1427                         /* Adjust appropriately if necessary */
1428                         rtp->rxcore.tv_usec += 1000000;
1429                         rtp->rxcore.tv_sec -= 1;
1430                 }
1431         }
1432
1433         gettimeofday(&now,NULL);
1434         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1435         when->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
1436         when->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
1437         if (when->tv_usec >= 1000000) {
1438                 when->tv_usec -= 1000000;
1439                 when->tv_sec += 1;
1440         }
1441         prog = (double)((timestamp-rtp->seedrxts)/8000.);
1442         dtv = (double)rtp->drxcore + (double)(prog);
1443         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1444         transit = current_time - dtv;
1445         d = transit - rtp->rxtransit;
1446         rtp->rxtransit = transit;
1447         if (d<0)
1448                 d=-d;
1449         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1450         if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
1451                 rtp->rtcp->maxrxjitter = rtp->rxjitter;
1452         if (rtp->rtcp->rxjitter_count == 1) 
1453                 rtp->rtcp->minrxjitter = rtp->rxjitter;
1454         if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1455                 rtp->rtcp->minrxjitter = rtp->rxjitter;
1456                 
1457         normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
1458         rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
1459
1460         rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
1461         rtp->rtcp->rxjitter_count++;
1462 }
1463
1464 /*! \brief Perform a Packet2Packet RTP write */
1465 static int bridge_p2p_rtp_write(struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
1466 {
1467         int res = 0, payload = 0, bridged_payload = 0, mark;
1468         struct rtpPayloadType rtpPT;
1469         int reconstruct = ntohl(rtpheader[0]);
1470
1471         /* Get fields from packet */
1472         payload = (reconstruct & 0x7f0000) >> 16;
1473         mark = (((reconstruct & 0x800000) >> 23) != 0);
1474
1475         /* Check what the payload value should be */
1476         rtpPT = ast_rtp_lookup_pt(rtp, payload);
1477
1478         /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1479         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
1480                 return -1;
1481
1482         /* Otherwise adjust bridged payload to match */
1483         bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
1484
1485         /* 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 */
1486         if (!bridged->current_RTP_PT[bridged_payload].code)
1487                 return -1;
1488
1489
1490         /* If the mark bit has not been sent yet... do it now */
1491         if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
1492                 mark = 1;
1493                 ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
1494         }
1495
1496         /* Reconstruct part of the packet */
1497         reconstruct &= 0xFF80FFFF;
1498         reconstruct |= (bridged_payload << 16);
1499         reconstruct |= (mark << 23);
1500         rtpheader[0] = htonl(reconstruct);
1501
1502         /* Send the packet back out */
1503         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
1504         if (res < 0) {
1505                 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1506                         ast_debug(1, "RTP Transmission error of packet to %s:%d: %s\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), strerror(errno));
1507                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1508                         if (option_debug || rtpdebug)
1509                                 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(bridged->them.sin_addr), ntohs(bridged->them.sin_port));
1510                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1511                 }
1512                 return 0;
1513         } else if (rtp_debug_test_addr(&bridged->them))
1514                         ast_verbose("Sent RTP P2P packet to %s:%u (type %-2.2d, len %-6.6u)\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), bridged_payload, len - hdrlen);
1515
1516         return 0;
1517 }
1518
1519 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
1520 {
1521         int res;
1522         struct sockaddr_in sock_in;
1523         socklen_t len;
1524         unsigned int seqno;
1525         int version;
1526         int payloadtype;
1527         int hdrlen = 12;
1528         int padding;
1529         int mark;
1530         int ext;
1531         int cc;
1532         unsigned int ssrc;
1533         unsigned int timestamp;
1534         unsigned int *rtpheader;
1535         struct rtpPayloadType rtpPT;
1536         struct ast_rtp *bridged = NULL;
1537         int prev_seqno;
1538         
1539         /* If time is up, kill it */
1540         if (rtp->sending_digit)
1541                 ast_rtp_senddigit_continuation(rtp);
1542
1543         len = sizeof(sock_in);
1544         
1545         /* Cache where the header will go */
1546         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
1547                                         0, (struct sockaddr *)&sock_in, &len);
1548
1549         /* If strict RTP protection is enabled see if we need to learn this address or if the packet should be dropped */
1550         if (rtp->strict_rtp_state == STRICT_RTP_LEARN) {
1551                 /* Copy over address that this packet was received on */
1552                 memcpy(&rtp->strict_rtp_address, &sock_in, sizeof(rtp->strict_rtp_address));
1553                 /* Now move over to actually protecting the RTP port */
1554                 rtp->strict_rtp_state = STRICT_RTP_CLOSED;
1555                 ast_debug(1, "Learned remote address is %s:%d for strict RTP purposes, now protecting the port.\n", ast_inet_ntoa(rtp->strict_rtp_address.sin_addr), ntohs(rtp->strict_rtp_address.sin_port));
1556         } else if (rtp->strict_rtp_state == STRICT_RTP_CLOSED) {
1557                 /* If the address we previously learned doesn't match the address this packet came in on simply drop it */
1558                 if ((rtp->strict_rtp_address.sin_addr.s_addr != sock_in.sin_addr.s_addr) || (rtp->strict_rtp_address.sin_port != sock_in.sin_port)) {
1559                         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(sock_in.sin_addr), ntohs(sock_in.sin_port), ast_inet_ntoa(rtp->strict_rtp_address.sin_addr), ntohs(rtp->strict_rtp_address.sin_port));
1560                         return &ast_null_frame;
1561                 }
1562         }
1563
1564         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
1565         if (res < 0) {
1566                 ast_assert(errno != EBADF);
1567                 if (errno != EAGAIN) {
1568                         ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up.\n", strerror(errno));
1569                         return NULL;
1570                 }
1571                 return &ast_null_frame;
1572         }
1573         
1574         if (res < hdrlen) {
1575                 ast_log(LOG_WARNING, "RTP Read too short\n");
1576                 return &ast_null_frame;
1577         }
1578
1579         /* Get fields */
1580         seqno = ntohl(rtpheader[0]);
1581
1582         /* Check RTP version */
1583         version = (seqno & 0xC0000000) >> 30;
1584         if (!version) {
1585                 /* If the two high bits are 0, this might be a
1586                  * STUN message, so process it. stun_handle_packet()
1587                  * answers to requests, and it returns STUN_ACCEPT
1588                  * if the request is valid.
1589                  */
1590                 if ((stun_handle_packet(rtp->s, &sock_in, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == STUN_ACCEPT) &&
1591                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
1592                         memcpy(&rtp->them, &sock_in, sizeof(rtp->them));
1593                 }
1594                 return &ast_null_frame;
1595         }
1596
1597 #if 0   /* Allow to receive RTP stream with closed transmission path */
1598         /* If we don't have the other side's address, then ignore this */
1599         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1600                 return &ast_null_frame;
1601 #endif
1602
1603         /* Send to whoever send to us if NAT is turned on */
1604         if (rtp->nat) {
1605                 if ((rtp->them.sin_addr.s_addr != sock_in.sin_addr.s_addr) ||
1606                     (rtp->them.sin_port != sock_in.sin_port)) {
1607                         rtp->them = sock_in;
1608                         if (rtp->rtcp) {
1609                                 int h = 0;
1610                                 memcpy(&rtp->rtcp->them, &sock_in, sizeof(rtp->rtcp->them));
1611                                 h = ntohs(rtp->them.sin_port);
1612                                 rtp->rtcp->them.sin_port = htons(h + 1);
1613                         }
1614                         rtp->rxseqno = 0;
1615                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1616                         if (option_debug || rtpdebug)
1617                                 ast_debug(0, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
1618                 }
1619         }
1620
1621         /* If we are bridged to another RTP stream, send direct */
1622         if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen))
1623                 return &ast_null_frame;
1624
1625         if (version != 2)
1626                 return &ast_null_frame;
1627
1628         payloadtype = (seqno & 0x7f0000) >> 16;
1629         padding = seqno & (1 << 29);
1630         mark = seqno & (1 << 23);
1631         ext = seqno & (1 << 28);
1632         cc = (seqno & 0xF000000) >> 24;
1633         seqno &= 0xffff;
1634         timestamp = ntohl(rtpheader[1]);
1635         ssrc = ntohl(rtpheader[2]);
1636         
1637         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1638                 if (option_debug || rtpdebug)
1639                         ast_debug(0, "Forcing Marker bit, because SSRC has changed\n");
1640                 mark = 1;
1641         }
1642
1643         rtp->rxssrc = ssrc;
1644         
1645         if (padding) {
1646                 /* Remove padding bytes */
1647                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1648         }
1649         
1650         if (cc) {
1651                 /* CSRC fields present */
1652                 hdrlen += cc*4;
1653         }
1654
1655         if (ext) {
1656                 /* RTP Extension present */
1657                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
1658                 hdrlen += 4;
1659                 if (option_debug) {
1660                         int profile;
1661                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1662                         if (profile == 0x505a)
1663                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1664                         else
1665                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
1666                 }
1667         }
1668
1669         if (res < hdrlen) {
1670                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1671                 return &ast_null_frame;
1672         }
1673
1674         rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1675
1676         if (rtp->rxcount==1) {
1677                 /* This is the first RTP packet successfully received from source */
1678                 rtp->seedrxseqno = seqno;
1679         }
1680
1681         /* Do not schedule RR if RTCP isn't run */
1682         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1683                 /* Schedule transmission of Receiver Report */
1684                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1685         }
1686         if ((int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
1687                 rtp->cycles += RTP_SEQ_MOD;
1688         
1689         prev_seqno = rtp->lastrxseqno;
1690
1691         rtp->lastrxseqno = seqno;
1692         
1693         if (!rtp->themssrc)
1694                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1695         
1696         if (rtp_debug_test_addr(&sock_in))
1697                 ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1698                         ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1699
1700         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1701         if (!rtpPT.isAstFormat) {
1702                 struct ast_frame *f = NULL;
1703
1704                 /* This is special in-band data that's not one of our codecs */
1705                 if (rtpPT.code == AST_RTP_DTMF) {
1706                         /* It's special -- rfc2833 process it */
1707                         if (rtp_debug_test_addr(&sock_in)) {
1708                                 unsigned char *data;
1709                                 unsigned int event;
1710                                 unsigned int event_end;
1711                                 unsigned int duration;
1712                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1713                                 event = ntohl(*((unsigned int *)(data)));
1714                                 event >>= 24;
1715                                 event_end = ntohl(*((unsigned int *)(data)));
1716                                 event_end <<= 8;
1717                                 event_end >>= 24;
1718                                 duration = ntohl(*((unsigned int *)(data)));
1719                                 duration &= 0xFFFF;
1720                                 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(sock_in.sin_addr), ntohs(sock_in.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration);
1721                         }
1722                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp);
1723                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1724                         /* It's really special -- process it the Cisco way */
1725                         if (rtp->lastevent <= seqno || (rtp->lastevent >= 65530 && seqno <= 6)) {
1726                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1727                                 rtp->lastevent = seqno;
1728                         }
1729                 } else if (rtpPT.code == AST_RTP_CN) {
1730                         /* Comfort Noise */
1731                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1732                 } else {
1733                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1734                 }
1735                 return f ? f : &ast_null_frame;
1736         }
1737         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1738         rtp->f.frametype = (rtp->f.subclass & AST_FORMAT_AUDIO_MASK) ? AST_FRAME_VOICE : (rtp->f.subclass & AST_FORMAT_VIDEO_MASK) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
1739
1740         rtp->rxseqno = seqno;
1741
1742         if (rtp->dtmfcount) {
1743                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
1744
1745                 if (rtp->dtmfcount < 0) {
1746                         rtp->dtmfcount = 0;
1747                 }
1748
1749                 if (rtp->resp && !rtp->dtmfcount) {
1750                         struct ast_frame *f;
1751                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
1752                         rtp->resp = 0;
1753                         return f;
1754                 }
1755         }
1756
1757         /* Record received timestamp as last received now */
1758         rtp->lastrxts = timestamp;
1759
1760         rtp->f.mallocd = 0;
1761         rtp->f.datalen = res - hdrlen;
1762         rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1763         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1764         rtp->f.seqno = seqno;
1765
1766         if (rtp->f.subclass == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
1767                   unsigned char *data = rtp->f.data.ptr;
1768                   
1769                   memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
1770                   rtp->f.datalen +=3;
1771                   *data++ = 0xEF;
1772                   *data++ = 0xBF;
1773                   *data = 0xBD;
1774         }
1775  
1776         if (rtp->f.subclass == AST_FORMAT_T140RED) {
1777                 unsigned char *data = rtp->f.data.ptr;
1778                 unsigned char *header_end;
1779                 int num_generations;
1780                 int header_length;
1781                 int length;
1782                 int diff =(int)seqno - (prev_seqno+1); /* if diff = 0, no drop*/
1783                 int x;
1784
1785                 rtp->f.subclass = AST_FORMAT_T140;
1786                 header_end = memchr(data, ((*data) & 0x7f), rtp->f.datalen);
1787                 header_end++;
1788                 
1789                 header_length = header_end - data;
1790                 num_generations = header_length / 4;
1791                 length = header_length;
1792
1793                 if (!diff) {
1794                         for (x = 0; x < num_generations; x++)
1795                                 length += data[x * 4 + 3];
1796                         
1797                         if (!(rtp->f.datalen - length))
1798                                 return &ast_null_frame;
1799                         
1800                         rtp->f.data.ptr += length;
1801                         rtp->f.datalen -= length;
1802                 } else if (diff > num_generations && diff < 10) {
1803                         length -= 3;
1804                         rtp->f.data.ptr += length;
1805                         rtp->f.datalen -= length;
1806                         
1807                         data = rtp->f.data.ptr;
1808                         *data++ = 0xEF;
1809                         *data++ = 0xBF;
1810                         *data = 0xBD;
1811                 } else  {
1812                         for ( x = 0; x < num_generations - diff; x++) 
1813                                 length += data[x * 4 + 3];
1814                         
1815                         rtp->f.data.ptr += length;
1816                         rtp->f.datalen -= length;
1817                 }
1818         }
1819
1820         if (rtp->f.subclass & AST_FORMAT_AUDIO_MASK) {
1821                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1822                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
1823                         ast_frame_byteswap_be(&rtp->f);
1824                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1825                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1826                 ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
1827                 rtp->f.ts = timestamp / 8;
1828                 rtp->f.len = rtp->f.samples / ((ast_format_rate(rtp->f.subclass) / 1000));
1829         } else if (rtp->f.subclass & AST_FORMAT_VIDEO_MASK) {
1830                 /* Video -- samples is # of samples vs. 90000 */
1831                 if (!rtp->lastividtimestamp)
1832                         rtp->lastividtimestamp = timestamp;
1833                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1834                 rtp->lastividtimestamp = timestamp;
1835                 rtp->f.delivery.tv_sec = 0;
1836                 rtp->f.delivery.tv_usec = 0;
1837                 /* Pass the RTP marker bit as bit 0 in the subclass field.
1838                  * This is ok because subclass is actually a bitmask, and
1839                  * the low bits represent audio formats, that are not
1840                  * involved here since we deal with video.
1841                  */
1842                 if (mark)
1843                         rtp->f.subclass |= 0x1;
1844         } else {
1845                 /* TEXT -- samples is # of samples vs. 1000 */
1846                 if (!rtp->lastitexttimestamp)
1847                         rtp->lastitexttimestamp = timestamp;
1848                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
1849                 rtp->lastitexttimestamp = timestamp;
1850                 rtp->f.delivery.tv_sec = 0;
1851                 rtp->f.delivery.tv_usec = 0;
1852         }
1853         rtp->f.src = "RTP";
1854         return &rtp->f;
1855 }
1856
1857 /* The following array defines the MIME Media type (and subtype) for each
1858    of our codecs, or RTP-specific data type. */
1859 static const struct mimeType {
1860         struct rtpPayloadType payloadType;
1861         char *type;
1862         char *subtype;
1863         unsigned int sample_rate;
1864 } mimeTypes[] = {
1865         {{1, AST_FORMAT_G723_1}, "audio", "G723", 8000},
1866         {{1, AST_FORMAT_GSM}, "audio", "GSM", 8000},
1867         {{1, AST_FORMAT_ULAW}, "audio", "PCMU", 8000},
1868         {{1, AST_FORMAT_ULAW}, "audio", "G711U", 8000},
1869         {{1, AST_FORMAT_ALAW}, "audio", "PCMA", 8000},
1870         {{1, AST_FORMAT_ALAW}, "audio", "G711A", 8000},
1871         {{1, AST_FORMAT_G726}, "audio", "G726-32", 8000},
1872         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4", 8000},
1873         {{1, AST_FORMAT_SLINEAR}, "audio", "L16", 8000},
1874         {{1, AST_FORMAT_LPC10}, "audio", "LPC", 8000},
1875         {{1, AST_FORMAT_G729A}, "audio", "G729", 8000},
1876         {{1, AST_FORMAT_G729A}, "audio", "G729A", 8000},
1877         {{1, AST_FORMAT_G729A}, "audio", "G.729", 8000},
1878         {{1, AST_FORMAT_SPEEX}, "audio", "speex", 8000},
1879         {{1, AST_FORMAT_ILBC}, "audio", "iLBC", 8000},
1880         /* this is the sample rate listed in the RTP profile for the G.722
1881            codec, *NOT* the actual sample rate of the media stream
1882         */
1883         {{1, AST_FORMAT_G722}, "audio", "G722", 8000},
1884         {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32", 8000},
1885         {{0, AST_RTP_DTMF}, "audio", "telephone-event", 8000},
1886         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event", 8000},
1887         {{0, AST_RTP_CN}, "audio", "CN", 8000},
1888         {{1, AST_FORMAT_JPEG}, "video", "JPEG", 90000},
1889         {{1, AST_FORMAT_PNG}, "video", "PNG", 90000},
1890         {{1, AST_FORMAT_H261}, "video", "H261", 90000},
1891         {{1, AST_FORMAT_H263}, "video", "H263", 90000},
1892         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998", 90000},
1893         {{1, AST_FORMAT_H264}, "video", "H264", 90000},
1894         {{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES", 90000},
1895         {{1, AST_FORMAT_T140RED}, "text", "RED", 1000},
1896         {{1, AST_FORMAT_T140}, "text", "T140", 1000},
1897         {{1, AST_FORMAT_SIREN7}, "audio", "G7221", 16000},
1898         {{1, AST_FORMAT_SIREN14}, "audio", "G7221", 32000},
1899 };
1900
1901 /*! 
1902  * \brief Mapping between Asterisk codecs and rtp payload types
1903  *
1904  * Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1905  * also, our own choices for dynamic payload types.  This is our master
1906  * table for transmission 
1907  * 
1908  * See http://www.iana.org/assignments/rtp-parameters for a list of
1909  * assigned values
1910  */
1911 static const struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1912         [0] = {1, AST_FORMAT_ULAW},
1913 #ifdef USE_DEPRECATED_G726
1914         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1915 #endif
1916         [3] = {1, AST_FORMAT_GSM},
1917         [4] = {1, AST_FORMAT_G723_1},
1918         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1919         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1920         [7] = {1, AST_FORMAT_LPC10},
1921         [8] = {1, AST_FORMAT_ALAW},
1922         [9] = {1, AST_FORMAT_G722},
1923         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1924         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1925         [13] = {0, AST_RTP_CN},
1926         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1927         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1928         [18] = {1, AST_FORMAT_G729A},
1929         [19] = {0, AST_RTP_CN},         /* Also used for CN */
1930         [26] = {1, AST_FORMAT_JPEG},
1931         [31] = {1, AST_FORMAT_H261},
1932         [34] = {1, AST_FORMAT_H263},
1933         [97] = {1, AST_FORMAT_ILBC},
1934         [98] = {1, AST_FORMAT_H263_PLUS},
1935         [99] = {1, AST_FORMAT_H264},
1936         [101] = {0, AST_RTP_DTMF},
1937         [102] = {1, AST_FORMAT_SIREN7},
1938         [103] = {1, AST_FORMAT_H263_PLUS},
1939         [104] = {1, AST_FORMAT_MP4_VIDEO},
1940         [105] = {1, AST_FORMAT_T140RED},        /* Real time text chat (with redundancy encoding) */
1941         [106] = {1, AST_FORMAT_T140},   /* Real time text chat */
1942         [110] = {1, AST_FORMAT_SPEEX},
1943         [111] = {1, AST_FORMAT_G726},
1944         [112] = {1, AST_FORMAT_G726_AAL2},
1945         [115] = {1, AST_FORMAT_SIREN14},
1946         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1947 };
1948
1949 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
1950 {
1951         int i;
1952
1953         if (!rtp)
1954                 return;
1955
1956         rtp_bridge_lock(rtp);
1957
1958         for (i = 0; i < MAX_RTP_PT; ++i) {
1959                 rtp->current_RTP_PT[i].isAstFormat = 0;
1960                 rtp->current_RTP_PT[i].code = 0;
1961         }
1962
1963         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1964         rtp->rtp_lookup_code_cache_code = 0;
1965         rtp->rtp_lookup_code_cache_result = 0;
1966
1967         rtp_bridge_unlock(rtp);
1968 }
1969
1970 void ast_rtp_pt_default(struct ast_rtp* rtp) 
1971 {
1972         int i;
1973
1974         rtp_bridge_lock(rtp);
1975
1976         /* Initialize to default payload types */
1977         for (i = 0; i < MAX_RTP_PT; ++i) {
1978                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1979                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1980         }
1981
1982         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1983         rtp->rtp_lookup_code_cache_code = 0;
1984         rtp->rtp_lookup_code_cache_result = 0;
1985
1986         rtp_bridge_unlock(rtp);
1987 }
1988
1989 void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
1990 {
1991         unsigned int i;
1992
1993         rtp_bridge_lock(dest);
1994         rtp_bridge_lock(src);
1995
1996         for (i = 0; i < MAX_RTP_PT; ++i) {
1997                 dest->current_RTP_PT[i].isAstFormat = 
1998                         src->current_RTP_PT[i].isAstFormat;
1999                 dest->current_RTP_PT[i].code = 
2000                         src->current_RTP_PT[i].code; 
2001         }
2002         dest->rtp_lookup_code_cache_isAstFormat = 0;
2003         dest->rtp_lookup_code_cache_code = 0;
2004         dest->rtp_lookup_code_cache_result = 0;
2005
2006         rtp_bridge_unlock(src);
2007         rtp_bridge_unlock(dest);
2008 }
2009
2010 /*! \brief Get channel driver interface structure */
2011 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
2012 {
2013         struct ast_rtp_protocol *cur = NULL;
2014
2015         AST_RWLIST_RDLOCK(&protos);
2016         AST_RWLIST_TRAVERSE(&protos, cur, list) {
2017                 if (cur->type == chan->tech->type)
2018                         break;
2019         }
2020         AST_RWLIST_UNLOCK(&protos);
2021
2022         return cur;
2023 }
2024
2025 int ast_rtp_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
2026 {
2027         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
2028         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
2029         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
2030         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
2031         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED, text_dest_res = AST_RTP_GET_FAILED;
2032         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED, text_src_res = AST_RTP_GET_FAILED;
2033         int srccodec, destcodec, nat_active = 0;
2034
2035         /* Lock channels */
2036         ast_channel_lock(c0);
2037         if (c1) {
2038                 while (ast_channel_trylock(c1)) {
2039                         ast_channel_unlock(c0);
2040                         usleep(1);
2041                         ast_channel_lock(c0);
2042                 }
2043         }
2044
2045         /* Find channel driver interfaces */
2046         destpr = get_proto(c0);
2047         if (c1)
2048                 srcpr = get_proto(c1);
2049         if (!destpr) {
2050                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c0->name);
2051                 ast_channel_unlock(c0);
2052                 if (c1)
2053                         ast_channel_unlock(c1);
2054                 return -1;
2055         }
2056         if (!srcpr) {
2057                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>");
2058                 ast_channel_unlock(c0);
2059                 if (c1)
2060                         ast_channel_unlock(c1);
2061                 return -1;
2062         }
2063
2064         /* Get audio, video  and text interface (if native bridge is possible) */
2065         audio_dest_res = destpr->get_rtp_info(c0, &destp);
2066         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED;
2067         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(c0, &tdestp) : AST_RTP_GET_FAILED;
2068         if (srcpr) {
2069                 audio_src_res = srcpr->get_rtp_info(c1, &srcp);
2070                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED;
2071                 text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(c1, &tsrcp) : AST_RTP_GET_FAILED;
2072         }
2073
2074         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
2075         if (audio_dest_res != AST_RTP_TRY_NATIVE || (video_dest_res != AST_RTP_GET_FAILED && video_dest_res != AST_RTP_TRY_NATIVE)) {
2076                 /* Somebody doesn't want to play... */
2077                 ast_channel_unlock(c0);
2078                 if (c1)
2079                         ast_channel_unlock(c1);
2080                 return -1;
2081         }
2082         if (audio_src_res == AST_RTP_TRY_NATIVE && (video_src_res == AST_RTP_GET_FAILED || video_src_res == AST_RTP_TRY_NATIVE) && srcpr->get_codec)
2083                 srccodec = srcpr->get_codec(c1);
2084         else
2085                 srccodec = 0;
2086         if (audio_dest_res == AST_RTP_TRY_NATIVE && (video_dest_res == AST_RTP_GET_FAILED || video_dest_res == AST_RTP_TRY_NATIVE) && destpr->get_codec)
2087                 destcodec = destpr->get_codec(c0);
2088         else
2089                 destcodec = 0;
2090         /* Ensure we have at least one matching codec */
2091         if (srcp && !(srccodec & destcodec)) {
2092                 ast_channel_unlock(c0);
2093                 ast_channel_unlock(c1);
2094                 return 0;
2095         }
2096         /* Consider empty media as non-existent */
2097         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
2098                 srcp = NULL;
2099         if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
2100                 nat_active = 1;
2101         /* Bridge media early */
2102         if (destpr->set_rtp_peer(c0, srcp, vsrcp, tsrcp, srccodec, nat_active))
2103                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
2104         ast_channel_unlock(c0);
2105         if (c1)
2106                 ast_channel_unlock(c1);
2107         ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
2108         return 0;
2109 }
2110
2111 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
2112 {
2113         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
2114         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
2115         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
2116         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
2117         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED, text_dest_res = AST_RTP_GET_FAILED;
2118         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED, text_src_res = AST_RTP_GET_FAILED; 
2119         int srccodec, destcodec;
2120
2121         /* Lock channels */
2122         ast_channel_lock(dest);
2123         while (ast_channel_trylock(src)) {
2124                 ast_channel_unlock(dest);
2125                 usleep(1);
2126                 ast_channel_lock(dest);
2127         }
2128
2129         /* Find channel driver interfaces */
2130         if (!(destpr = get_proto(dest))) {
2131                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", dest->name);
2132                 ast_channel_unlock(dest);
2133                 ast_channel_unlock(src);
2134                 return 0;
2135         }
2136         if (!(srcpr = get_proto(src))) {
2137                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", src->name);
2138                 ast_channel_unlock(dest);
2139                 ast_channel_unlock(src);
2140                 return 0;
2141         }
2142
2143         /* Get audio and video interface (if native bridge is possible) */
2144         audio_dest_res = destpr->get_rtp_info(dest, &destp);
2145         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
2146         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(dest, &tdestp) : AST_RTP_GET_FAILED;
2147         audio_src_res = srcpr->get_rtp_info(src, &srcp);
2148         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
2149         text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(src, &tsrcp) : AST_RTP_GET_FAILED;
2150
2151         /* Ensure we have at least one matching codec */
2152         if (srcpr->get_codec)
2153                 srccodec = srcpr->get_codec(src);
2154         else
2155                 srccodec = 0;
2156         if (destpr->get_codec)
2157                 destcodec = destpr->get_codec(dest);
2158         else
2159                 destcodec = 0;
2160
2161         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
2162         if (audio_dest_res != AST_RTP_TRY_NATIVE || (video_dest_res != AST_RTP_GET_FAILED && video_dest_res != AST_RTP_TRY_NATIVE) || audio_src_res != AST_RTP_TRY_NATIVE || (video_src_res != AST_RTP_GET_FAILED && video_src_res != AST_RTP_TRY_NATIVE) || !(srccodec & destcodec)) {
2163                 /* Somebody doesn't want to play... */
2164                 ast_channel_unlock(dest);
2165                 ast_channel_unlock(src);
2166                 return 0;
2167         }
2168         ast_rtp_pt_copy(destp, srcp);
2169         if (vdestp && vsrcp)
2170                 ast_rtp_pt_copy(vdestp, vsrcp);
2171         if (tdestp && tsrcp)
2172                 ast_rtp_pt_copy(tdestp, tsrcp);
2173         if (media) {
2174                 /* Bridge early */
2175                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, tsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
2176                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
2177         }
2178         ast_channel_unlock(dest);
2179         ast_channel_unlock(src);
2180         ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
2181         return 1;
2182 }
2183
2184 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
2185  * By default, use the well-known value for this type (although it may 
2186  * still be set to a different value by a subsequent "a=rtpmap:" line)
2187  */
2188 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
2189 {
2190         if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) 
2191                 return; /* bogus payload type */
2192
2193         rtp_bridge_lock(rtp);
2194         rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
2195         rtp_bridge_unlock(rtp);
2196
2197
2198 /*! \brief remove setting from payload type list if the rtpmap header indicates
2199         an unknown media type */
2200 void ast_rtp_unset_m_type(struct ast_rtp* rtp, int pt) 
2201 {
2202         if (pt < 0 || pt > MAX_RTP_PT)
2203                 return; /* bogus payload type */
2204
2205         rtp_bridge_lock(rtp);
2206         rtp->current_RTP_PT[pt].isAstFormat = 0;
2207         rtp->current_RTP_PT[pt].code = 0;
2208         rtp_bridge_unlock(rtp);
2209 }
2210
2211 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
2212  * an SDP "a=rtpmap:" line.
2213  * \return 0 if the MIME type was found and set, -1 if it wasn't found
2214  */
2215 int ast_rtp_set_rtpmap_type_rate(struct ast_rtp *rtp, int pt,
2216                                  char *mimeType, char *mimeSubtype,
2217                                  enum ast_rtp_options options,
2218                                  unsigned int sample_rate)
2219 {
2220         unsigned int i;
2221         int found = 0;
2222
2223         if (pt < 0 || pt > MAX_RTP_PT)
2224                 return -1; /* bogus payload type */
2225
2226         rtp_bridge_lock(rtp);
2227
2228         for (i = 0; i < ARRAY_LEN(mimeTypes); ++i) {
2229                 const struct mimeType *t = &mimeTypes[i];
2230
2231                 if (strcasecmp(mimeSubtype, t->subtype)) {
2232                         continue;
2233                 }
2234
2235                 if (strcasecmp(mimeType, t->type)) {
2236                         continue;
2237                 }
2238
2239                 /* if both sample rates have been supplied, and they don't match,
2240                    then this not a match; if one has not been supplied, then the
2241                    rates are not compared */
2242                 if (sample_rate && t->sample_rate &&
2243                     (sample_rate != t->sample_rate)) {
2244                         continue;
2245                 }
2246
2247                 found = 1;
2248                 rtp->current_RTP_PT[pt] = t->payloadType;
2249
2250                 if ((t->payloadType.code == AST_FORMAT_G726) &&
2251                     t->payloadType.isAstFormat &&
2252                     (options & AST_RTP_OPT_G726_NONSTANDARD)) {
2253                         rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
2254                 }
2255
2256                 break;
2257         }
2258
2259         rtp_bridge_unlock(rtp);
2260
2261         return (found ? 0 : -2);
2262 }
2263
2264 int ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
2265                             char *mimeType, char *mimeSubtype,
2266                             enum ast_rtp_options options)
2267 {
2268         return ast_rtp_set_rtpmap_type_rate(rtp, pt, mimeType, mimeSubtype, options, 0);
2269 }
2270
2271 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
2272  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
2273 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
2274                                  int* astFormats, int* nonAstFormats)
2275 {
2276         int pt;
2277         
2278         rtp_bridge_lock(rtp);
2279         
2280         *astFormats = *nonAstFormats = 0;
2281         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2282                 if (rtp->current_RTP_PT[pt].isAstFormat) {
2283                         *astFormats |= rtp->current_RTP_PT[pt].code;
2284                 } else {
2285                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
2286                 }
2287         }
2288
2289         rtp_bridge_unlock(rtp);
2290 }
2291
2292 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
2293 {
2294         struct rtpPayloadType result;
2295
2296         result.isAstFormat = result.code = 0;
2297
2298         if (pt < 0 || pt > MAX_RTP_PT) 
2299                 return result; /* bogus payload type */
2300
2301         /* Start with negotiated codecs */
2302         rtp_bridge_lock(rtp);
2303         result = rtp->current_RTP_PT[pt];
2304         rtp_bridge_unlock(rtp);
2305
2306         /* If it doesn't exist, check our static RTP type list, just in case */
2307         if (!result.code) 
2308                 result = static_RTP_PT[pt];
2309
2310         return result;
2311 }
2312
2313 /*! \brief Looks up an RTP code out of our *static* outbound list */
2314 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
2315 {
2316         int pt = 0;
2317
2318         rtp_bridge_lock(rtp);
2319
2320         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
2321                 code == rtp->rtp_lookup_code_cache_code) {
2322                 /* Use our cached mapping, to avoid the overhead of the loop below */
2323                 pt = rtp->rtp_lookup_code_cache_result;
2324                 rtp_bridge_unlock(rtp);
2325                 return pt;
2326         }
2327
2328         /* Check the dynamic list first */
2329         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2330                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
2331                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
2332                         rtp->rtp_lookup_code_cache_code = code;
2333                         rtp->rtp_lookup_code_cache_result = pt;
2334                         rtp_bridge_unlock(rtp);
2335                         return pt;
2336                 }
2337         }
2338
2339         /* Then the static list */
2340         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2341                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
2342                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
2343                         rtp->rtp_lookup_code_cache_code = code;
2344                         rtp->rtp_lookup_code_cache_result = pt;
2345                         rtp_bridge_unlock(rtp);
2346                         return pt;
2347                 }
2348         }
2349
2350         rtp_bridge_unlock(rtp);
2351
2352         return -1;
2353 }
2354
2355 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
2356                                   enum ast_rtp_options options)
2357 {
2358         unsigned int i;
2359
2360         for (i = 0; i < ARRAY_LEN(mimeTypes); ++i) {
2361                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
2362                         if (isAstFormat &&
2363                             (code == AST_FORMAT_G726_AAL2) &&
2364                             (options & AST_RTP_OPT_G726_NONSTANDARD))
2365                                 return "G726-32";
2366                         else
2367                                 return mimeTypes[i].subtype;
2368                 }
2369         }
2370
2371         return "";
2372 }
2373
2374 unsigned int ast_rtp_lookup_sample_rate(int isAstFormat, int code)
2375 {
2376         unsigned int i;
2377
2378         for (i = 0; i < ARRAY_LEN(mimeTypes); ++i) {
2379                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
2380                         return mimeTypes[i].sample_rate;
2381                 }
2382         }
2383
2384         return 0;
2385 }
2386
2387 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
2388                                    const int isAstFormat, enum ast_rtp_options options)
2389 {
2390         int format;
2391         unsigned len;
2392         char *end = buf;
2393         char *start = buf;
2394
2395         if (!buf || !size)
2396                 return NULL;
2397
2398         snprintf(end, size, "0x%x (", capability);
2399
2400         len = strlen(end);
2401         end += len;
2402         size -= len;
2403         start = end;
2404
2405         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
2406                 if (capability & format) {
2407                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
2408
2409                         snprintf(end, size, "%s|", name);
2410                         len = strlen(end);
2411                         end += len;
2412                         size -= len;
2413                 }
2414         }
2415
2416         if (start == end)
2417                 ast_copy_string(start, "nothing)", size); 
2418         else if (size > 1)
2419                 *(end -1) = ')';
2420         
2421         return buf;
2422 }
2423
2424 /*! \brief Open RTP or RTCP socket for a session.
2425  * Print a message on failure. 
2426  */
2427 static int rtp_socket(const char *type)
2428 {
2429         int s = socket(AF_INET, SOCK_DGRAM, 0);
2430         if (s < 0) {
2431                 if (type == NULL)
2432                         type = "RTP/RTCP";
2433                 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
2434         } else {
2435                 long flags = fcntl(s, F_GETFL);
2436                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
2437 #ifdef SO_NO_CHECK
2438                 if (nochecksums)
2439                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
2440 #endif
2441         }
2442         return s;
2443 }
2444
2445 /*!
2446  * \brief Initialize a new RTCP session.
2447  * 
2448  * \returns The newly initialized RTCP session.
2449  */
2450 static struct ast_rtcp *ast_rtcp_new(void)
2451 {
2452         struct ast_rtcp *rtcp;
2453
2454         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
2455                 return NULL;
2456         rtcp->s = rtp_socket("RTCP");
2457         rtcp->us.sin_family = AF_INET;
2458         rtcp->them.sin_family = AF_INET;
2459         rtcp->schedid = -1;
2460
2461         if (rtcp->s < 0) {
2462                 ast_free(rtcp);
2463                 return NULL;
2464         }
2465
2466         return rtcp;
2467 }
2468
2469 /*!
2470  * \brief Initialize a new RTP structure.
2471  *
2472  */
2473 void ast_rtp_new_init(struct ast_rtp *rtp)
2474 {
2475 #ifdef P2P_INTENSE
2476         ast_mutex_init(&rtp->bridge_lock);
2477 #endif
2478
2479         rtp->them.sin_family = AF_INET;
2480         rtp->us.sin_family = AF_INET;
2481         rtp->ssrc = ast_random();
2482         rtp->seqno = ast_random() & 0xffff;
2483         ast_set_flag(rtp, FLAG_HAS_DTMF);
2484         rtp->strict_rtp_state = (strictrtp ? STRICT_RTP_LEARN : STRICT_RTP_OPEN);
2485 }
2486
2487 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
2488 {
2489         struct ast_rtp *rtp;
2490         int x;
2491         int startplace;
2492         
2493         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
2494                 return NULL;
2495
2496         ast_rtp_new_init(rtp);
2497
2498         rtp->s = rtp_socket("RTP");
2499         if (rtp->s < 0)
2500                 goto fail;
2501         if (sched && rtcpenable) {
2502                 rtp->sched = sched;
2503                 rtp->rtcp = ast_rtcp_new();
2504         }
2505         
2506         /*
2507          * Try to bind the RTP port, x, and possibly the RTCP port, x+1 as well.
2508          * Start from a random (even, by RTP spec) port number, and
2509          * iterate until success or no ports are available.
2510          * Note that the requirement of RTP port being even, or RTCP being the
2511          * next one, cannot be enforced in presence of a NAT box because the
2512          * mapping is not under our control.
2513          */
2514         x = (rtpend == rtpstart) ? rtpstart : (ast_random() % (rtpend - rtpstart)) + rtpstart;
2515         x = x & ~1;             /* make it an even number */
2516         startplace = x;         /* remember the starting point */
2517         /* this is constant across the loop */
2518         rtp->us.sin_addr = addr;
2519         if (rtp->rtcp)
2520                 rtp->rtcp->us.sin_addr = addr;
2521         for (;;) {
2522                 rtp->us.sin_port = htons(x);
2523                 if (!bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) {
2524                         /* bind succeeded, if no rtcp then we are done */
2525                         if (!rtp->rtcp)
2526                                 break;
2527                         /* have rtcp, try to bind it */
2528                         rtp->rtcp->us.sin_port = htons(x + 1);
2529                         if (!bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us)))
2530                                 break;  /* success again, we are really done */
2531                         /*
2532                          * RTCP bind failed, so close and recreate the
2533                          * already bound RTP socket for the next round.
2534                          */
2535                         close(rtp->s);
2536                         rtp->s = rtp_socket("RTP");
2537                         if (rtp->s < 0)
2538                                 goto fail;
2539                 }
2540                 /*
2541                  * If we get here, there was an error in one of the bind()
2542                  * calls, so make sure it is nothing unexpected.
2543                  */
2544                 if (errno != EADDRINUSE) {
2545                         /* We got an error that wasn't expected, abort! */
2546                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
2547                         goto fail;
2548                 }
2549                 /*
2550                  * One of the ports is in use. For the next iteration,
2551                  * increment by two and handle wraparound.
2552                  * If we reach the starting point, then declare failure.
2553                  */
2554                 x += 2;
2555                 if (x > rtpend)
2556                         x = (rtpstart + 1) & ~1;
2557                 if (x == startplace) {
2558                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
2559                         goto fail;
2560                 }
2561         }
2562         rtp->sched = sched;
2563         rtp->io = io;
2564         if (callbackmode) {
2565                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2566                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
2567         }
2568         ast_rtp_pt_default(rtp);
2569         return rtp;
2570
2571 fail:
2572         if (rtp->s >= 0)
2573                 close(rtp->s);
2574         if (rtp->rtcp) {
2575                 close(rtp->rtcp->s);
2576                 ast_free(rtp->rtcp);
2577         }
2578         ast_free(rtp);
2579         return NULL;
2580 }
2581
2582 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
2583 {
2584         struct in_addr ia;
2585
2586         memset(&ia, 0, sizeof(ia));
2587         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
2588 }
2589
2590 int ast_rtp_setqos(struct ast_rtp *rtp, int type_of_service, int class_of_service, char *desc)
2591 {
2592         return ast_netsock_set_qos(rtp->s, type_of_service, class_of_service, desc);
2593 }
2594
2595 void ast_rtp_new_source(struct ast_rtp *rtp)
2596 {
2597         if (rtp) {
2598                 rtp->set_marker_bit = 1;
2599         }
2600         return;
2601 }
2602
2603 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2604 {
2605         rtp->them.sin_port = them->sin_port;
2606         rtp->them.sin_addr = them->sin_addr;
2607         if (rtp->rtcp) {
2608                 int h = ntohs(them->sin_port);
2609                 rtp->rtcp->them.sin_port = htons(h + 1);
2610                 rtp->rtcp->them.sin_addr = them->sin_addr;
2611         }
2612         rtp->rxseqno = 0;
2613         /* If strict RTP protection is enabled switch back to the learn state so we don't drop packets from above */
2614         if (strictrtp)
2615                 rtp->strict_rtp_state = STRICT_RTP_LEARN;
2616 }
2617
2618 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2619 {
2620         if ((them->sin_family != AF_INET) ||
2621                 (them->sin_port != rtp->them.sin_port) ||
2622                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2623                 them->sin_family = AF_INET;
2624                 them->sin_port = rtp->them.sin_port;
2625                 them->sin_addr = rtp->them.sin_addr;
2626                 return 1;
2627         }
2628         return 0;
2629 }
2630
2631 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2632 {
2633         *us = rtp->us;
2634 }
2635
2636 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2637 {
2638         struct ast_rtp *bridged = NULL;
2639
2640         rtp_bridge_lock(rtp);
2641         bridged = rtp->bridged;
2642         rtp_bridge_unlock(rtp);
2643
2644         return bridged;
2645 }
2646
2647 void ast_rtp_stop(struct ast_rtp *rtp)
2648 {
2649         if (rtp->rtcp) {
2650                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2651         }
2652         if (rtp->red) {
2653                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
2654                 free(rtp->red);
2655                 rtp->red = NULL;
2656         }
2657
2658         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2659         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2660         if (rtp->rtcp) {
2661                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2662                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2663         }
2664         
2665         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2666 }
2667
2668 void ast_rtp_reset(struct ast_rtp *rtp)
2669 {
2670         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2671         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2672         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2673         rtp->lastts = 0;
2674         rtp->lastdigitts = 0;
2675         rtp->lastrxts = 0;
2676         rtp->lastividtimestamp = 0;
2677         rtp->lastovidtimestamp = 0;
2678         rtp->lastitexttimestamp = 0;
2679         rtp->lastotexttimestamp = 0;
2680         rtp->lasteventseqn = 0;
2681         rtp->lastevent = 0;
2682         rtp->lasttxformat = 0;
2683         rtp->lastrxformat = 0;
2684         rtp->dtmfcount = 0;
2685         rtp->dtmfsamples = 0;
2686         rtp->seqno = 0;
2687         rtp->rxseqno = 0;
2688 }
2689
2690 /*! Get QoS values from RTP and RTCP data (used in "sip show channelstats") */
2691 unsigned int ast_rtp_get_qosvalue(struct ast_rtp *rtp, enum ast_rtp_qos_vars value)
2692 {
2693         if (rtp == NULL) {
2694                 if (option_debug > 1)
2695                         ast_log(LOG_DEBUG, "NO RTP Structure? Kidding me? \n");
2696                 return 0;
2697         }
2698         if (option_debug > 1 && rtp->rtcp == NULL) {
2699                 ast_log(LOG_DEBUG, "NO RTCP structure. Maybe in RTP p2p bridging mode? \n");
2700         }
2701
2702         switch (value) {
2703         case AST_RTP_TXCOUNT:
2704                 return (unsigned int) rtp->txcount;
2705         case AST_RTP_RXCOUNT:
2706                 return (unsigned int) rtp->rxcount;
2707         case AST_RTP_TXJITTER:
2708                 return (unsigned int) (rtp->rxjitter * 100.0);
2709         case AST_RTP_RXJITTER:
2710                 return (unsigned int) (rtp->rtcp ? (rtp->rtcp->reported_jitter / (unsigned int) 65536.0) : 0);
2711         case AST_RTP_RXPLOSS:
2712                 return rtp->rtcp ? (rtp->rtcp->expected_prior - rtp->rtcp->received_prior) : 0;
2713         case AST_RTP_TXPLOSS:
2714                 return rtp->rtcp ? rtp->rtcp->reported_lost : 0;
2715         case AST_RTP_RTT:
2716                 return (unsigned int) (rtp->rtcp ? (rtp->rtcp->rtt * 100) : 0);
2717         }
2718         return 0;       /* To make the compiler happy */
2719 }
2720
2721 static double __ast_rtp_get_qos(struct ast_rtp *rtp, const char *qos, int *found)
2722 {
2723         *found = 1;
2724
2725         if (!strcasecmp(qos, "remote_maxjitter"))
2726                 return rtp->rtcp->reported_maxjitter * 1000.0;
2727         if (!strcasecmp(qos, "remote_minjitter"))
2728                 return rtp->rtcp->reported_minjitter * 1000.0;
2729         if (!strcasecmp(qos, "remote_normdevjitter"))
2730                 return rtp->rtcp->reported_normdev_jitter * 1000.0;
2731         if (!strcasecmp(qos, "remote_stdevjitter"))
2732                 return sqrt(rtp->rtcp->reported_stdev_jitter) * 1000.0;
2733
2734         if (!strcasecmp(qos, "local_maxjitter"))
2735                 return rtp->rtcp->maxrxjitter * 1000.0;
2736         if (!strcasecmp(qos, "local_minjitter"))
2737                 return rtp->rtcp->minrxjitter * 1000.0;
2738         if (!strcasecmp(qos, "local_normdevjitter"))
2739                 return rtp->rtcp->normdev_rxjitter * 1000.0;
2740         if (!strcasecmp(qos, "local_stdevjitter"))
2741                 return sqrt(rtp->rtcp->stdev_rxjitter) * 1000.0;
2742
2743         if (!strcasecmp(qos, "maxrtt"))
2744                 return rtp->rtcp->maxrtt * 1000.0;
2745         if (!strcasecmp(qos, "minrtt"))
2746                 return rtp->rtcp->minrtt * 1000.0;
2747         if (!strcasecmp(qos, "normdevrtt"))
2748                 return rtp->rtcp->normdevrtt * 1000.0;
2749         if (!strcasecmp(qos, "stdevrtt"))
2750                 return sqrt(rtp->rtcp->stdevrtt) * 1000.0;
2751
2752         *found = 0;
2753
2754         return 0.0;
2755 }
2756
2757 int ast_rtp_get_qos(struct ast_rtp *rtp, const char *qos, char *buf, unsigned int buflen)
2758 {
2759         double value;
2760         int found;
2761
2762         value = __ast_rtp_get_qos(rtp, qos, &found);
2763
2764         if (!found)
2765                 return -1;
2766
2767         snprintf(buf, buflen, "%.0lf", value);
2768
2769         return 0;
2770 }
2771
2772 void ast_rtp_set_vars(struct ast_channel *chan, struct ast_rtp *rtp) {
2773         char *audioqos;
2774         char *audioqos_jitter;
2775         char *audioqos_loss;
2776         char *audioqos_rtt;
2777         struct ast_channel *bridge;
2778
2779         if (!rtp || !chan)
2780                 return;
2781
2782         bridge = ast_bridged_channel(chan);
2783
2784         audioqos        = ast_rtp_get_quality(rtp, NULL, RTPQOS_SUMMARY);
2785         audioqos_jitter = ast_rtp_get_quality(rtp, NULL, RTPQOS_JITTER);
2786         audioqos_loss   = ast_rtp_get_quality(rtp, NULL, RTPQOS_LOSS);
2787         audioqos_rtt    = ast_rtp_get_quality(rtp, NULL, RTPQOS_RTT);
2788
2789         pbx_builtin_setvar_helper(chan, "RTPAUDIOQOS", audioqos);
2790         pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSJITTER", audioqos_jitter);
2791         pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSLOSS", audioqos_loss);
2792         pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSRTT", audioqos_rtt);
2793
2794         if (!bridge)
2795                 return;
2796
2797         pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSBRIDGED", audioqos);
2798         pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSJITTERBRIDGED", audioqos_jitter);
2799         pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSLOSSBRIDGED", audioqos_loss);
2800         pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSRTTBRIDGED", audioqos_rtt);
2801 }
2802
2803 static char *__ast_rtp_get_quality_jitter(struct ast_rtp *rtp)
2804 {
2805         /*
2806         *ssrc          our ssrc
2807         *themssrc      their ssrc
2808         *lp            lost packets
2809         *rxjitter      our calculated jitter(rx)
2810         *rxcount       no. received packets
2811         *txjitter      reported jitter of the other end
2812         *txcount       transmitted packets
2813         *rlp           remote lost packets
2814         *rtt           round trip time
2815         */
2816 #define RTCP_JITTER_FORMAT1 \
2817         "minrxjitter=%f;" \
2818         "maxrxjitter=%f;" \
2819         "avgrxjitter=%f;" \
2820         "stdevrxjitter=%f;" \
2821         "reported_minjitter=%f;" \
2822         "reported_maxjitter=%f;" \
2823         "reported_avgjitter=%f;" \
2824         "reported_stdevjitter=%f;"
2825
2826 #define RTCP_JITTER_FORMAT2 \
2827         "rxjitter=%f;"
2828
2829         if (rtp->rtcp && rtp->rtcp->rtcp_info) {
2830                 snprintf(rtp->rtcp->quality_jitter, sizeof(rtp->rtcp->quality_jitter), RTCP_JITTER_FORMAT1,
2831                         rtp->rtcp->minrxjitter,
2832                         rtp->rtcp->maxrxjitter,
2833                         rtp->rtcp->normdev_rxjitter,
2834                         sqrt(rtp->rtcp->stdev_rxjitter),
2835                         rtp->rtcp->reported_minjitter,
2836                         rtp->rtcp->reported_maxjitter,
2837                         rtp->rtcp->reported_normdev_jitter,
2838                         sqrt(rtp->rtcp->reported_stdev_jitter)
2839                 );
2840         } else {
2841                 snprintf(rtp->rtcp->quality_jitter, sizeof(rtp->rtcp->quality_jitter), RTCP_JITTER_FORMAT2,
2842                         rtp->rxjitter
2843                 );
2844         }
2845
2846         return rtp->rtcp->quality_jitter;
2847
2848 #undef RTCP_JITTER_FORMAT1
2849 #undef RTCP_JITTER_FORMAT2
2850 }
2851
2852 static char *__ast_rtp_get_quality_loss(struct ast_rtp *rtp)
2853 {
2854         unsigned int lost;
2855         unsigned int extended;
2856         unsigned int expected;
2857         int fraction;
2858
2859 #define RTCP_LOSS_FORMAT1 \
2860         "minrxlost=%f;" \
2861         "maxrxlost=%f;" \
2862         "avgrxlostr=%f;" \
2863         "stdevrxlost=%f;" \
2864         "reported_minlost=%f;" \
2865         "reported_maxlost=%f;" \
2866         "reported_avglost=%f;" \
2867         "reported_stdevlost=%f;"
2868
2869 #define RTCP_LOSS_FORMAT2 \
2870         "lost=%d;" \
2871         "expected=%d;"
2872         
2873         if (rtp->rtcp && rtp->rtcp->rtcp_info && rtp->rtcp->maxrxlost > 0) {
2874                 snprintf(rtp->rtcp->quality_loss, sizeof(rtp->rtcp->quality_loss), RTCP_LOSS_FORMAT1,
2875                         rtp->rtcp->minrxlost,
2876                         rtp->rtcp->maxrxlost,
2877                         rtp->rtcp->normdev_rxlost,
2878                         sqrt(rtp->rtcp->stdev_rxlost),
2879                         rtp->rtcp->reported_minlost,
2880                         rtp->rtcp->reported_maxlost,
2881                         rtp->rtcp->reported_normdev_lost,
2882                         sqrt(rtp->rtcp->reported_stdev_lost)
2883                 );
2884         } else {
2885                 extended = rtp->cycles + rtp->lastrxseqno;
2886                 expected = extended - rtp->seedrxseqno + 1;
2887                 if (rtp->rxcount > expected) 
2888                         expected += rtp->rxcount - expected;
2889                 lost = expected - rtp->rxcount;
2890
2891                 if (!expected || lost <= 0)
2892                         fraction = 0;
2893                 else
2894                         fraction = (lost << 8) / expected;
2895
2896                 snprintf(rtp->rtcp->quality_loss, sizeof(rtp->rtcp->quality_loss), RTCP_LOSS_FORMAT2,
2897                         lost,
2898                         expected
2899                 );
2900         }
2901
2902         return rtp->rtcp->quality_loss;
2903
2904 #undef RTCP_LOSS_FORMAT1
2905 #undef RTCP_LOSS_FORMAT2
2906 }
2907
2908 static char *__ast_rtp_get_quality_rtt(struct ast_rtp *rtp)
2909 {
2910         if (rtp->rtcp && rtp->rtcp->rtcp_info) {
2911                 snprintf(rtp->rtcp->quality_rtt, sizeof(rtp->rtcp->quality_rtt), "minrtt=%f;maxrtt=%f;avgrtt=%f;stdevrtt=%f;",
2912                         rtp->rtcp->minrtt,
2913                         rtp->rtcp->maxrtt,
2914                         rtp->rtcp->normdevrtt,
2915                         sqrt(rtp->rtcp->stdevrtt)
2916                 );
2917         } else {
2918                 snprintf(rtp->rtcp->quality_rtt, sizeof(rtp->rtcp->quality_rtt), "Not available");
2919         }
2920
2921         return rtp->rtcp->quality_rtt;
2922 }
2923
2924 static char *__ast_rtp_get_quality(struct ast_rtp *rtp)
2925 {
2926         /*
2927         *ssrc          our ssrc
2928         *themssrc      their ssrc
2929         *lp            lost packets
2930         *rxjitter      our calculated jitter(rx)
2931         *rxcount       no. received packets
2932         *txjitter      reported jitter of the other end
2933         *txcount       transmitted packets
2934         *rlp           remote lost packets
2935         *rtt           round trip time
2936         */      
2937
2938         if (rtp->rtcp && rtp->rtcp->rtcp_info) {
2939                 snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality),
2940                         "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f",
2941                         rtp->ssrc,
2942                         rtp->themssrc,
2943                         rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2944                         rtp->rxjitter,
2945                         rtp->rxcount,
2946                         (double)rtp->rtcp->reported_jitter / 65536.0,
2947                         rtp->txcount,
2948                         rtp->rtcp->reported_lost,
2949                         rtp->rtcp->rtt
2950                 );
2951         } else {
2952                 snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality), "ssrc=%u;themssrc=%u;rxjitter=%f;rxcount=%u;txcount=%u;",
2953                         rtp->ssrc,
2954                         rtp->themssrc,
2955                         rtp->rxjitter,
2956                         rtp->rxcount,
2957                         rtp->txcount
2958                 );
2959         }
2960
2961         return rtp->rtcp->quality;
2962 }
2963
2964 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual, enum ast_rtp_quality_type qtype) 
2965 {
2966         if (qual && rtp) {
2967                 qual->local_ssrc   = rtp->ssrc;
2968                 qual->local_jitter = rtp->rxjitter;
2969                 qual->local_count  = rtp->rxcount;
2970                 qual->remote_ssrc  = rtp->themssrc;
2971                 qual->remote_count = rtp->txcount;
2972
2973                 if (rtp->rtcp) {
2974                         qual->local_lostpackets  = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2975                         qual->remote_lostpackets = rtp->rtcp->reported_lost;
2976                         qual->remote_jitter      = rtp->rtcp->reported_jitter / 65536.0;
2977                         qual->rtt                = rtp->rtcp->rtt;
2978                 }
2979         }
2980
2981         switch (qtype) {
2982         case RTPQOS_SUMMARY:
2983                 return __ast_rtp_get_quality(rtp);
2984         case RTPQOS_JITTER:
2985                 return __ast_rtp_get_quality_jitter(rtp);
2986         case RTPQOS_LOSS:
2987                 return __ast_rtp_get_quality_loss(rtp);
2988         case RTPQOS_RTT:
2989                 return __ast_rtp_get_quality_rtt(rtp);
2990         }
2991
2992         return NULL;
2993 }
2994
2995 void ast_rtp_destroy(struct ast_rtp *rtp)
2996 {
2997         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2998                 /*Print some info on the call here */
2999                 ast_verbose("  RTP-stats\n");
3000                 ast_verbose("* Our Receiver:\n");
3001                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
3002                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
3003                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp ? (rtp->rtcp->expected_prior - rtp->rtcp->received_prior) : 0);
3004                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
3005                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
3006                 ast_verbose("  RR-count:         %u\n", rtp->rtcp ? rtp->rtcp->rr_count : 0);
3007                 ast_verbose("* Our Sender:\n");
3008                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
3009                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
3010                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp ? rtp->rtcp->reported_lost : 0);
3011                 ast_verbose("  Jitter:           %u\n", rtp->rtcp ? (rtp->rtcp->reported_jitter / (unsigned int)65536.0) : 0);
3012                 ast_verbose("  SR-count:         %u\n", rtp->rtcp ? rtp->rtcp->sr_count : 0);
3013                 ast_verbose("  RTT:              %f\n", rtp->rtcp ? rtp->rtcp->rtt : 0);
3014         }
3015
3016         manager_event(EVENT_FLAG_REPORTING, "RTPReceiverStat", "SSRC: %u\r\n"
3017                                             "ReceivedPackets: %u\r\n"
3018                                             "LostPackets: %u\r\n"
3019                                             "Jitter: %.4f\r\n"
3020                                             "Transit: %.4f\r\n"
3021                                             "RRCount: %u\r\n",
3022                                             rtp->themssrc,
3023                                             rtp->rxcount,
3024                                             rtp->rtcp ? (rtp->rtcp->expected_prior - rtp->rtcp->received_prior) : 0,
3025                                             rtp->rxjitter,
3026                                             rtp->rxtransit,
3027                                             rtp->rtcp ? rtp->rtcp->rr_count : 0);
3028         manager_event(EVENT_FLAG_REPORTING, "RTPSenderStat", "SSRC: %u\r\n"
3029                                             "SentPackets: %u\r\n"
3030                                             "LostPackets: %u\r\n"
3031                                             "Jitter: %u\r\n"
3032                                             "SRCount: %u\r\n"
3033                                             "RTT: %f\r\n",
3034                                             rtp->ssrc,
3035                                             rtp->txcount,
3036                                             rtp->rtcp ? rtp->rtcp->reported_lost : 0,
3037                                             rtp->rtcp ? rtp->rtcp->reported_jitter : 0,
3038                                             rtp->rtcp ? rtp->rtcp->sr_count : 0,
3039                                             rtp->rtcp ? rtp->rtcp->rtt : 0);
3040         if (rtp->smoother)
3041                 ast_smoother_free(rtp->smoother);
3042         if (rtp->ioid)
3043                 ast_io_remove(rtp->io, rtp->ioid);
3044         if (rtp->s > -1)
3045                 close(rtp->s);
3046         if (rtp->rtcp) {
3047                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
3048                 close(rtp->rtcp->s);
3049                 ast_free(rtp->rtcp);
3050                 rtp->rtcp=NULL;
3051         }
3052 #ifdef P2P_INTENSE
3053         ast_mutex_destroy(&rtp->bridge_lock);
3054 #endif
3055         ast_free(rtp);
3056 }
3057
3058 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
3059 {
3060         struct timeval t;
3061         long ms;
3062         if (ast_tvzero(rtp->txcore)) {
3063                 rtp->txcore = ast_tvnow();
3064                 /* Round to 20ms for nice, pretty timestamps */
3065                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
3066         }
3067         /* Use previous txcore if available */
3068         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
3069         ms = ast_tvdiff_ms(t, rtp->txcore);
3070         if (ms < 0)
3071                 ms = 0;
3072         /* Use what we just got for next time */
3073         rtp->txcore = t;
3074         return (unsigned int) ms;
3075 }
3076
3077 /*! \brief Send begin frames for DTMF */
3078 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
3079 {
3080         unsigned int *rtpheader;
3081         int hdrlen = 12, res = 0, i = 0, payload = 0;
3082         char data[256];
3083
3084         if ((digit <= '9') && (digit >= '0'))
3085                 digit -= '0';
3086         else if (digit == '*')
3087                 digit = 10;
3088         else if (digit == '#')
3089                 digit = 11;
3090         else if ((digit >= 'A') && (digit <= 'D'))
3091                 digit = digit - 'A' + 12;
3092         else if ((digit >= 'a') && (digit <= 'd'))
3093                 digit = digit - 'a' + 12;
3094         else {
3095                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
3096                 return 0;
3097         }
3098
3099         /* If we have no peer, return immediately */    
3100         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
3101                 return 0;
3102
3103         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
3104
3105         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
3106         rtp->send_duration = 160;
3107         rtp->lastdigitts = rtp->lastts + rtp->send_duration;
3108         
3109         /* Get a pointer to the header */
3110         rtpheader = (unsigned int *)data;
3111         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
3112         rtpheader[1] = htonl(rtp->lastdigitts);
3113         rtpheader[2] = htonl(rtp->ssrc); 
3114
3115         for (i = 0; i < 2; i++) {
3116                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
3117                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
3118                 if (res < 0) 
3119                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
3120                                 ast_inet_ntoa(rtp->them.sin_addr),
3121                                 ntohs(rtp->them.sin_port), strerror(errno));
3122                 if (rtp_debug_test_addr(&rtp->them))
3123                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
3124                                     ast_inet_ntoa(rtp->them.sin_addr),
3125                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
3126                 /* Increment sequence number */
3127                 rtp->seqno++;
3128                 /* Increment duration */
3129                 rtp->send_duration += 160;
3130                 /* Clear marker bit and set seqno */
3131                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
3132         }
3133
3134         /* Since we received a begin, we can safely store the digit and disable any compensation */
3135         rtp->sending_digit = 1;
3136         rtp->send_digit = digit;
3137         rtp->send_payload = payload;
3138
3139         return 0;
3140 }
3141
3142 /*! \brief Send continuation frame for DTMF */
3143 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
3144 {
3145         unsigned int *rtpheader;
3146         int hdrlen = 12, res = 0;
3147         char data[256];
3148
3149         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
3150                 return 0;
3151
3152         /* Setup packet to send */
3153         rtpheader = (unsigned int *)data;
3154         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
3155         rtpheader[1] = htonl(rtp->lastdigitts);
3156         rtpheader[2] = htonl(rtp->ssrc);
3157         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
3158         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
3159         
3160         /* Transmit */
3161         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
3162         if (res < 0)
3163                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
3164                         ast_inet_ntoa(rtp->them.sin_addr),
3165                         ntohs(rtp->them.sin_port), strerror(errno));
3166         if (rtp_debug_test_addr(&rtp->them))
3167                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
3168                             ast_inet_ntoa(rtp->them.sin_addr),
3169                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
3170
3171         /* Increment sequence number */
3172         rtp->seqno++;
3173         /* Increment duration */
3174         rtp->send_duration += 160;
3175
3176         return 0;
3177 }
3178
3179 /*! \brief Send end packets for DTMF */
3180 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
3181 {
3182         unsigned int *rtpheader;
3183         int hdrlen = 12, res = 0, i = 0;
3184         char data[256];
3185         
3186         /* If no address, then bail out */
3187         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
3188                 return 0;
3189         
3190         if ((digit <= '9') && (digit >= '0'))
3191                 digit -= '0';
3192         else if (digit == '*')
3193                 digit = 10;
3194         else if (digit == '#')
3195                 digit = 11;
3196         else if ((digit >= 'A') && (digit <= 'D'))
3197                 digit = digit - 'A' + 12;
3198         else if ((digit >= 'a') && (digit <= 'd'))
3199                 digit = digit - 'a' + 12;
3200         else {
3201                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
3202                 return 0;
3203         }
3204
3205         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
3206
3207         rtpheader = (unsigned int *)data;
3208         rtpheader[1] = htonl(rtp->lastdigitts);
3209         rtpheader[2] = htonl(rtp->ssrc);
3210         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
3211         /* Set end bit */
3212         rtpheader[3] |= htonl((1 << 23));
3213
3214         /* Send 3 termination packets */
3215         for (i = 0; i < 3; i++) {
3216                 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
3217                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
3218                 rtp->seqno++;
3219                 if (res < 0)
3220                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
3221                                 ast_inet_ntoa(rtp->them.sin_addr),
3222                                 ntohs(rtp->them.sin_port), strerror(errno));
3223                 if (rtp_debug_test_addr(&rtp->them))
3224                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
3225                                     ast_inet_ntoa(rtp->them.sin_addr),
3226                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
3227         }
3228         rtp->lastts += rtp->send_duration;
3229         rtp->sending_digit = 0;
3230         rtp->send_digit = 0;
3231
3232         return res;
3233 }
3234
3235 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
3236 int ast_rtcp_send_h261fur(void *data)
3237 {
3238         struct ast_rtp *rtp = data;
3239         int res;
3240
3241         rtp->rtcp->sendfur = 1;
3242         res = ast_rtcp_write(data);
3243         
3244         return res;
3245 }
3246
3247 /*! \brief Send RTCP sender's report */
3248 static int ast_rtcp_write_sr(const void *data)
3249 {
3250         struct ast_rtp *rtp = (struct ast_rtp *)data;
3251         int res;
3252         int len = 0;
3253         struct timeval now;
3254         unsigned int now_lsw;
3255         unsigned int now_msw;
3256         unsigned int *rtcpheader;
3257         unsigned int lost;
3258         unsigned int extended;
3259         unsigned int expected;
3260         unsigned int expected_interval;
3261         unsigned int received_interval;
3262         int lost_interval;
3263         int fraction;
3264         struct timeval dlsr;
3265         char bdata[512];
3266
3267         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
3268         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
3269                 return 0;
3270         
3271         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
3272                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
3273                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
3274                 return 0;
3275         }
3276
3277         gettimeofday(&now, NULL);
3278         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
3279         rtcpheader = (unsigned int *)bdata;
3280         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
3281         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
3282         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
3283         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
3284         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
3285         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
3286         len += 28;
3287         
3288         extended = rtp->cycles + rtp->lastrxseqno;
3289         expected = extended - rtp->seedrxseqno + 1;
3290         if (rtp->rxcount > expected) 
3291                 expected += rtp->rxcount - expected;
3292         lost = expected - rtp->rxcount;
3293         expected_interval = expected - rtp->rtcp->expected_prior;
3294         rtp->rtcp->expected_prior = expected;
3295         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
3296         rtp->rtcp->received_prior = rtp->rxcount;
3297         lost_interval = expected_interval - received_interval;
3298         if (expected_interval == 0 || lost_interval <= 0)
3299                 fraction = 0;
3300         else
3301                 fraction = (lost_interval << 8) / expected_interval;
3302         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
3303         rtcpheader[7] = htonl(rtp->themssrc);
3304         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
3305         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
3306         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
3307         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
3308         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
3309         len += 24;
3310         
3311         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
3312
3313         if (rtp->rtcp->sendfur) {
3314                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
3315                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
3316                 len += 8;
3317                 rtp->rtcp->sendfur = 0;
3318         }
3319         
3320         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
3321         /* it can change mid call, and SDES can't) */
3322         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
3323         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
3324         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
3325         len += 12;
3326         
3327         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
3328         if (res < 0) {
3329                 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));
3330                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
3331                 return 0;
3332         }
3333         
3334         /* FIXME Don't need to get a new one */
3335         gettimeofday(&rtp->rtcp->txlsr, NULL);
3336         rtp->rtcp->sr_count++;
3337
3338         rtp->rtcp->lastsrtxcount = rtp->txcount;        
3339         
3340         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
3341                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
3342                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
3343                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
3344                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
3345                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
3346                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
3347                 ast_verbose("  Report block:\n");
3348                 ast_verbose("  Fraction lost: %u\n", fraction);
3349                 ast_verbose("  Cumulative loss: %u\n", lost);
3350                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
3351                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
3352                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
3353         }
3354         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To: %s:%d\r\n"
3355                                             "OurSSRC: %u\r\n"
3356                                             "SentNTP: %u.%010u\r\n"
3357                                             "SentRTP: %u\r\n"
3358                                             "SentPackets: %u\r\n"
3359                                             "SentOctets: %u\r\n"
3360                                             "ReportBlock:\r\n"
3361                                             "FractionLost: %u\r\n"
3362                                             "CumulativeLoss: %u\r\n"
3363                                             "IAJitter: %.4f\r\n"
3364                                             "TheirLastSR: %u\r\n"
3365                                             "DLSR: %4.4f (sec)\r\n",
3366                                             ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
3367                                             rtp->ssrc,
3368                                             (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
3369                                             rtp->lastts,
3370                                             rtp->txcount,
3371                                             rtp->txoctetcount,
3372                                             fraction,
3373                                             lost,
3374                                             rtp->rxjitter,
3375                                             rtp->rtcp->themrxlsr,
3376                                             (double)(ntohl(rtcpheader[12])/65536.0));
3377         return res;
3378 }
3379
3380 /*! \brief Send RTCP recipient's report */
3381 static int ast_rtcp_write_rr(const void *data)
3382 {
3383         struct ast_rtp *rtp = (struct ast_rtp *)data;
3384         int res;
3385         int len = 32;
3386         unsigned int lost;
3387         unsigned int extended;
3388         unsigned int expected;
3389         unsigned int expected_interval;
3390         unsigned int received_interval;
3391         int lost_interval;
3392         struct timeval now;
3393         unsigned int *rtcpheader;
3394         char bdata[1024];
3395         struct timeval dlsr;
3396         int fraction;
3397
3398         double rxlost_current;
3399         
3400         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
3401                 return 0;
3402           
3403         if (!rtp->rtcp->them.sin_addr.s_addr) {
3404                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
3405                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
3406                 return 0;
3407         }
3408
3409         extended = rtp->cycles + rtp->lastrxseqno;
3410         expected = extended - rtp->seedrxseqno + 1;
3411         lost = expected - rtp->rxcount;
3412         expected_interval = expected - rtp->rtcp->expected_prior;
3413         rtp->rtcp->expected_prior = expected;
3414         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
3415         rtp->rtcp->received_prior = rtp->rxcount;
3416         lost_interval = expected_interval - received_interval;
3417
3418         if (lost_interval <= 0)
3419                 rtp->rtcp->rxlost = 0;
3420         else rtp->rtcp->rxlost = rtp->rtcp->rxlost;
3421         if (rtp->rtcp->rxlost_count == 0)
3422                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
3423         if (lost_interval < rtp->rtcp->minrxlost) 
3424                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
3425         if (lost_interval > rtp->rtcp->maxrxlost) 
3426                 rtp->rtcp->maxrxlost = rtp->rtcp->rxlost;
3427
3428         rxlost_current = normdev_compute(rtp->rtcp->normdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->rxlost_count);
3429         rtp->rtcp->stdev_rxlost = stddev_compute(rtp->rtcp->stdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->normdev_rxlost, rxlost_current, rtp->rtcp->rxlost_count);
3430         rtp->rtcp->normdev_rxlost = rxlost_current;
3431         rtp->rtcp->rxlost_count++;
3432
3433         if (expected_interval == 0 || lost_interval <= 0)
3434                 fraction = 0;
3435         else
3436                 fraction = (lost_interval << 8) / expected_interval;
3437         gettimeofday(&now, NULL);
3438         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
3439         rtcpheader = (unsigned int *)bdata;
3440         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
3441         rtcpheader[1] = htonl(rtp->ssrc);
3442         rtcpheader[2] = htonl(rtp->themssrc);
3443         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
3444         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
3445         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
3446         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
3447         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
3448
3449         if (rtp->rtcp->sendfur) {
3450                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
3451                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
3452                 len += 8;
3453                 rtp->rtcp->sendfur = 0;
3454         }
3455
3456         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
3457         it can change mid call, and SDES can't) */
3458         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
3459         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
3460         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
3461         len += 12;
3462         
3463         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
3464
3465         if (res < 0) {
3466                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
3467                 /* Remove the scheduler */
3468                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
3469                 return 0;
3470         }
3471
3472         rtp->rtcp->rr_count++;
3473
3474         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
3475                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
3476                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
3477                         "  IA jitter: %.4f\n" 
3478                         "  Their last SR: %u\n" 
3479                         "  DLSR: %4.4f (sec)\n\n",
3480                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
3481                         ntohs(rtp->rtcp->them.sin_port),
3482                         rtp->ssrc, rtp->themssrc, fraction, lost,
3483                         rtp->rxjitter,
3484                         rtp->rtcp->themrxlsr,
3485                         (double)(ntohl(rtcpheader[7])/65536.0));
3486         }
3487
3488         return res;
3489 }
3490
3491 /*! \brief Write and RTCP packet to the far end
3492  * \note Decide if we are going to send an SR (with Reception Block) or RR 
3493  * RR is sent if we have not sent any rtp packets in the previous interval */
3494 static int ast_rtcp_write(const void *data)
3495 {
3496         struct ast_rtp *rtp = (struct ast_rtp *)data;
3497         int res;
3498         
3499         if (!rtp || !rtp->rtcp)
3500                 return 0;
3501
3502         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
3503                 res = ast_rtcp_write_sr(data);
3504         else
3505                 res = ast_rtcp_write_rr(data);
3506         
3507         return res;
3508 }
3509
3510 /*! \brief generate comfort noice (CNG) */
3511 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
3512 {
3513         unsigned int *rtpheader;
3514         int hdrlen = 12;
3515         int res;
3516         int payload;
3517         char data[256];
3518         level = 127 - (level & 0x7f);
3519         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
3520
3521         /* If we have no peer, return immediately */    
3522         if (!rtp->them.sin_addr.s_addr)
3523                 return 0;
3524
3525         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
3526
3527         /* Get a pointer to the header */
3528         rtpheader = (unsigned int *)data;
3529         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
3530         rtpheader[1] = htonl(rtp->lastts);
3531         rtpheader[2] = htonl(rtp->ssrc); 
3532         data[12] = level;
3533         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
3534                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
3535                 if (res <0) 
3536                         ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s:%d: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
3537                 if (rtp_debug_test_addr(&rtp->them))
3538                         ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
3539                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
3540                    
3541         }
3542         return 0;
3543 }
3544
3545 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
3546 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
3547 {
3548         unsigned char *rtpheader;
3549         int hdrlen = 12;
3550         int res;
3551         unsigned int ms;
3552         int pred;
3553         int mark = 0;
3554
3555         if (rtp->sending_digit) {
3556                 return 0;
3557         }
3558
3559         ms = calc_txstamp(rtp, &f->delivery);
3560         /* Default prediction */
3561         if (f->frametype == AST_FRAME_VOICE) {
3562                 pred = rtp->lastts + f->samples;
3563
3564                 /* Re-calculate last TS */
3565                 rtp->lastts = rtp->lastts + ms * 8;
3566                 if (ast_tvzero(f->delivery)) {
3567                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
3568                            and if so, go with our prediction */
3569                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
3570                                 rtp->lastts = pred;
3571                         else {
3572                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
3573                                 mark = 1;
3574                         }
3575                 }
3576         } else if (f->frametype == AST_FRAME_VIDEO) {
3577                 mark = f->subclass & 0x1;
3578                 pred = rtp->lastovidtimestamp + f->samples;
3579                 /* Re-calculate last TS */
3580                 rtp->lastts = rtp->lastts + ms * 90;
3581                 /* If it's close to our prediction, go for it */
3582                 if (ast_tvzero(f->delivery)) {
3583                         if (abs(rtp->lastts - pred) < 7200) {
3584                                 rtp->lastts = pred;
3585                                 rtp->lastovidtimestamp += f->samples;
3586                         } else {
3587                                 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, f->samples);
3588                                 rtp->lastovidtimestamp = rtp->lastts;
3589                         }
3590                 }
3591         } else {
3592                 pred = rtp->lastotexttimestamp + f->samples;
3593                 /* Re-calculate last TS */
3594                 rtp->lastts = rtp->lastts + ms * 90;
3595                 /* If it's close to our prediction, go for it */
3596                 if (ast_tvzero(f->delivery)) {
3597                         if (abs(rtp->lastts - pred) < 7200) {
3598                                 rtp->lastts = pred;
3599                                 rtp->lastotexttimestamp += f->samples;
3600                         } else {
3601                                 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, f->samples);
3602                                 rtp->lastotexttimestamp = rtp->lastts;
3603                         }
3604                 }
3605         }
3606
3607         /* If we have been explicitly told to set the marker bit do so */
3608         if (rtp->set_marker_bit) {
3609                 mark = 1;
3610                 rtp->set_marker_bit = 0;
3611         }
3612
3613         /* If the timestamp for non-digit packets has moved beyond the timestamp
3614            for digits, update the digit timestamp.
3615         */
3616         if (rtp->lastts > rtp->lastdigitts)
3617                 rtp->lastdigitts = rtp->lastts;
3618
3619         if (ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO))
3620                 rtp->lastts = f->ts * 8;
3621
3622         /* Get a pointer to the header */
3623         rtpheader = (unsigned char *)(f->data.ptr - hdrlen);
3624
3625         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
3626         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
3627         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
3628
3629         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
3630                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
3631                 if (res < 0) {
3632                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
3633                                 ast_debug(1, "RTP Transmission error of packet %d to %s:%d: %s\n", rtp->seqno, ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
3634                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
3635                                 /* Only give this error message once if we are not RTP debugging */
3636                                 if (option_debug || rtpdebug)
3637                                         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(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
3638                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);