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