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