05f4cdee15c5f05c07916c96251a20fc3ad52e5a
[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 <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <sys/time.h>
33 #include <signal.h>
34 #include <errno.h>
35 #include <unistd.h>
36 #include <netinet/in.h>
37 #include <sys/time.h>
38 #include <sys/socket.h>
39 #include <arpa/inet.h>
40 #include <fcntl.h>
41
42 #include "asterisk.h"
43
44 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
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_MTU         1200
63
64 #define DEFAULT_DTMF_TIMEOUT 3000       /*!< samples */
65
66 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
67
68 static int rtpstart = 0;                /*!< First port for RTP sessions (set in rtp.conf) */
69 static int rtpend = 0;                  /*!< Last port for RTP sessions (set in rtp.conf) */
70 static int rtpdebug = 0;                /*!< Are we debugging? */
71 static int stundebug = 0;               /*!< Are we debugging stun? */
72 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
73 #ifdef SO_NO_CHECK
74 static int nochecksums = 0;
75 #endif
76
77 /*! \brief The value of each payload format mapping: */
78 struct rtpPayloadType {
79         int isAstFormat;        /*!< whether the following code is an AST_FORMAT */
80         int code;
81 };
82
83 #define MAX_RTP_PT                      256
84
85 #define FLAG_3389_WARNING               (1 << 0)
86 #define FLAG_NAT_ACTIVE                 (3 << 1)
87 #define FLAG_NAT_INACTIVE               (0 << 1)
88 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
89
90 /*! \brief RTP session description */
91 struct ast_rtp {
92         int s;
93         char resp;
94         struct ast_frame f;
95         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
96         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
97         unsigned int rxssrc;
98         unsigned int lastts;
99         unsigned int lastdigitts;
100         unsigned int lastrxts;
101         unsigned int lastividtimestamp;
102         unsigned int lastovidtimestamp;
103         unsigned int lasteventseqn;
104         unsigned int lasteventendseqn;
105         int lasttxformat;
106         int lastrxformat;
107         int dtmfcount;
108         unsigned int dtmfduration;
109         int nat;
110         unsigned int flags;
111         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
112         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
113         struct timeval rxcore;
114         struct timeval txcore;
115         struct timeval dtmfmute;
116         struct ast_smoother *smoother;
117         int *ioid;
118         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
119         unsigned short rxseqno;
120         struct sched_context *sched;
121         struct io_context *io;
122         void *data;
123         ast_rtp_callback callback;
124         struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
125         int rtp_lookup_code_cache_isAstFormat; /*!< a cache for the result of rtp_lookup_code(): */
126         int rtp_lookup_code_cache_code;
127         int rtp_lookup_code_cache_result;
128         struct ast_rtcp *rtcp;
129 };
130
131 /*!
132  * \brief Structure defining an RTCP session.
133  * 
134  * The concept "RTCP session" is not defined in RFC 3550, but since 
135  * this structure is analogous to ast_rtp, which tracks a RTP session, 
136  * it is logical to think of this as a RTCP session.
137  *
138  * RTCP packet is defined on page 9 of RFC 3550.
139  * 
140  */
141 struct ast_rtcp {
142         int s;                          /*!< Socket */
143         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
144         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
145 };
146
147
148 typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
149
150 /* XXX Maybe stun belongs in another file if it ever has use outside of RTP */
151 struct stun_header {
152         unsigned short msgtype;
153         unsigned short msglen;
154         stun_trans_id  id;
155         unsigned char ies[0];
156 } __attribute__((packed));
157
158 struct stun_attr {
159         unsigned short attr;
160         unsigned short len;
161         unsigned char value[0];
162 } __attribute__((packed));
163
164 struct stun_addr {
165         unsigned char unused;
166         unsigned char family;
167         unsigned short port;
168         unsigned int addr;
169 } __attribute__((packed));
170
171 #define STUN_IGNORE             (0)
172 #define STUN_ACCEPT             (1)
173
174 #define STUN_BINDREQ    0x0001
175 #define STUN_BINDRESP   0x0101
176 #define STUN_BINDERR    0x0111
177 #define STUN_SECREQ             0x0002
178 #define STUN_SECRESP    0x0102
179 #define STUN_SECERR             0x0112
180
181 #define STUN_MAPPED_ADDRESS             0x0001
182 #define STUN_RESPONSE_ADDRESS   0x0002
183 #define STUN_CHANGE_REQUEST             0x0003
184 #define STUN_SOURCE_ADDRESS             0x0004
185 #define STUN_CHANGED_ADDRESS    0x0005
186 #define STUN_USERNAME                   0x0006
187 #define STUN_PASSWORD                   0x0007
188 #define STUN_MESSAGE_INTEGRITY  0x0008
189 #define STUN_ERROR_CODE                 0x0009
190 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
191 #define STUN_REFLECTED_FROM             0x000b
192
193 static const char *stun_msg2str(int msg)
194 {
195         switch(msg) {
196         case STUN_BINDREQ:
197                 return "Binding Request";
198         case STUN_BINDRESP:
199                 return "Binding Response";
200         case STUN_BINDERR:
201                 return "Binding Error Response";
202         case STUN_SECREQ:
203                 return "Shared Secret Request";
204         case STUN_SECRESP:
205                 return "Shared Secret Response";
206         case STUN_SECERR:
207                 return "Shared Secret Error Response";
208         }
209         return "Non-RFC3489 Message";
210 }
211
212 static const char *stun_attr2str(int msg)
213 {
214         switch(msg) {
215         case STUN_MAPPED_ADDRESS:
216                 return "Mapped Address";
217         case STUN_RESPONSE_ADDRESS:
218                 return "Response Address";
219         case STUN_CHANGE_REQUEST:
220                 return "Change Request";
221         case STUN_SOURCE_ADDRESS:
222                 return "Source Address";
223         case STUN_CHANGED_ADDRESS:
224                 return "Changed Address";
225         case STUN_USERNAME:
226                 return "Username";
227         case STUN_PASSWORD:
228                 return "Password";
229         case STUN_MESSAGE_INTEGRITY:
230                 return "Message Integrity";
231         case STUN_ERROR_CODE:
232                 return "Error Code";
233         case STUN_UNKNOWN_ATTRIBUTES:
234                 return "Unknown Attributes";
235         case STUN_REFLECTED_FROM:
236                 return "Reflected From";
237         }
238         return "Non-RFC3489 Attribute";
239 }
240
241 struct stun_state {
242         unsigned char *username;
243         unsigned char *password;
244 };
245
246 static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
247 {
248         if (stundebug)
249                 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
250                         stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
251         switch(ntohs(attr->attr)) {
252         case STUN_USERNAME:
253                 state->username = (unsigned char *)(attr->value);
254                 break;
255         case STUN_PASSWORD:
256                 state->password = (unsigned char *)(attr->value);
257                 break;
258         default:
259                 if (stundebug)
260                         ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n", 
261                                 stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
262         }
263         return 0;
264 }
265
266 static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
267 {
268         int size = sizeof(**attr) + strlen(s);
269         if (*left > size) {
270                 (*attr)->attr = htons(attrval);
271                 (*attr)->len = htons(strlen(s));
272                 memcpy((*attr)->value, s, strlen(s));
273                 (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
274                 *len += size;
275                 *left -= size;
276         }
277 }
278
279 static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
280 {
281         int size = sizeof(**attr) + 8;
282         struct stun_addr *addr;
283         if (*left > size) {
284                 (*attr)->attr = htons(attrval);
285                 (*attr)->len = htons(8);
286                 addr = (struct stun_addr *)((*attr)->value);
287                 addr->unused = 0;
288                 addr->family = 0x01;
289                 addr->port = sin->sin_port;
290                 addr->addr = sin->sin_addr.s_addr;
291                 (*attr) = (struct stun_attr *)((*attr)->value + 8);
292                 *len += size;
293                 *left -= size;
294         }
295 }
296
297 static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
298 {
299         return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0, dst, sizeof(*dst));
300 }
301
302 static void stun_req_id(struct stun_header *req)
303 {
304         int x;
305         for (x=0;x<4;x++)
306                 req->id.id[x] = ast_random();
307 }
308
309 void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
310 {
311         struct stun_header *req;
312         unsigned char reqdata[1024];
313         int reqlen, reqleft;
314         struct stun_attr *attr;
315
316         req = (struct stun_header *)reqdata;
317         stun_req_id(req);
318         reqlen = 0;
319         reqleft = sizeof(reqdata) - sizeof(struct stun_header);
320         req->msgtype = 0;
321         req->msglen = 0;
322         attr = (struct stun_attr *)req->ies;
323         if (username)
324                 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
325         req->msglen = htons(reqlen);
326         req->msgtype = htons(STUN_BINDREQ);
327         stun_send(rtp->s, suggestion, req);
328 }
329
330 static int stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, int len)
331 {
332         struct stun_header *resp, *hdr = (struct stun_header *)data;
333         struct stun_attr *attr;
334         struct stun_state st;
335         int ret = STUN_IGNORE;  
336         unsigned char respdata[1024];
337         int resplen, respleft;
338         
339         if (len < sizeof(struct stun_header)) {
340                 ast_log(LOG_DEBUG, "Runt STUN packet (only %d, wanting at least %d)\n", len, sizeof(struct stun_header));
341                 return -1;
342         }
343         if (stundebug)
344                 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), ntohs(hdr->msglen));
345         if (ntohs(hdr->msglen) > len - sizeof(struct stun_header)) {
346                 ast_log(LOG_DEBUG, "Scrambled STUN packet length (got %d, expecting %d)\n", ntohs(hdr->msglen), len - sizeof(struct stun_header));
347         } else
348                 len = ntohs(hdr->msglen);
349         data += sizeof(struct stun_header);
350         memset(&st, 0, sizeof(st));
351         while(len) {
352                 if (len < sizeof(struct stun_attr)) {
353                         ast_log(LOG_DEBUG, "Runt Attribute (got %d, expecting %d)\n", len, sizeof(struct stun_attr));
354                         break;
355                 }
356                 attr = (struct stun_attr *)data;
357                 if (ntohs(attr->len) > len) {
358                         ast_log(LOG_DEBUG, "Inconsistant Attribute (length %d exceeds remaining msg len %d)\n", ntohs(attr->len), len);
359                         break;
360                 }
361                 if (stun_process_attr(&st, attr)) {
362                         ast_log(LOG_DEBUG, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
363                         break;
364                 }
365                 /* Clear attribute in case previous entry was a string */
366                 attr->attr = 0;
367                 data += ntohs(attr->len) + sizeof(struct stun_attr);
368                 len -= ntohs(attr->len) + sizeof(struct stun_attr);
369         }
370         /* Null terminate any string */
371         *data = '\0';
372         resp = (struct stun_header *)respdata;
373         resplen = 0;
374         respleft = sizeof(respdata) - sizeof(struct stun_header);
375         resp->id = hdr->id;
376         resp->msgtype = 0;
377         resp->msglen = 0;
378         attr = (struct stun_attr *)resp->ies;
379         if (!len) {
380                 switch(ntohs(hdr->msgtype)) {
381                 case STUN_BINDREQ:
382                         if (stundebug)
383                                 ast_verbose("STUN Bind Request, username: %s\n", 
384                                         st.username ? (const char *)st.username : "<none>");
385                         if (st.username)
386                                 append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
387                         append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
388                         resp->msglen = htons(resplen);
389                         resp->msgtype = htons(STUN_BINDRESP);
390                         stun_send(s, src, resp);
391                         ret = STUN_ACCEPT;
392                         break;
393                 default:
394                         if (stundebug)
395                                 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
396                 }
397         }
398         return ret;
399 }
400
401 /*! \brief List of current sessions */
402 static AST_LIST_HEAD_STATIC(protos, ast_rtp_protocol);
403
404 int ast_rtp_fd(struct ast_rtp *rtp)
405 {
406         return rtp->s;
407 }
408
409 int ast_rtcp_fd(struct ast_rtp *rtp)
410 {
411         if (rtp->rtcp)
412                 return rtp->rtcp->s;
413         return -1;
414 }
415
416 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
417 {
418         rtp->data = data;
419 }
420
421 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
422 {
423         rtp->callback = callback;
424 }
425
426 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
427 {
428         rtp->nat = nat;
429 }
430
431 static struct ast_frame *send_dtmf(struct ast_rtp *rtp)
432 {
433         char iabuf[INET_ADDRSTRLEN];
434
435         if (ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
436                 if (option_debug)
437                         ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
438                 rtp->resp = 0;
439                 rtp->dtmfduration = 0;
440                 return &ast_null_frame;
441         }
442         if (option_debug)
443                 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));
444         if (rtp->resp == 'X') {
445                 rtp->f.frametype = AST_FRAME_CONTROL;
446                 rtp->f.subclass = AST_CONTROL_FLASH;
447         } else {
448                 rtp->f.frametype = AST_FRAME_DTMF;
449                 rtp->f.subclass = rtp->resp;
450         }
451         rtp->f.datalen = 0;
452         rtp->f.samples = 0;
453         rtp->f.mallocd = 0;
454         rtp->f.src = "RTP";
455         rtp->resp = 0;
456         rtp->dtmfduration = 0;
457         return &rtp->f;
458         
459 }
460
461 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
462 {
463         if (rtpdebug == 0)
464                 return 0;
465         if (rtpdebugaddr.sin_addr.s_addr) {
466                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
467                         && (rtpdebugaddr.sin_port != addr->sin_port))
468                         || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
469                 return 0;
470         }
471         return 1;
472 }
473
474 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
475 {
476         unsigned int event;
477         char resp = 0;
478         struct ast_frame *f = NULL;
479         event = ntohl(*((unsigned int *)(data)));
480         event &= 0x001F;
481         if (option_debug > 2 || rtpdebug)
482                 ast_log(LOG_DEBUG, "Cisco DTMF Digit: %08x (len = %d)\n", event, len);
483         if (event < 10) {
484                 resp = '0' + event;
485         } else if (event < 11) {
486                 resp = '*';
487         } else if (event < 12) {
488                 resp = '#';
489         } else if (event < 16) {
490                 resp = 'A' + (event - 12);
491         } else if (event < 17) {
492                 resp = 'X';
493         }
494         if (rtp->resp && (rtp->resp != resp)) {
495                 f = send_dtmf(rtp);
496         }
497         rtp->resp = resp;
498         rtp->dtmfcount = dtmftimeout;
499         return f;
500 }
501
502 /*! 
503  * \brief Process RTP DTMF and events according to RFC 2833.
504  * 
505  * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
506  * 
507  * \param rtp
508  * \param data
509  * \param len
510  * \param seqno
511  * \returns
512  */
513 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno)
514 {
515         unsigned int event;
516         unsigned int event_end;
517         unsigned int duration;
518         char resp = 0;
519         struct ast_frame *f = NULL;
520
521         event = ntohl(*((unsigned int *)(data)));
522         event >>= 24;
523         event_end = ntohl(*((unsigned int *)(data)));
524         event_end <<= 8;
525         event_end >>= 24;
526         duration = ntohl(*((unsigned int *)(data)));
527         duration &= 0xFFFF;
528         if (rtpdebug || option_debug > 2)
529                 ast_log(LOG_DEBUG, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
530         if (event < 10) {
531                 resp = '0' + event;
532         } else if (event < 11) {
533                 resp = '*';
534         } else if (event < 12) {
535                 resp = '#';
536         } else if (event < 16) {
537                 resp = 'A' + (event - 12);
538         } else if (event < 17) {        /* Event 16: Hook flash */
539                 resp = 'X';     
540         }
541         if (rtp->resp && (rtp->resp != resp)) {
542                 f = send_dtmf(rtp);
543         } else if(event_end & 0x80) {
544                 if (rtp->resp) {
545                         if(rtp->lasteventendseqn != seqno) {
546                                 f = send_dtmf(rtp);
547                                 rtp->lasteventendseqn = seqno;
548                         }
549                         rtp->resp = 0;
550                 }
551                 resp = 0;
552                 duration = 0;
553         } else if (rtp->resp && rtp->dtmfduration && (duration < rtp->dtmfduration)) {
554                 f = send_dtmf(rtp);
555         }
556         if (!(event_end & 0x80))
557                 rtp->resp = resp;
558         rtp->dtmfcount = dtmftimeout;
559         rtp->dtmfduration = duration;
560         return f;
561 }
562
563 /*!
564  * \brief Process Comfort Noise RTP.
565  * 
566  * This is incomplete at the moment.
567  * 
568 */
569 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
570 {
571         struct ast_frame *f = NULL;
572         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
573            totally help us out becuase we don't have an engine to keep it going and we are not
574            guaranteed to have it every 20ms or anything */
575         if (rtpdebug)
576                 ast_log(LOG_DEBUG, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
577
578         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
579                 char iabuf[INET_ADDRSTRLEN];
580
581                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
582                         ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
583                 ast_set_flag(rtp, FLAG_3389_WARNING);
584         }
585
586         /* Must have at least one byte */
587         if (!len)
588                 return NULL;
589         if (len < 24) {
590                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
591                 rtp->f.datalen = len - 1;
592                 rtp->f.offset = AST_FRIENDLY_OFFSET;
593                 memcpy(rtp->f.data, data + 1, len - 1);
594         } else {
595                 rtp->f.data = NULL;
596                 rtp->f.offset = 0;
597                 rtp->f.datalen = 0;
598         }
599         rtp->f.frametype = AST_FRAME_CNG;
600         rtp->f.subclass = data[0] & 0x7f;
601         rtp->f.datalen = len - 1;
602         rtp->f.samples = 0;
603         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
604         f = &rtp->f;
605         return f;
606 }
607
608 static int rtpread(int *id, int fd, short events, void *cbdata)
609 {
610         struct ast_rtp *rtp = cbdata;
611         struct ast_frame *f;
612         f = ast_rtp_read(rtp);
613         if (f) {
614                 if (rtp->callback)
615                         rtp->callback(rtp, f, rtp->data);
616         }
617         return 1;
618 }
619
620 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
621 {
622         socklen_t len;
623         int hdrlen = 8;
624         int res;
625         struct sockaddr_in sin;
626         unsigned int rtcpdata[1024];
627         char iabuf[INET_ADDRSTRLEN];
628         
629         if (!rtp || !rtp->rtcp)
630                 return &ast_null_frame;
631
632         len = sizeof(sin);
633         
634         res = recvfrom(rtp->rtcp->s, rtcpdata, sizeof(rtcpdata),
635                                         0, (struct sockaddr *)&sin, &len);
636         
637         if (res < 0) {
638                 if (errno != EAGAIN)
639                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
640                 if (errno == EBADF)
641                         CRASH;
642                 return &ast_null_frame;
643         }
644
645         if (res < hdrlen) {
646                 ast_log(LOG_WARNING, "RTP Read too short\n");
647                 return &ast_null_frame;
648         }
649
650         if (rtp->nat) {
651                 /* Send to whoever sent to us */
652                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
653                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
654                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
655                         if (option_debug || rtpdebug)
656                                 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));
657                 }
658         }
659         if (option_debug)
660                 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
661         return &ast_null_frame;
662 }
663
664 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
665 {
666         struct timeval ts = ast_samp2tv( timestamp, 8000);
667         if (ast_tvzero(rtp->rxcore) || mark) {
668                 rtp->rxcore = ast_tvsub(ast_tvnow(), ts);
669                 /* Round to 20ms for nice, pretty timestamps */
670                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 20000;
671         }
672         *tv = ast_tvadd(rtp->rxcore, ts);
673 }
674
675 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
676 {
677         int res;
678         struct sockaddr_in sin;
679         socklen_t len;
680         unsigned int seqno;
681         int version;
682         int payloadtype;
683         int hdrlen = 12;
684         int padding;
685         int mark;
686         int ext;
687         int x;
688         char iabuf[INET_ADDRSTRLEN];
689         unsigned int ssrc;
690         unsigned int timestamp;
691         unsigned int *rtpheader;
692         struct rtpPayloadType rtpPT;
693         
694         len = sizeof(sin);
695         
696         /* Cache where the header will go */
697         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
698                                         0, (struct sockaddr *)&sin, &len);
699
700         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
701         if (res < 0) {
702                 if (errno != EAGAIN)
703                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
704                 if (errno == EBADF)
705                         CRASH;
706                 return &ast_null_frame;
707         }
708         if (res < hdrlen) {
709                 ast_log(LOG_WARNING, "RTP Read too short\n");
710                 return &ast_null_frame;
711         }
712
713         /* Get fields */
714         seqno = ntohl(rtpheader[0]);
715
716         /* Check RTP version */
717         version = (seqno & 0xC0000000) >> 30;
718         if (!version) {
719                 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) &&
720                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
721                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
722                 }
723                 return &ast_null_frame;
724         }
725
726         if (version != 2)
727                 return &ast_null_frame;
728         /* Ignore if the other side hasn't been given an address
729            yet.  */
730         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
731                 return &ast_null_frame;
732
733         if (rtp->nat) {
734                 /* Send to whoever sent to us */
735                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
736                     (rtp->them.sin_port != sin.sin_port)) {
737                         rtp->them = sin;
738                         rtp->rxseqno = 0;
739                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
740                         if (option_debug || rtpdebug)
741                                 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));
742                 }
743         }
744
745         payloadtype = (seqno & 0x7f0000) >> 16;
746         padding = seqno & (1 << 29);
747         mark = seqno & (1 << 23);
748         ext = seqno & (1 << 28);
749         seqno &= 0xffff;
750         timestamp = ntohl(rtpheader[1]);
751         ssrc = ntohl(rtpheader[2]);
752         
753         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
754                 ast_log(LOG_WARNING, "Forcing Marker bit, because SSRC has changed\n");
755                 mark = 1;
756         }
757
758         rtp->rxssrc = ssrc;
759         
760         if (padding) {
761                 /* Remove padding bytes */
762                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
763         }
764         
765         if (ext) {
766                 /* RTP Extension present */
767                 hdrlen += 4;
768                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
769         }
770
771         if (res < hdrlen) {
772                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
773                 return &ast_null_frame;
774         }
775
776         if(rtp_debug_test_addr(&sin))
777                 ast_verbose("Got RTP packet from %s:%d (type %d, seq %d, ts %d, len %d)\n"
778                         , ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
779
780         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
781         if (!rtpPT.isAstFormat) {
782                 struct ast_frame *f = NULL;
783
784                 /* This is special in-band data that's not one of our codecs */
785                 if (rtpPT.code == AST_RTP_DTMF) {
786                         /* It's special -- rfc2833 process it */
787                         if(rtp_debug_test_addr(&sin)) {
788                                 unsigned char *data;
789                                 unsigned int event;
790                                 unsigned int event_end;
791                                 unsigned int duration;
792                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
793                                 event = ntohl(*((unsigned int *)(data)));
794                                 event >>= 24;
795                                 event_end = ntohl(*((unsigned int *)(data)));
796                                 event_end <<= 8;
797                                 event_end >>= 24;
798                                 duration = ntohl(*((unsigned int *)(data)));
799                                 duration &= 0xFFFF;
800                                 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);
801                         }
802                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
803                                 f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno);
804                                 rtp->lasteventseqn = seqno;
805                         }
806                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
807                         /* It's really special -- process it the Cisco way */
808                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
809                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
810                                 rtp->lasteventseqn = seqno;
811                         }
812                 } else if (rtpPT.code == AST_RTP_CN) {
813                         /* Comfort Noise */
814                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
815                 } else {
816                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
817                 }
818                 return f ? f : &ast_null_frame;
819         }
820         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
821         rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO;
822
823         if (!rtp->lastrxts)
824                 rtp->lastrxts = timestamp;
825
826         if (rtp->rxseqno) {
827                 for (x=rtp->rxseqno + 1; x < seqno; x++) {
828                         /* Queue empty frames */
829                         rtp->f.mallocd = 0;
830                         rtp->f.datalen = 0;
831                         rtp->f.data = NULL;
832                         rtp->f.offset = 0;
833                         rtp->f.samples = 0;
834                         rtp->f.src = "RTPMissedFrame";
835                 }
836         }
837         rtp->rxseqno = seqno;
838
839         if (rtp->dtmfcount) {
840 #if 0
841                 printf("dtmfcount was %d\n", rtp->dtmfcount);
842 #endif          
843                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
844                 if (rtp->dtmfcount < 0)
845                         rtp->dtmfcount = 0;
846 #if 0
847                 if (dtmftimeout != rtp->dtmfcount)
848                         printf("dtmfcount is %d\n", rtp->dtmfcount);
849 #endif
850         }
851         rtp->lastrxts = timestamp;
852
853         /* Send any pending DTMF */
854         if (rtp->resp && !rtp->dtmfcount) {
855                 if (option_debug)
856                         ast_log(LOG_DEBUG, "Sending pending DTMF\n");
857                 return send_dtmf(rtp);
858         }
859         rtp->f.mallocd = 0;
860         rtp->f.datalen = res - hdrlen;
861         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
862         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
863         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
864                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
865                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
866                         ast_frame_byteswap_be(&rtp->f);
867                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
868         } else {
869                 /* Video -- samples is # of samples vs. 90000 */
870                 if (!rtp->lastividtimestamp)
871                         rtp->lastividtimestamp = timestamp;
872                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
873                 rtp->lastividtimestamp = timestamp;
874                 rtp->f.delivery.tv_sec = 0;
875                 rtp->f.delivery.tv_usec = 0;
876                 if (mark)
877                         rtp->f.subclass |= 0x1;
878                 
879         }
880         rtp->f.src = "RTP";
881         return &rtp->f;
882 }
883
884 /* The following array defines the MIME Media type (and subtype) for each
885    of our codecs, or RTP-specific data type. */
886 static struct {
887         struct rtpPayloadType payloadType;
888         char* type;
889         char* subtype;
890 } mimeTypes[] = {
891         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
892         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
893         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
894         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
895         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
896         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
897         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
898         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
899         {{1, AST_FORMAT_G729A}, "audio", "G729"},
900         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
901         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
902         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
903         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
904         {{0, AST_RTP_CN}, "audio", "CN"},
905         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
906         {{1, AST_FORMAT_PNG}, "video", "PNG"},
907         {{1, AST_FORMAT_H261}, "video", "H261"},
908         {{1, AST_FORMAT_H263}, "video", "H263"},
909         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
910         {{1, AST_FORMAT_H264}, "video", "H264"},
911 };
912
913 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
914    also, our own choices for dynamic payload types.  This is our master
915    table for transmission */
916 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
917         [0] = {1, AST_FORMAT_ULAW},
918 #ifdef USE_DEPRECATED_G726
919         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
920 #endif
921         [3] = {1, AST_FORMAT_GSM},
922         [4] = {1, AST_FORMAT_G723_1},
923         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
924         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
925         [7] = {1, AST_FORMAT_LPC10},
926         [8] = {1, AST_FORMAT_ALAW},
927         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
928         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
929         [13] = {0, AST_RTP_CN},
930         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
931         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
932         [18] = {1, AST_FORMAT_G729A},
933         [19] = {0, AST_RTP_CN},         /* Also used for CN */
934         [26] = {1, AST_FORMAT_JPEG},
935         [31] = {1, AST_FORMAT_H261},
936         [34] = {1, AST_FORMAT_H263},
937         [103] = {1, AST_FORMAT_H263_PLUS},
938         [97] = {1, AST_FORMAT_ILBC},
939         [99] = {1, AST_FORMAT_H264},
940         [101] = {0, AST_RTP_DTMF},
941         [110] = {1, AST_FORMAT_SPEEX},
942         [111] = {1, AST_FORMAT_G726},
943         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
944 };
945
946 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
947 {
948         int i;
949         if (!rtp)
950                 return;
951
952         for (i = 0; i < MAX_RTP_PT; ++i) {
953                 rtp->current_RTP_PT[i].isAstFormat = 0;
954                 rtp->current_RTP_PT[i].code = 0;
955         }
956
957         rtp->rtp_lookup_code_cache_isAstFormat = 0;
958         rtp->rtp_lookup_code_cache_code = 0;
959         rtp->rtp_lookup_code_cache_result = 0;
960 }
961
962 void ast_rtp_pt_default(struct ast_rtp* rtp) 
963 {
964         int i;
965
966         /* Initialize to default payload types */
967         for (i = 0; i < MAX_RTP_PT; ++i) {
968                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
969                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
970         }
971
972         rtp->rtp_lookup_code_cache_isAstFormat = 0;
973         rtp->rtp_lookup_code_cache_code = 0;
974         rtp->rtp_lookup_code_cache_result = 0;
975 }
976
977 static void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
978 {
979         int i;
980         /* Copy payload types from source to destination */
981         for (i=0; i < MAX_RTP_PT; ++i) {
982                 dest->current_RTP_PT[i].isAstFormat = 
983                         src->current_RTP_PT[i].isAstFormat;
984                 dest->current_RTP_PT[i].code = 
985                         src->current_RTP_PT[i].code; 
986         }
987         dest->rtp_lookup_code_cache_isAstFormat = 0;
988         dest->rtp_lookup_code_cache_code = 0;
989         dest->rtp_lookup_code_cache_result = 0;
990 }
991
992 /*! \brief Get channel driver interface structure */
993 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
994 {
995         struct ast_rtp_protocol *cur = NULL;
996
997         AST_LIST_LOCK(&protos);
998         AST_LIST_TRAVERSE(&protos, cur, list) {
999                 if (cur->type == chan->tech->type)
1000                         break;
1001         }
1002         AST_LIST_UNLOCK(&protos);
1003
1004         return cur;
1005 }
1006
1007 int ast_rtp_early_media(struct ast_channel *dest, struct ast_channel *src)
1008 {
1009         struct ast_rtp *destp, *srcp=NULL;              /* Audio RTP Channels */
1010         struct ast_rtp *vdestp, *vsrcp=NULL;            /* Video RTP channels */
1011         struct ast_rtp_protocol *destpr, *srcpr=NULL;
1012         int srccodec;
1013         /* Lock channels */
1014         ast_channel_lock(dest);
1015         if (src) {
1016                 while(ast_channel_trylock(src)) {
1017                         ast_channel_unlock(dest);
1018                         usleep(1);
1019                         ast_channel_lock(dest);
1020                 }
1021         }
1022
1023         /* Find channel driver interfaces */
1024         destpr = get_proto(dest);
1025         if (src)
1026                 srcpr = get_proto(src);
1027         if (!destpr) {
1028                 if (option_debug)
1029                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1030                 ast_channel_unlock(dest);
1031                 if (src)
1032                         ast_channel_unlock(src);
1033                 return 0;
1034         }
1035         if (!srcpr) {
1036                 if (option_debug)
1037                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src ? src->name : "<unspecified>");
1038                 ast_channel_unlock(dest);
1039                 if (src)
1040                         ast_channel_unlock(src);
1041                 return 0;
1042         }
1043
1044         /* Get audio and video interface (if native bridge is possible) */
1045         destp = destpr->get_rtp_info(dest);
1046         vdestp = (destpr->get_vrtp_info) ? destpr->get_vrtp_info(dest) : NULL;
1047         if (srcpr) {
1048                 srcp = srcpr->get_rtp_info(src);
1049                 vsrcp = (srcpr->get_vrtp_info) ? srcpr->get_vrtp_info(src) : NULL;
1050         }
1051
1052         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1053         if (!destp) {
1054                 /* Somebody doesn't want to play... */
1055                 ast_channel_unlock(dest);
1056                 if (src)
1057                         ast_channel_unlock(src);
1058                 return 0;
1059         }
1060         if (srcpr && srcpr->get_codec)
1061                 srccodec = srcpr->get_codec(src);
1062         else
1063                 srccodec = 0;
1064         /* Consider empty media as non-existant */
1065         if (srcp && !srcp->them.sin_addr.s_addr)
1066                 srcp = NULL;
1067         /* Bridge early media */
1068         if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, srcp ? ast_test_flag(srcp, FLAG_NAT_ACTIVE) : 0))
1069                 ast_log(LOG_WARNING, "Channel '%s' failed to send early media to '%s'\n", dest->name, src ? src->name : "<unspecified>");
1070         ast_channel_unlock(dest);
1071         if (src)
1072                 ast_channel_unlock(src);
1073         if (option_debug)
1074                 ast_log(LOG_DEBUG, "Setting early  media SDP of '%s' with that of '%s'\n", dest->name, src ? src->name : "<unspecified>");
1075         return 1;
1076 }
1077
1078 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1079 {
1080         struct ast_rtp *destp, *srcp;           /* Audio RTP Channels */
1081         struct ast_rtp *vdestp, *vsrcp;         /* Video RTP channels */
1082         struct ast_rtp_protocol *destpr, *srcpr;
1083         int srccodec;
1084         /* Lock channels */
1085         ast_channel_lock(dest);
1086         while(ast_channel_trylock(src)) {
1087                 ast_channel_unlock(dest);
1088                 usleep(1);
1089                 ast_channel_lock(dest);
1090         }
1091
1092         /* Find channel driver interfaces */
1093         destpr = get_proto(dest);
1094         srcpr = get_proto(src);
1095         if (!destpr) {
1096                 if (option_debug)
1097                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1098                 ast_channel_unlock(dest);
1099                 ast_channel_unlock(src);
1100                 return 0;
1101         }
1102         if (!srcpr) {
1103                 if (option_debug)
1104                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1105                 ast_channel_unlock(dest);
1106                 ast_channel_unlock(src);
1107                 return 0;
1108         }
1109
1110         /* Get audio and video interface (if native bridge is possible) */
1111         destp = destpr->get_rtp_info(dest);
1112         vdestp = (destpr->get_vrtp_info) ? destpr->get_vrtp_info(dest) : NULL;
1113         srcp = srcpr->get_rtp_info(src);
1114         vsrcp = (srcpr->get_vrtp_info) ? srcpr->get_vrtp_info(src) : NULL;
1115
1116         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1117         if (!destp || !srcp) {
1118                 /* Somebody doesn't want to play... */
1119                 ast_channel_unlock(dest);
1120                 ast_channel_unlock(src);
1121                 return 0;
1122         }
1123         ast_rtp_pt_copy(destp, srcp);
1124         if (vdestp && vsrcp)
1125                 ast_rtp_pt_copy(vdestp, vsrcp);
1126         if (srcpr->get_codec)
1127                 srccodec = srcpr->get_codec(src);
1128         else
1129                 srccodec = 0;
1130         if (media) {
1131                 /* Bridge early media */
1132                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1133                         ast_log(LOG_WARNING, "Channel '%s' failed to send early media to '%s'\n", dest->name, src->name);
1134         }
1135         ast_channel_unlock(dest);
1136         ast_channel_unlock(src);
1137         if (option_debug)
1138                 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1139         return 1;
1140 }
1141
1142 /*! \brief  Make a note of a RTP paymoad type that was seen in a SDP "m=" line.
1143  * By default, use the well-known value for this type (although it may 
1144  * still be set to a different value by a subsequent "a=rtpmap:" line)
1145  */
1146 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1147 {
1148         if (pt < 0 || pt > MAX_RTP_PT) 
1149                 return; /* bogus payload type */
1150
1151         if (static_RTP_PT[pt].code != 0) {
1152                 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1153         }
1154
1155
1156 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1157         a SDP "a=rtpmap:" line. */
1158 void ast_rtp_set_rtpmap_type(struct ast_rtp* rtp, int pt,
1159                          char* mimeType, char* mimeSubtype) 
1160 {
1161         int i;
1162
1163         if (pt < 0 || pt > MAX_RTP_PT) 
1164                 return; /* bogus payload type */
1165
1166         for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
1167                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1168                      strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1169                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1170                         return;
1171                 }
1172         }
1173
1174
1175 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1176  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1177 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1178                              int* astFormats, int* nonAstFormats) {
1179         int pt;
1180
1181         *astFormats = *nonAstFormats = 0;
1182         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1183                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1184                         *astFormats |= rtp->current_RTP_PT[pt].code;
1185                 } else {
1186                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1187                 }
1188         }
1189 }
1190
1191 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
1192 {
1193         struct rtpPayloadType result;
1194
1195         result.isAstFormat = result.code = 0;
1196         if (pt < 0 || pt > MAX_RTP_PT) 
1197                 return result; /* bogus payload type */
1198
1199         /* Start with the negotiated codecs */
1200         result = rtp->current_RTP_PT[pt];
1201
1202         /* If it doesn't exist, check our static RTP type list, just in case */
1203         if (!result.code) 
1204                 result = static_RTP_PT[pt];
1205         return result;
1206 }
1207
1208 /*! \brief Looks up an RTP code out of our *static* outbound list */
1209 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code) {
1210
1211         int pt;
1212
1213         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1214                 code == rtp->rtp_lookup_code_cache_code) {
1215
1216                 /* Use our cached mapping, to avoid the overhead of the loop below */
1217                 return rtp->rtp_lookup_code_cache_result;
1218         }
1219
1220         /* Check the dynamic list first */
1221         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1222                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1223                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1224                         rtp->rtp_lookup_code_cache_code = code;
1225                         rtp->rtp_lookup_code_cache_result = pt;
1226                         return pt;
1227                 }
1228         }
1229
1230         /* Then the static list */
1231         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1232                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1233                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1234                         rtp->rtp_lookup_code_cache_code = code;
1235                         rtp->rtp_lookup_code_cache_result = pt;
1236                         return pt;
1237                 }
1238         }
1239         return -1;
1240 }
1241
1242 char* ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code) 
1243 {
1244
1245         int i;
1246
1247         for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
1248                 if (mimeTypes[i].payloadType.code == code && mimeTypes[i].payloadType.isAstFormat == isAstFormat)
1249                         return mimeTypes[i].subtype;
1250         }
1251         return "";
1252 }
1253
1254 char *ast_rtp_lookup_mime_multiple(char *buf, int size, const int capability, const int isAstFormat)
1255 {
1256         int format;
1257         unsigned len;
1258         char *end = buf;
1259         char *start = buf;
1260
1261         if (!buf || !size)
1262                 return NULL;
1263
1264         snprintf(end, size, "0x%x (", capability);
1265
1266         len = strlen(end);
1267         end += len;
1268         size -= len;
1269         start = end;
1270
1271         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1272                 if (capability & format) {
1273                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format);
1274                         snprintf(end, size, "%s|", name);
1275                         len = strlen(end);
1276                         end += len;
1277                         size -= len;
1278                 }
1279         }
1280
1281         if (start == end)
1282                 snprintf(start, size, "nothing)"); 
1283         else if (size > 1)
1284                 *(end -1) = ')';
1285         
1286         return buf;
1287 }
1288
1289 static int rtp_socket(void)
1290 {
1291         int s;
1292         long flags;
1293         s = socket(AF_INET, SOCK_DGRAM, 0);
1294         if (s > -1) {
1295                 flags = fcntl(s, F_GETFL);
1296                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1297 #ifdef SO_NO_CHECK
1298                 if (nochecksums)
1299                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1300 #endif
1301         }
1302         return s;
1303 }
1304
1305 /*!
1306  * \brief Initialize a new RTCP session.
1307  * 
1308  * \returns The newly initialized RTCP session.
1309  */
1310 static struct ast_rtcp *ast_rtcp_new(void)
1311 {
1312         struct ast_rtcp *rtcp;
1313
1314         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1315                 return NULL;
1316         rtcp->s = rtp_socket();
1317         rtcp->us.sin_family = AF_INET;
1318         if (rtcp->s < 0) {
1319                 free(rtcp);
1320                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
1321                 return NULL;
1322         }
1323
1324         return rtcp;
1325 }
1326
1327 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1328 {
1329         struct ast_rtp *rtp;
1330         int x;
1331         int first;
1332         int startplace;
1333         
1334         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1335                 return NULL;
1336         rtp->them.sin_family = AF_INET;
1337         rtp->us.sin_family = AF_INET;
1338         rtp->s = rtp_socket();
1339         rtp->ssrc = ast_random();
1340         rtp->seqno = ast_random() & 0xffff;
1341         if (rtp->s < 0) {
1342                 free(rtp);
1343                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1344                 return NULL;
1345         }
1346         if (sched && rtcpenable) {
1347                 rtp->sched = sched;
1348                 rtp->rtcp = ast_rtcp_new();
1349         }
1350         
1351         /* Select a random port number in the range of possible RTP */
1352         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1353         x = x & ~1;
1354         /* Save it for future references. */
1355         startplace = x;
1356         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1357         for (;;) {
1358                 /* Must be an even port number by RTP spec */
1359                 rtp->us.sin_port = htons(x);
1360                 rtp->us.sin_addr = addr;
1361                 /* If there's rtcp, initialize it as well. */
1362                 if (rtp->rtcp)
1363                         rtp->rtcp->us.sin_port = htons(x + 1);
1364                 /* Try to bind it/them. */
1365                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1366                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1367                         break;
1368                 if (!first) {
1369                         /* Primary bind succeeded! Gotta recreate it */
1370                         close(rtp->s);
1371                         rtp->s = rtp_socket();
1372                 }
1373                 if (errno != EADDRINUSE) {
1374                         /* We got an error that wasn't expected, abort! */
1375                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1376                         close(rtp->s);
1377                         if (rtp->rtcp) {
1378                                 close(rtp->rtcp->s);
1379                                 free(rtp->rtcp);
1380                         }
1381                         free(rtp);
1382                         return NULL;
1383                 }
1384                 /* The port was used, increment it (by two). */
1385                 x += 2;
1386                 /* Did we go over the limit ? */
1387                 if (x > rtpend)
1388                         /* then, start from the begingig. */
1389                         x = (rtpstart + 1) & ~1;
1390                 /* Check if we reached the place were we started. */
1391                 if (x == startplace) {
1392                         /* If so, there's no ports available. */
1393                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1394                         close(rtp->s);
1395                         if (rtp->rtcp) {
1396                                 close(rtp->rtcp->s);
1397                                 free(rtp->rtcp);
1398                         }
1399                         free(rtp);
1400                         return NULL;
1401                 }
1402         }
1403         if (io && sched && callbackmode) {
1404                 /* Operate this one in a callback mode */
1405                 rtp->sched = sched;
1406                 rtp->io = io;
1407                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1408         }
1409         ast_rtp_pt_default(rtp);
1410         return rtp;
1411 }
1412
1413 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1414 {
1415         struct in_addr ia;
1416
1417         memset(&ia, 0, sizeof(ia));
1418         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1419 }
1420
1421 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1422 {
1423         int res;
1424
1425         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
1426                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1427         return res;
1428 }
1429
1430 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1431 {
1432         rtp->them.sin_port = them->sin_port;
1433         rtp->them.sin_addr = them->sin_addr;
1434         if (rtp->rtcp) {
1435                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1436                 rtp->rtcp->them.sin_addr = them->sin_addr;
1437         }
1438         rtp->rxseqno = 0;
1439 }
1440
1441 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1442 {
1443         if ((them->sin_family != AF_INET) ||
1444                 (them->sin_port != rtp->them.sin_port) ||
1445                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
1446                 them->sin_family = AF_INET;
1447                 them->sin_port = rtp->them.sin_port;
1448                 them->sin_addr = rtp->them.sin_addr;
1449                 return 1;
1450         }
1451         return 0;
1452 }
1453
1454 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
1455 {
1456         *us = rtp->us;
1457 }
1458
1459 void ast_rtp_stop(struct ast_rtp *rtp)
1460 {
1461         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1462         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1463         if (rtp->rtcp) {
1464                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1465                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1466         }
1467 }
1468
1469 void ast_rtp_reset(struct ast_rtp *rtp)
1470 {
1471         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1472         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1473         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1474         rtp->lastts = 0;
1475         rtp->lastdigitts = 0;
1476         rtp->lastrxts = 0;
1477         rtp->lastividtimestamp = 0;
1478         rtp->lastovidtimestamp = 0;
1479         rtp->lasteventseqn = 0;
1480         rtp->lasteventendseqn = 0;
1481         rtp->lasttxformat = 0;
1482         rtp->lastrxformat = 0;
1483         rtp->dtmfcount = 0;
1484         rtp->dtmfduration = 0;
1485         rtp->seqno = 0;
1486         rtp->rxseqno = 0;
1487 }
1488
1489 void ast_rtp_destroy(struct ast_rtp *rtp)
1490 {
1491         if (rtp->smoother)
1492                 ast_smoother_free(rtp->smoother);
1493         if (rtp->ioid)
1494                 ast_io_remove(rtp->io, rtp->ioid);
1495         if (rtp->s > -1)
1496                 close(rtp->s);
1497         if (rtp->rtcp) {
1498                 close(rtp->rtcp->s);
1499                 free(rtp->rtcp);
1500         }
1501         free(rtp);
1502 }
1503
1504 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
1505 {
1506         struct timeval t;
1507         long ms;
1508         if (ast_tvzero(rtp->txcore)) {
1509                 rtp->txcore = ast_tvnow();
1510                 /* Round to 20ms for nice, pretty timestamps */
1511                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
1512         }
1513         /* Use previous txcore if available */
1514         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
1515         ms = ast_tvdiff_ms(t, rtp->txcore);
1516         if (ms < 0)
1517                 ms = 0;
1518         /* Use what we just got for next time */
1519         rtp->txcore = t;
1520         return (unsigned int) ms;
1521 }
1522
1523 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
1524 {
1525         unsigned int *rtpheader;
1526         int hdrlen = 12;
1527         int res;
1528         int x;
1529         int payload;
1530         char data[256];
1531         char iabuf[INET_ADDRSTRLEN];
1532
1533         if ((digit <= '9') && (digit >= '0'))
1534                 digit -= '0';
1535         else if (digit == '*')
1536                 digit = 10;
1537         else if (digit == '#')
1538                 digit = 11;
1539         else if ((digit >= 'A') && (digit <= 'D')) 
1540                 digit = digit - 'A' + 12;
1541         else if ((digit >= 'a') && (digit <= 'd')) 
1542                 digit = digit - 'a' + 12;
1543         else {
1544                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1545                 return -1;
1546         }
1547         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
1548
1549         /* If we have no peer, return immediately */    
1550         if (!rtp->them.sin_addr.s_addr)
1551                 return 0;
1552
1553         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1554         
1555         /* Get a pointer to the header */
1556         rtpheader = (unsigned int *)data;
1557         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
1558         rtpheader[1] = htonl(rtp->lastdigitts);
1559         rtpheader[2] = htonl(rtp->ssrc); 
1560         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
1561         for (x = 0; x < 6; x++) {
1562                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1563                         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
1564                         if (res < 0) 
1565                                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
1566                                         ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
1567                                         ntohs(rtp->them.sin_port), strerror(errno));
1568                         if (rtp_debug_test_addr(&rtp->them))
1569                                 ast_verbose("Sent RTP packet to %s:%d (type %d, seq %u, ts %u, len %u)\n",
1570                                             ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
1571                                             ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1572                 }
1573                 /* Sequence number of last two end packets does not get incremented */
1574                 if (x < 3)
1575                         rtp->seqno++;
1576                 /* Clear marker bit and set seqno */
1577                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
1578                 /* For the last three packets, set the duration and the end bit */
1579                 if (x == 2) {
1580 #if 0
1581                         /* No, this is wrong...  Do not increment lastdigitts, that's not according
1582                            to the RFC, as best we can determine */
1583                         rtp->lastdigitts++; /* or else the SPA3000 will click instead of beeping... */
1584                         rtpheader[1] = htonl(rtp->lastdigitts);
1585 #endif                  
1586                         /* Make duration 800 (100ms) */
1587                         rtpheader[3] |= htonl((800));
1588                         /* Set the End bit */
1589                         rtpheader[3] |= htonl((1 << 23));
1590                 }
1591         }
1592         /* Increment the digit timestamp by 120ms, to ensure that digits
1593            sent sequentially with no intervening non-digit packets do not
1594            get sent with the same timestamp, and that sequential digits
1595            have some 'dead air' in between them
1596         */
1597         rtp->lastdigitts += 960;
1598         /* Increment the sequence number to reflect the last packet
1599            that was sent
1600         */
1601         rtp->seqno++;
1602         return 0;
1603 }
1604
1605 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
1606 {
1607         unsigned int *rtpheader;
1608         int hdrlen = 12;
1609         int res;
1610         int payload;
1611         char data[256];
1612         char iabuf[INET_ADDRSTRLEN];
1613         level = 127 - (level & 0x7f);
1614         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
1615
1616         /* If we have no peer, return immediately */    
1617         if (!rtp->them.sin_addr.s_addr)
1618                 return 0;
1619
1620         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1621
1622         /* Get a pointer to the header */
1623         rtpheader = (unsigned int *)data;
1624         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1625         rtpheader[1] = htonl(rtp->lastts);
1626         rtpheader[2] = htonl(rtp->ssrc); 
1627         data[12] = level;
1628         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1629                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1630                 if (res <0) 
1631                         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));
1632                 if(rtp_debug_test_addr(&rtp->them))
1633                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1634                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);              
1635                    
1636         }
1637         return 0;
1638 }
1639
1640 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
1641 {
1642         unsigned char *rtpheader;
1643         char iabuf[INET_ADDRSTRLEN];
1644         int hdrlen = 12;
1645         int res;
1646         unsigned int ms;
1647         int pred;
1648         int mark = 0;
1649
1650         ms = calc_txstamp(rtp, &f->delivery);
1651         /* Default prediction */
1652         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
1653                 pred = rtp->lastts + f->samples;
1654
1655                 /* Re-calculate last TS */
1656                 rtp->lastts = rtp->lastts + ms * 8;
1657                 if (ast_tvzero(f->delivery)) {
1658                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
1659                            and if so, go with our prediction */
1660                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
1661                                 rtp->lastts = pred;
1662                         else {
1663                                 if (option_debug > 2)
1664                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1665                                 mark = 1;
1666                         }
1667                 }
1668         } else {
1669                 mark = f->subclass & 0x1;
1670                 pred = rtp->lastovidtimestamp + f->samples;
1671                 /* Re-calculate last TS */
1672                 rtp->lastts = rtp->lastts + ms * 90;
1673                 /* If it's close to our prediction, go for it */
1674                 if (ast_tvzero(f->delivery)) {
1675                         if (abs(rtp->lastts - pred) < 7200) {
1676                                 rtp->lastts = pred;
1677                                 rtp->lastovidtimestamp += f->samples;
1678                         } else {
1679                                 if (option_debug > 2)
1680                                         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);
1681                                 rtp->lastovidtimestamp = rtp->lastts;
1682                         }
1683                 }
1684         }
1685         /* If the timestamp for non-digit packets has moved beyond the timestamp
1686            for digits, update the digit timestamp.
1687         */
1688         if (rtp->lastts > rtp->lastdigitts)
1689                 rtp->lastdigitts = rtp->lastts;
1690
1691         /* Get a pointer to the header */
1692         rtpheader = (unsigned char *)(f->data - hdrlen);
1693
1694         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1695         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1696         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
1697
1698         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1699                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1700                 if (res <0) {
1701                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1702                                 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));
1703                         } else if ((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) {
1704                                 /* Only give this error message once if we are not RTP debugging */
1705                                 if (option_debug || rtpdebug)
1706                                         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));
1707                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
1708                         }
1709                 }
1710                                 
1711                 if(rtp_debug_test_addr(&rtp->them))
1712                         ast_verbose("Sent RTP packet to %s:%d (type %d, seq %u, ts %u, len %u)\n"
1713                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
1714         }
1715
1716         rtp->seqno++;
1717
1718         return 0;
1719 }
1720
1721 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1722 {
1723         struct ast_frame *f;
1724         int codec;
1725         int hdrlen = 12;
1726         int subclass;
1727         
1728
1729         /* If we have no peer, return immediately */    
1730         if (!rtp->them.sin_addr.s_addr)
1731                 return 0;
1732
1733         /* If there is no data length, return immediately */
1734         if (!_f->datalen) 
1735                 return 0;
1736         
1737         /* Make sure we have enough space for RTP header */
1738         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1739                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1740                 return -1;
1741         }
1742
1743         subclass = _f->subclass;
1744         if (_f->frametype == AST_FRAME_VIDEO)
1745                 subclass &= ~0x1;
1746
1747         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1748         if (codec < 0) {
1749                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1750                 return -1;
1751         }
1752
1753         if (rtp->lasttxformat != subclass) {
1754                 /* New format, reset the smoother */
1755                 if (option_debug)
1756                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1757                 rtp->lasttxformat = subclass;
1758                 if (rtp->smoother)
1759                         ast_smoother_free(rtp->smoother);
1760                 rtp->smoother = NULL;
1761         }
1762
1763
1764         switch(subclass) {
1765         case AST_FORMAT_SLINEAR:
1766                 if (!rtp->smoother) {
1767                         rtp->smoother = ast_smoother_new(320);
1768                 }
1769                 if (!rtp->smoother) {
1770                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1771                         return -1;
1772                 }
1773                 ast_smoother_feed_be(rtp->smoother, _f);
1774                 
1775                 while((f = ast_smoother_read(rtp->smoother)))
1776                         ast_rtp_raw_write(rtp, f, codec);
1777                 break;
1778         case AST_FORMAT_ULAW:
1779         case AST_FORMAT_ALAW:
1780                 if (!rtp->smoother) {
1781                         rtp->smoother = ast_smoother_new(160);
1782                 }
1783                 if (!rtp->smoother) {
1784                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1785                         return -1;
1786                 }
1787                 ast_smoother_feed(rtp->smoother, _f);
1788                 
1789                 while((f = ast_smoother_read(rtp->smoother)))
1790                         ast_rtp_raw_write(rtp, f, codec);
1791                 break;
1792         case AST_FORMAT_ADPCM:
1793         case AST_FORMAT_G726:
1794                 if (!rtp->smoother) {
1795                         rtp->smoother = ast_smoother_new(80);
1796                 }
1797                 if (!rtp->smoother) {
1798                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1799                         return -1;
1800                 }
1801                 ast_smoother_feed(rtp->smoother, _f);
1802                 
1803                 while((f = ast_smoother_read(rtp->smoother)))
1804                         ast_rtp_raw_write(rtp, f, codec);
1805                 break;
1806         case AST_FORMAT_G729A:
1807                 if (!rtp->smoother) {
1808                         rtp->smoother = ast_smoother_new(20);
1809                         if (rtp->smoother)
1810                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1811                 }
1812                 if (!rtp->smoother) {
1813                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1814                         return -1;
1815                 }
1816                 ast_smoother_feed(rtp->smoother, _f);
1817                 
1818                 while((f = ast_smoother_read(rtp->smoother)))
1819                         ast_rtp_raw_write(rtp, f, codec);
1820                 break;
1821         case AST_FORMAT_GSM:
1822                 if (!rtp->smoother) {
1823                         rtp->smoother = ast_smoother_new(33);
1824                 }
1825                 if (!rtp->smoother) {
1826                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1827                         return -1;
1828                 }
1829                 ast_smoother_feed(rtp->smoother, _f);
1830                 while((f = ast_smoother_read(rtp->smoother)))
1831                         ast_rtp_raw_write(rtp, f, codec);
1832                 break;
1833         case AST_FORMAT_ILBC:
1834                 if (!rtp->smoother) {
1835                         rtp->smoother = ast_smoother_new(50);
1836                 }
1837                 if (!rtp->smoother) {
1838                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1839                         return -1;
1840                 }
1841                 ast_smoother_feed(rtp->smoother, _f);
1842                 while((f = ast_smoother_read(rtp->smoother)))
1843                         ast_rtp_raw_write(rtp, f, codec);
1844                 break;
1845         default:        
1846                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1847                 /* fall through to... */
1848         case AST_FORMAT_H261:
1849         case AST_FORMAT_H263:
1850         case AST_FORMAT_H263_PLUS:
1851         case AST_FORMAT_H264:
1852         case AST_FORMAT_G723_1:
1853         case AST_FORMAT_LPC10:
1854         case AST_FORMAT_SPEEX:
1855                 /* Don't buffer outgoing frames; send them one-per-packet: */
1856                 if (_f->offset < hdrlen) {
1857                         f = ast_frdup(_f);
1858                 } else {
1859                         f = _f;
1860                 }
1861                 ast_rtp_raw_write(rtp, f, codec);
1862         }
1863                 
1864         return 0;
1865 }
1866
1867 /*! \brief Unregister interface to channel driver */
1868 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1869 {
1870         AST_LIST_LOCK(&protos);
1871         AST_LIST_REMOVE(&protos, proto, list);
1872         AST_LIST_UNLOCK(&protos);
1873 }
1874
1875 /*! \brief Register interface to channel driver */
1876 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1877 {
1878         struct ast_rtp_protocol *cur;
1879
1880         AST_LIST_LOCK(&protos);
1881         AST_LIST_TRAVERSE(&protos, cur, list) { 
1882                 if (!strcmp(cur->type, proto->type)) {
1883                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1884                         AST_LIST_UNLOCK(&protos);
1885                         return -1;
1886                 }
1887         }
1888         AST_LIST_INSERT_HEAD(&protos, proto, list);
1889         AST_LIST_UNLOCK(&protos);
1890         
1891         return 0;
1892 }
1893
1894 /*! \brief Bridge calls. If possible and allowed, initiate
1895         re-invite so the peers exchange media directly outside 
1896         of Asterisk. */
1897 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)
1898 {
1899         struct ast_frame *f;
1900         struct ast_channel *who, *other, *cs[3];
1901         struct ast_rtp *p0, *p1;                /* Audio RTP Channels */
1902         struct ast_rtp *vp0, *vp1;              /* Video RTP channels */
1903         struct ast_rtp_protocol *pr0, *pr1;
1904         struct sockaddr_in ac0, ac1;
1905         struct sockaddr_in vac0, vac1;
1906         struct sockaddr_in t0, t1;
1907         struct sockaddr_in vt0, vt1;
1908         char iabuf[INET_ADDRSTRLEN];
1909         
1910         void *pvt0, *pvt1;
1911         int codec0,codec1, oldcodec0, oldcodec1;
1912         
1913         memset(&vt0, 0, sizeof(vt0));
1914         memset(&vt1, 0, sizeof(vt1));
1915         memset(&vac0, 0, sizeof(vac0));
1916         memset(&vac1, 0, sizeof(vac1));
1917
1918         /* if need DTMF, cant native bridge */
1919         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1920                 return AST_BRIDGE_FAILED_NOWARN;
1921
1922         /* Lock channels */
1923         ast_channel_lock(c0);
1924         while(ast_channel_trylock(c1)) {
1925                 ast_channel_unlock(c0);
1926                 usleep(1);
1927                 ast_channel_lock(c0);
1928         }
1929
1930         /* Find channel driver interfaces */
1931         pr0 = get_proto(c0);
1932         pr1 = get_proto(c1);
1933         if (!pr0) {
1934                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1935                 ast_channel_unlock(c0);
1936                 ast_channel_unlock(c1);
1937                 return AST_BRIDGE_FAILED;
1938         }
1939         if (!pr1) {
1940                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1941                 ast_channel_unlock(c0);
1942                 ast_channel_unlock(c1);
1943                 return AST_BRIDGE_FAILED;
1944         }
1945
1946         /* Get channel specific interface structures */
1947         pvt0 = c0->tech_pvt;
1948         pvt1 = c1->tech_pvt;
1949
1950         /* Get audio and video interface (if native bridge is possible) */
1951         p0 = pr0->get_rtp_info(c0);
1952         vp0 = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0) : NULL;
1953         p1 = pr1->get_rtp_info(c1);
1954         vp1 = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1) : NULL;
1955
1956         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1957         if (!p0 || !p1) {
1958                 /* Somebody doesn't want to play... */
1959                 ast_channel_unlock(c0);
1960                 ast_channel_unlock(c1);
1961                 return AST_BRIDGE_FAILED_NOWARN;
1962         }
1963         /* Get codecs from both sides */
1964         codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
1965         codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
1966         if (pr0->get_codec && pr1->get_codec) {
1967                 /* Hey, we can't do reinvite if both parties speak different codecs */
1968                 if (!(codec0 & codec1)) {
1969                         if (option_debug)
1970                                 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
1971                         ast_channel_unlock(c0);
1972                         ast_channel_unlock(c1);
1973                         return AST_BRIDGE_FAILED_NOWARN;
1974                 }
1975         }
1976
1977         if (option_verbose > 2) 
1978                 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
1979
1980         /* Ok, we should be able to redirect the media. Start with one channel */
1981         if (pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE))) 
1982                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1983         else {
1984                 /* Store RTP peer */
1985                 ast_rtp_get_peer(p1, &ac1);
1986                 if (vp1)
1987                         ast_rtp_get_peer(vp1, &vac1);
1988         }
1989         /* Then test the other channel */
1990         if (pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
1991                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1992         else {
1993                 /* Store RTP peer */
1994                 ast_rtp_get_peer(p0, &ac0);
1995                 if (vp0)
1996                         ast_rtp_get_peer(vp0, &vac0);
1997         }
1998         ast_channel_unlock(c0);
1999         ast_channel_unlock(c1);
2000         /* External RTP Bridge up, now loop and see if something happes that force us to take the
2001                 media back to Asterisk */
2002         cs[0] = c0;
2003         cs[1] = c1;
2004         cs[2] = NULL;
2005         oldcodec0 = codec0;
2006         oldcodec1 = codec1;
2007         for (;;) {
2008                 /* Check if something changed... */
2009                 if ((c0->tech_pvt != pvt0)  ||
2010                         (c1->tech_pvt != pvt1) ||
2011                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2012                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2013                                 if (c0->tech_pvt == pvt0) {
2014                                         if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0)) 
2015                                                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2016                                 }
2017                                 if (c1->tech_pvt == pvt1) {
2018                                         if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0)) 
2019                                                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2020                                 }
2021                                 return AST_BRIDGE_RETRY;
2022                 }
2023                 /* Now check if they have changed address */
2024                 ast_rtp_get_peer(p1, &t1);
2025                 ast_rtp_get_peer(p0, &t0);
2026                 if (pr0->get_codec)
2027                         codec0 = pr0->get_codec(c0);
2028                 if (pr1->get_codec)
2029                         codec1 = pr1->get_codec(c1);
2030                 if (vp1)
2031                         ast_rtp_get_peer(vp1, &vt1);
2032                 if (vp0)
2033                         ast_rtp_get_peer(vp0, &vt0);
2034                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
2035                         if (option_debug > 1) {
2036                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
2037                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t1.sin_addr), ntohs(t1.sin_port), codec1);
2038                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n", 
2039                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2040                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
2041                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2042                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
2043                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2044                         }
2045                         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))) 
2046                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2047                         memcpy(&ac1, &t1, sizeof(ac1));
2048                         memcpy(&vac1, &vt1, sizeof(vac1));
2049                         oldcodec1 = codec1;
2050                 }
2051                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
2052                         if (option_debug) {
2053                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
2054                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t0.sin_addr), ntohs(t0.sin_port), codec0);
2055                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
2056                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2057                         }
2058                         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)))
2059                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2060                         memcpy(&ac0, &t0, sizeof(ac0));
2061                         memcpy(&vac0, &vt0, sizeof(vac0));
2062                         oldcodec0 = codec0;
2063                 }
2064                 who = ast_waitfor_n(cs, 2, &timeoutms);
2065                 if (!who) {
2066                         if (!timeoutms) 
2067                                 return AST_BRIDGE_RETRY;
2068                         if (option_debug)
2069                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2070                         /* check for hangup / whentohangup */
2071                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2072                                 break;
2073                         continue;
2074                 }
2075                 f = ast_read(who);
2076                 other = (who == c0) ? c1 : c0; /* the other channel */
2077                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
2078                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
2079                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2080                         /* breaking out of the bridge. */
2081                         *fo = f;
2082                         *rc = who;
2083                         if (option_debug)
2084                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
2085                         if ((c0->tech_pvt == pvt0)) {
2086                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0)) 
2087                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2088                         }
2089                         if ((c1->tech_pvt == pvt1)) {
2090                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0)) 
2091                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2092                         }
2093                         return AST_BRIDGE_COMPLETE;
2094                 } else if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2095                         if ((f->subclass == AST_CONTROL_HOLD) || (f->subclass == AST_CONTROL_UNHOLD) ||
2096                             (f->subclass == AST_CONTROL_VIDUPDATE)) {
2097                                 ast_indicate(other, f->subclass);
2098                                 ast_frfree(f);
2099                         } else {
2100                                 *fo = f;
2101                                 *rc = who;
2102                                 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
2103                                 return AST_BRIDGE_COMPLETE;
2104                         }
2105                 } else {
2106                         if ((f->frametype == AST_FRAME_DTMF) || 
2107                                 (f->frametype == AST_FRAME_VOICE) || 
2108                                 (f->frametype == AST_FRAME_VIDEO)) {
2109                                 /* Forward voice or DTMF frames if they happen upon us */
2110                                 ast_write(other, f);
2111                         }
2112                         ast_frfree(f);
2113                 }
2114                 /* Swap priority not that it's a big deal at this point */
2115                 cs[2] = cs[0];
2116                 cs[0] = cs[1];
2117                 cs[1] = cs[2];
2118                 
2119         }
2120         return AST_BRIDGE_FAILED;
2121 }
2122
2123 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
2124 {
2125         struct hostent *hp;
2126         struct ast_hostent ahp;
2127         char iabuf[INET_ADDRSTRLEN];
2128         int port = 0;
2129         char *p, *arg;
2130
2131         if (argc != 4)
2132                 return RESULT_SHOWUSAGE;
2133         arg = argv[3];
2134         p = strstr(arg, ":");
2135         if (p) {
2136                 *p = '\0';
2137                 p++;
2138                 port = atoi(p);
2139         }
2140         hp = ast_gethostbyname(arg, &ahp);
2141         if (hp == NULL)
2142                 return RESULT_SHOWUSAGE;
2143         rtpdebugaddr.sin_family = AF_INET;
2144         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
2145         rtpdebugaddr.sin_port = htons(port);
2146         if (port == 0)
2147                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr));
2148         else
2149                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr), port);
2150         rtpdebug = 1;
2151         return RESULT_SUCCESS;
2152 }
2153
2154 static int rtp_do_debug(int fd, int argc, char *argv[])
2155 {
2156         if(argc != 2) {
2157                 if(argc != 4)
2158                         return RESULT_SHOWUSAGE;
2159                 return rtp_do_debug_ip(fd, argc, argv);
2160         }
2161         rtpdebug = 1;
2162         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
2163         ast_cli(fd, "RTP Debugging Enabled\n");
2164         return RESULT_SUCCESS;
2165 }
2166    
2167 static int rtp_no_debug(int fd, int argc, char *argv[])
2168 {
2169         if(argc !=3)
2170                 return RESULT_SHOWUSAGE;
2171         rtpdebug = 0;
2172         ast_cli(fd,"RTP Debugging Disabled\n");
2173         return RESULT_SUCCESS;
2174 }
2175
2176 static int stun_do_debug(int fd, int argc, char *argv[])
2177 {
2178         if(argc != 2) {
2179                 return RESULT_SHOWUSAGE;
2180         }
2181         stundebug = 1;
2182         ast_cli(fd, "STUN Debugging Enabled\n");
2183         return RESULT_SUCCESS;
2184 }
2185    
2186 static int stun_no_debug(int fd, int argc, char *argv[])
2187 {
2188         if(argc !=3)
2189                 return RESULT_SHOWUSAGE;
2190         stundebug = 0;
2191         ast_cli(fd,"STUN Debugging Disabled\n");
2192         return RESULT_SUCCESS;
2193 }
2194
2195
2196 static char debug_usage[] =
2197   "Usage: rtp debug [ip host[:port]]\n"
2198   "       Enable dumping of all RTP packets to and from host.\n";
2199
2200 static char no_debug_usage[] =
2201   "Usage: rtp no debug\n"
2202   "       Disable all RTP debugging\n";
2203
2204 static char stun_debug_usage[] =
2205   "Usage: stun debug\n"
2206   "       Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
2207
2208 static char stun_no_debug_usage[] =
2209   "Usage: stun no debug\n"
2210   "       Disable STUN debugging\n";
2211
2212
2213 static struct ast_cli_entry  cli_debug_ip =
2214 {{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage };
2215
2216 static struct ast_cli_entry  cli_debug =
2217 {{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage };
2218
2219 static struct ast_cli_entry  cli_no_debug =
2220 {{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage };
2221
2222 static struct ast_cli_entry  cli_stun_debug =
2223 {{ "stun", "debug", NULL } , stun_do_debug, "Enable STUN debugging", stun_debug_usage };
2224
2225 static struct ast_cli_entry  cli_stun_no_debug =
2226 {{ "stun", "no", "debug", NULL } , stun_no_debug, "Disable STUN debugging", stun_no_debug_usage };
2227
2228 int ast_rtp_reload(void)
2229 {
2230         struct ast_config *cfg;
2231         char *s;
2232
2233         rtpstart = 5000;
2234         rtpend = 31000;
2235         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2236         cfg = ast_config_load("rtp.conf");
2237         if (cfg) {
2238                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
2239                         rtpstart = atoi(s);
2240                         if (rtpstart < 1024)
2241                                 rtpstart = 1024;
2242                         if (rtpstart > 65535)
2243                                 rtpstart = 65535;
2244                 }
2245                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
2246                         rtpend = atoi(s);
2247                         if (rtpend < 1024)
2248                                 rtpend = 1024;
2249                         if (rtpend > 65535)
2250                                 rtpend = 65535;
2251                 }
2252                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
2253 #ifdef SO_NO_CHECK
2254                         if (ast_false(s))
2255                                 nochecksums = 1;
2256                         else
2257                                 nochecksums = 0;
2258 #else
2259                         if (ast_false(s))
2260                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
2261 #endif
2262                 }
2263                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
2264                         dtmftimeout = atoi(s);
2265                         if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
2266                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
2267                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
2268                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2269                         };
2270                 }
2271                 ast_config_destroy(cfg);
2272         }
2273         if (rtpstart >= rtpend) {
2274                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
2275                 rtpstart = 5000;
2276                 rtpend = 31000;
2277         }
2278         if (option_verbose > 1)
2279                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
2280         return 0;
2281 }
2282
2283 /*! \brief Initialize the RTP system in Asterisk */
2284 void ast_rtp_init(void)
2285 {
2286         ast_cli_register(&cli_debug);
2287         ast_cli_register(&cli_debug_ip);
2288         ast_cli_register(&cli_no_debug);
2289         ast_cli_register(&cli_stun_debug);
2290         ast_cli_register(&cli_stun_no_debug);
2291         ast_rtp_reload();
2292 }