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