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