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