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