Issue #8663 - Add passthrough support for MPEG4 (neutrino88).
[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 <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <sys/time.h>
37 #include <signal.h>
38 #include <errno.h>
39 #include <unistd.h>
40 #include <netinet/in.h>
41 #include <sys/time.h>
42 #include <sys/socket.h>
43 #include <arpa/inet.h>
44 #include <fcntl.h>
45
46 #include "asterisk/rtp.h"
47 #include "asterisk/frame.h"
48 #include "asterisk/logger.h"
49 #include "asterisk/options.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/acl.h"
52 #include "asterisk/channel.h"
53 #include "asterisk/config.h"
54 #include "asterisk/lock.h"
55 #include "asterisk/utils.h"
56 #include "asterisk/cli.h"
57 #include "asterisk/unaligned.h"
58 #include "asterisk/utils.h"
59
60 #define MAX_TIMESTAMP_SKEW      640
61
62 #define RTP_SEQ_MOD     (1<<16)         /*!< A sequence number can't be more than 16 bits */
63 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
64 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
65 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
66
67 #define RTCP_PT_FUR     192
68 #define RTCP_PT_SR      200
69 #define RTCP_PT_RR      201
70 #define RTCP_PT_SDES    202
71 #define RTCP_PT_BYE     203
72 #define RTCP_PT_APP     204
73
74 #define RTP_MTU         1200
75
76 #define DEFAULT_DTMF_TIMEOUT 3000       /*!< samples */
77
78 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
79
80 static int rtpstart;                    /*!< First port for RTP sessions (set in rtp.conf) */
81 static int rtpend;                      /*!< Last port for RTP sessions (set in rtp.conf) */
82 static int rtpdebug;                    /*!< Are we debugging? */
83 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
84 static int rtcpstats;                   /*!< Are we debugging RTCP? */
85 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
86 static int stundebug;                   /*!< Are we debugging stun? */
87 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
88 static struct sockaddr_in rtcpdebugaddr;        /*!< Debug RTCP packets to/from this host */
89 #ifdef SO_NO_CHECK
90 static int nochecksums;
91 #endif
92
93 /*!
94  * \brief Structure representing a RTP session.
95  *
96  * 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 [...]"
97  *
98  */
99 /*! \brief The value of each payload format mapping: */
100 struct rtpPayloadType {
101         int isAstFormat;        /*!< whether the following code is an AST_FORMAT */
102         int code;
103 };
104
105
106 /*! \brief RTP session description */
107 struct ast_rtp {
108         int s;
109         struct ast_frame f;
110         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
111         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
112         unsigned int themssrc;          /*!< Their SSRC */
113         unsigned int rxssrc;
114         unsigned int lastts;
115         unsigned int lastrxts;
116         unsigned int lastividtimestamp;
117         unsigned int lastovidtimestamp;
118         unsigned int lasteventseqn;
119         int lastrxseqno;                /*!< Last received sequence number */
120         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
121         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
122         unsigned int rxcount;           /*!< How many packets have we received? */
123         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
124         unsigned int txcount;           /*!< How many packets have we sent? */
125         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
126         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
127         double rxjitter;                /*!< Interarrival jitter at the moment */
128         double rxtransit;               /*!< Relative transit time for previous packet */
129         int lasttxformat;
130         int lastrxformat;
131
132         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
133         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
134         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
135
136         /* DTMF Reception Variables */
137         char resp;
138         unsigned int lasteventendseqn;
139         int dtmfcount;
140         unsigned int dtmfduration;
141         /* DTMF Transmission Variables */
142         unsigned int lastdigitts;
143         char send_digit;
144         int send_payload;
145         int send_duration;
146         int nat;
147         unsigned int flags;
148         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
149         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
150         struct timeval rxcore;
151         struct timeval txcore;
152         double drxcore;                 /*!< The double representation of the first received packet */
153         struct timeval lastrx;          /*!< timeval when we last received a packet */
154         struct timeval dtmfmute;
155         struct ast_smoother *smoother;
156         int *ioid;
157         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
158         unsigned short rxseqno;
159         struct sched_context *sched;
160         struct io_context *io;
161         void *data;
162         ast_rtp_callback callback;
163         ast_mutex_t bridge_lock;
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
173 /* Forward declarations */
174 static int ast_rtcp_write(void *data);
175 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw);
176 static int ast_rtcp_write_sr(void *data);
177 static int ast_rtcp_write_rr(void *data);
178 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp);
179 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp);
180 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit);
181
182 #define FLAG_3389_WARNING               (1 << 0)
183 #define FLAG_NAT_ACTIVE                 (3 << 1)
184 #define FLAG_NAT_INACTIVE               (0 << 1)
185 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
186 #define FLAG_HAS_DTMF                   (1 << 3)
187 #define FLAG_P2P_SENT_MARK              (1 << 4)
188 #define FLAG_P2P_NEED_DTMF              (1 << 5)
189 #define FLAG_CALLBACK_MODE              (1 << 6)
190 #define FLAG_DTMF_COMPENSATE            (1 << 7)
191 #define FLAG_HAS_STUN                   (1 << 8)
192
193 /*!
194  * \brief Structure defining an RTCP session.
195  * 
196  * The concept "RTCP session" is not defined in RFC 3550, but since 
197  * this structure is analogous to ast_rtp, which tracks a RTP session, 
198  * it is logical to think of this as a RTCP session.
199  *
200  * RTCP packet is defined on page 9 of RFC 3550.
201  * 
202  */
203 struct ast_rtcp {
204         int s;                          /*!< Socket */
205         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
206         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
207         unsigned int soc;               /*!< What they told us */
208         unsigned int spc;               /*!< What they told us */
209         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
210         struct timeval rxlsr;           /*!< Time when we got their last SR */
211         struct timeval txlsr;           /*!< Time when we sent or last SR*/
212         unsigned int expected_prior;    /*!< no. packets in previous interval */
213         unsigned int received_prior;    /*!< no. packets received in previous interval */
214         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
215         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
216         unsigned int sr_count;          /*!< number of SRs we've sent */
217         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
218         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
219         double rtt;                     /*!< Last reported rtt */
220         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
221         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
222         char quality[AST_MAX_USER_FIELD];
223         double maxrxjitter;
224         double minrxjitter;
225         double maxrtt;
226         double minrtt;
227         int sendfur;
228 };
229
230
231 typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
232
233 /* XXX Maybe stun belongs in another file if it ever has use outside of RTP */
234 struct stun_header {
235         unsigned short msgtype;
236         unsigned short msglen;
237         stun_trans_id  id;
238         unsigned char ies[0];
239 } __attribute__((packed));
240
241 struct stun_attr {
242         unsigned short attr;
243         unsigned short len;
244         unsigned char value[0];
245 } __attribute__((packed));
246
247 struct stun_addr {
248         unsigned char unused;
249         unsigned char family;
250         unsigned short port;
251         unsigned int addr;
252 } __attribute__((packed));
253
254 #define STUN_IGNORE             (0)
255 #define STUN_ACCEPT             (1)
256
257 #define STUN_BINDREQ    0x0001
258 #define STUN_BINDRESP   0x0101
259 #define STUN_BINDERR    0x0111
260 #define STUN_SECREQ     0x0002
261 #define STUN_SECRESP    0x0102
262 #define STUN_SECERR     0x0112
263
264 #define STUN_MAPPED_ADDRESS     0x0001
265 #define STUN_RESPONSE_ADDRESS   0x0002
266 #define STUN_CHANGE_REQUEST     0x0003
267 #define STUN_SOURCE_ADDRESS     0x0004
268 #define STUN_CHANGED_ADDRESS    0x0005
269 #define STUN_USERNAME           0x0006
270 #define STUN_PASSWORD           0x0007
271 #define STUN_MESSAGE_INTEGRITY  0x0008
272 #define STUN_ERROR_CODE         0x0009
273 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
274 #define STUN_REFLECTED_FROM     0x000b
275
276 static const char *stun_msg2str(int msg)
277 {
278         switch(msg) {
279         case STUN_BINDREQ:
280                 return "Binding Request";
281         case STUN_BINDRESP:
282                 return "Binding Response";
283         case STUN_BINDERR:
284                 return "Binding Error Response";
285         case STUN_SECREQ:
286                 return "Shared Secret Request";
287         case STUN_SECRESP:
288                 return "Shared Secret Response";
289         case STUN_SECERR:
290                 return "Shared Secret Error Response";
291         }
292         return "Non-RFC3489 Message";
293 }
294
295 static const char *stun_attr2str(int msg)
296 {
297         switch(msg) {
298         case STUN_MAPPED_ADDRESS:
299                 return "Mapped Address";
300         case STUN_RESPONSE_ADDRESS:
301                 return "Response Address";
302         case STUN_CHANGE_REQUEST:
303                 return "Change Request";
304         case STUN_SOURCE_ADDRESS:
305                 return "Source Address";
306         case STUN_CHANGED_ADDRESS:
307                 return "Changed Address";
308         case STUN_USERNAME:
309                 return "Username";
310         case STUN_PASSWORD:
311                 return "Password";
312         case STUN_MESSAGE_INTEGRITY:
313                 return "Message Integrity";
314         case STUN_ERROR_CODE:
315                 return "Error Code";
316         case STUN_UNKNOWN_ATTRIBUTES:
317                 return "Unknown Attributes";
318         case STUN_REFLECTED_FROM:
319                 return "Reflected From";
320         }
321         return "Non-RFC3489 Attribute";
322 }
323
324 struct stun_state {
325         const char *username;
326         const char *password;
327 };
328
329 static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
330 {
331         if (stundebug)
332                 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
333                         stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
334         switch(ntohs(attr->attr)) {
335         case STUN_USERNAME:
336                 state->username = (const char *) (attr->value);
337                 break;
338         case STUN_PASSWORD:
339                 state->password = (const char *) (attr->value);
340                 break;
341         default:
342                 if (stundebug)
343                         ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n", 
344                                 stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
345         }
346         return 0;
347 }
348
349 static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
350 {
351         int size = sizeof(**attr) + strlen(s);
352         if (*left > size) {
353                 (*attr)->attr = htons(attrval);
354                 (*attr)->len = htons(strlen(s));
355                 memcpy((*attr)->value, s, strlen(s));
356                 (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
357                 *len += size;
358                 *left -= size;
359         }
360 }
361
362 static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
363 {
364         int size = sizeof(**attr) + 8;
365         struct stun_addr *addr;
366         if (*left > size) {
367                 (*attr)->attr = htons(attrval);
368                 (*attr)->len = htons(8);
369                 addr = (struct stun_addr *)((*attr)->value);
370                 addr->unused = 0;
371                 addr->family = 0x01;
372                 addr->port = sin->sin_port;
373                 addr->addr = sin->sin_addr.s_addr;
374                 (*attr) = (struct stun_attr *)((*attr)->value + 8);
375                 *len += size;
376                 *left -= size;
377         }
378 }
379
380 static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
381 {
382         return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
383                 (struct sockaddr *)dst, sizeof(*dst));
384 }
385
386 static void stun_req_id(struct stun_header *req)
387 {
388         int x;
389         for (x=0;x<4;x++)
390                 req->id.id[x] = ast_random();
391 }
392
393 size_t ast_rtp_alloc_size(void)
394 {
395         return sizeof(struct ast_rtp);
396 }
397
398 void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
399 {
400         struct stun_header *req;
401         unsigned char reqdata[1024];
402         int reqlen, reqleft;
403         struct stun_attr *attr;
404
405         req = (struct stun_header *)reqdata;
406         stun_req_id(req);
407         reqlen = 0;
408         reqleft = sizeof(reqdata) - sizeof(struct stun_header);
409         req->msgtype = 0;
410         req->msglen = 0;
411         attr = (struct stun_attr *)req->ies;
412         if (username)
413                 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
414         req->msglen = htons(reqlen);
415         req->msgtype = htons(STUN_BINDREQ);
416         stun_send(rtp->s, suggestion, req);
417 }
418
419 static int stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, size_t len)
420 {
421         struct stun_header *resp, *hdr = (struct stun_header *)data;
422         struct stun_attr *attr;
423         struct stun_state st;
424         int ret = STUN_IGNORE;  
425         unsigned char respdata[1024];
426         int resplen, respleft;
427         
428         if (len < sizeof(struct stun_header)) {
429                 if (option_debug)
430                         ast_log(LOG_DEBUG, "Runt STUN packet (only %zd, wanting at least %zd)\n", len, sizeof(struct stun_header));
431                 return -1;
432         }
433         if (stundebug)
434                 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), ntohs(hdr->msglen));
435         if (ntohs(hdr->msglen) > len - sizeof(struct stun_header)) {
436                 if (option_debug)
437                         ast_log(LOG_DEBUG, "Scrambled STUN packet length (got %d, expecting %zd)\n", ntohs(hdr->msglen), len - sizeof(struct stun_header));
438         } else
439                 len = ntohs(hdr->msglen);
440         data += sizeof(struct stun_header);
441         memset(&st, 0, sizeof(st));
442         while(len) {
443                 if (len < sizeof(struct stun_attr)) {
444                         if (option_debug)
445                                 ast_log(LOG_DEBUG, "Runt Attribute (got %zd, expecting %zd)\n", len, sizeof(struct stun_attr));
446                         break;
447                 }
448                 attr = (struct stun_attr *)data;
449                 if (ntohs(attr->len) > len) {
450                         if (option_debug)
451                                 ast_log(LOG_DEBUG, "Inconsistent Attribute (length %d exceeds remaining msg len %zd)\n", ntohs(attr->len), len);
452                         break;
453                 }
454                 if (stun_process_attr(&st, attr)) {
455                         if (option_debug)
456                                 ast_log(LOG_DEBUG, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
457                         break;
458                 }
459                 /* Clear attribute in case previous entry was a string */
460                 attr->attr = 0;
461                 data += ntohs(attr->len) + sizeof(struct stun_attr);
462                 len -= ntohs(attr->len) + sizeof(struct stun_attr);
463         }
464         /* Null terminate any string */
465         *data = '\0';
466         resp = (struct stun_header *)respdata;
467         resplen = 0;
468         respleft = sizeof(respdata) - sizeof(struct stun_header);
469         resp->id = hdr->id;
470         resp->msgtype = 0;
471         resp->msglen = 0;
472         attr = (struct stun_attr *)resp->ies;
473         if (!len) {
474                 switch(ntohs(hdr->msgtype)) {
475                 case STUN_BINDREQ:
476                         if (stundebug)
477                                 ast_verbose("STUN Bind Request, username: %s\n", 
478                                         st.username ? st.username : "<none>");
479                         if (st.username)
480                                 append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
481                         append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
482                         resp->msglen = htons(resplen);
483                         resp->msgtype = htons(STUN_BINDRESP);
484                         stun_send(s, src, resp);
485                         ret = STUN_ACCEPT;
486                         break;
487                 default:
488                         if (stundebug)
489                                 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
490                 }
491         }
492         return ret;
493 }
494
495 /*! \brief List of current sessions */
496 static AST_LIST_HEAD_STATIC(protos, ast_rtp_protocol);
497
498 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
499 {
500         unsigned int sec, usec, frac;
501         sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
502         usec = tv.tv_usec;
503         frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
504         *msw = sec;
505         *lsw = frac;
506 }
507
508 int ast_rtp_fd(struct ast_rtp *rtp)
509 {
510         return rtp->s;
511 }
512
513 int ast_rtcp_fd(struct ast_rtp *rtp)
514 {
515         if (rtp->rtcp)
516                 return rtp->rtcp->s;
517         return -1;
518 }
519
520 unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
521 {
522         unsigned int interval;
523         /*! \todo XXX Do a more reasonable calculation on this one
524         * Look in RFC 3550 Section A.7 for an example*/
525         interval = rtcpinterval;
526         return interval;
527 }
528
529 /* \brief Put RTP timeout timers on hold during another transaction, like T.38 */
530 void ast_rtp_set_rtptimers_onhold(struct ast_rtp *rtp)
531 {
532         rtp->rtptimeout = (-1) * rtp->rtptimeout;
533         rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout;
534 }
535
536 /*! \brief Set rtp timeout */
537 void ast_rtp_set_rtptimeout(struct ast_rtp *rtp, int timeout)
538 {
539         rtp->rtptimeout = timeout;
540 }
541
542 /*! \brief Set rtp hold timeout */
543 void ast_rtp_set_rtpholdtimeout(struct ast_rtp *rtp, int timeout)
544 {
545         rtp->rtpholdtimeout = timeout;
546 }
547
548 /*! \brief set RTP keepalive interval */
549 void ast_rtp_set_rtpkeepalive(struct ast_rtp *rtp, int period)
550 {
551         rtp->rtpkeepalive = period;
552 }
553
554 /*! \brief Get rtp timeout */
555 int ast_rtp_get_rtptimeout(struct ast_rtp *rtp)
556 {
557         if (rtp->rtptimeout < 0)        /* We're not checking, but remembering the setting (during T.38 transmission) */
558                 return 0;
559         return rtp->rtptimeout;
560 }
561
562 /*! \brief Get rtp hold timeout */
563 int ast_rtp_get_rtpholdtimeout(struct ast_rtp *rtp)
564 {
565         if (rtp->rtptimeout < 0)        /* We're not checking, but remembering the setting (during T.38 transmission) */
566                 return 0;
567         return rtp->rtpholdtimeout;
568 }
569
570 /*! \brief Get RTP keepalive interval */
571 int ast_rtp_get_rtpkeepalive(struct ast_rtp *rtp)
572 {
573         return rtp->rtpkeepalive;
574 }
575
576 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
577 {
578         rtp->data = data;
579 }
580
581 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
582 {
583         rtp->callback = callback;
584 }
585
586 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
587 {
588         rtp->nat = nat;
589 }
590
591 void ast_rtp_setdtmf(struct ast_rtp *rtp, int dtmf)
592 {
593         ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF);
594 }
595
596 void ast_rtp_setdtmfcompensate(struct ast_rtp *rtp, int compensate)
597 {
598         ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE);
599 }
600
601 void ast_rtp_setstun(struct ast_rtp *rtp, int stun_enable)
602 {
603         ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN);
604 }
605
606 static struct ast_frame *send_dtmf(struct ast_rtp *rtp, enum ast_frame_type type)
607 {
608         if (((ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && type == AST_FRAME_DTMF_END) ||
609              (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
610                 if (option_debug)
611                         ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(rtp->them.sin_addr));
612                 rtp->resp = 0;
613                 rtp->dtmfduration = 0;
614                 return &ast_null_frame;
615         }
616         if (option_debug)
617                 ast_log(LOG_DEBUG, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(rtp->them.sin_addr));
618         if (rtp->resp == 'X') {
619                 rtp->f.frametype = AST_FRAME_CONTROL;
620                 rtp->f.subclass = AST_CONTROL_FLASH;
621         } else {
622                 rtp->f.frametype = type;
623                 rtp->f.subclass = rtp->resp;
624         }
625         rtp->f.datalen = 0;
626         rtp->f.samples = 0;
627         rtp->f.mallocd = 0;
628         rtp->f.src = "RTP";
629         return &rtp->f;
630         
631 }
632
633 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
634 {
635         if (rtpdebug == 0)
636                 return 0;
637         if (rtpdebugaddr.sin_addr.s_addr) {
638                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
639                         && (rtpdebugaddr.sin_port != addr->sin_port))
640                         || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
641                 return 0;
642         }
643         return 1;
644 }
645
646 static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
647 {
648         if (rtcpdebug == 0)
649                 return 0;
650         if (rtcpdebugaddr.sin_addr.s_addr) {
651                 if (((ntohs(rtcpdebugaddr.sin_port) != 0)
652                         && (rtcpdebugaddr.sin_port != addr->sin_port))
653                         || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
654                 return 0;
655         }
656         return 1;
657 }
658
659
660 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
661 {
662         unsigned int event;
663         char resp = 0;
664         struct ast_frame *f = NULL;
665         unsigned char seq;
666         unsigned int flags;
667         unsigned int power;
668
669         /* We should have at least 4 bytes in RTP data */
670         if (len < 4)
671                 return f;
672
673         /*      The format of Cisco RTP DTMF packet looks like next:
674                 +0                              - sequence number of DTMF RTP packet (begins from 1,
675                                                   wrapped to 0)
676                 +1                              - set of flags
677                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
678                                                   or repeated digit without audio???
679                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
680                                                   then falls to 0 at its end)
681                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
682                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
683                 by each new packet and thus provides some redudancy.
684                 
685                 Sample of Cisco RTP DTMF packet is (all data in hex):
686                         19 07 00 02 12 02 20 02
687                 showing end of DTMF digit '2'.
688
689                 The packets
690                         27 07 00 02 0A 02 20 02
691                         28 06 20 02 00 02 0A 02
692                 shows begin of new digit '2' with very short pause (20 ms) after
693                 previous digit '2'. Bit +1.0 flips at begin of new digit.
694                 
695                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
696                 so its uses the same sequencing and timestamping rules as replaced
697                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
698                 on audio framing parameters. Marker bit isn't used within stream of
699                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
700                 are not sequential at borders between DTMF and audio streams,
701         */
702
703         seq = data[0];
704         flags = data[1];
705         power = data[2];
706         event = data[3] & 0x1f;
707
708         if (option_debug > 2 || rtpdebug)
709                 ast_log(LOG_DEBUG, "Cisco DTMF Digit: %02x (len=%d, seq=%d, flags=%02x, power=%d, history count=%d)\n", event, len, seq, flags, power, (len - 4) / 2);
710         if (event < 10) {
711                 resp = '0' + event;
712         } else if (event < 11) {
713                 resp = '*';
714         } else if (event < 12) {
715                 resp = '#';
716         } else if (event < 16) {
717                 resp = 'A' + (event - 12);
718         } else if (event < 17) {
719                 resp = 'X';
720         }
721         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
722                 rtp->resp = resp;
723                 /* Why we should care on DTMF compensation at reception? */
724                 if (!ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
725                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
726                         rtp->dtmfduration = 0;
727                 }
728         } else if ((rtp->resp == resp) && !power) {
729                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
730                 f->samples = rtp->dtmfduration * 8;
731                 rtp->resp = 0;
732         } else if (rtp->resp == resp)
733                 rtp->dtmfduration += 20 * 8;
734         rtp->dtmfcount = dtmftimeout;
735         return f;
736 }
737
738 /*! 
739  * \brief Process RTP DTMF and events according to RFC 2833.
740  * 
741  * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
742  * 
743  * \param rtp
744  * \param data
745  * \param len
746  * \param seqno
747  * \returns
748  */
749 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno)
750 {
751         unsigned int event;
752         unsigned int event_end;
753         unsigned int duration;
754         char resp = 0;
755         struct ast_frame *f = NULL;
756
757         /* Figure out event, event end, and duration */
758         event = ntohl(*((unsigned int *)(data)));
759         event >>= 24;
760         event_end = ntohl(*((unsigned int *)(data)));
761         event_end <<= 8;
762         event_end >>= 24;
763         duration = ntohl(*((unsigned int *)(data)));
764         duration &= 0xFFFF;
765
766         /* Print out debug if turned on */
767         if (rtpdebug || option_debug > 2)
768                 ast_log(LOG_DEBUG, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
769
770         /* Figure out what digit was pressed */
771         if (event < 10) {
772                 resp = '0' + event;
773         } else if (event < 11) {
774                 resp = '*';
775         } else if (event < 12) {
776                 resp = '#';
777         } else if (event < 16) {
778                 resp = 'A' + (event - 12);
779         } else if (event < 17) {        /* Event 16: Hook flash */
780                 resp = 'X';     
781         }
782
783         if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
784                 rtp->resp = resp;
785                 if (!ast_test_flag(rtp, FLAG_DTMF_COMPENSATE))
786                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
787         } else if (event_end & 0x80 && rtp->lasteventendseqn != seqno && rtp->resp) {
788                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
789                 f->samples = duration;
790                 rtp->resp = 0;
791                 rtp->lasteventendseqn = seqno;
792         } else if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && event_end & 0x80 && rtp->lasteventendseqn != seqno) {
793                 rtp->resp = resp;
794                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
795                 f->samples = duration;
796                 rtp->resp = 0;
797                 rtp->lasteventendseqn = seqno;
798         }
799
800         rtp->dtmfcount = dtmftimeout;
801         rtp->dtmfduration = duration;
802
803         return f;
804 }
805
806 /*!
807  * \brief Process Comfort Noise RTP.
808  * 
809  * This is incomplete at the moment.
810  * 
811 */
812 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
813 {
814         struct ast_frame *f = NULL;
815         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
816            totally help us out becuase we don't have an engine to keep it going and we are not
817            guaranteed to have it every 20ms or anything */
818         if (rtpdebug)
819                 ast_log(LOG_DEBUG, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
820
821         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
822                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
823                         ast_inet_ntoa(rtp->them.sin_addr));
824                 ast_set_flag(rtp, FLAG_3389_WARNING);
825         }
826
827         /* Must have at least one byte */
828         if (!len)
829                 return NULL;
830         if (len < 24) {
831                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
832                 rtp->f.datalen = len - 1;
833                 rtp->f.offset = AST_FRIENDLY_OFFSET;
834                 memcpy(rtp->f.data, data + 1, len - 1);
835         } else {
836                 rtp->f.data = NULL;
837                 rtp->f.offset = 0;
838                 rtp->f.datalen = 0;
839         }
840         rtp->f.frametype = AST_FRAME_CNG;
841         rtp->f.subclass = data[0] & 0x7f;
842         rtp->f.datalen = len - 1;
843         rtp->f.samples = 0;
844         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
845         f = &rtp->f;
846         return f;
847 }
848
849 static int rtpread(int *id, int fd, short events, void *cbdata)
850 {
851         struct ast_rtp *rtp = cbdata;
852         struct ast_frame *f;
853         f = ast_rtp_read(rtp);
854         if (f) {
855                 if (rtp->callback)
856                         rtp->callback(rtp, f, rtp->data);
857         }
858         return 1;
859 }
860
861 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
862 {
863         socklen_t len;
864         int position, i, packetwords;
865         int res;
866         struct sockaddr_in sin;
867         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
868         unsigned int *rtcpheader;
869         int pt;
870         struct timeval now;
871         unsigned int length;
872         int rc;
873         double rtt = 0;
874         double a;
875         double dlsr;
876         double lsr;
877         unsigned int msw;
878         unsigned int lsw;
879         unsigned int comp;
880         struct ast_frame *f = &ast_null_frame;
881         
882         if (!rtp || !rtp->rtcp)
883                 return &ast_null_frame;
884
885         len = sizeof(sin);
886         
887         res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
888                                         0, (struct sockaddr *)&sin, &len);
889         rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
890         
891         if (res < 0) {
892                 if (errno != EAGAIN)
893                         ast_log(LOG_WARNING, "RTCP Read error: %s\n", strerror(errno));
894                 if (errno == EBADF)
895                         CRASH;
896                 return &ast_null_frame;
897         }
898
899         packetwords = res / 4;
900         
901         if (rtp->nat) {
902                 /* Send to whoever sent to us */
903                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
904                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
905                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
906                         if (option_debug || rtpdebug)
907                                 ast_log(LOG_DEBUG, "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));
908                 }
909         }
910
911         if (option_debug)
912                 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
913
914         /* Process a compound packet */
915         position = 0;
916         while (position < packetwords) {
917                 i = position;
918                 length = ntohl(rtcpheader[i]);
919                 pt = (length & 0xff0000) >> 16;
920                 rc = (length & 0x1f000000) >> 24;
921                 length &= 0xffff;
922     
923                 if ((i + length) > packetwords) {
924                         ast_log(LOG_WARNING, "RTCP Read too short\n");
925                         return &ast_null_frame;
926                 }
927                 
928                 if (rtcp_debug_test_addr(&sin)) {
929                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
930                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
931                         ast_verbose("Reception reports: %d\n", rc);
932                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
933                 }
934     
935                 i += 2; /* Advance past header and ssrc */
936                 
937                 switch (pt) {
938                 case RTCP_PT_SR:
939                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
940                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
941                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
942                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff) >> 16); /* Going to LSR in RR*/
943     
944                         if (rtcp_debug_test_addr(&sin)) {
945                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
946                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
947                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
948                         }
949                         i += 5;
950                         if (rc < 1)
951                                 break;
952                         /* Intentional fall through */
953                 case RTCP_PT_RR:
954                         /* This is the place to calculate RTT */
955                         /* Don't handle multiple reception reports (rc > 1) yet */
956                         gettimeofday(&now, NULL);
957                         timeval2ntp(now, &msw, &lsw);
958                         /* Use the one we sent them in our SR instead, rtcp->txlsr could have been rewritten if the dlsr is large */
959                         if (ntohl(rtcpheader[i + 4])) { /* We must have the LSR */
960                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
961                                 a = (double)((comp & 0xffff0000) >> 16) + (double)((double)(comp & 0xffff)/1000000.);
962                                 lsr = (double)((ntohl(rtcpheader[i + 4]) & 0xffff0000) >> 16) + (double)((double)(ntohl(rtcpheader[i + 4]) & 0xffff) / 1000000.);
963                                 dlsr = (double)(ntohl(rtcpheader[i + 5])/65536.);
964                                 rtt = a - dlsr - lsr;
965                                 rtp->rtcp->accumulated_transit += rtt;
966                                 rtp->rtcp->rtt = rtt;
967                                 if (rtp->rtcp->maxrtt<rtt)
968                                         rtp->rtcp->maxrtt = rtt;
969                                 if (rtp->rtcp->minrtt>rtt)
970                                 rtp->rtcp->minrtt = rtt;
971                         }
972                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
973                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
974                         if (rtcp_debug_test_addr(&sin)) {
975                                 ast_verbose("Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
976                                 ast_verbose("Packets lost so far: %d\n", rtp->rtcp->reported_lost);
977                                 ast_verbose("Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
978                                 ast_verbose("Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
979                                 ast_verbose("Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
980                                 ast_verbose("Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
981                                 ast_verbose("DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
982                                 if (rtt)
983                                         ast_verbose("RTT: %f(sec)\n", rtt);
984                         }
985                         break;
986                 case RTCP_PT_FUR:
987                         if (rtcp_debug_test_addr(&sin))
988                                 ast_verbose("Received an RTCP Fast Update Request\n");
989                         rtp->f.frametype = AST_FRAME_CONTROL;
990                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
991                         rtp->f.datalen = 0;
992                         rtp->f.samples = 0;
993                         rtp->f.mallocd = 0;
994                         rtp->f.src = "RTP";
995                         f = &rtp->f;
996                         break;
997                 case RTCP_PT_SDES:
998                         if (rtcp_debug_test_addr(&sin))
999                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1000                         break;
1001                 case RTCP_PT_BYE:
1002                         if (rtcp_debug_test_addr(&sin))
1003                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1004                         break;
1005                 default:
1006                         if (option_debug)
1007                                 ast_log(LOG_DEBUG, "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));
1008                         break;
1009                 }
1010                 position += (length + 1);
1011         }
1012                         
1013         return f;
1014 }
1015
1016 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1017 {
1018         struct timeval now;
1019         double transit;
1020         double current_time;
1021         double d;
1022         double dtv;
1023         double prog;
1024         
1025         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1026                 gettimeofday(&rtp->rxcore, NULL);
1027                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1028                 /* map timestamp to a real time */
1029                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1030                 rtp->rxcore.tv_sec -= timestamp / 8000;
1031                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
1032                 /* Round to 0.1ms for nice, pretty timestamps */
1033                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1034                 if (rtp->rxcore.tv_usec < 0) {
1035                         /* Adjust appropriately if necessary */
1036                         rtp->rxcore.tv_usec += 1000000;
1037                         rtp->rxcore.tv_sec -= 1;
1038                 }
1039         }
1040
1041         gettimeofday(&now,NULL);
1042         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1043         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
1044         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
1045         if (tv->tv_usec >= 1000000) {
1046                 tv->tv_usec -= 1000000;
1047                 tv->tv_sec += 1;
1048         }
1049         prog = (double)((timestamp-rtp->seedrxts)/8000.);
1050         dtv = (double)rtp->drxcore + (double)(prog);
1051         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1052         transit = current_time - dtv;
1053         d = transit - rtp->rxtransit;
1054         rtp->rxtransit = transit;
1055         if (d<0)
1056                 d=-d;
1057         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1058         if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
1059                 rtp->rtcp->maxrxjitter = rtp->rxjitter;
1060         if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1061                 rtp->rtcp->minrxjitter = rtp->rxjitter;
1062 }
1063
1064 /*! \brief Perform a Packet2Packet RTP write */
1065 static int bridge_p2p_rtp_write(struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
1066 {
1067         int res = 0, payload = 0, bridged_payload = 0, version, padding, mark, ext;
1068         struct rtpPayloadType rtpPT;
1069         unsigned int seqno;
1070         
1071         /* Get fields from packet */
1072         seqno = ntohl(rtpheader[0]);
1073         version = (seqno & 0xC0000000) >> 30;
1074         payload = (seqno & 0x7f0000) >> 16;
1075         padding = seqno & (1 << 29);
1076         mark = seqno & (1 << 23);
1077         ext = seqno & (1 << 28);
1078         seqno &= 0xffff;
1079
1080         /* Check what the payload value should be */
1081         rtpPT = ast_rtp_lookup_pt(rtp, payload);
1082
1083         /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1084         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
1085                 return -1;
1086
1087         /* Otherwise adjust bridged payload to match */
1088         bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
1089
1090         /* If the mark bit has not been sent yet... do it now */
1091         if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
1092                 mark = 1;
1093                 ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
1094         }
1095
1096         /* Reconstruct part of the packet */
1097         rtpheader[0] = htonl((version << 30) | (mark << 23) | (bridged_payload << 16) | (seqno));
1098
1099         /* Send the packet back out */
1100         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
1101         if (res < 0) {
1102                 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1103                         if (option_debug)
1104                                 ast_log(LOG_DEBUG, "RTP Transmission error of packet to %s:%d: %s\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), strerror(errno));
1105                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1106                         if (option_debug || rtpdebug)
1107                                 ast_log(LOG_DEBUG, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port));
1108                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1109                 }
1110                 return -1;
1111         } else if (rtp_debug_test_addr(&bridged->them))
1112                         ast_verbose("Sent RTP P2P packet to %s:%d (type %-2.2d, len %-6.6u)\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), bridged_payload, len - hdrlen);
1113
1114         return -1;
1115 }
1116
1117 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
1118 {
1119         int res;
1120         struct sockaddr_in sin;
1121         socklen_t len;
1122         unsigned int seqno;
1123         int version;
1124         int payloadtype;
1125         int tseqno;
1126         int hdrlen = 12;
1127         int padding;
1128         int mark;
1129         int ext;
1130         unsigned int ssrc;
1131         unsigned int timestamp;
1132         unsigned int *rtpheader;
1133         struct rtpPayloadType rtpPT;
1134         struct ast_rtp *bridged = NULL;
1135         
1136         /* If time is up, kill it */
1137         if (rtp->send_digit)
1138                 ast_rtp_senddigit_continuation(rtp);
1139
1140         len = sizeof(sin);
1141         
1142         /* Cache where the header will go */
1143         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
1144                                         0, (struct sockaddr *)&sin, &len);
1145
1146         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
1147         if (res < 0) {
1148                 if (errno != EAGAIN)
1149                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
1150                 if (errno == EBADF)
1151                         CRASH;
1152                 return &ast_null_frame;
1153         }
1154         
1155         if (res < hdrlen) {
1156                 ast_log(LOG_WARNING, "RTP Read too short\n");
1157                 return &ast_null_frame;
1158         }
1159
1160         /* Get fields */
1161         seqno = ntohl(rtpheader[0]);
1162
1163         /* Check RTP version */
1164         version = (seqno & 0xC0000000) >> 30;
1165         if (!version) {
1166                 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) &&
1167                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
1168                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
1169                 }
1170                 return &ast_null_frame;
1171         }
1172
1173 #if 0   /* Allow to receive RTP stream with closed transmission path */
1174         /* If we don't have the other side's address, then ignore this */
1175         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1176                 return &ast_null_frame;
1177 #endif
1178
1179         /* Send to whoever send to us if NAT is turned on */
1180         if (rtp->nat) {
1181                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1182                     (rtp->them.sin_port != sin.sin_port)) {
1183                         rtp->them = sin;
1184                         if (rtp->rtcp) {
1185                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1186                                 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1);
1187                         }
1188                         rtp->rxseqno = 0;
1189                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1190                         if (option_debug || rtpdebug)
1191                                 ast_log(LOG_DEBUG, "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));
1192                 }
1193         }
1194
1195         /* If we are bridged to another RTP stream, send direct */
1196         if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen))
1197                 return &ast_null_frame;
1198
1199         if (version != 2)
1200                 return &ast_null_frame;
1201
1202         payloadtype = (seqno & 0x7f0000) >> 16;
1203         padding = seqno & (1 << 29);
1204         mark = seqno & (1 << 23);
1205         ext = seqno & (1 << 28);
1206         seqno &= 0xffff;
1207         timestamp = ntohl(rtpheader[1]);
1208         ssrc = ntohl(rtpheader[2]);
1209         
1210         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1211                 if (option_debug || rtpdebug)
1212                         ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n");
1213                 mark = 1;
1214         }
1215
1216         rtp->rxssrc = ssrc;
1217         
1218         if (padding) {
1219                 /* Remove padding bytes */
1220                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1221         }
1222         
1223         if (ext) {
1224                 /* RTP Extension present */
1225                 hdrlen += 4;
1226                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
1227                 if (option_debug) {
1228                         int profile;
1229                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1230                         if (profile == 0x505a)
1231                                 ast_log(LOG_DEBUG, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1232                         else
1233                                 ast_log(LOG_DEBUG, "Found unknown RTP Extensions %x\n", profile);
1234                 }
1235         }
1236
1237         if (res < hdrlen) {
1238                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1239                 return &ast_null_frame;
1240         }
1241
1242         rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1243
1244         tseqno = rtp->lastrxseqno +1;
1245
1246         if (rtp->rxcount==1) {
1247                 /* This is the first RTP packet successfully received from source */
1248                 rtp->seedrxseqno = seqno;
1249         }
1250
1251         /* Do not schedule RR if RTCP isn't run */
1252         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1253                 /* Schedule transmission of Receiver Report */
1254                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1255         }
1256
1257         if (tseqno > RTP_SEQ_MOD) { /* if tseqno is greater than RTP_SEQ_MOD it would indicate that the sender cycled */
1258                 rtp->cycles += RTP_SEQ_MOD;
1259                 ast_verbose("SEQNO cycled: %u\t%d\n", rtp->cycles, seqno);
1260         }
1261
1262         rtp->lastrxseqno = seqno;
1263         
1264         if (rtp->themssrc==0)
1265                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1266         
1267         if (rtp_debug_test_addr(&sin))
1268                 ast_verbose("Got  RTP packet from    %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1269                         ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1270
1271         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1272         if (!rtpPT.isAstFormat) {
1273                 struct ast_frame *f = NULL;
1274
1275                 /* This is special in-band data that's not one of our codecs */
1276                 if (rtpPT.code == AST_RTP_DTMF) {
1277                         /* It's special -- rfc2833 process it */
1278                         if (rtp_debug_test_addr(&sin)) {
1279                                 unsigned char *data;
1280                                 unsigned int event;
1281                                 unsigned int event_end;
1282                                 unsigned int duration;
1283                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1284                                 event = ntohl(*((unsigned int *)(data)));
1285                                 event >>= 24;
1286                                 event_end = ntohl(*((unsigned int *)(data)));
1287                                 event_end <<= 8;
1288                                 event_end >>= 24;
1289                                 duration = ntohl(*((unsigned int *)(data)));
1290                                 duration &= 0xFFFF;
1291                                 ast_verbose("Got  RTP RFC2833 from   %s:%d (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(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration);
1292                         }
1293                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno);
1294                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1295                         /* It's really special -- process it the Cisco way */
1296                         if (rtp->lasteventseqn <= seqno || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
1297                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1298                                 rtp->lasteventseqn = seqno;
1299                         }
1300                 } else if (rtpPT.code == AST_RTP_CN) {
1301                         /* Comfort Noise */
1302                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1303                 } else {
1304                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1305                 }
1306                 return f ? f : &ast_null_frame;
1307         }
1308         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1309         rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO;
1310
1311         if (!rtp->lastrxts)
1312                 rtp->lastrxts = timestamp;
1313
1314         rtp->rxseqno = seqno;
1315
1316         /* Record received timestamp as last received now */
1317         rtp->lastrxts = timestamp;
1318
1319         rtp->f.mallocd = 0;
1320         rtp->f.datalen = res - hdrlen;
1321         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1322         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1323         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
1324                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1325                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
1326                         ast_frame_byteswap_be(&rtp->f);
1327                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1328                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1329                 rtp->f.has_timing_info = 1;
1330                 rtp->f.ts = timestamp / 8;
1331                 rtp->f.len = rtp->f.samples / 8;
1332                 rtp->f.seqno = seqno;
1333         } else {
1334                 /* Video -- samples is # of samples vs. 90000 */
1335                 if (!rtp->lastividtimestamp)
1336                         rtp->lastividtimestamp = timestamp;
1337                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1338                 rtp->lastividtimestamp = timestamp;
1339                 rtp->f.delivery.tv_sec = 0;
1340                 rtp->f.delivery.tv_usec = 0;
1341                 if (mark)
1342                         rtp->f.subclass |= 0x1;
1343                 
1344         }
1345         rtp->f.src = "RTP";
1346         return &rtp->f;
1347 }
1348
1349 /* The following array defines the MIME Media type (and subtype) for each
1350    of our codecs, or RTP-specific data type. */
1351 static struct {
1352         struct rtpPayloadType payloadType;
1353         char* type;
1354         char* subtype;
1355 } mimeTypes[] = {
1356         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
1357         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
1358         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
1359         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
1360         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
1361         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
1362         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
1363         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
1364         {{1, AST_FORMAT_G729A}, "audio", "G729"},
1365         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
1366         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1367         {{1, AST_FORMAT_G722}, "audio", "G722"},
1368         {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1369         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1370         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1371         {{0, AST_RTP_CN}, "audio", "CN"},
1372         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1373         {{1, AST_FORMAT_PNG}, "video", "PNG"},
1374         {{1, AST_FORMAT_H261}, "video", "H261"},
1375         {{1, AST_FORMAT_H263}, "video", "H263"},
1376         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1377         {{1, AST_FORMAT_H264}, "video", "H264"},
1378         {{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES"},
1379         {{1, AST_FORMAT_T140}, "text", "T140"},
1380 };
1381
1382 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1383    also, our own choices for dynamic payload types.  This is our master
1384    table for transmission */
1385 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1386         [0] = {1, AST_FORMAT_ULAW},
1387 #ifdef USE_DEPRECATED_G726
1388         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1389 #endif
1390         [3] = {1, AST_FORMAT_GSM},
1391         [4] = {1, AST_FORMAT_G723_1},
1392         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1393         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1394         [7] = {1, AST_FORMAT_LPC10},
1395         [8] = {1, AST_FORMAT_ALAW},
1396         [9] = {1, AST_FORMAT_G722},
1397         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1398         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1399         [13] = {0, AST_RTP_CN},
1400         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1401         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1402         [18] = {1, AST_FORMAT_G729A},
1403         [19] = {0, AST_RTP_CN},         /* Also used for CN */
1404         [26] = {1, AST_FORMAT_JPEG},
1405         [31] = {1, AST_FORMAT_H261},
1406         [34] = {1, AST_FORMAT_H263},
1407         [97] = {1, AST_FORMAT_ILBC},
1408         [99] = {1, AST_FORMAT_H264},
1409         [101] = {0, AST_RTP_DTMF},
1410         [102] = {1, AST_FORMAT_T140},   /* Real time text chat */
1411         [103] = {1, AST_FORMAT_H263_PLUS},
1412         [104] = {1, AST_FORMAT_MP4_VIDEO},
1413         [110] = {1, AST_FORMAT_SPEEX},
1414         [111] = {1, AST_FORMAT_G726},
1415         [112] = {1, AST_FORMAT_G726_AAL2},
1416         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1417 };
1418
1419 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
1420 {
1421         int i;
1422
1423         if (!rtp)
1424                 return;
1425
1426         ast_mutex_lock(&rtp->bridge_lock);
1427
1428         for (i = 0; i < MAX_RTP_PT; ++i) {
1429                 rtp->current_RTP_PT[i].isAstFormat = 0;
1430                 rtp->current_RTP_PT[i].code = 0;
1431         }
1432
1433         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1434         rtp->rtp_lookup_code_cache_code = 0;
1435         rtp->rtp_lookup_code_cache_result = 0;
1436
1437         ast_mutex_unlock(&rtp->bridge_lock);
1438 }
1439
1440 void ast_rtp_pt_default(struct ast_rtp* rtp) 
1441 {
1442         int i;
1443
1444         ast_mutex_lock(&rtp->bridge_lock);
1445
1446         /* Initialize to default payload types */
1447         for (i = 0; i < MAX_RTP_PT; ++i) {
1448                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1449                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1450         }
1451
1452         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1453         rtp->rtp_lookup_code_cache_code = 0;
1454         rtp->rtp_lookup_code_cache_result = 0;
1455
1456         ast_mutex_unlock(&rtp->bridge_lock);
1457 }
1458
1459 void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
1460 {
1461         unsigned int i;
1462
1463         ast_mutex_lock(&dest->bridge_lock);
1464         ast_mutex_lock(&src->bridge_lock);
1465
1466         for (i=0; i < MAX_RTP_PT; ++i) {
1467                 dest->current_RTP_PT[i].isAstFormat = 
1468                         src->current_RTP_PT[i].isAstFormat;
1469                 dest->current_RTP_PT[i].code = 
1470                         src->current_RTP_PT[i].code; 
1471         }
1472         dest->rtp_lookup_code_cache_isAstFormat = 0;
1473         dest->rtp_lookup_code_cache_code = 0;
1474         dest->rtp_lookup_code_cache_result = 0;
1475
1476         ast_mutex_unlock(&src->bridge_lock);
1477         ast_mutex_unlock(&dest->bridge_lock);
1478 }
1479
1480 /*! \brief Get channel driver interface structure */
1481 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1482 {
1483         struct ast_rtp_protocol *cur = NULL;
1484
1485         AST_LIST_LOCK(&protos);
1486         AST_LIST_TRAVERSE(&protos, cur, list) {
1487                 if (cur->type == chan->tech->type)
1488                         break;
1489         }
1490         AST_LIST_UNLOCK(&protos);
1491
1492         return cur;
1493 }
1494
1495 int ast_rtp_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
1496 {
1497         // dest = c0, src = c1
1498         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1499         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1500         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1501         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1502         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED;
1503         int srccodec, nat_active = 0;
1504
1505         /* Lock channels */
1506         ast_channel_lock(c0);
1507         if (c1) {
1508                 while(ast_channel_trylock(c1)) {
1509                         ast_channel_unlock(c0);
1510                         usleep(1);
1511                         ast_channel_lock(c0);
1512                 }
1513         }
1514
1515         /* Find channel driver interfaces */
1516         destpr = get_proto(c0);
1517         if (c1)
1518                 srcpr = get_proto(c1);
1519         if (!destpr) {
1520                 if (option_debug)
1521                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c0->name);
1522                 ast_channel_unlock(c0);
1523                 if (c1)
1524                         ast_channel_unlock(c1);
1525                 return -1;
1526         }
1527         if (!srcpr) {
1528                 if (option_debug)
1529                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>");
1530                 ast_channel_unlock(c0);
1531                 if (c1)
1532                         ast_channel_unlock(c1);
1533                 return -1;
1534         }
1535
1536         /* Get audio and video interface (if native bridge is possible) */
1537         audio_dest_res = destpr->get_rtp_info(c0, &destp);
1538         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED;
1539         if (srcpr) {
1540                 audio_src_res = srcpr->get_rtp_info(c1, &srcp);
1541                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED;
1542         }
1543
1544         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1545         if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1546                 /* Somebody doesn't want to play... */
1547                 ast_channel_unlock(c0);
1548                 if (c1)
1549                         ast_channel_unlock(c1);
1550                 return -1;
1551         }
1552         if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1553                 srccodec = srcpr->get_codec(c1);
1554         else
1555                 srccodec = 0;
1556         /* Consider empty media as non-existant */
1557         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1558                 srcp = NULL;
1559         if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1560                 nat_active = 1;
1561         /* Bridge media early */
1562         if (destpr->set_rtp_peer(c0, srcp, vsrcp, srccodec, nat_active))
1563                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1564         ast_channel_unlock(c0);
1565         if (c1)
1566                 ast_channel_unlock(c1);
1567         if (option_debug)
1568                 ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1569         return 0;
1570 }
1571
1572 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1573 {
1574         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1575         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1576         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1577         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1578         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; 
1579         int srccodec;
1580
1581         /* Lock channels */
1582         ast_channel_lock(dest);
1583         while(ast_channel_trylock(src)) {
1584                 ast_channel_unlock(dest);
1585                 usleep(1);
1586                 ast_channel_lock(dest);
1587         }
1588
1589         /* Find channel driver interfaces */
1590         if (!(destpr = get_proto(dest))) {
1591                 if (option_debug)
1592                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1593                 ast_channel_unlock(dest);
1594                 ast_channel_unlock(src);
1595                 return 0;
1596         }
1597         if (!(srcpr = get_proto(src))) {
1598                 if (option_debug)
1599                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1600                 ast_channel_unlock(dest);
1601                 ast_channel_unlock(src);
1602                 return 0;
1603         }
1604
1605         /* Get audio and video interface (if native bridge is possible) */
1606         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1607         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1608         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1609         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1610
1611         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1612         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE) {
1613                 /* Somebody doesn't want to play... */
1614                 ast_channel_unlock(dest);
1615                 ast_channel_unlock(src);
1616                 return 0;
1617         }
1618         ast_rtp_pt_copy(destp, srcp);
1619         if (vdestp && vsrcp)
1620                 ast_rtp_pt_copy(vdestp, vsrcp);
1621         if (srcpr->get_codec)
1622                 srccodec = srcpr->get_codec(src);
1623         else
1624                 srccodec = 0;
1625         if (media) {
1626                 /* Bridge early */
1627                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1628                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1629         }
1630         ast_channel_unlock(dest);
1631         ast_channel_unlock(src);
1632         if (option_debug)
1633                 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1634         return 1;
1635 }
1636
1637 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1638  * By default, use the well-known value for this type (although it may 
1639  * still be set to a different value by a subsequent "a=rtpmap:" line)
1640  */
1641 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1642 {
1643         if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) 
1644                 return; /* bogus payload type */
1645
1646         ast_mutex_lock(&rtp->bridge_lock);
1647         rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1648         ast_mutex_unlock(&rtp->bridge_lock);
1649
1650
1651 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1652  * an SDP "a=rtpmap:" line.
1653  */
1654 void ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1655                              char *mimeType, char *mimeSubtype,
1656                              enum ast_rtp_options options)
1657 {
1658         unsigned int i;
1659
1660         if (pt < 0 || pt > MAX_RTP_PT) 
1661                 return; /* bogus payload type */
1662         
1663         ast_mutex_lock(&rtp->bridge_lock);
1664
1665         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1666                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1667                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1668                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1669                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1670                             mimeTypes[i].payloadType.isAstFormat &&
1671                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1672                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1673                         break;
1674                 }
1675         }
1676
1677         ast_mutex_unlock(&rtp->bridge_lock);
1678
1679         return;
1680
1681
1682 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1683  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1684 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1685                                  int* astFormats, int* nonAstFormats)
1686 {
1687         int pt;
1688         
1689         ast_mutex_lock(&rtp->bridge_lock);
1690         
1691         *astFormats = *nonAstFormats = 0;
1692         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1693                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1694                         *astFormats |= rtp->current_RTP_PT[pt].code;
1695                 } else {
1696                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1697                 }
1698         }
1699         
1700         ast_mutex_unlock(&rtp->bridge_lock);
1701         
1702         return;
1703 }
1704
1705 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
1706 {
1707         struct rtpPayloadType result;
1708
1709         result.isAstFormat = result.code = 0;
1710
1711         if (pt < 0 || pt > MAX_RTP_PT) 
1712                 return result; /* bogus payload type */
1713
1714         /* Start with negotiated codecs */
1715         ast_mutex_lock(&rtp->bridge_lock);
1716         result = rtp->current_RTP_PT[pt];
1717         ast_mutex_unlock(&rtp->bridge_lock);
1718
1719         /* If it doesn't exist, check our static RTP type list, just in case */
1720         if (!result.code) 
1721                 result = static_RTP_PT[pt];
1722
1723         return result;
1724 }
1725
1726 /*! \brief Looks up an RTP code out of our *static* outbound list */
1727 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
1728 {
1729         int pt = 0;
1730
1731         ast_mutex_lock(&rtp->bridge_lock);
1732
1733         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1734                 code == rtp->rtp_lookup_code_cache_code) {
1735                 /* Use our cached mapping, to avoid the overhead of the loop below */
1736                 pt = rtp->rtp_lookup_code_cache_result;
1737                 ast_mutex_unlock(&rtp->bridge_lock);
1738                 return pt;
1739         }
1740
1741         /* Check the dynamic list first */
1742         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1743                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1744                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1745                         rtp->rtp_lookup_code_cache_code = code;
1746                         rtp->rtp_lookup_code_cache_result = pt;
1747                         ast_mutex_unlock(&rtp->bridge_lock);
1748                         return pt;
1749                 }
1750         }
1751
1752         /* Then the static list */
1753         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1754                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1755                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1756                         rtp->rtp_lookup_code_cache_code = code;
1757                         rtp->rtp_lookup_code_cache_result = pt;
1758                         ast_mutex_unlock(&rtp->bridge_lock);
1759                         return pt;
1760                 }
1761         }
1762
1763         ast_mutex_unlock(&rtp->bridge_lock);
1764
1765         return -1;
1766 }
1767
1768 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
1769                                   enum ast_rtp_options options)
1770 {
1771         unsigned int i;
1772
1773         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1774                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
1775                         if (isAstFormat &&
1776                             (code == AST_FORMAT_G726_AAL2) &&
1777                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1778                                 return "G726-32";
1779                         else
1780                                 return mimeTypes[i].subtype;
1781                 }
1782         }
1783
1784         return "";
1785 }
1786
1787 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
1788                                    const int isAstFormat, enum ast_rtp_options options)
1789 {
1790         int format;
1791         unsigned len;
1792         char *end = buf;
1793         char *start = buf;
1794
1795         if (!buf || !size)
1796                 return NULL;
1797
1798         snprintf(end, size, "0x%x (", capability);
1799
1800         len = strlen(end);
1801         end += len;
1802         size -= len;
1803         start = end;
1804
1805         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1806                 if (capability & format) {
1807                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
1808
1809                         snprintf(end, size, "%s|", name);
1810                         len = strlen(end);
1811                         end += len;
1812                         size -= len;
1813                 }
1814         }
1815
1816         if (start == end)
1817                 snprintf(start, size, "nothing)"); 
1818         else if (size > 1)
1819                 *(end -1) = ')';
1820         
1821         return buf;
1822 }
1823
1824 /*! \brief Open RTP or RTCP socket for a session */
1825 static int rtp_socket(void)
1826 {
1827         int s;
1828         long flags;
1829         s = socket(AF_INET, SOCK_DGRAM, 0);
1830         if (s > -1) {
1831                 flags = fcntl(s, F_GETFL);
1832                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1833 #ifdef SO_NO_CHECK
1834                 if (nochecksums)
1835                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1836 #endif
1837         }
1838         return s;
1839 }
1840
1841 /*!
1842  * \brief Initialize a new RTCP session.
1843  * 
1844  * \returns The newly initialized RTCP session.
1845  */
1846 static struct ast_rtcp *ast_rtcp_new(void)
1847 {
1848         struct ast_rtcp *rtcp;
1849
1850         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1851                 return NULL;
1852         rtcp->s = rtp_socket();
1853         rtcp->us.sin_family = AF_INET;
1854         rtcp->them.sin_family = AF_INET;
1855
1856         if (rtcp->s < 0) {
1857                 free(rtcp);
1858                 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
1859                 return NULL;
1860         }
1861
1862         return rtcp;
1863 }
1864
1865 /*!
1866  * \brief Initialize a new RTP structure.
1867  *
1868  */
1869 void ast_rtp_new_init(struct ast_rtp *rtp)
1870 {
1871         ast_mutex_init(&rtp->bridge_lock);
1872
1873         rtp->them.sin_family = AF_INET;
1874         rtp->us.sin_family = AF_INET;
1875         rtp->ssrc = ast_random();
1876         rtp->seqno = ast_random() & 0xffff;
1877         ast_set_flag(rtp, FLAG_HAS_DTMF);
1878
1879         return;
1880 }
1881
1882 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1883 {
1884         struct ast_rtp *rtp;
1885         int x;
1886         int first;
1887         int startplace;
1888         
1889         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1890                 return NULL;
1891
1892         ast_rtp_new_init(rtp);
1893
1894         rtp->s = rtp_socket();
1895         if (rtp->s < 0) {
1896                 free(rtp);
1897                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1898                 return NULL;
1899         }
1900         if (sched && rtcpenable) {
1901                 rtp->sched = sched;
1902                 rtp->rtcp = ast_rtcp_new();
1903         }
1904         
1905         /* Select a random port number in the range of possible RTP */
1906         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1907         x = x & ~1;
1908         /* Save it for future references. */
1909         startplace = x;
1910         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1911         for (;;) {
1912                 /* Must be an even port number by RTP spec */
1913                 rtp->us.sin_port = htons(x);
1914                 rtp->us.sin_addr = addr;
1915
1916                 /* If there's rtcp, initialize it as well. */
1917                 if (rtp->rtcp) {
1918                         rtp->rtcp->us.sin_port = htons(x + 1);
1919                         rtp->rtcp->us.sin_addr = addr;
1920                 }
1921                 /* Try to bind it/them. */
1922                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1923                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1924                         break;
1925                 if (!first) {
1926                         /* Primary bind succeeded! Gotta recreate it */
1927                         close(rtp->s);
1928                         rtp->s = rtp_socket();
1929                 }
1930                 if (errno != EADDRINUSE) {
1931                         /* We got an error that wasn't expected, abort! */
1932                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1933                         close(rtp->s);
1934                         if (rtp->rtcp) {
1935                                 close(rtp->rtcp->s);
1936                                 free(rtp->rtcp);
1937                         }
1938                         free(rtp);
1939                         return NULL;
1940                 }
1941                 /* The port was used, increment it (by two). */
1942                 x += 2;
1943                 /* Did we go over the limit ? */
1944                 if (x > rtpend)
1945                         /* then, start from the begingig. */
1946                         x = (rtpstart + 1) & ~1;
1947                 /* Check if we reached the place were we started. */
1948                 if (x == startplace) {
1949                         /* If so, there's no ports available. */
1950                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1951                         close(rtp->s);
1952                         if (rtp->rtcp) {
1953                                 close(rtp->rtcp->s);
1954                                 free(rtp->rtcp);
1955                         }
1956                         free(rtp);
1957                         return NULL;
1958                 }
1959         }
1960         rtp->sched = sched;
1961         rtp->io = io;
1962         if (callbackmode) {
1963                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1964                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
1965         }
1966         ast_rtp_pt_default(rtp);
1967         return rtp;
1968 }
1969
1970 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1971 {
1972         struct in_addr ia;
1973
1974         memset(&ia, 0, sizeof(ia));
1975         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1976 }
1977
1978 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1979 {
1980         int res;
1981
1982         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
1983                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1984         return res;
1985 }
1986
1987 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1988 {
1989         rtp->them.sin_port = them->sin_port;
1990         rtp->them.sin_addr = them->sin_addr;
1991         if (rtp->rtcp) {
1992                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1993                 rtp->rtcp->them.sin_addr = them->sin_addr;
1994         }
1995         rtp->rxseqno = 0;
1996 }
1997
1998 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1999 {
2000         if ((them->sin_family != AF_INET) ||
2001                 (them->sin_port != rtp->them.sin_port) ||
2002                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2003                 them->sin_family = AF_INET;
2004                 them->sin_port = rtp->them.sin_port;
2005                 them->sin_addr = rtp->them.sin_addr;
2006                 return 1;
2007         }
2008         return 0;
2009 }
2010
2011 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2012 {
2013         *us = rtp->us;
2014 }
2015
2016 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2017 {
2018         struct ast_rtp *bridged = NULL;
2019
2020         ast_mutex_lock(&rtp->bridge_lock);
2021         bridged = rtp->bridged;
2022         ast_mutex_unlock(&rtp->bridge_lock);
2023
2024         return bridged;
2025 }
2026
2027 void ast_rtp_stop(struct ast_rtp *rtp)
2028 {
2029         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
2030                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2031                 rtp->rtcp->schedid = -1;
2032         }
2033
2034         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2035         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2036         if (rtp->rtcp) {
2037                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2038                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2039         }
2040         
2041         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2042 }
2043
2044 void ast_rtp_reset(struct ast_rtp *rtp)
2045 {
2046         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2047         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2048         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2049         rtp->lastts = 0;
2050         rtp->lastdigitts = 0;
2051         rtp->lastrxts = 0;
2052         rtp->lastividtimestamp = 0;
2053         rtp->lastovidtimestamp = 0;
2054         rtp->lasteventseqn = 0;
2055         rtp->lasteventendseqn = 0;
2056         rtp->lasttxformat = 0;
2057         rtp->lastrxformat = 0;
2058         rtp->dtmfcount = 0;
2059         rtp->dtmfduration = 0;
2060         rtp->seqno = 0;
2061         rtp->rxseqno = 0;
2062 }
2063
2064 char *ast_rtp_get_quality(struct ast_rtp *rtp)
2065 {
2066         /*
2067         *ssrc          our ssrc
2068         *themssrc      their ssrc
2069         *lp            lost packets
2070         *rxjitter      our calculated jitter(rx)
2071         *rxcount       no. received packets
2072         *txjitter      reported jitter of the other end
2073         *txcount       transmitted packets
2074         *rlp           remote lost packets
2075         */
2076         
2077         snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality), "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f", rtp->ssrc, rtp->themssrc, rtp->rtcp->expected_prior - rtp->rtcp->received_prior, rtp->rxjitter, rtp->rxcount, (double)rtp->rtcp->reported_jitter/65536., rtp->txcount, rtp->rtcp->reported_lost, rtp->rtcp->rtt);
2078         
2079         return rtp->rtcp->quality;
2080 }
2081
2082 void ast_rtp_destroy(struct ast_rtp *rtp)
2083 {
2084         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2085                 /*Print some info on the call here */
2086                 ast_verbose("  RTP-stats\n");
2087                 ast_verbose("* Our Receiver:\n");
2088                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
2089                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
2090                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2091                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
2092                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2093                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2094                 ast_verbose("* Our Sender:\n");
2095                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2096                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2097                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2098                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter);
2099                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2100                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2101         }
2102
2103         if (rtp->smoother)
2104                 ast_smoother_free(rtp->smoother);
2105         if (rtp->ioid)
2106                 ast_io_remove(rtp->io, rtp->ioid);
2107         if (rtp->s > -1)
2108                 close(rtp->s);
2109         if (rtp->rtcp) {
2110                 if (rtp->rtcp->schedid > 0)
2111                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2112                 close(rtp->rtcp->s);
2113                 free(rtp->rtcp);
2114                 rtp->rtcp=NULL;
2115         }
2116
2117         ast_mutex_destroy(&rtp->bridge_lock);
2118
2119         free(rtp);
2120 }
2121
2122 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2123 {
2124         struct timeval t;
2125         long ms;
2126         if (ast_tvzero(rtp->txcore)) {
2127                 rtp->txcore = ast_tvnow();
2128                 /* Round to 20ms for nice, pretty timestamps */
2129                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2130         }
2131         /* Use previous txcore if available */
2132         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2133         ms = ast_tvdiff_ms(t, rtp->txcore);
2134         if (ms < 0)
2135                 ms = 0;
2136         /* Use what we just got for next time */
2137         rtp->txcore = t;
2138         return (unsigned int) ms;
2139 }
2140
2141 /*! \brief Send begin frames for DTMF */
2142 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2143 {
2144         unsigned int *rtpheader;
2145         int hdrlen = 12, res = 0, i = 0, payload = 0;
2146         char data[256];
2147
2148         if ((digit <= '9') && (digit >= '0'))
2149                 digit -= '0';
2150         else if (digit == '*')
2151                 digit = 10;
2152         else if (digit == '#')
2153                 digit = 11;
2154         else if ((digit >= 'A') && (digit <= 'D'))
2155                 digit = digit - 'A' + 12;
2156         else if ((digit >= 'a') && (digit <= 'd'))
2157                 digit = digit - 'a' + 12;
2158         else {
2159                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2160                 return 0;
2161         }
2162
2163         /* If we have no peer, return immediately */    
2164         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2165                 return 0;
2166
2167         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2168
2169         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2170         rtp->send_duration = 160;
2171         
2172         /* Get a pointer to the header */
2173         rtpheader = (unsigned int *)data;
2174         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2175         rtpheader[1] = htonl(rtp->lastdigitts);
2176         rtpheader[2] = htonl(rtp->ssrc); 
2177
2178         for (i = 0; i < 2; i++) {
2179                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2180                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2181                 if (res < 0) 
2182                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2183                                 ast_inet_ntoa(rtp->them.sin_addr),
2184                                 ntohs(rtp->them.sin_port), strerror(errno));
2185                 if (rtp_debug_test_addr(&rtp->them))
2186                         ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2187                                     ast_inet_ntoa(rtp->them.sin_addr),
2188                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2189                 /* Increment sequence number */
2190                 rtp->seqno++;
2191                 /* Increment duration */
2192                 rtp->send_duration += 160;
2193                 /* Clear marker bit and set seqno */
2194                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2195         }
2196
2197         /* Since we received a begin, we can safely store the digit and disable any compensation */
2198         rtp->send_digit = digit;
2199         rtp->send_payload = payload;
2200
2201         return 0;
2202 }
2203
2204 /*! \brief Send continuation frame for DTMF */
2205 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2206 {
2207         unsigned int *rtpheader;
2208         int hdrlen = 12, res = 0;
2209         char data[256];
2210
2211         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2212                 return 0;
2213
2214         /* Setup packet to send */
2215         rtpheader = (unsigned int *)data;
2216         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2217         rtpheader[1] = htonl(rtp->lastdigitts);
2218         rtpheader[2] = htonl(rtp->ssrc);
2219         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2220         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2221         
2222         /* Transmit */
2223         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2224         if (res < 0)
2225                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2226                         ast_inet_ntoa(rtp->them.sin_addr),
2227                         ntohs(rtp->them.sin_port), strerror(errno));
2228         if (rtp_debug_test_addr(&rtp->them))
2229                 ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2230                             ast_inet_ntoa(rtp->them.sin_addr),
2231                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2232
2233         /* Increment sequence number */
2234         rtp->seqno++;
2235         /* Increment duration */
2236         rtp->send_duration += 160;
2237
2238         return 0;
2239 }
2240
2241 /*! \brief Send end packets for DTMF */
2242 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2243 {
2244         unsigned int *rtpheader;
2245         int hdrlen = 12, res = 0, i = 0;
2246         char data[256];
2247         
2248         /* If no address, then bail out */
2249         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2250                 return 0;
2251         
2252         if ((digit <= '9') && (digit >= '0'))
2253                 digit -= '0';
2254         else if (digit == '*')
2255                 digit = 10;
2256         else if (digit == '#')
2257                 digit = 11;
2258         else if ((digit >= 'A') && (digit <= 'D'))
2259                 digit = digit - 'A' + 12;
2260         else if ((digit >= 'a') && (digit <= 'd'))
2261                 digit = digit - 'a' + 12;
2262         else {
2263                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2264                 return 0;
2265         }
2266
2267         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2268
2269         rtpheader = (unsigned int *)data;
2270         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2271         rtpheader[1] = htonl(rtp->lastdigitts);
2272         rtpheader[2] = htonl(rtp->ssrc);
2273         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2274         /* Set end bit */
2275         rtpheader[3] |= htonl((1 << 23));
2276         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2277         /* Send 3 termination packets */
2278         for (i = 0; i < 3; i++) {
2279                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2280                 if (res < 0)
2281                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2282                                 ast_inet_ntoa(rtp->them.sin_addr),
2283                                 ntohs(rtp->them.sin_port), strerror(errno));
2284                 if (rtp_debug_test_addr(&rtp->them))
2285                         ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2286                                     ast_inet_ntoa(rtp->them.sin_addr),
2287                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2288         }
2289         rtp->send_digit = 0;
2290         /* Increment lastdigitts */
2291         rtp->lastdigitts += 960;
2292         rtp->seqno++;
2293
2294         return res;
2295 }
2296
2297 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2298 int ast_rtcp_send_h261fur(void *data)
2299 {
2300         struct ast_rtp *rtp = data;
2301         int res;
2302
2303         rtp->rtcp->sendfur = 1;
2304         res = ast_rtcp_write(data);
2305         
2306         return res;
2307 }
2308
2309 /*! \brief Send RTCP sender's report */
2310 static int ast_rtcp_write_sr(void *data)
2311 {
2312         struct ast_rtp *rtp = data;
2313         int res;
2314         int len = 0;
2315         struct timeval now;
2316         unsigned int now_lsw;
2317         unsigned int now_msw;
2318         unsigned int *rtcpheader;
2319         unsigned int lost;
2320         unsigned int extended;
2321         unsigned int expected;
2322         unsigned int expected_interval;
2323         unsigned int received_interval;
2324         int lost_interval;
2325         int fraction;
2326         struct timeval dlsr;
2327         char bdata[512];
2328
2329         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2330         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2331                 return 0;
2332         
2333         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2334                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2335                 if (rtp->rtcp->schedid > 0)
2336                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2337                 rtp->rtcp->schedid = -1;
2338                 return 0;
2339         }
2340
2341         gettimeofday(&now, NULL);
2342         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2343         rtcpheader = (unsigned int *)bdata;
2344         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2345         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2346         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2347         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2348         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2349         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2350         len += 28;
2351         
2352         extended = rtp->cycles + rtp->lastrxseqno;
2353         expected = extended - rtp->seedrxseqno + 1;
2354         if (rtp->rxcount > expected) 
2355                 expected += rtp->rxcount - expected;
2356         lost = expected - rtp->rxcount;
2357         expected_interval = expected - rtp->rtcp->expected_prior;
2358         rtp->rtcp->expected_prior = expected;
2359         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2360         rtp->rtcp->received_prior = rtp->rxcount;
2361         lost_interval = expected_interval - received_interval;
2362         if (expected_interval == 0 || lost_interval <= 0)
2363                 fraction = 0;
2364         else
2365                 fraction = (lost_interval << 8) / expected_interval;
2366         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2367         rtcpheader[7] = htonl(rtp->themssrc);
2368         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2369         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2370         rtcpheader[10] = htonl((unsigned int)rtp->rxjitter);
2371         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2372         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2373         len += 24;
2374         
2375         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2376
2377         if (rtp->rtcp->sendfur) {
2378                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2379                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2380                 len += 8;
2381                 rtp->rtcp->sendfur = 0;
2382         }
2383         
2384         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2385         /* it can change mid call, and SDES can't) */
2386         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2387         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2388         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2389         len += 12;
2390         
2391         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2392         if (res < 0) {
2393                 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));
2394                 if (rtp->rtcp->schedid > 0)
2395                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2396                 rtp->rtcp->schedid = -1;
2397                 return 0;
2398         }
2399         
2400         /* FIXME Don't need to get a new one */
2401         gettimeofday(&rtp->rtcp->txlsr, NULL);
2402         rtp->rtcp->sr_count++;
2403
2404         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2405         
2406         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2407                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2408                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2409                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2410                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2411                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2412                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2413                 ast_verbose("  Report block:\n");
2414                 ast_verbose("  Fraction lost: %u\n", fraction);
2415                 ast_verbose("  Cumulative loss: %u\n", lost);
2416                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2417                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2418                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2419         }
2420         return res;
2421 }
2422
2423 /*! \brief Send RTCP recipient's report */
2424 static int ast_rtcp_write_rr(void *data)
2425 {
2426         struct ast_rtp *rtp = data;
2427         int res;
2428         int len = 32;
2429         unsigned int lost;
2430         unsigned int extended;
2431         unsigned int expected;
2432         unsigned int expected_interval;
2433         unsigned int received_interval;
2434         int lost_interval;
2435         struct timeval now;
2436         unsigned int *rtcpheader;
2437         char bdata[1024];
2438         struct timeval dlsr;
2439         int fraction;
2440
2441         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2442                 return 0;
2443           
2444         if (!rtp->rtcp->them.sin_addr.s_addr) {
2445                 ast_log(LOG_ERROR, "RTCP RR transmission error to, rtcp halted %s\n",strerror(errno));
2446                 if (rtp->rtcp->schedid > 0)
2447                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2448                 rtp->rtcp->schedid = -1;
2449                 return 0;
2450         }
2451
2452         extended = rtp->cycles + rtp->lastrxseqno;
2453         expected = extended - rtp->seedrxseqno + 1;
2454         lost = expected - rtp->rxcount;
2455         expected_interval = expected - rtp->rtcp->expected_prior;
2456         rtp->rtcp->expected_prior = expected;
2457         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2458         rtp->rtcp->received_prior = rtp->rxcount;
2459         lost_interval = expected_interval - received_interval;
2460         if (expected_interval == 0 || lost_interval <= 0)
2461                 fraction = 0;
2462         else
2463                 fraction = (lost_interval << 8) / expected_interval;
2464         gettimeofday(&now, NULL);
2465         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2466         rtcpheader = (unsigned int *)bdata;
2467         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2468         rtcpheader[1] = htonl(rtp->ssrc);
2469         rtcpheader[2] = htonl(rtp->themssrc);
2470         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2471         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2472         rtcpheader[5] = htonl((unsigned int)rtp->rxjitter);
2473         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2474         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2475
2476         if (rtp->rtcp->sendfur) {
2477                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2478                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2479                 len += 8;
2480                 rtp->rtcp->sendfur = 0;
2481         }
2482
2483         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2484         it can change mid call, and SDES can't) */
2485         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2486         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2487         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2488         len += 12;
2489         
2490         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2491
2492         if (res < 0) {
2493                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2494                 /* Remove the scheduler */
2495                 if (rtp->rtcp->schedid > 0)
2496                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2497                 rtp->rtcp->schedid = -1;
2498                 return 0;
2499         }
2500
2501         rtp->rtcp->rr_count++;
2502
2503         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2504                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2505                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2506                         "  IA jitter: %.4f\n" 
2507                         "  Their last SR: %u\n" 
2508                         "  DLSR: %4.4f (sec)\n\n",
2509                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2510                         ntohs(rtp->rtcp->them.sin_port),
2511                         rtp->ssrc, rtp->themssrc, fraction, lost,
2512                         rtp->rxjitter,
2513                         rtp->rtcp->themrxlsr,
2514                         (double)(ntohl(rtcpheader[7])/65536.0));
2515         }
2516
2517         return res;
2518 }
2519
2520 /*! \brief Write and RTCP packet to the far end
2521  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2522  * RR is sent if we have not sent any rtp packets in the previous interval */
2523 static int ast_rtcp_write(void *data)
2524 {
2525         struct ast_rtp *rtp = data;
2526         int res;
2527         
2528         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2529                 res = ast_rtcp_write_sr(data);
2530         else
2531                 res = ast_rtcp_write_rr(data);
2532         
2533         return res;
2534 }
2535
2536 /*! \brief generate comfort noice (CNG) */
2537 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2538 {
2539         unsigned int *rtpheader;
2540         int hdrlen = 12;
2541         int res;
2542         int payload;
2543         char data[256];
2544         level = 127 - (level & 0x7f);
2545         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2546
2547         /* If we have no peer, return immediately */    
2548         if (!rtp->them.sin_addr.s_addr)
2549                 return 0;
2550
2551         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2552
2553         /* Get a pointer to the header */
2554         rtpheader = (unsigned int *)data;
2555         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2556         rtpheader[1] = htonl(rtp->lastts);
2557         rtpheader[2] = htonl(rtp->ssrc); 
2558         data[12] = level;
2559         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2560                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2561                 if (res <0) 
2562                         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));
2563                 if (rtp_debug_test_addr(&rtp->them))
2564                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %u, len %d)\n"
2565                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2566                    
2567         }
2568         return 0;
2569 }
2570
2571 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
2572 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2573 {
2574         unsigned char *rtpheader;
2575         int hdrlen = 12;
2576         int res;
2577         unsigned int ms;
2578         int pred;
2579         int mark = 0;
2580
2581         ms = calc_txstamp(rtp, &f->delivery);
2582         /* Default prediction */
2583         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2584                 pred = rtp->lastts + f->samples;
2585
2586                 /* Re-calculate last TS */
2587                 rtp->lastts = rtp->lastts + ms * 8;
2588                 if (ast_tvzero(f->delivery)) {
2589                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2590                            and if so, go with our prediction */
2591                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2592                                 rtp->lastts = pred;
2593                         else {
2594                                 if (option_debug > 2)
2595                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2596                                 mark = 1;
2597                         }
2598                 }
2599         } else {
2600                 mark = f->subclass & 0x1;
2601                 pred = rtp->lastovidtimestamp + f->samples;
2602                 /* Re-calculate last TS */
2603                 rtp->lastts = rtp->lastts + ms * 90;
2604                 /* If it's close to our prediction, go for it */
2605                 if (ast_tvzero(f->delivery)) {
2606                         if (abs(rtp->lastts - pred) < 7200) {
2607                                 rtp->lastts = pred;
2608                                 rtp->lastovidtimestamp += f->samples;
2609                         } else {
2610                                 if (option_debug > 2)
2611                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, f->samples);
2612                                 rtp->lastovidtimestamp = rtp->lastts;
2613                         }
2614                 }
2615         }
2616         /* If the timestamp for non-digit packets has moved beyond the timestamp
2617            for digits, update the digit timestamp.
2618         */
2619         if (rtp->lastts > rtp->lastdigitts)
2620                 rtp->lastdigitts = rtp->lastts;
2621
2622         if (f->has_timing_info)
2623                 rtp->lastts = f->ts * 8;
2624
2625         /* Get a pointer to the header */
2626         rtpheader = (unsigned char *)(f->data - hdrlen);
2627
2628         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2629         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2630         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
2631
2632         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2633                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2634                 if (res <0) {
2635                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2636                                 if (option_debug)
2637                                         ast_log(LOG_DEBUG, "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));
2638                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2639                                 /* Only give this error message once if we are not RTP debugging */
2640                                 if (option_debug || rtpdebug)
2641                                         ast_log(LOG_DEBUG, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
2642                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2643                         }
2644                 } else {
2645                         rtp->txcount++;
2646                         rtp->txoctetcount +=(res - hdrlen);
2647                         
2648                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
2649                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2650                 }
2651                                 
2652                 if (rtp_debug_test_addr(&rtp->them))
2653                         ast_verbose("Sent RTP packet to      %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2654                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2655         }
2656
2657         rtp->seqno++;
2658
2659         return 0;
2660 }
2661
2662 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
2663 {
2664         int x;
2665         for (x = 0; x < 32; x++) {  /* Ugly way */
2666                 rtp->pref.order[x] = prefs->order[x];
2667                 rtp->pref.framing[x] = prefs->framing[x];
2668         }
2669         if (rtp->smoother)
2670                 ast_smoother_free(rtp->smoother);
2671         rtp->smoother = NULL;
2672         return 0;
2673 }
2674
2675 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
2676 {
2677         return &rtp->pref;
2678 }
2679
2680 int ast_rtp_codec_getformat(int pt)
2681 {
2682         if (pt < 0 || pt > MAX_RTP_PT)
2683                 return 0; /* bogus payload type */
2684
2685         if (static_RTP_PT[pt].isAstFormat)
2686                 return static_RTP_PT[pt].code;
2687         else
2688                 return 0;
2689 }
2690
2691 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2692 {
2693         struct ast_frame *f;
2694         int codec;
2695         int hdrlen = 12;
2696         int subclass;
2697         
2698
2699         /* If we have no peer, return immediately */    
2700         if (!rtp->them.sin_addr.s_addr)
2701                 return 0;
2702
2703         /* If there is no data length, return immediately */
2704         if (!_f->datalen) 
2705                 return 0;
2706         
2707         /* Make sure we have enough space for RTP header */
2708         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
2709                 ast_log(LOG_WARNING, "RTP can only send voice and video\n");
2710                 return -1;
2711         }
2712
2713         subclass = _f->subclass;
2714         if (_f->frametype == AST_FRAME_VIDEO)
2715                 subclass &= ~0x1;
2716
2717         codec = ast_rtp_lookup_code(rtp, 1, subclass);
2718         if (codec < 0) {
2719                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2720                 return -1;
2721         }
2722
2723         if (rtp->lasttxformat != subclass) {
2724                 /* New format, reset the smoother */
2725                 if (option_debug)
2726                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2727                 rtp->lasttxformat = subclass;
2728                 if (rtp->smoother)
2729                         ast_smoother_free(rtp->smoother);
2730                 rtp->smoother = NULL;
2731         }
2732
2733         if (!rtp->smoother) {
2734                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
2735                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
2736                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2737                                 ast_log(LOG_WARNING, "Unable to create smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
2738                                 return -1;
2739                         }
2740                         if (fmt.flags)
2741                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
2742                         if (option_debug)
2743                                 ast_log(LOG_DEBUG, "Created smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
2744                 }
2745         }
2746         if (rtp->smoother) {
2747                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
2748                         ast_smoother_feed_be(rtp->smoother, _f);
2749                 } else {
2750                         ast_smoother_feed(rtp->smoother, _f);
2751                 }
2752
2753                 while((f = ast_smoother_read(rtp->smoother)))
2754                         ast_rtp_raw_write(rtp, f, codec);
2755         } else {
2756                 /* Don't buffer outgoing frames; send them one-per-packet: */
2757                 if (_f->offset < hdrlen) 
2758                         f = ast_frdup(_f);      /*! \bug XXX this might never be free'd. Why do we do this? */
2759                 else
2760                         f = _f;
2761                 ast_rtp_raw_write(rtp, f, codec);
2762                 if (f != _f)
2763                         ast_frfree(f);
2764         }
2765                 
2766         return 0;
2767 }
2768
2769 /*! \brief Unregister interface to channel driver */
2770 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2771 {
2772         AST_LIST_LOCK(&protos);
2773         AST_LIST_REMOVE(&protos, proto, list);
2774         AST_LIST_UNLOCK(&protos);
2775 }
2776
2777 /*! \brief Register interface to channel driver */
2778 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2779 {
2780         struct ast_rtp_protocol *cur;
2781
2782         AST_LIST_LOCK(&protos);
2783         AST_LIST_TRAVERSE(&protos, cur, list) { 
2784                 if (!strcmp(cur->type, proto->type)) {
2785                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2786                         AST_LIST_UNLOCK(&protos);
2787                         return -1;
2788                 }
2789         }
2790         AST_LIST_INSERT_HEAD(&protos, proto, list);
2791         AST_LIST_UNLOCK(&protos);
2792         
2793         return 0;
2794 }
2795
2796 /*! \brief Bridge loop for true native bridge (reinvite) */
2797 static enum ast_bridge_result bridge_native_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, struct ast_rtp *vp0, struct ast_rtp *vp1, struct ast_rtp_protocol *pr0, struct ast_rtp_protocol *pr1, int codec0, int codec1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
2798 {
2799         struct ast_frame *fr = NULL;
2800         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2801         int oldcodec0 = codec0, oldcodec1 = codec1;
2802         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, ac0 = {0,}, vac0 = {0,};
2803         struct sockaddr_in t1 = {0,}, vt1 = {0,}, t0 = {0,}, vt0 = {0,};
2804
2805         /* Set it up so audio goes directly between the two endpoints */
2806
2807         /* Test the first channel */
2808         if (!(pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
2809                 ast_rtp_get_peer(p1, &ac1);
2810                 if (vp1)
2811                         ast_rtp_get_peer(vp1, &vac1);
2812         } else
2813                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2814         
2815         /* Test the second channel */
2816         if (!(pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
2817                 ast_rtp_get_peer(p0, &ac0);
2818                 if (vp0)
2819                         ast_rtp_get_peer(vp0, &vac0);
2820         } else
2821                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
2822
2823         /* Now we can unlock and move into our loop */
2824         ast_channel_unlock(c0);
2825         ast_channel_unlock(c1);
2826
2827         /* Throw our channels into the structure and enter the loop */
2828         cs[0] = c0;
2829         cs[1] = c1;
2830         cs[2] = NULL;
2831         for (;;) {
2832                 /* Check if anything changed */
2833                 if ((c0->tech_pvt != pvt0) ||
2834                     (c1->tech_pvt != pvt1) ||
2835                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2836                         if (option_debug)
2837                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2838                         if (c0->tech_pvt == pvt0)
2839                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2840                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2841                         if (c1->tech_pvt == pvt1)
2842                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2843                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2844                         return AST_BRIDGE_RETRY;
2845                 }
2846
2847                 /* Check if they have changed their address */
2848                 ast_rtp_get_peer(p1, &t1);
2849                 if (vp1)
2850                         ast_rtp_get_peer(vp1, &vt1);
2851                 if (pr1->get_codec)
2852                         codec1 = pr1->get_codec(c1);
2853                 ast_rtp_get_peer(p0, &t0);
2854                 if (vp0)
2855                         ast_rtp_get_peer(vp0, &vt0);
2856                 if (pr0->get_codec)
2857                         codec0 = pr0->get_codec(c0);
2858                 if ((inaddrcmp(&t1, &ac1)) ||
2859                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
2860                     (codec1 != oldcodec1)) {
2861                         if (option_debug > 1) {
2862                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2863                                         c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
2864                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2865                                         c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2866                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2867                                         c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2868                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2869                                         c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2870                         }
2871                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))
2872                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2873                         memcpy(&ac1, &t1, sizeof(ac1));
2874                         memcpy(&vac1, &vt1, sizeof(vac1));
2875                         oldcodec1 = codec1;
2876                 }
2877                 if ((inaddrcmp(&t0, &ac0)) ||
2878                     (vp0 && inaddrcmp(&vt0, &vac0))) {
2879                         if (option_debug > 1) {
2880                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2881                                         c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
2882                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2883                                         c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2884                         }
2885                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
2886                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2887                         memcpy(&ac0, &t0, sizeof(ac0));
2888                         memcpy(&vac0, &vt0, sizeof(vac0));
2889                         oldcodec0 = codec0;
2890                 }
2891
2892                 /* Wait for frame to come in on the channels */
2893                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2894                         if (!timeoutms)
2895                                 return AST_BRIDGE_RETRY;
2896                         if (option_debug)
2897                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2898                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2899                                 break;
2900                         continue;
2901                 }
2902                 fr = ast_read(who);
2903                 other = (who == c0) ? c1 : c0;
2904                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
2905                             (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
2906                              ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2907                         /* Break out of bridge */
2908                         *fo = fr;
2909                         *rc = who;
2910                         if (option_debug)
2911                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2912                         if (c0->tech_pvt == pvt0)
2913                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2914                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2915                         if (c1->tech_pvt == pvt1)
2916                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2917                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2918                         return AST_BRIDGE_COMPLETE;
2919                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2920                         if ((fr->subclass == AST_CONTROL_HOLD) ||
2921                             (fr->subclass == AST_CONTROL_UNHOLD) ||
2922                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
2923                                 ast_indicate(other, fr->subclass);
2924                                 ast_frfree(fr);
2925                         } else {
2926                                 *fo = fr;
2927                                 *rc = who;
2928                                 if (option_debug)
2929                                         ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
2930                                 return AST_BRIDGE_COMPLETE;
2931                         }
2932                 } else {
2933                         if ((fr->frametype == AST_FRAME_DTMF) ||
2934                             (fr->frametype == AST_FRAME_VOICE) ||
2935                             (fr->frametype == AST_FRAME_VIDEO)) {
2936                                 ast_write(other, fr);
2937                         }
2938                         ast_frfree(fr);
2939                 }
2940                 /* Swap priority */
2941                 cs[2] = cs[0];
2942                 cs[0] = cs[1];
2943                 cs[1] = cs[2];
2944         }
2945
2946         return AST_BRIDGE_FAILED;
2947 }
2948
2949 /*! \brief P2P RTP Callback */
2950 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
2951 {
2952         int res = 0, hdrlen = 12;
2953         struct sockaddr_in sin;
2954         socklen_t len;
2955         unsigned int *header;
2956         struct ast_rtp *rtp = cbdata, *bridged = NULL;
2957
2958         if (!rtp)
2959                 return 1;
2960
2961         len = sizeof(sin);
2962         if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
2963                 return 1;
2964
2965         header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
2966
2967         /* If NAT support is turned on, then see if we need to change their address */
2968         if ((rtp->nat) && 
2969             ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
2970              (rtp->them.sin_port != sin.sin_port))) {
2971                 rtp->them = sin;
2972                 rtp->rxseqno = 0;
2973                 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
2974                 if (option_debug || rtpdebug)
2975                         ast_log(LOG_DEBUG, "P2P 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));
2976         }
2977
2978         /* Write directly out to other RTP stream if bridged */
2979         if ((bridged = ast_rtp_get_bridged(rtp)))
2980                 bridge_p2p_rtp_write(rtp, bridged, header, res, hdrlen);
2981
2982         return 1;
2983 }
2984
2985 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
2986 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
2987 {
2988         /* If we need DTMF, are looking for STUN, or we have no IO structure then we can't do direct callback */
2989         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || ast_test_flag(rtp, FLAG_HAS_STUN) || !rtp->io)
2990                 return 0;
2991
2992         /* If the RTP structure is already in callback mode, remove it temporarily */
2993         if (rtp->ioid) {
2994                 ast_io_remove(rtp->io, rtp->ioid);
2995                 rtp->ioid = NULL;
2996         }
2997
2998         /* Steal the file descriptors from the channel */
2999         chan->fds[0] = -1;
3000
3001         /* Now, fire up callback mode */
3002         iod[0] = ast_io_add(rtp->io, ast_rtp_fd(rtp), p2p_rtp_callback, AST_IO_IN, rtp);
3003
3004         return 1;
3005 }
3006
3007 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
3008 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3009 {
3010         ast_channel_lock(chan);
3011
3012         /* Remove the callback from the IO context */
3013         ast_io_remove(rtp->io, iod[0]);
3014
3015         /* Restore file descriptors */
3016         chan->fds[0] = ast_rtp_fd(rtp);
3017         ast_channel_unlock(chan);
3018
3019         /* Restore callback mode if previously used */
3020         if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
3021                 rtp->ioid = ast_io_add(rtp->io, ast_rtp_fd(rtp), rtpread, AST_IO_IN, rtp);
3022
3023         return 0;
3024 }
3025
3026 /*! \brief Helper function that sets what an RTP structure is bridged to */
3027 static void p2p_set_bridge(struct ast_rtp *rtp0, struct ast_rtp *rtp1)
3028 {
3029         ast_mutex_lock(&rtp0->bridge_lock);
3030         rtp0->bridged = rtp1;
3031         ast_mutex_unlock(&rtp0->bridge_lock);
3032
3033         return;
3034 }
3035
3036 /*! \brief Bridge loop for partial native bridge (packet2packet) 
3037
3038         In p2p mode, Asterisk is a very basic RTP proxy, just forwarding whatever
3039         rtp/rtcp we get in to the channel. 
3040         \note this currently only works for Audio
3041 */
3042 static enum ast_bridge_result bridge_p2p_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
3043 {
3044         struct ast_frame *fr = NULL;
3045         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
3046         int *p0_iod[2] = {NULL, NULL}, *p1_iod[2] = {NULL, NULL};
3047         int p0_callback = 0, p1_callback = 0;
3048         enum ast_bridge_result res = AST_BRIDGE_FAILED;
3049
3050         /* Okay, setup each RTP structure to do P2P forwarding */
3051         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3052         p2p_set_bridge(p0, p1);
3053         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3054         p2p_set_bridge(p1, p0);
3055
3056         /* Activate callback modes if possible */
3057         p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
3058         p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
3059
3060         /* Now let go of the channel locks and be on our way */
3061         ast_channel_unlock(c0);
3062         ast_channel_unlock(c1);
3063
3064         /* Go into a loop forwarding frames until we don't need to anymore */
3065         cs[0] = c0;
3066         cs[1] = c1;
3067         cs[2] = NULL;
3068         for (;;) {
3069                 /* Check if anything changed */
3070                 if ((c0->tech_pvt != pvt0) ||
3071                     (c1->tech_pvt != pvt1) ||
3072                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
3073                         if (option_debug > 2)
3074                                 ast_log(LOG_DEBUG, "p2p-rtp-bridge: Oooh, something is weird, backing out\n");
3075                         /* If a masquerade needs to happen we have to try to read in a frame so that it actually happens. Without this we risk being called again and going into a loop */
3076                         if ((c0->masq || c0->masqr) && (fr = ast_read(c0)))
3077                                 ast_frfree(fr);
3078                         if ((c1->masq || c1->masqr) && (fr = ast_read(c1)))
3079                                 ast_frfree(fr);
3080                         res = AST_BRIDGE_RETRY;
3081                         break;
3082                 }
3083                 /* Wait on a channel to feed us a frame */
3084                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
3085                         if (!timeoutms) {
3086                                 res = AST_BRIDGE_RETRY;
3087                                 break;
3088                         }
3089                         if (option_debug > 2)
3090                                 ast_log(LOG_NOTICE, "p2p-rtp-bridge: Ooh, empty read...\n");
3091                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
3092                                 break;
3093                         continue;
3094                 }
3095                 /* Read in frame from channel */
3096                 fr = ast_read(who);
3097                 other = (who == c0) ? c1 : c0;
3098                 /* Depending on the frame we may need to break out of our bridge */
3099                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
3100                             ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
3101                             ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
3102                         /* Record received frame and who */
3103                         *fo = fr;
3104                         *rc = who;
3105                         if (option_debug > 2)
3106                                 ast_log(LOG_DEBUG, "p2p-rtp-bridge: Ooh, got a %s\n", fr ? "digit" : "hangup");
3107                         res = AST_BRIDGE_COMPLETE;
3108                         break;
3109                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3110                         if ((fr->subclass == AST_CONTROL_HOLD) ||
3111                             (fr->subclass == AST_CONTROL_UNHOLD) ||
3112                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
3113                                 /* If we are going on hold, then break callback mode and P2P bridging */
3114                                 if (fr->subclass == AST_CONTROL_HOLD) {
3115                                         if (p0_callback)
3116                                                 p0_callback = p2p_callback_disable(c0, p0, &p0_iod[0]);
3117                                         if (p1_callback)
3118                                                 p1_callback = p2p_callback_disable(c1, p1, &p1_iod[0]);
3119                                         p2p_set_bridge(p0, NULL);
3120                                         p2p_set_bridge(p1, NULL);
3121                                 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3122                                         /* If we are off hold, then go back to callback mode and P2P bridging */
3123                                         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3124                                         p2p_set_bridge(p0, p1);
3125                                         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3126                                         p2p_set_bridge(p1, p0);
3127                                         p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
3128                                         p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
3129                                 }
3130                                 ast_indicate(other, fr->subclass);
3131                                 ast_frfree(fr);
3132                         } else {
3133                                 *fo = fr;
3134                                 *rc = who;
3135                                 if (option_debug > 2)
3136                                         ast_log(LOG_DEBUG, "p2p-rtp-bridge: Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3137                                 res = AST_BRIDGE_COMPLETE;
3138                                 break;
3139                         }
3140                 } else {
3141                         /* If this is a DTMF, voice, or video frame write it to the other channel */
3142                         if ((fr->frametype == AST_FRAME_DTMF) ||
3143                             (fr->frametype == AST_FRAME_VOICE) ||
3144                             (fr->frametype == AST_FRAME_VIDEO)) {
3145                                 ast_write(other, fr);
3146                         }
3147                         ast_frfree(fr);
3148                 }
3149                 /* Swap priority */
3150                 cs[2] = cs[0];
3151                 cs[0] = cs[1];
3152                 cs[1] = cs[2];
3153         }
3154
3155         /* If we are totally avoiding the core, then restore our link to it */
3156         if (p0_callback)
3157                 p0_callback = p2p_callback_disable(c0, p0, &p0_iod[0]);
3158         if (p1_callback)
3159                 p1_callback = p2p_callback_disable(c1, p1, &p1_iod[0]);
3160
3161         /* Break out of the direct bridge */
3162         p2p_set_bridge(p0, NULL);
3163         p2p_set_bridge(p1, NULL);
3164
3165         return res;
3166 }
3167
3168 /*! \brief Bridge calls. If possible and allowed, initiate
3169         re-invite so the peers exchange media directly outside 
3170         of Asterisk. 
3171 */
3172 /*! \page AstRTPbridge The Asterisk RTP bridge 
3173         The RTP bridge is called from the channel drivers that are using the RTP
3174         subsystem in Asterisk - like SIP, H.323 and Jingle/Google Talk.