Merge in RTP-level packet bridging. Packet comes in, packet goes out - that's what...
[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 (version != 2)
1046                 return &ast_null_frame;
1047         /* Ignore if the other side hasn't been given an address
1048            yet.  */
1049         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1050                 return &ast_null_frame;
1051
1052         if (rtp->nat) {
1053                 /* Send to whoever sent to us */
1054                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1055                     (rtp->them.sin_port != sin.sin_port)) {
1056                         rtp->them = sin;
1057                         if (rtp->rtcp) {
1058                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1059                                 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1);
1060                         }
1061                         rtp->rxseqno = 0;
1062                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1063                         if (option_debug || rtpdebug)
1064                                 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));
1065                 }
1066         }
1067
1068         payloadtype = (seqno & 0x7f0000) >> 16;
1069         padding = seqno & (1 << 29);
1070         mark = seqno & (1 << 23);
1071         ext = seqno & (1 << 28);
1072         seqno &= 0xffff;
1073         timestamp = ntohl(rtpheader[1]);
1074         ssrc = ntohl(rtpheader[2]);
1075         
1076         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1077                 if (option_debug || rtpdebug)
1078                         ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n");
1079                 mark = 1;
1080         }
1081
1082         rtp->rxssrc = ssrc;
1083         
1084         if (padding) {
1085                 /* Remove padding bytes */
1086                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1087         }
1088         
1089         if (ext) {
1090                 /* RTP Extension present */
1091                 hdrlen += 4;
1092                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
1093         }
1094
1095         if (res < hdrlen) {
1096                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1097                 return &ast_null_frame;
1098         }
1099
1100         rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1101
1102         tseqno = rtp->lastrxseqno +1;
1103
1104         if (rtp->rxcount==1) {
1105                 /* This is the first RTP packet successfully received from source */
1106                 rtp->seedrxseqno = seqno;
1107         }
1108
1109         if (rtp->rtcp && rtp->rtcp->schedid < 1) {
1110                 /* Schedule transmission of Receiver Report */
1111                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1112         }
1113
1114         if (tseqno > RTP_SEQ_MOD) { /* if tseqno is greater than RTP_SEQ_MOD it would indicate that the sender cycled */
1115                 rtp->cycles += RTP_SEQ_MOD;
1116                 ast_verbose("SEQNO cycled: %u\t%d\n", rtp->cycles, seqno);
1117         }
1118
1119         rtp->lastrxseqno = seqno;
1120         
1121         if (rtp->themssrc==0)
1122                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1123         
1124         if (rtp_debug_test_addr(&sin))
1125                 ast_verbose("Got  RTP packet from    %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1126                         ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1127
1128         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1129         if (!rtpPT.isAstFormat) {
1130                 struct ast_frame *f = NULL;
1131
1132                 /* This is special in-band data that's not one of our codecs */
1133                 if (rtpPT.code == AST_RTP_DTMF) {
1134                         /* It's special -- rfc2833 process it */
1135                         if (rtp_debug_test_addr(&sin)) {
1136                                 unsigned char *data;
1137                                 unsigned int event;
1138                                 unsigned int event_end;
1139                                 unsigned int duration;
1140                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1141                                 event = ntohl(*((unsigned int *)(data)));
1142                                 event >>= 24;
1143                                 event_end = ntohl(*((unsigned int *)(data)));
1144                                 event_end <<= 8;
1145                                 event_end >>= 24;
1146                                 duration = ntohl(*((unsigned int *)(data)));
1147                                 duration &= 0xFFFF;
1148                                 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);
1149                         }
1150                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
1151                                 f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno);
1152                                 rtp->lasteventseqn = seqno;
1153                         }
1154                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1155                         /* It's really special -- process it the Cisco way */
1156                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
1157                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1158                                 rtp->lasteventseqn = seqno;
1159                         }
1160                 } else if (rtpPT.code == AST_RTP_CN) {
1161                         /* Comfort Noise */
1162                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1163                 } else {
1164                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1165                 }
1166                 return f ? f : &ast_null_frame;
1167         }
1168         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1169         rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO;
1170
1171         if (!rtp->lastrxts)
1172                 rtp->lastrxts = timestamp;
1173
1174         rtp->rxseqno = seqno;
1175
1176         if (rtp->dtmfcount) {
1177 #if 0
1178                 printf("dtmfcount was %d\n", rtp->dtmfcount);
1179 #endif          
1180                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
1181                 if (rtp->dtmfcount < 0)
1182                         rtp->dtmfcount = 0;
1183 #if 0
1184                 if (dtmftimeout != rtp->dtmfcount)
1185                         printf("dtmfcount is %d\n", rtp->dtmfcount);
1186 #endif
1187         }
1188         rtp->lastrxts = timestamp;
1189
1190         /* Send any pending DTMF */
1191         if (rtp->resp && !rtp->dtmfcount) {
1192                 if (option_debug)
1193                         ast_log(LOG_DEBUG, "Sending pending DTMF\n");
1194                 return send_dtmf(rtp);
1195         }
1196         rtp->f.mallocd = 0;
1197         rtp->f.datalen = res - hdrlen;
1198         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1199         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1200         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
1201                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1202                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
1203                         ast_frame_byteswap_be(&rtp->f);
1204                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1205                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1206                 rtp->f.has_timing_info = 1;
1207                 rtp->f.ts = timestamp / 8;
1208                 rtp->f.len = rtp->f.samples / 8;
1209                 rtp->f.seqno = seqno;
1210         } else {
1211                 /* Video -- samples is # of samples vs. 90000 */
1212                 if (!rtp->lastividtimestamp)
1213                         rtp->lastividtimestamp = timestamp;
1214                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1215                 rtp->lastividtimestamp = timestamp;
1216                 rtp->f.delivery.tv_sec = 0;
1217                 rtp->f.delivery.tv_usec = 0;
1218                 if (mark)
1219                         rtp->f.subclass |= 0x1;
1220                 
1221         }
1222         rtp->f.src = "RTP";
1223         return &rtp->f;
1224 }
1225
1226 /* The following array defines the MIME Media type (and subtype) for each
1227    of our codecs, or RTP-specific data type. */
1228 static struct {
1229         struct rtpPayloadType payloadType;
1230         char* type;
1231         char* subtype;
1232 } mimeTypes[] = {
1233         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
1234         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
1235         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
1236         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
1237         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
1238         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
1239         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
1240         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
1241         {{1, AST_FORMAT_G729A}, "audio", "G729"},
1242         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
1243         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1244         {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1245         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1246         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1247         {{0, AST_RTP_CN}, "audio", "CN"},
1248         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1249         {{1, AST_FORMAT_PNG}, "video", "PNG"},
1250         {{1, AST_FORMAT_H261}, "video", "H261"},
1251         {{1, AST_FORMAT_H263}, "video", "H263"},
1252         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1253         {{1, AST_FORMAT_H264}, "video", "H264"},
1254 };
1255
1256 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1257    also, our own choices for dynamic payload types.  This is our master
1258    table for transmission */
1259 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1260         [0] = {1, AST_FORMAT_ULAW},
1261 #ifdef USE_DEPRECATED_G726
1262         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1263 #endif
1264         [3] = {1, AST_FORMAT_GSM},
1265         [4] = {1, AST_FORMAT_G723_1},
1266         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1267         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1268         [7] = {1, AST_FORMAT_LPC10},
1269         [8] = {1, AST_FORMAT_ALAW},
1270         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1271         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1272         [13] = {0, AST_RTP_CN},
1273         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1274         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1275         [18] = {1, AST_FORMAT_G729A},
1276         [19] = {0, AST_RTP_CN},         /* Also used for CN */
1277         [26] = {1, AST_FORMAT_JPEG},
1278         [31] = {1, AST_FORMAT_H261},
1279         [34] = {1, AST_FORMAT_H263},
1280         [103] = {1, AST_FORMAT_H263_PLUS},
1281         [97] = {1, AST_FORMAT_ILBC},
1282         [99] = {1, AST_FORMAT_H264},
1283         [101] = {0, AST_RTP_DTMF},
1284         [110] = {1, AST_FORMAT_SPEEX},
1285         [111] = {1, AST_FORMAT_G726},
1286         [112] = {1, AST_FORMAT_G726_AAL2},
1287         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1288 };
1289
1290 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
1291 {
1292         int i;
1293         if (!rtp)
1294                 return;
1295
1296         for (i = 0; i < MAX_RTP_PT; ++i) {
1297                 rtp->current_RTP_PT[i].isAstFormat = 0;
1298                 rtp->current_RTP_PT[i].code = 0;
1299         }
1300
1301         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1302         rtp->rtp_lookup_code_cache_code = 0;
1303         rtp->rtp_lookup_code_cache_result = 0;
1304 }
1305
1306 void ast_rtp_pt_default(struct ast_rtp* rtp) 
1307 {
1308         int i;
1309
1310         /* Initialize to default payload types */
1311         for (i = 0; i < MAX_RTP_PT; ++i) {
1312                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1313                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1314         }
1315
1316         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1317         rtp->rtp_lookup_code_cache_code = 0;
1318         rtp->rtp_lookup_code_cache_result = 0;
1319 }
1320
1321 void ast_rtp_pt_copy(struct ast_rtp *dest, const struct ast_rtp *src)
1322 {
1323         unsigned int i;
1324
1325         for (i=0; i < MAX_RTP_PT; ++i) {
1326                 dest->current_RTP_PT[i].isAstFormat = 
1327                         src->current_RTP_PT[i].isAstFormat;
1328                 dest->current_RTP_PT[i].code = 
1329                         src->current_RTP_PT[i].code; 
1330         }
1331         dest->rtp_lookup_code_cache_isAstFormat = 0;
1332         dest->rtp_lookup_code_cache_code = 0;
1333         dest->rtp_lookup_code_cache_result = 0;
1334 }
1335
1336 /*! \brief Get channel driver interface structure */
1337 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1338 {
1339         struct ast_rtp_protocol *cur = NULL;
1340
1341         AST_LIST_LOCK(&protos);
1342         AST_LIST_TRAVERSE(&protos, cur, list) {
1343                 if (cur->type == chan->tech->type)
1344                         break;
1345         }
1346         AST_LIST_UNLOCK(&protos);
1347
1348         return cur;
1349 }
1350
1351 int ast_rtp_early_bridge(struct ast_channel *dest, struct ast_channel *src)
1352 {
1353         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1354         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1355         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1356         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1357         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED;
1358         int srccodec;
1359
1360         /* Lock channels */
1361         ast_channel_lock(dest);
1362         if (src) {
1363                 while(ast_channel_trylock(src)) {
1364                         ast_channel_unlock(dest);
1365                         usleep(1);
1366                         ast_channel_lock(dest);
1367                 }
1368         }
1369
1370         /* Find channel driver interfaces */
1371         destpr = get_proto(dest);
1372         if (src)
1373                 srcpr = get_proto(src);
1374         if (!destpr) {
1375                 if (option_debug)
1376                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1377                 ast_channel_unlock(dest);
1378                 if (src)
1379                         ast_channel_unlock(src);
1380                 return 0;
1381         }
1382         if (!srcpr) {
1383                 if (option_debug)
1384                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src ? src->name : "<unspecified>");
1385                 ast_channel_unlock(dest);
1386                 if (src)
1387                         ast_channel_unlock(src);
1388                 return 0;
1389         }
1390
1391         /* Get audio and video interface (if native bridge is possible) */
1392         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1393         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1394         if (srcpr) {
1395                 audio_src_res = srcpr->get_rtp_info(src, &srcp);
1396                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1397         }
1398
1399         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1400         if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1401                 /* Somebody doesn't want to play... */
1402                 ast_channel_unlock(dest);
1403                 if (src)
1404                         ast_channel_unlock(src);
1405                 return 0;
1406         }
1407         if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1408                 srccodec = srcpr->get_codec(src);
1409         else
1410                 srccodec = 0;
1411         /* Consider empty media as non-existant */
1412         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1413                 srcp = NULL;
1414         /* Bridge media early */
1415         if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, srcp ? ast_test_flag(srcp, FLAG_NAT_ACTIVE) : 0))
1416                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src ? src->name : "<unspecified>");
1417         ast_channel_unlock(dest);
1418         if (src)
1419                 ast_channel_unlock(src);
1420         if (option_debug)
1421                 ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", dest->name, src ? src->name : "<unspecified>");
1422         return 1;
1423 }
1424
1425 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1426 {
1427         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1428         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1429         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1430         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1431         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; 
1432         int srccodec;
1433
1434         /* Lock channels */
1435         ast_channel_lock(dest);
1436         while(ast_channel_trylock(src)) {
1437                 ast_channel_unlock(dest);
1438                 usleep(1);
1439                 ast_channel_lock(dest);
1440         }
1441
1442         /* Find channel driver interfaces */
1443         if (!(destpr = get_proto(dest))) {
1444                 if (option_debug)
1445                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1446                 ast_channel_unlock(dest);
1447                 ast_channel_unlock(src);
1448                 return 0;
1449         }
1450         if (!(srcpr = get_proto(src))) {
1451                 if (option_debug)
1452                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1453                 ast_channel_unlock(dest);
1454                 ast_channel_unlock(src);
1455                 return 0;
1456         }
1457
1458         /* Get audio and video interface (if native bridge is possible) */
1459         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1460         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1461         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1462         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1463
1464         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1465         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE) {
1466                 /* Somebody doesn't want to play... */
1467                 ast_channel_unlock(dest);
1468                 ast_channel_unlock(src);
1469                 return 0;
1470         }
1471         ast_rtp_pt_copy(destp, srcp);
1472         if (vdestp && vsrcp)
1473                 ast_rtp_pt_copy(vdestp, vsrcp);
1474         if (srcpr->get_codec)
1475                 srccodec = srcpr->get_codec(src);
1476         else
1477                 srccodec = 0;
1478         if (media) {
1479                 /* Bridge early */
1480                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1481                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1482         }
1483         ast_channel_unlock(dest);
1484         ast_channel_unlock(src);
1485         if (option_debug)
1486                 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1487         return 1;
1488 }
1489
1490 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1491  * By default, use the well-known value for this type (although it may 
1492  * still be set to a different value by a subsequent "a=rtpmap:" line)
1493  */
1494 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1495 {
1496         if (pt < 0 || pt > MAX_RTP_PT) 
1497                 return; /* bogus payload type */
1498
1499         if (static_RTP_PT[pt].code != 0) 
1500                 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1501
1502
1503 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1504  * an SDP "a=rtpmap:" line.
1505  */
1506 void ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1507                              char *mimeType, char *mimeSubtype,
1508                              enum ast_rtp_options options)
1509 {
1510         unsigned int i;
1511
1512         if (pt < 0 || pt > MAX_RTP_PT) 
1513                 return; /* bogus payload type */
1514
1515         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1516                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1517                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1518                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1519                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1520                             mimeTypes[i].payloadType.isAstFormat &&
1521                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1522                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1523                         return;
1524                 }
1525         }
1526
1527
1528 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1529  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1530 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1531                              int* astFormats, int* nonAstFormats) {
1532         int pt;
1533
1534         *astFormats = *nonAstFormats = 0;
1535         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1536                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1537                         *astFormats |= rtp->current_RTP_PT[pt].code;
1538                 } else {
1539                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1540                 }
1541         }
1542 }
1543
1544 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
1545 {
1546         struct rtpPayloadType result;
1547
1548         result.isAstFormat = result.code = 0;
1549         if (pt < 0 || pt > MAX_RTP_PT) 
1550                 return result; /* bogus payload type */
1551
1552         /* Start with negotiated codecs */
1553         result = rtp->current_RTP_PT[pt];
1554
1555         /* If it doesn't exist, check our static RTP type list, just in case */
1556         if (!result.code) 
1557                 result = static_RTP_PT[pt];
1558         return result;
1559 }
1560
1561 /*! \brief Looks up an RTP code out of our *static* outbound list */
1562 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code) {
1563
1564         int pt;
1565
1566         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1567                 code == rtp->rtp_lookup_code_cache_code) {
1568
1569                 /* Use our cached mapping, to avoid the overhead of the loop below */
1570                 return rtp->rtp_lookup_code_cache_result;
1571         }
1572
1573         /* Check the dynamic list first */
1574         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1575                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1576                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1577                         rtp->rtp_lookup_code_cache_code = code;
1578                         rtp->rtp_lookup_code_cache_result = pt;
1579                         return pt;
1580                 }
1581         }
1582
1583         /* Then the static list */
1584         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1585                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1586                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1587                         rtp->rtp_lookup_code_cache_code = code;
1588                         rtp->rtp_lookup_code_cache_result = pt;
1589                         return pt;
1590                 }
1591         }
1592         return -1;
1593 }
1594
1595 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
1596                                   enum ast_rtp_options options)
1597 {
1598         unsigned int i;
1599
1600         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1601                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
1602                         if (isAstFormat &&
1603                             (code == AST_FORMAT_G726_AAL2) &&
1604                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1605                                 return "AAL2-G726-32";
1606                         else
1607                                 return mimeTypes[i].subtype;
1608                 }
1609         }
1610
1611         return "";
1612 }
1613
1614 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
1615                                    const int isAstFormat, enum ast_rtp_options options)
1616 {
1617         int format;
1618         unsigned len;
1619         char *end = buf;
1620         char *start = buf;
1621
1622         if (!buf || !size)
1623                 return NULL;
1624
1625         snprintf(end, size, "0x%x (", capability);
1626
1627         len = strlen(end);
1628         end += len;
1629         size -= len;
1630         start = end;
1631
1632         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1633                 if (capability & format) {
1634                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
1635
1636                         snprintf(end, size, "%s|", name);
1637                         len = strlen(end);
1638                         end += len;
1639                         size -= len;
1640                 }
1641         }
1642
1643         if (start == end)
1644                 snprintf(start, size, "nothing)"); 
1645         else if (size > 1)
1646                 *(end -1) = ')';
1647         
1648         return buf;
1649 }
1650
1651 static int rtp_socket(void)
1652 {
1653         int s;
1654         long flags;
1655         s = socket(AF_INET, SOCK_DGRAM, 0);
1656         if (s > -1) {
1657                 flags = fcntl(s, F_GETFL);
1658                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1659 #ifdef SO_NO_CHECK
1660                 if (nochecksums)
1661                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1662 #endif
1663         }
1664         return s;
1665 }
1666
1667 /*!
1668  * \brief Initialize a new RTCP session.
1669  * 
1670  * \returns The newly initialized RTCP session.
1671  */
1672 static struct ast_rtcp *ast_rtcp_new(void)
1673 {
1674         struct ast_rtcp *rtcp;
1675
1676         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1677                 return NULL;
1678         rtcp->s = rtp_socket();
1679         rtcp->us.sin_family = AF_INET;
1680         rtcp->them.sin_family = AF_INET;
1681
1682         if (rtcp->s < 0) {
1683                 free(rtcp);
1684                 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
1685                 return NULL;
1686         }
1687
1688         return rtcp;
1689 }
1690
1691 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1692 {
1693         struct ast_rtp *rtp;
1694         int x;
1695         int first;
1696         int startplace;
1697         
1698         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1699                 return NULL;
1700         rtp->them.sin_family = AF_INET;
1701         rtp->us.sin_family = AF_INET;
1702         rtp->s = rtp_socket();
1703         rtp->ssrc = ast_random();
1704         rtp->seqno = ast_random() & 0xffff;
1705         ast_set_flag(rtp, FLAG_HAS_DTMF);
1706         if (rtp->s < 0) {
1707                 free(rtp);
1708                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1709                 return NULL;
1710         }
1711         if (sched && rtcpenable) {
1712                 rtp->sched = sched;
1713                 rtp->rtcp = ast_rtcp_new();
1714         }
1715         
1716         /* Select a random port number in the range of possible RTP */
1717         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1718         x = x & ~1;
1719         /* Save it for future references. */
1720         startplace = x;
1721         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1722         for (;;) {
1723                 /* Must be an even port number by RTP spec */
1724                 rtp->us.sin_port = htons(x);
1725                 rtp->us.sin_addr = addr;
1726                 /* If there's rtcp, initialize it as well. */
1727                 if (rtp->rtcp)
1728                         rtp->rtcp->us.sin_port = htons(x + 1);
1729                 /* Try to bind it/them. */
1730                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1731                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1732                         break;
1733                 if (!first) {
1734                         /* Primary bind succeeded! Gotta recreate it */
1735                         close(rtp->s);
1736                         rtp->s = rtp_socket();
1737                 }
1738                 if (errno != EADDRINUSE) {
1739                         /* We got an error that wasn't expected, abort! */
1740                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1741                         close(rtp->s);
1742                         if (rtp->rtcp) {
1743                                 close(rtp->rtcp->s);
1744                                 free(rtp->rtcp);
1745                         }
1746                         free(rtp);
1747                         return NULL;
1748                 }
1749                 /* The port was used, increment it (by two). */
1750                 x += 2;
1751                 /* Did we go over the limit ? */
1752                 if (x > rtpend)
1753                         /* then, start from the begingig. */
1754                         x = (rtpstart + 1) & ~1;
1755                 /* Check if we reached the place were we started. */
1756                 if (x == startplace) {
1757                         /* If so, there's no ports available. */
1758                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1759                         close(rtp->s);
1760                         if (rtp->rtcp) {
1761                                 close(rtp->rtcp->s);
1762                                 free(rtp->rtcp);
1763                         }
1764                         free(rtp);
1765                         return NULL;
1766                 }
1767         }
1768         if (io && sched && callbackmode) {
1769                 /* Operate this one in a callback mode */
1770                 rtp->sched = sched;
1771                 rtp->io = io;
1772                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1773         }
1774         ast_rtp_pt_default(rtp);
1775         return rtp;
1776 }
1777
1778 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1779 {
1780         struct in_addr ia;
1781
1782         memset(&ia, 0, sizeof(ia));
1783         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1784 }
1785
1786 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1787 {
1788         int res;
1789
1790         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
1791                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1792         return res;
1793 }
1794
1795 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1796 {
1797         rtp->them.sin_port = them->sin_port;
1798         rtp->them.sin_addr = them->sin_addr;
1799         if (rtp->rtcp) {
1800                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1801                 rtp->rtcp->them.sin_addr = them->sin_addr;
1802         }
1803         rtp->rxseqno = 0;
1804 }
1805
1806 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1807 {
1808         if ((them->sin_family != AF_INET) ||
1809                 (them->sin_port != rtp->them.sin_port) ||
1810                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
1811                 them->sin_family = AF_INET;
1812                 them->sin_port = rtp->them.sin_port;
1813                 them->sin_addr = rtp->them.sin_addr;
1814                 return 1;
1815         }
1816         return 0;
1817 }
1818
1819 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
1820 {
1821         *us = rtp->us;
1822 }
1823
1824 void ast_rtp_stop(struct ast_rtp *rtp)
1825 {
1826         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
1827                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
1828                 rtp->rtcp->schedid = -1;
1829         }
1830
1831         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1832         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1833         if (rtp->rtcp) {
1834                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
1835                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
1836         }
1837         
1838         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
1839 }
1840
1841 void ast_rtp_reset(struct ast_rtp *rtp)
1842 {
1843         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1844         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1845         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1846         rtp->lastts = 0;
1847         rtp->lastdigitts = 0;
1848         rtp->lastrxts = 0;
1849         rtp->lastividtimestamp = 0;
1850         rtp->lastovidtimestamp = 0;
1851         rtp->lasteventseqn = 0;
1852         rtp->lasteventendseqn = 0;
1853         rtp->lasttxformat = 0;
1854         rtp->lastrxformat = 0;
1855         rtp->dtmfcount = 0;
1856         rtp->dtmfduration = 0;
1857         rtp->seqno = 0;
1858         rtp->rxseqno = 0;
1859 }
1860
1861 char *ast_rtp_get_quality(struct ast_rtp *rtp)
1862 {
1863         /*
1864         *ssrc          our ssrc
1865         *themssrc      their ssrc
1866         *lp            lost packets
1867         *rxjitter      our calculated jitter(rx)
1868         *rxcount       no. received packets
1869         *txjitter      reported jitter of the other end
1870         *txcount       transmitted packets
1871         *rlp           remote lost packets
1872         */
1873         
1874         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);
1875         
1876         return rtp->rtcp->quality;
1877 }
1878
1879 void ast_rtp_destroy(struct ast_rtp *rtp)
1880 {
1881         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
1882                 /*Print some info on the call here */
1883                 ast_verbose("  RTP-stats\n");
1884                 ast_verbose("* Our Receiver:\n");
1885                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
1886                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
1887                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
1888                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
1889                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
1890                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
1891                 ast_verbose("* Our Sender:\n");
1892                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
1893                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
1894                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
1895                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter);
1896                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
1897                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
1898         }
1899
1900         if (rtp->smoother)
1901                 ast_smoother_free(rtp->smoother);
1902         if (rtp->ioid)
1903                 ast_io_remove(rtp->io, rtp->ioid);
1904         if (rtp->s > -1)
1905                 close(rtp->s);
1906         if (rtp->rtcp) {
1907                 if (rtp->rtcp->schedid > 0)
1908                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
1909                 close(rtp->rtcp->s);
1910                 free(rtp->rtcp);
1911                 rtp->rtcp=NULL;
1912         }
1913         free(rtp);
1914 }
1915
1916 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
1917 {
1918         struct timeval t;
1919         long ms;
1920         if (ast_tvzero(rtp->txcore)) {
1921                 rtp->txcore = ast_tvnow();
1922                 /* Round to 20ms for nice, pretty timestamps */
1923                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
1924         }
1925         /* Use previous txcore if available */
1926         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
1927         ms = ast_tvdiff_ms(t, rtp->txcore);
1928         if (ms < 0)
1929                 ms = 0;
1930         /* Use what we just got for next time */
1931         rtp->txcore = t;
1932         return (unsigned int) ms;
1933 }
1934
1935 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
1936 {
1937         unsigned int *rtpheader;
1938         int hdrlen = 12;
1939         int res;
1940         int x;
1941         int payload;
1942         char data[256];
1943
1944         if ((digit <= '9') && (digit >= '0'))
1945                 digit -= '0';
1946         else if (digit == '*')
1947                 digit = 10;
1948         else if (digit == '#')
1949                 digit = 11;
1950         else if ((digit >= 'A') && (digit <= 'D')) 
1951                 digit = digit - 'A' + 12;
1952         else if ((digit >= 'a') && (digit <= 'd')) 
1953                 digit = digit - 'a' + 12;
1954         else {
1955                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1956                 return -1;
1957         }
1958         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
1959
1960         /* If we have no peer, return immediately */    
1961         if (!rtp->them.sin_addr.s_addr)
1962                 return 0;
1963
1964         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1965         
1966         /* Get a pointer to the header */
1967         rtpheader = (unsigned int *)data;
1968         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
1969         rtpheader[1] = htonl(rtp->lastdigitts);
1970         rtpheader[2] = htonl(rtp->ssrc); 
1971         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
1972         for (x = 0; x < 6; x++) {
1973                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1974                         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
1975                         if (res < 0) 
1976                                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
1977                                         ast_inet_ntoa(rtp->them.sin_addr),
1978                                         ntohs(rtp->them.sin_port), strerror(errno));
1979                         if (rtp_debug_test_addr(&rtp->them))
1980                                 ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1981                                             ast_inet_ntoa(rtp->them.sin_addr),
1982                                             ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1983                 }
1984                 /* Sequence number of last two end packets does not get incremented */
1985                 if (x < 3)
1986                         rtp->seqno++;
1987                 /* Clear marker bit and set seqno */
1988                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
1989                 /* For the last three packets, set the duration and the end bit */
1990                 if (x == 2) {
1991 #if 0
1992                         /* No, this is wrong...  Do not increment lastdigitts, that's not according
1993                            to the RFC, as best we can determine */
1994                         rtp->lastdigitts++; /* or else the SPA3000 will click instead of beeping... */
1995                         rtpheader[1] = htonl(rtp->lastdigitts);
1996 #endif                  
1997                         /* Make duration 800 (100ms) */
1998                         rtpheader[3] |= htonl((800));
1999                         /* Set the End bit */
2000                         rtpheader[3] |= htonl((1 << 23));
2001                 }
2002         }
2003         /*! \note Increment the digit timestamp by 120ms, to ensure that digits
2004            sent sequentially with no intervening non-digit packets do not
2005            get sent with the same timestamp, and that sequential digits
2006            have some 'dead air' in between them
2007         */
2008         rtp->lastdigitts += 960;
2009         /* Increment the sequence number to reflect the last packet
2010            that was sent
2011         */
2012         rtp->seqno++;
2013         return 0;
2014 }
2015
2016 /* \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2017 int ast_rtcp_send_h261fur(void *data)
2018 {
2019         struct ast_rtp *rtp = data;
2020         int res;
2021
2022         rtp->rtcp->sendfur = 1;
2023         res = ast_rtcp_write(data);
2024         
2025         return res;
2026 }
2027
2028 /*! \brief Send RTCP sender's report */
2029 static int ast_rtcp_write_sr(void *data)
2030 {
2031         struct ast_rtp *rtp = data;
2032         int res;
2033         int len = 0;
2034         struct timeval now;
2035         unsigned int now_lsw;
2036         unsigned int now_msw;
2037         unsigned int *rtcpheader;
2038         unsigned int lost;
2039         unsigned int extended;
2040         unsigned int expected;
2041         unsigned int expected_interval;
2042         unsigned int received_interval;
2043         int lost_interval;
2044         int fraction;
2045         struct timeval dlsr;
2046         char bdata[512];
2047
2048         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2049                 return 0;
2050         
2051         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2052                 ast_verbose("RTCP SR transmission error, rtcp halted %s\n",strerror(errno));
2053                 if (rtp->rtcp->schedid > 0)
2054                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2055                 rtp->rtcp->schedid = -1;
2056                 return 0;
2057         }
2058
2059         gettimeofday(&now, NULL);
2060         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2061         rtcpheader = (unsigned int *)bdata;
2062         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2063         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2064         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2065         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2066         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2067         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2068         len += 28;
2069         
2070         extended = rtp->cycles + rtp->lastrxseqno;
2071         expected = extended - rtp->seedrxseqno + 1;
2072         if (rtp->rxcount > expected) 
2073                 expected += rtp->rxcount - expected;
2074         lost = expected - rtp->rxcount;
2075         expected_interval = expected - rtp->rtcp->expected_prior;
2076         rtp->rtcp->expected_prior = expected;
2077         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2078         rtp->rtcp->received_prior = rtp->rxcount;
2079         lost_interval = expected_interval - received_interval;
2080         if (expected_interval == 0 || lost_interval <= 0)
2081                 fraction = 0;
2082         else
2083                 fraction = (lost_interval << 8) / expected_interval;
2084         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2085         rtcpheader[7] = htonl(rtp->themssrc);
2086         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2087         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2088         rtcpheader[10] = htonl((unsigned int)rtp->rxjitter);
2089         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2090         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2091         len += 24;
2092         
2093         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2094
2095         if (rtp->rtcp->sendfur) {
2096                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2097                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2098                 len += 8;
2099                 rtp->rtcp->sendfur = 0;
2100         }
2101         
2102         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2103         /* it can change mid call, and SDES can't) */
2104         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2105         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2106         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2107         len += 12;
2108         
2109         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2110         if (res < 0) {
2111                 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));
2112                 if (rtp->rtcp->schedid > 0)
2113                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2114                 rtp->rtcp->schedid = -1;
2115                 return 0;
2116         }
2117         
2118         /* FIXME Don't need to get a new one */
2119         gettimeofday(&rtp->rtcp->txlsr, NULL);
2120         rtp->rtcp->sr_count++;
2121
2122         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2123         
2124         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2125                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2126                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2127                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2128                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2129                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2130                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2131                 ast_verbose("  Report block:\n");
2132                 ast_verbose("  Fraction lost: %u\n", fraction);
2133                 ast_verbose("  Cumulative loss: %u\n", lost);
2134                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2135                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2136                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2137         }
2138         return res;
2139 }
2140
2141 /*! \brief Send RTCP recepient's report */
2142 static int ast_rtcp_write_rr(void *data)
2143 {
2144         struct ast_rtp *rtp = data;
2145         int res;
2146         int len = 32;
2147         unsigned int lost;
2148         unsigned int extended;
2149         unsigned int expected;
2150         unsigned int expected_interval;
2151         unsigned int received_interval;
2152         int lost_interval;
2153         struct timeval now;
2154         unsigned int *rtcpheader;
2155         char bdata[1024];
2156         struct timeval dlsr;
2157         int fraction;
2158
2159         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2160                 return 0;
2161           
2162         if (!rtp->rtcp->them.sin_addr.s_addr) {
2163                 ast_log(LOG_ERROR, "RTCP RR transmission error to, rtcp halted %s\n",strerror(errno));
2164                 if (rtp->rtcp->schedid > 0)
2165                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2166                 rtp->rtcp->schedid = -1;
2167                 return 0;
2168         }
2169
2170         extended = rtp->cycles + rtp->lastrxseqno;
2171         expected = extended - rtp->seedrxseqno + 1;
2172         lost = expected - rtp->rxcount;
2173         expected_interval = expected - rtp->rtcp->expected_prior;
2174         rtp->rtcp->expected_prior = expected;
2175         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2176         rtp->rtcp->received_prior = rtp->rxcount;
2177         lost_interval = expected_interval - received_interval;
2178         if (expected_interval == 0 || lost_interval <= 0)
2179                 fraction = 0;
2180         else
2181                 fraction = (lost_interval << 8) / expected_interval;
2182         gettimeofday(&now, NULL);
2183         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2184         rtcpheader = (unsigned int *)bdata;
2185         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2186         rtcpheader[1] = htonl(rtp->ssrc);
2187         rtcpheader[2] = htonl(rtp->themssrc);
2188         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2189         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2190         rtcpheader[5] = htonl((unsigned int)rtp->rxjitter);
2191         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2192         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2193
2194         if (rtp->rtcp->sendfur) {
2195                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2196                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2197                 len += 8;
2198                 rtp->rtcp->sendfur = 0;
2199         }
2200
2201         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2202         it can change mid call, and SDES can't) */
2203         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2204         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2205         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2206         len += 12;
2207         
2208         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2209
2210         if (res < 0) {
2211                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2212                 /* Remove the scheduler */
2213                 if (rtp->rtcp->schedid > 0)
2214                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2215                 rtp->rtcp->schedid = -1;
2216                 return 0;
2217         }
2218
2219         rtp->rtcp->rr_count++;
2220
2221         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2222                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2223                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2224                         "  IA jitter: %.4f\n" 
2225                         "  Their last SR: %u\n" 
2226                         "  DLSR: %4.4f (sec)\n\n",
2227                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2228                         ntohs(rtp->rtcp->them.sin_port),
2229                         rtp->ssrc, rtp->themssrc, fraction, lost,
2230                         rtp->rxjitter,
2231                         rtp->rtcp->themrxlsr,
2232                         (double)(ntohl(rtcpheader[7])/65536.0));
2233         }
2234
2235         return res;
2236 }
2237
2238 /*! \brief Write and RTCP packet to the far end
2239  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2240  * RR is sent if we have not sent any rtp packets in the previous interval */
2241 static int ast_rtcp_write(void *data)
2242 {
2243         struct ast_rtp *rtp = data;
2244         int res;
2245         
2246         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2247                 res = ast_rtcp_write_sr(data);
2248         else
2249                 res = ast_rtcp_write_rr(data);
2250         
2251         return res;
2252 }
2253
2254 /*! \brief generate comfort noice (CNG) */
2255 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2256 {
2257         unsigned int *rtpheader;
2258         int hdrlen = 12;
2259         int res;
2260         int payload;
2261         char data[256];
2262         level = 127 - (level & 0x7f);
2263         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2264
2265         /* If we have no peer, return immediately */    
2266         if (!rtp->them.sin_addr.s_addr)
2267                 return 0;
2268
2269         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2270
2271         /* Get a pointer to the header */
2272         rtpheader = (unsigned int *)data;
2273         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2274         rtpheader[1] = htonl(rtp->lastts);
2275         rtpheader[2] = htonl(rtp->ssrc); 
2276         data[12] = level;
2277         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2278                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2279                 if (res <0) 
2280                         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));
2281                 if (rtp_debug_test_addr(&rtp->them))
2282                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %u, len %d)\n"
2283                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2284                    
2285         }
2286         return 0;
2287 }
2288
2289 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2290 {
2291         unsigned char *rtpheader;
2292         int hdrlen = 12;
2293         int res;
2294         unsigned int ms;
2295         int pred;
2296         int mark = 0;
2297
2298         ms = calc_txstamp(rtp, &f->delivery);
2299         /* Default prediction */
2300         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2301                 pred = rtp->lastts + f->samples;
2302
2303                 /* Re-calculate last TS */
2304                 rtp->lastts = rtp->lastts + ms * 8;
2305                 if (ast_tvzero(f->delivery)) {
2306                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2307                            and if so, go with our prediction */
2308                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2309                                 rtp->lastts = pred;
2310                         else {
2311                                 if (option_debug > 2)
2312                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2313                                 mark = 1;
2314                         }
2315                 }
2316         } else {
2317                 mark = f->subclass & 0x1;
2318                 pred = rtp->lastovidtimestamp + f->samples;
2319                 /* Re-calculate last TS */
2320                 rtp->lastts = rtp->lastts + ms * 90;
2321                 /* If it's close to our prediction, go for it */
2322                 if (ast_tvzero(f->delivery)) {
2323                         if (abs(rtp->lastts - pred) < 7200) {
2324                                 rtp->lastts = pred;
2325                                 rtp->lastovidtimestamp += f->samples;
2326                         } else {
2327                                 if (option_debug > 2)
2328                                         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);
2329                                 rtp->lastovidtimestamp = rtp->lastts;
2330                         }
2331                 }
2332         }
2333         /* If the timestamp for non-digit packets has moved beyond the timestamp
2334            for digits, update the digit timestamp.
2335         */
2336         if (rtp->lastts > rtp->lastdigitts)
2337                 rtp->lastdigitts = rtp->lastts;
2338
2339         if (f->has_timing_info)
2340                 rtp->lastts = f->ts * 8;
2341
2342         /* Get a pointer to the header */
2343         rtpheader = (unsigned char *)(f->data - hdrlen);
2344
2345         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2346         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2347         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
2348
2349         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2350                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2351                 if (res <0) {
2352                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2353                                 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));
2354                         } else if ((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) {
2355                                 /* Only give this error message once if we are not RTP debugging */
2356                                 if (option_debug || rtpdebug)
2357                                         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));
2358                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2359                         }
2360                 } else {
2361                         rtp->txcount++;
2362                         rtp->txoctetcount +=(res - hdrlen);
2363                         
2364                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
2365                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2366                 }
2367                                 
2368                 if (rtp_debug_test_addr(&rtp->them))
2369                         ast_verbose("Sent RTP packet to      %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2370                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2371         }
2372
2373         rtp->seqno++;
2374
2375         return 0;
2376 }
2377
2378 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2379 {
2380         struct ast_frame *f;
2381         int codec;
2382         int hdrlen = 12;
2383         int subclass;
2384         
2385
2386         /* If we have no peer, return immediately */    
2387         if (!rtp->them.sin_addr.s_addr)
2388                 return 0;
2389
2390         /* If there is no data length, return immediately */
2391         if (!_f->datalen) 
2392                 return 0;
2393         
2394         /* Make sure we have enough space for RTP header */
2395         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
2396                 ast_log(LOG_WARNING, "RTP can only send voice and video\n");
2397                 return -1;
2398         }
2399
2400         subclass = _f->subclass;
2401         if (_f->frametype == AST_FRAME_VIDEO)
2402                 subclass &= ~0x1;
2403
2404         codec = ast_rtp_lookup_code(rtp, 1, subclass);
2405         if (codec < 0) {
2406                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2407                 return -1;
2408         }
2409
2410         if (rtp->lasttxformat != subclass) {
2411                 /* New format, reset the smoother */
2412                 if (option_debug)
2413                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2414                 rtp->lasttxformat = subclass;
2415                 if (rtp->smoother)
2416                         ast_smoother_free(rtp->smoother);
2417                 rtp->smoother = NULL;
2418         }
2419
2420
2421         switch(subclass) {
2422         case AST_FORMAT_SLINEAR:
2423                 if (!rtp->smoother) {
2424                         rtp->smoother = ast_smoother_new(320);
2425                 }
2426                 if (!rtp->smoother) {
2427                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
2428                         return -1;
2429                 }
2430                 ast_smoother_feed_be(rtp->smoother, _f);
2431                 
2432                 while((f = ast_smoother_read(rtp->smoother)))
2433                         ast_rtp_raw_write(rtp, f, codec);
2434                 break;
2435         case AST_FORMAT_ULAW:
2436         case AST_FORMAT_ALAW:
2437                 if (!rtp->smoother) {
2438                         rtp->smoother = ast_smoother_new(160);
2439                 }
2440                 if (!rtp->smoother) {
2441                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
2442                         return -1;
2443                 }
2444                 ast_smoother_feed(rtp->smoother, _f);
2445                 
2446                 while((f = ast_smoother_read(rtp->smoother)))
2447                         ast_rtp_raw_write(rtp, f, codec);
2448                 break;
2449         case AST_FORMAT_ADPCM:
2450         case AST_FORMAT_G726:
2451         case AST_FORMAT_G726_AAL2:
2452                 if (!rtp->smoother) {
2453                         rtp->smoother = ast_smoother_new(80);
2454                 }
2455                 if (!rtp->smoother) {
2456                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
2457                         return -1;
2458                 }
2459                 ast_smoother_feed(rtp->smoother, _f);
2460                 
2461                 while((f = ast_smoother_read(rtp->smoother)))
2462                         ast_rtp_raw_write(rtp, f, codec);
2463                 break;
2464         case AST_FORMAT_G729A:
2465                 if (!rtp->smoother) {
2466                         rtp->smoother = ast_smoother_new(20);
2467                         if (rtp->smoother)
2468                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
2469                 }
2470                 if (!rtp->smoother) {
2471                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
2472                         return -1;
2473                 }
2474                 ast_smoother_feed(rtp->smoother, _f);
2475                 
2476                 while((f = ast_smoother_read(rtp->smoother)))
2477                         ast_rtp_raw_write(rtp, f, codec);
2478                 break;
2479         case AST_FORMAT_GSM:
2480                 if (!rtp->smoother) {
2481                         rtp->smoother = ast_smoother_new(33);
2482                 }
2483                 if (!rtp->smoother) {
2484                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
2485                         return -1;
2486                 }
2487                 ast_smoother_feed(rtp->smoother, _f);
2488                 while((f = ast_smoother_read(rtp->smoother)))
2489                         ast_rtp_raw_write(rtp, f, codec);
2490                 break;
2491         case AST_FORMAT_ILBC:
2492                 if (!rtp->smoother) {
2493                         rtp->smoother = ast_smoother_new(50);
2494                 }
2495                 if (!rtp->smoother) {
2496                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
2497                         return -1;
2498                 }
2499                 ast_smoother_feed(rtp->smoother, _f);
2500                 while((f = ast_smoother_read(rtp->smoother)))
2501                         ast_rtp_raw_write(rtp, f, codec);
2502                 break;
2503         default:        
2504                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
2505                 /* fall through to... */
2506         case AST_FORMAT_H261:
2507         case AST_FORMAT_H263:
2508         case AST_FORMAT_H263_PLUS:
2509         case AST_FORMAT_H264:
2510         case AST_FORMAT_G723_1:
2511         case AST_FORMAT_LPC10:
2512         case AST_FORMAT_SPEEX:
2513                 /* Don't buffer outgoing frames; send them one-per-packet: */
2514                 if (_f->offset < hdrlen) {
2515                         f = ast_frdup(_f);
2516                 } else {
2517                         f = _f;
2518                 }
2519                 ast_rtp_raw_write(rtp, f, codec);
2520         }
2521                 
2522         return 0;
2523 }
2524
2525 /*! \brief Unregister interface to channel driver */
2526 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2527 {
2528         AST_LIST_LOCK(&protos);
2529         AST_LIST_REMOVE(&protos, proto, list);
2530         AST_LIST_UNLOCK(&protos);
2531 }
2532
2533 /*! \brief Register interface to channel driver */
2534 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2535 {
2536         struct ast_rtp_protocol *cur;
2537
2538         AST_LIST_LOCK(&protos);
2539         AST_LIST_TRAVERSE(&protos, cur, list) { 
2540                 if (!strcmp(cur->type, proto->type)) {
2541                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2542                         AST_LIST_UNLOCK(&protos);
2543                         return -1;
2544                 }
2545         }
2546         AST_LIST_INSERT_HEAD(&protos, proto, list);
2547         AST_LIST_UNLOCK(&protos);
2548         
2549         return 0;
2550 }
2551
2552 /*! \brief Bridge loop for true native bridge (reinvite) */
2553 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)
2554 {
2555         struct ast_frame *fr = NULL;
2556         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2557         int oldcodec0 = codec0, oldcodec1 = codec1;
2558         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, ac0 = {0,}, vac0 = {0,};
2559         struct sockaddr_in t1 = {0,}, vt1 = {0,}, t0 = {0,}, vt0 = {0,};
2560
2561         /* Set it up so audio goes directly between the two endpoints */
2562
2563         /* Test the first channel */
2564         if (!(pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
2565                 ast_rtp_get_peer(p1, &ac1);
2566                 if (vp1)
2567                         ast_rtp_get_peer(vp1, &vac1);
2568         } else
2569                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2570         
2571         /* Test the second channel */
2572         if (!(pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
2573                 ast_rtp_get_peer(p0, &ac0);
2574                 if (vp0)
2575                         ast_rtp_get_peer(vp0, &vac0);
2576         } else
2577                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
2578
2579         /* Now we can unlock and move into our loop */
2580         ast_channel_unlock(c0);
2581         ast_channel_unlock(c1);
2582
2583         /* Throw our channels into the structure and enter the loop */
2584         cs[0] = c0;
2585         cs[1] = c1;
2586         cs[2] = NULL;
2587         for (;;) {
2588                 /* Check if anything changed */
2589                 if ((c0->tech_pvt != pvt0) ||
2590                     (c1->tech_pvt != pvt1) ||
2591                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2592                         ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2593                         if (c0->tech_pvt == pvt0)
2594                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2595                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2596                         if (c1->tech_pvt == pvt1)
2597                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2598                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2599                         return AST_BRIDGE_RETRY;
2600                 }
2601
2602                 /* Check if they have changed their address */
2603                 ast_rtp_get_peer(p1, &t1);
2604                 if (vp1)
2605                         ast_rtp_get_peer(vp1, &vt1);
2606                 if (pr1->get_codec)
2607                         codec1 = pr1->get_codec(c1);
2608                 ast_rtp_get_peer(p0, &t0);
2609                 if (vp0)
2610                         ast_rtp_get_peer(vp0, &vt0);
2611                 if (pr0->get_codec)
2612                         codec0 = pr0->get_codec(c0);
2613                 if ((inaddrcmp(&t1, &ac1)) ||
2614                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
2615                     (codec1 != oldcodec1)) {
2616                         if (option_debug > 1) {
2617                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2618                                         c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
2619                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2620                                         c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2621                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2622                                         c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2623                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2624                                         c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2625                         }
2626                         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)))
2627                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2628                         memcpy(&ac1, &t1, sizeof(ac1));
2629                         memcpy(&vac1, &vt1, sizeof(vac1));
2630                         oldcodec1 = codec1;
2631                 }
2632                 if ((inaddrcmp(&t0, &ac0)) ||
2633                     (vp0 && inaddrcmp(&vt0, &vac0))) {
2634                         if (option_debug > 1) {
2635                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2636                                         c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
2637                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2638                                         c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2639                         }
2640                         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)))
2641                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2642                         memcpy(&ac0, &t0, sizeof(ac0));
2643                         memcpy(&vac0, &vt0, sizeof(vac0));
2644                         oldcodec0 = codec0;
2645                 }
2646
2647                 /* Wait for frame to come in on the channels */
2648                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2649                         if (!timeoutms)
2650                                 return AST_BRIDGE_RETRY;
2651                         if (option_debug)
2652                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2653                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2654                                 break;
2655                         continue;
2656                 }
2657                 fr = ast_read(who);
2658                 other = (who == c0) ? c1 : c0;
2659                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
2660                             (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
2661                              ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2662                         /* Break out of bridge */
2663                         *fo = fr;
2664                         *rc = who;
2665                         if (option_debug)
2666                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2667                         if (c0->tech_pvt == pvt0)
2668                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2669                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2670                         if (c1->tech_pvt == pvt1)
2671                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2672                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2673                         return AST_BRIDGE_COMPLETE;
2674                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2675                         if ((fr->subclass == AST_CONTROL_HOLD) ||
2676                             (fr->subclass == AST_CONTROL_UNHOLD) ||
2677                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
2678                                 ast_indicate(other, fr->subclass);
2679                                 ast_frfree(fr);
2680                         } else {
2681                                 *fo = fr;
2682                                 *rc = who;
2683                                 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
2684                                 return AST_BRIDGE_COMPLETE;
2685                         }
2686                 } else {
2687                         if ((fr->frametype == AST_FRAME_DTMF) ||
2688                             (fr->frametype == AST_FRAME_VOICE) ||
2689                             (fr->frametype == AST_FRAME_VIDEO)) {
2690                                 ast_write(other, fr);
2691                         }
2692                         ast_frfree(fr);
2693                 }
2694                 /* Swap priority */
2695                 cs[2] = cs[0];
2696                 cs[0] = cs[1];
2697                 cs[1] = cs[2];
2698         }
2699
2700         return AST_BRIDGE_FAILED;
2701 }
2702
2703 /*! \brief Bridge loop for partial native bridge (packet2packet) */
2704 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)
2705 {
2706         struct ast_frame *fr = NULL;
2707         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2708
2709         /* Okay, setup each RTP structure to do P2P forwarding */
2710         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
2711         p0->bridged = p1;
2712         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
2713         p1->bridged = p0;
2714         if (vp0) {
2715                 ast_clear_flag(vp0, FLAG_P2P_SENT_MARK);
2716                 vp0->bridged = vp1;
2717                 ast_clear_flag(vp1, FLAG_P2P_SENT_MARK);
2718                 vp1->bridged = vp0;
2719         }
2720
2721         /* Now let go of the channel locks and be on our way */
2722         ast_channel_unlock(c0);
2723         ast_channel_unlock(c1);
2724
2725         /* Go into a loop forwarding frames until we don't need to anymore */
2726         cs[0] = c0;
2727         cs[1] = c1;
2728         cs[2] = NULL;
2729         for (;;) {
2730                 /* Check if anything changed */
2731                 if ((c0->tech_pvt != pvt0) ||
2732                     (c1->tech_pvt != pvt1) ||
2733                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2734                         ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2735                         return AST_BRIDGE_RETRY;
2736                 }
2737                 /* Wait on a channel to feed us a frame */
2738                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2739                         if (!timeoutms)
2740                                 return AST_BRIDGE_RETRY;
2741                         if (option_debug)
2742                                 ast_log(LOG_NOTICE, "Ooh, empty read...\n");
2743                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2744                                 break;
2745                         continue;
2746                 }
2747                 /* Read in frame from channel */
2748                 fr = ast_read(who);
2749                 other = (who == c0) ? c1 : c0;
2750                 /* Dependong on the frame we may need to break out of our bridge */
2751                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
2752                             ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
2753                             ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
2754                         /* Record received frame and who */
2755                         *fo = fr;
2756                         *rc = who;
2757                         if (option_debug)
2758                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2759                         /* Break out of the bridge */
2760                         p0->bridged = NULL;
2761                         p1->bridged = NULL;
2762                         if (vp0) {
2763                                 vp0->bridged = NULL;
2764                                 vp1->bridged = NULL;
2765                         }
2766                         return AST_BRIDGE_COMPLETE;
2767                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2768                         if ((fr->subclass == AST_CONTROL_HOLD) ||
2769                             (fr->subclass == AST_CONTROL_UNHOLD) ||
2770                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
2771                                 ast_indicate(other, fr->subclass);
2772                                 ast_frfree(fr);
2773                         } else {
2774                                 *fo = fr;
2775                                 *rc = who;
2776                                 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
2777                                 return AST_BRIDGE_COMPLETE;
2778                         }
2779                 } else {
2780                         /* If this is a DTMF, voice, or video frame write it to the other channel */
2781                         if ((fr->frametype == AST_FRAME_DTMF) ||
2782                             (fr->frametype == AST_FRAME_VOICE) ||
2783                             (fr->frametype == AST_FRAME_VIDEO)) {
2784                                 ast_write(other, fr);
2785                         }
2786                         ast_frfree(fr);
2787                 }
2788                 /* Swap priority */
2789                 cs[2] = cs[0];
2790                 cs[0] = cs[1];
2791                 cs[1] = cs[2];
2792         }
2793
2794         return AST_BRIDGE_FAILED;
2795 }
2796
2797 /*! \brief Bridge calls. If possible and allowed, initiate
2798         re-invite so the peers exchange media directly outside 
2799         of Asterisk. */
2800 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)
2801 {
2802         struct ast_rtp *p0 = NULL, *p1 = NULL;          /* Audio RTP Channels */
2803         struct ast_rtp *vp0 = NULL, *vp1 = NULL;        /* Video RTP channels */
2804         struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL;
2805         enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED;
2806         enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED;
2807         enum ast_bridge_result res = AST_BRIDGE_FAILED;
2808         int codec0 = 0, codec1 = 0;
2809         void *pvt0 = NULL, *pvt1 = NULL;
2810
2811         /* Lock channels */
2812         ast_channel_lock(c0);
2813         while(ast_channel_trylock(c1)) {
2814                 ast_channel_unlock(c0);
2815                 usleep(1);
2816                 ast_channel_lock(c0);
2817         }
2818
2819         /* Find channel driver interfaces */
2820         if (!(pr0 = get_proto(c0))) {
2821                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
2822                 ast_channel_unlock(c0);
2823                 ast_channel_unlock(c1);
2824                 return AST_BRIDGE_FAILED;
2825         }
2826         if (!(pr1 = get_proto(c1))) {
2827                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
2828                 ast_channel_unlock(c0);
2829                 ast_channel_unlock(c1);
2830                 return AST_BRIDGE_FAILED;
2831         }
2832
2833         /* Get channel specific interface structures */
2834         pvt0 = c0->tech_pvt;
2835         pvt1 = c1->tech_pvt;
2836
2837         /* Get audio and video interface (if native bridge is possible) */
2838         audio_p0_res = pr0->get_rtp_info(c0, &p0);
2839         video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED;
2840         audio_p1_res = pr1->get_rtp_info(c1, &p1);
2841         video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED;
2842
2843         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
2844         if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) {
2845                 /* Somebody doesn't want to play... */
2846                 ast_channel_unlock(c0);
2847                 ast_channel_unlock(c1);
2848                 return AST_BRIDGE_FAILED_NOWARN;
2849         }
2850
2851         /* If we need to feed DTMF frames into the core then only do a partial native bridge */
2852         if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
2853                 ast_set_flag(p0, FLAG_P2P_NEED_DTMF);
2854                 audio_p0_res = AST_RTP_TRY_PARTIAL;
2855         }
2856
2857         if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
2858                 ast_set_flag(p1, FLAG_P2P_NEED_DTMF);
2859                 audio_p1_res = AST_RTP_TRY_PARTIAL;
2860         }
2861
2862         /* Get codecs from both sides */
2863         codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
2864         codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
2865         if (pr0->get_codec && pr1->get_codec) {
2866                 /* Hey, we can't do native bridging if both parties speak different codecs */
2867                 if (!(codec0 & codec1)) {
2868                         if (option_debug)
2869                                 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
2870                         ast_channel_unlock(c0);
2871                         ast_channel_unlock(c1);
2872                         return AST_BRIDGE_FAILED_NOWARN;
2873                 }
2874         }
2875
2876         /* If either side can only do a partial bridge, then don't try for a true native bridge */
2877         if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) {
2878                 if (option_verbose > 2)
2879                         ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name);
2880                 res = bridge_p2p_loop(c0, c1, p0, p1, vp0, vp1, timeoutms, flags, fo, rc, pvt0, pvt1);
2881         } else {
2882                 if (option_verbose > 2) 
2883                         ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
2884                 res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1);
2885         }
2886
2887         return res;
2888 }
2889
2890 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
2891 {
2892         struct hostent *hp;
2893         struct ast_hostent ahp;
2894         int port = 0;
2895         char *p, *arg;
2896
2897         if (argc != 4)
2898                 return RESULT_SHOWUSAGE;
2899         arg = argv[3];
2900         p = strstr(arg, ":");
2901         if (p) {
2902                 *p = '\0';
2903                 p++;
2904                 port = atoi(p);
2905         }
2906         hp = ast_gethostbyname(arg, &ahp);
2907         if (hp == NULL)
2908                 return RESULT_SHOWUSAGE;
2909         rtpdebugaddr.sin_family = AF_INET;
2910         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
2911         rtpdebugaddr.sin_port = htons(port);
2912         if (port == 0)
2913                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
2914         else
2915                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
2916         rtpdebug = 1;
2917         return RESULT_SUCCESS;
2918 }
2919
2920 static int rtcp_do_debug_ip(int fd, int argc, char *argv[])
2921 {
2922         struct hostent *hp;
2923         struct ast_hostent ahp;
2924         int port = 0;
2925         char *p, *arg;
2926         if (argc != 5)
2927                 return RESULT_SHOWUSAGE;
2928
2929         arg = argv[4];
2930         p = strstr(arg, ":");
2931         if (p) {
2932                 *p = '\0';
2933                 p++;
2934                 port = atoi(p);
2935         }
2936         hp = ast_gethostbyname(arg, &ahp);
2937         if (hp == NULL)
2938                 return RESULT_SHOWUSAGE;
2939         rtcpdebugaddr.sin_family = AF_INET;
2940         memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
2941         rtcpdebugaddr.sin_port = htons(port);
2942         if (port == 0)
2943                 ast_cli(fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
2944         else
2945                 ast_cli(fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
2946         rtcpdebug = 1;
2947         return RESULT_SUCCESS;
2948 }
2949
2950 static int rtp_do_debug(int fd, int argc, char *argv[])
2951 {
2952         if (argc != 2) {
2953                 if (argc != 4)
2954                         return RESULT_SHOWUSAGE;
2955                 return rtp_do_debug_ip(fd, argc, argv);
2956         }
2957         rtpdebug = 1;
2958         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
2959         ast_cli(fd, "RTP Debugging Enabled\n");
2960         return RESULT_SUCCESS;
2961 }
2962    
2963 static int rtcp_do_debug(int fd, int argc, char *argv[]) {
2964         if (argc != 3) {
2965                 if (argc != 5)
2966                         return RESULT_SHOWUSAGE;
2967                 return rtcp_do_debug_ip(fd, argc, argv);
2968         }
2969         rtcpdebug = 1;
2970         memset(&rtcpdebugaddr,0,sizeof(rtcpdebugaddr));
2971         ast_cli(fd, "RTCP Debugging Enabled\n");
2972         return RESULT_SUCCESS;
2973 }
2974
2975 static int rtcp_do_stats(int fd, int argc, char *argv[]) {
2976         if (argc != 3) {
2977                 return RESULT_SHOWUSAGE;
2978         }
2979         rtcpstats = 1;
2980         ast_cli(fd, "RTCP Stats Enabled\n");
2981         return RESULT_SUCCESS;
2982 }
2983
2984 static int rtp_no_debug(int fd, int argc, char *argv[])
2985 {
2986         if (argc != 3)
2987                 return RESULT_SHOWUSAGE;
2988         rtpdebug = 0;
2989         ast_cli(fd,"RTP Debugging Disabled\n");
2990         return RESULT_SUCCESS;
2991 }
2992
2993 static int rtcp_no_debug(int fd, int argc, char *argv[])
2994 {
2995         if (argc != 4)
2996                 return RESULT_SHOWUSAGE;
2997         rtcpdebug = 0;
2998         ast_cli(fd,"RTCP Debugging Disabled\n");
2999         return RESULT_SUCCESS;
3000 }
3001
3002 static int rtcp_no_stats(int fd, int argc, char *argv[])
3003 {
3004         if (argc != 4)
3005                 return RESULT_SHOWUSAGE;
3006         rtcpstats = 0;
3007         ast_cli(fd,"RTCP Stats Disabled\n");
3008         return RESULT_SUCCESS;
3009 }
3010
3011
3012 static int stun_do_debug(int fd, int argc, char *argv[])
3013 {
3014         if (argc != 2) {
3015                 return RESULT_SHOWUSAGE;
3016         }
3017         stundebug = 1;
3018         ast_cli(fd, "STUN Debugging Enabled\n");
3019         return RESULT_SUCCESS;
3020 }
3021    
3022 static int stun_no_debug(int fd, int argc, char *argv[])
3023 {
3024         if (argc != 3)
3025                 return RESULT_SHOWUSAGE;
3026         stundebug = 0;
3027         ast_cli(fd,"STUN Debugging Disabled\n");
3028         return RESULT_SUCCESS;
3029 }
3030
3031
3032 static char debug_usage[] =
3033   "Usage: rtp debug [ip host[:port]]\n"
3034   "       Enable dumping of all RTP packets to and from host.\n";
3035
3036 static char no_debug_usage[] =
3037   "Usage: rtp no debug\n"
3038   "       Disable all RTP debugging\n";
3039
3040 static char stun_debug_usage[] =
3041   "Usage: stun debug\n"
3042   "       Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
3043
3044 static char stun_no_debug_usage[] =
3045   "Usage: stun no debug\n"
3046   "       Disable STUN debugging\n";
3047
3048
3049 static struct ast_cli_entry  cli_debug_ip =
3050 {{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage };
3051
3052 static struct ast_cli_entry  cli_debug =
3053 {{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage };
3054
3055 static struct ast_cli_entry  cli_no_debug =
3056 {{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage };
3057
3058 static char rtcp_debug_usage[] =
3059   "Usage: rtp rtcp debug [ip host[:port]]\n"
3060   "       Enable dumping of all RTCP packets to and from host.\n";
3061   
3062 static char rtcp_no_debug_usage[] =
3063   "Usage: rtp rtcp no debug\n"
3064   "       Disable all RTCP debugging\n";
3065
3066 static char rtcp_stats_usage[] =
3067   "Usage: rtp rtcp stats\n"
3068   "       Enable dumping of RTCP stats.\n";
3069   
3070 static char rtcp_no_stats_usage[] =
3071   "Usage: rtp rtcp no stats\n"
3072   "       Disable all RTCP stats\n";
3073
3074 static struct ast_cli_entry  cli_debug_ip_rtcp =
3075 {{ "rtp", "rtcp", "debug", "ip", NULL } , rtcp_do_debug, "Enable RTCP debugging on IP", rtcp_debug_usage };
3076
3077 static struct ast_cli_entry  cli_debug_rtcp =
3078 {{ "rtp", "rtcp", "debug", NULL } , rtcp_do_debug, "Enable RTCP debugging", rtcp_debug_usage };
3079
3080 static struct ast_cli_entry  cli_no_debug_rtcp =
3081 {{ "rtp", "rtcp", "no", "debug", NULL } , rtcp_no_debug, "Disable RTCP debugging", rtcp_no_debug_usage };
3082
3083 static struct ast_cli_entry  cli_stats_rtcp =
3084 {{ "rtp", "rtcp", "stats", NULL } , rtcp_do_stats, "Enable RTCP stats", rtcp_stats_usage };
3085
3086 static struct ast_cli_entry  cli_no_stats_rtcp =
3087 {{ "rtp", "rtcp", "no", "stats", NULL } , rtcp_no_stats, "Disable RTCP stats", rtcp_no_stats_usage };
3088
3089 static struct ast_cli_entry  cli_stun_debug =
3090 {{ "stun", "debug", NULL } , stun_do_debug, "Enable STUN debugging", stun_debug_usage };
3091
3092 static struct ast_cli_entry  cli_stun_no_debug =
3093 {{ "stun", "no", "debug", NULL } , stun_no_debug, "Disable STUN debugging", stun_no_debug_usage };
3094
3095 int ast_rtp_reload(void)
3096 {
3097         struct ast_config *cfg;
3098         char *s;
3099
3100         rtpstart = 5000;
3101         rtpend = 31000;
3102         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3103         cfg = ast_config_load("rtp.conf");
3104         if (cfg) {
3105                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
3106                         rtpstart = atoi(s);
3107                         if (rtpstart < 1024)
3108                                 rtpstart = 1024;
3109                         if (rtpstart > 65535)
3110                                 rtpstart = 65535;
3111                 }
3112                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
3113                         rtpend = atoi(s);
3114                         if (rtpend < 1024)
3115                                 rtpend = 1024;
3116                         if (rtpend > 65535)
3117                                 rtpend = 65535;
3118                 }
3119                 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
3120                         rtcpinterval = atoi(s);
3121                         if (rtcpinterval == 0)
3122                                 rtcpinterval = 0; /* Just so we're clear... it's zero */
3123                         if (rtcpinterval < RTCP_MIN_INTERVALMS)
3124                                 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
3125                         if (rtcpinterval > RTCP_MAX_INTERVALMS)
3126                                 rtcpinterval = RTCP_MAX_INTERVALMS;
3127                 }
3128                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
3129 #ifdef SO_NO_CHECK
3130                         if (ast_false(s))
3131                                 nochecksums = 1;
3132                         else
3133                                 nochecksums = 0;
3134 #else
3135                         if (ast_false(s))
3136                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
3137 #endif
3138                 }
3139                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
3140                         dtmftimeout = atoi(s);
3141                         if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
3142                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
3143                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
3144                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3145                         };
3146                 }
3147                 ast_config_destroy(cfg);
3148         }
3149         if (rtpstart >= rtpend) {
3150                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
3151                 rtpstart = 5000;
3152                 rtpend = 31000;
3153         }
3154         if (option_verbose > 1)
3155                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
3156         return 0;
3157 }
3158
3159 /*! \brief Initialize the RTP system in Asterisk */
3160 void ast_rtp_init(void)
3161 {
3162         ast_cli_register(&cli_debug);
3163         ast_cli_register(&cli_debug_ip);
3164         ast_cli_register(&cli_no_debug);
3165
3166         ast_cli_register(&cli_debug_rtcp);
3167         ast_cli_register(&cli_debug_ip_rtcp);
3168         ast_cli_register(&cli_no_debug_rtcp);