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