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