- 5 is the highest used debug level, so let's stay there
[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 #define FLAG_HAS_DTMF                   (1 << 3)
90
91 /*! \brief RTP session description */
92 struct ast_rtp {
93         int s;
94         char resp;
95         struct ast_frame f;
96         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
97         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
98         unsigned int rxssrc;
99         unsigned int lastts;
100         unsigned int lastdigitts;
101         unsigned int lastrxts;
102         unsigned int lastividtimestamp;
103         unsigned int lastovidtimestamp;
104         unsigned int lasteventseqn;
105         unsigned int lasteventendseqn;
106         int lasttxformat;
107         int lastrxformat;
108         int dtmfcount;
109         unsigned int dtmfduration;
110         int nat;
111         unsigned int flags;
112         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
113         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
114         struct timeval rxcore;
115         struct timeval txcore;
116         struct timeval dtmfmute;
117         struct ast_smoother *smoother;
118         int *ioid;
119         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
120         unsigned short rxseqno;
121         struct sched_context *sched;
122         struct io_context *io;
123         void *data;
124         ast_rtp_callback callback;
125         struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
126         int rtp_lookup_code_cache_isAstFormat; /*!< a cache for the result of rtp_lookup_code(): */
127         int rtp_lookup_code_cache_code;
128         int rtp_lookup_code_cache_result;
129         struct ast_rtcp *rtcp;
130 };
131
132 /*!
133  * \brief Structure defining an RTCP session.
134  * 
135  * The concept "RTCP session" is not defined in RFC 3550, but since 
136  * this structure is analogous to ast_rtp, which tracks a RTP session, 
137  * it is logical to think of this as a RTCP session.
138  *
139  * RTCP packet is defined on page 9 of RFC 3550.
140  * 
141  */
142 struct ast_rtcp {
143         int s;                          /*!< Socket */
144         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
145         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
146 };
147
148
149 typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
150
151 /* XXX Maybe stun belongs in another file if it ever has use outside of RTP */
152 struct stun_header {
153         unsigned short msgtype;
154         unsigned short msglen;
155         stun_trans_id  id;
156         unsigned char ies[0];
157 } __attribute__((packed));
158
159 struct stun_attr {
160         unsigned short attr;
161         unsigned short len;
162         unsigned char value[0];
163 } __attribute__((packed));
164
165 struct stun_addr {
166         unsigned char unused;
167         unsigned char family;
168         unsigned short port;
169         unsigned int addr;
170 } __attribute__((packed));
171
172 #define STUN_IGNORE             (0)
173 #define STUN_ACCEPT             (1)
174
175 #define STUN_BINDREQ    0x0001
176 #define STUN_BINDRESP   0x0101
177 #define STUN_BINDERR    0x0111
178 #define STUN_SECREQ     0x0002
179 #define STUN_SECRESP    0x0102
180 #define STUN_SECERR     0x0112
181
182 #define STUN_MAPPED_ADDRESS     0x0001
183 #define STUN_RESPONSE_ADDRESS   0x0002
184 #define STUN_CHANGE_REQUEST     0x0003
185 #define STUN_SOURCE_ADDRESS     0x0004
186 #define STUN_CHANGED_ADDRESS    0x0005
187 #define STUN_USERNAME           0x0006
188 #define STUN_PASSWORD           0x0007
189 #define STUN_MESSAGE_INTEGRITY  0x0008
190 #define STUN_ERROR_CODE         0x0009
191 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
192 #define STUN_REFLECTED_FROM     0x000b
193
194 static const char *stun_msg2str(int msg)
195 {
196         switch(msg) {
197         case STUN_BINDREQ:
198                 return "Binding Request";
199         case STUN_BINDRESP:
200                 return "Binding Response";
201         case STUN_BINDERR:
202                 return "Binding Error Response";
203         case STUN_SECREQ:
204                 return "Shared Secret Request";
205         case STUN_SECRESP:
206                 return "Shared Secret Response";
207         case STUN_SECERR:
208                 return "Shared Secret Error Response";
209         }
210         return "Non-RFC3489 Message";
211 }
212
213 static const char *stun_attr2str(int msg)
214 {
215         switch(msg) {
216         case STUN_MAPPED_ADDRESS:
217                 return "Mapped Address";
218         case STUN_RESPONSE_ADDRESS:
219                 return "Response Address";
220         case STUN_CHANGE_REQUEST:
221                 return "Change Request";
222         case STUN_SOURCE_ADDRESS:
223                 return "Source Address";
224         case STUN_CHANGED_ADDRESS:
225                 return "Changed Address";
226         case STUN_USERNAME:
227                 return "Username";
228         case STUN_PASSWORD:
229                 return "Password";
230         case STUN_MESSAGE_INTEGRITY:
231                 return "Message Integrity";
232         case STUN_ERROR_CODE:
233                 return "Error Code";
234         case STUN_UNKNOWN_ATTRIBUTES:
235                 return "Unknown Attributes";
236         case STUN_REFLECTED_FROM:
237                 return "Reflected From";
238         }
239         return "Non-RFC3489 Attribute";
240 }
241
242 struct stun_state {
243         unsigned char *username;
244         unsigned char *password;
245 };
246
247 static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
248 {
249         if (stundebug)
250                 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
251                         stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
252         switch(ntohs(attr->attr)) {
253         case STUN_USERNAME:
254                 state->username = (unsigned char *)(attr->value);
255                 break;
256         case STUN_PASSWORD:
257                 state->password = (unsigned char *)(attr->value);
258                 break;
259         default:
260                 if (stundebug)
261                         ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n", 
262                                 stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
263         }
264         return 0;
265 }
266
267 static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
268 {
269         int size = sizeof(**attr) + strlen(s);
270         if (*left > size) {
271                 (*attr)->attr = htons(attrval);
272                 (*attr)->len = htons(strlen(s));
273                 memcpy((*attr)->value, s, strlen(s));
274                 (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
275                 *len += size;
276                 *left -= size;
277         }
278 }
279
280 static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
281 {
282         int size = sizeof(**attr) + 8;
283         struct stun_addr *addr;
284         if (*left > size) {
285                 (*attr)->attr = htons(attrval);
286                 (*attr)->len = htons(8);
287                 addr = (struct stun_addr *)((*attr)->value);
288                 addr->unused = 0;
289                 addr->family = 0x01;
290                 addr->port = sin->sin_port;
291                 addr->addr = sin->sin_addr.s_addr;
292                 (*attr) = (struct stun_attr *)((*attr)->value + 8);
293                 *len += size;
294                 *left -= size;
295         }
296 }
297
298 static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
299 {
300         return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
301                 (struct sockaddr *)dst, sizeof(*dst));
302 }
303
304 static void stun_req_id(struct stun_header *req)
305 {
306         int x;
307         for (x=0;x<4;x++)
308                 req->id.id[x] = ast_random();
309 }
310
311 void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
312 {
313         struct stun_header *req;
314         unsigned char reqdata[1024];
315         int reqlen, reqleft;
316         struct stun_attr *attr;
317
318         req = (struct stun_header *)reqdata;
319         stun_req_id(req);
320         reqlen = 0;
321         reqleft = sizeof(reqdata) - sizeof(struct stun_header);
322         req->msgtype = 0;
323         req->msglen = 0;
324         attr = (struct stun_attr *)req->ies;
325         if (username)
326                 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
327         req->msglen = htons(reqlen);
328         req->msgtype = htons(STUN_BINDREQ);
329         stun_send(rtp->s, suggestion, req);
330 }
331
332 static int stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, size_t len)
333 {
334         struct stun_header *resp, *hdr = (struct stun_header *)data;
335         struct stun_attr *attr;
336         struct stun_state st;
337         int ret = STUN_IGNORE;  
338         unsigned char respdata[1024];
339         int resplen, respleft;
340         
341         if (len < sizeof(struct stun_header)) {
342                 if (option_debug)
343                         ast_log(LOG_DEBUG, "Runt STUN packet (only %zd, wanting at least %zd)\n", len, sizeof(struct stun_header));
344                 return -1;
345         }
346         if (stundebug)
347                 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), ntohs(hdr->msglen));
348         if (ntohs(hdr->msglen) > len - sizeof(struct stun_header)) {
349                 if (option_debug)
350                         ast_log(LOG_DEBUG, "Scrambled STUN packet length (got %d, expecting %zd)\n", ntohs(hdr->msglen), len - sizeof(struct stun_header));
351         } else
352                 len = ntohs(hdr->msglen);
353         data += sizeof(struct stun_header);
354         memset(&st, 0, sizeof(st));
355         while(len) {
356                 if (len < sizeof(struct stun_attr)) {
357                         if (option_debug)
358                                 ast_log(LOG_DEBUG, "Runt Attribute (got %zd, expecting %zd)\n", len, sizeof(struct stun_attr));
359                         break;
360                 }
361                 attr = (struct stun_attr *)data;
362                 if (ntohs(attr->len) > len) {
363                         if (option_debug)
364                                 ast_log(LOG_DEBUG, "Inconsistant Attribute (length %d exceeds remaining msg len %zd)\n", ntohs(attr->len), len);
365                         break;
366                 }
367                 if (stun_process_attr(&st, attr)) {
368                         if (option_debug)
369                                 ast_log(LOG_DEBUG, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
370                         break;
371                 }
372                 /* Clear attribute in case previous entry was a string */
373                 attr->attr = 0;
374                 data += ntohs(attr->len) + sizeof(struct stun_attr);
375                 len -= ntohs(attr->len) + sizeof(struct stun_attr);
376         }
377         /* Null terminate any string */
378         *data = '\0';
379         resp = (struct stun_header *)respdata;
380         resplen = 0;
381         respleft = sizeof(respdata) - sizeof(struct stun_header);
382         resp->id = hdr->id;
383         resp->msgtype = 0;
384         resp->msglen = 0;
385         attr = (struct stun_attr *)resp->ies;
386         if (!len) {
387                 switch(ntohs(hdr->msgtype)) {
388                 case STUN_BINDREQ:
389                         if (stundebug)
390                                 ast_verbose("STUN Bind Request, username: %s\n", 
391                                         st.username ? (const char *)st.username : "<none>");
392                         if (st.username)
393                                 append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
394                         append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
395                         resp->msglen = htons(resplen);
396                         resp->msgtype = htons(STUN_BINDRESP);
397                         stun_send(s, src, resp);
398                         ret = STUN_ACCEPT;
399                         break;
400                 default:
401                         if (stundebug)
402                                 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
403                 }
404         }
405         return ret;
406 }
407
408 /*! \brief List of current sessions */
409 static AST_LIST_HEAD_STATIC(protos, ast_rtp_protocol);
410
411 int ast_rtp_fd(struct ast_rtp *rtp)
412 {
413         return rtp->s;
414 }
415
416 int ast_rtcp_fd(struct ast_rtp *rtp)
417 {
418         if (rtp->rtcp)
419                 return rtp->rtcp->s;
420         return -1;
421 }
422
423 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
424 {
425         rtp->data = data;
426 }
427
428 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
429 {
430         rtp->callback = callback;
431 }
432
433 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
434 {
435         rtp->nat = nat;
436 }
437
438 void ast_rtp_setdtmf(struct ast_rtp *rtp, int dtmf)
439 {
440         ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF);
441 }
442
443 static struct ast_frame *send_dtmf(struct ast_rtp *rtp)
444 {
445         char iabuf[INET_ADDRSTRLEN];
446
447         if (ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
448                 if (option_debug)
449                         ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
450                 rtp->resp = 0;
451                 rtp->dtmfduration = 0;
452                 return &ast_null_frame;
453         }
454         if (option_debug)
455                 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));
456         if (rtp->resp == 'X') {
457                 rtp->f.frametype = AST_FRAME_CONTROL;
458                 rtp->f.subclass = AST_CONTROL_FLASH;
459         } else {
460                 rtp->f.frametype = AST_FRAME_DTMF;
461                 rtp->f.subclass = rtp->resp;
462         }
463         rtp->f.datalen = 0;
464         rtp->f.samples = 0;
465         rtp->f.mallocd = 0;
466         rtp->f.src = "RTP";
467         rtp->resp = 0;
468         rtp->dtmfduration = 0;
469         return &rtp->f;
470         
471 }
472
473 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
474 {
475         if (rtpdebug == 0)
476                 return 0;
477         if (rtpdebugaddr.sin_addr.s_addr) {
478                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
479                         && (rtpdebugaddr.sin_port != addr->sin_port))
480                         || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
481                 return 0;
482         }
483         return 1;
484 }
485
486 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
487 {
488         unsigned int event;
489         char resp = 0;
490         struct ast_frame *f = NULL;
491         event = ntohl(*((unsigned int *)(data)));
492         event &= 0x001F;
493         if (option_debug > 2 || rtpdebug)
494                 ast_log(LOG_DEBUG, "Cisco DTMF Digit: %08x (len = %d)\n", event, len);
495         if (event < 10) {
496                 resp = '0' + event;
497         } else if (event < 11) {
498                 resp = '*';
499         } else if (event < 12) {
500                 resp = '#';
501         } else if (event < 16) {
502                 resp = 'A' + (event - 12);
503         } else if (event < 17) {
504                 resp = 'X';
505         }
506         if (rtp->resp && (rtp->resp != resp)) {
507                 f = send_dtmf(rtp);
508         }
509         rtp->resp = resp;
510         rtp->dtmfcount = dtmftimeout;
511         return f;
512 }
513
514 /*! 
515  * \brief Process RTP DTMF and events according to RFC 2833.
516  * 
517  * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
518  * 
519  * \param rtp
520  * \param data
521  * \param len
522  * \param seqno
523  * \returns
524  */
525 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno)
526 {
527         unsigned int event;
528         unsigned int event_end;
529         unsigned int duration;
530         char resp = 0;
531         struct ast_frame *f = NULL;
532
533         event = ntohl(*((unsigned int *)(data)));
534         event >>= 24;
535         event_end = ntohl(*((unsigned int *)(data)));
536         event_end <<= 8;
537         event_end >>= 24;
538         duration = ntohl(*((unsigned int *)(data)));
539         duration &= 0xFFFF;
540         if (rtpdebug || option_debug > 2)
541                 ast_log(LOG_DEBUG, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
542         if (event < 10) {
543                 resp = '0' + event;
544         } else if (event < 11) {
545                 resp = '*';
546         } else if (event < 12) {
547                 resp = '#';
548         } else if (event < 16) {
549                 resp = 'A' + (event - 12);
550         } else if (event < 17) {        /* Event 16: Hook flash */
551                 resp = 'X';     
552         }
553         if (rtp->resp && (rtp->resp != resp)) {
554                 f = send_dtmf(rtp);
555         } else if(event_end & 0x80) {
556                 if (rtp->resp) {
557                         if(rtp->lasteventendseqn != seqno) {
558                                 f = send_dtmf(rtp);
559                                 rtp->lasteventendseqn = seqno;
560                         }
561                         rtp->resp = 0;
562                 }
563                 resp = 0;
564                 duration = 0;
565         } else if (rtp->resp && rtp->dtmfduration && (duration < rtp->dtmfduration)) {
566                 f = send_dtmf(rtp);
567         }
568         if (!(event_end & 0x80))
569                 rtp->resp = resp;
570         rtp->dtmfcount = dtmftimeout;
571         rtp->dtmfduration = duration;
572         return f;
573 }
574
575 /*!
576  * \brief Process Comfort Noise RTP.
577  * 
578  * This is incomplete at the moment.
579  * 
580 */
581 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
582 {
583         struct ast_frame *f = NULL;
584         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
585            totally help us out becuase we don't have an engine to keep it going and we are not
586            guaranteed to have it every 20ms or anything */
587         if (rtpdebug)
588                 ast_log(LOG_DEBUG, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
589
590         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
591                 char iabuf[INET_ADDRSTRLEN];
592
593                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
594                         ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
595                 ast_set_flag(rtp, FLAG_3389_WARNING);
596         }
597
598         /* Must have at least one byte */
599         if (!len)
600                 return NULL;
601         if (len < 24) {
602                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
603                 rtp->f.datalen = len - 1;
604                 rtp->f.offset = AST_FRIENDLY_OFFSET;
605                 memcpy(rtp->f.data, data + 1, len - 1);
606         } else {
607                 rtp->f.data = NULL;
608                 rtp->f.offset = 0;
609                 rtp->f.datalen = 0;
610         }
611         rtp->f.frametype = AST_FRAME_CNG;
612         rtp->f.subclass = data[0] & 0x7f;
613         rtp->f.datalen = len - 1;
614         rtp->f.samples = 0;
615         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
616         f = &rtp->f;
617         return f;
618 }
619
620 static int rtpread(int *id, int fd, short events, void *cbdata)
621 {
622         struct ast_rtp *rtp = cbdata;
623         struct ast_frame *f;
624         f = ast_rtp_read(rtp);
625         if (f) {
626                 if (rtp->callback)
627                         rtp->callback(rtp, f, rtp->data);
628         }
629         return 1;
630 }
631
632 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
633 {
634         socklen_t len;
635         int hdrlen = 8;
636         int res;
637         struct sockaddr_in sin;
638         unsigned int rtcpdata[1024];
639         char iabuf[INET_ADDRSTRLEN];
640         
641         if (!rtp || !rtp->rtcp)
642                 return &ast_null_frame;
643
644         len = sizeof(sin);
645         
646         res = recvfrom(rtp->rtcp->s, rtcpdata, sizeof(rtcpdata),
647                                         0, (struct sockaddr *)&sin, &len);
648         
649         if (res < 0) {
650                 if (errno != EAGAIN)
651                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
652                 if (errno == EBADF)
653                         CRASH;
654                 return &ast_null_frame;
655         }
656
657         if (res < hdrlen) {
658                 ast_log(LOG_WARNING, "RTP Read too short\n");
659                 return &ast_null_frame;
660         }
661
662         if (rtp->nat) {
663                 /* Send to whoever sent to us */
664                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
665                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
666                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
667                         if (option_debug || rtpdebug)
668                                 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));
669                 }
670         }
671         if (option_debug)
672                 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
673         return &ast_null_frame;
674 }
675
676 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
677 {
678         struct timeval ts = ast_samp2tv( timestamp, 8000);
679         if (ast_tvzero(rtp->rxcore) || mark) {
680                 rtp->rxcore = ast_tvsub(ast_tvnow(), ts);
681                 /* Round to 20ms for nice, pretty timestamps */
682                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 20000;
683         }
684         *tv = ast_tvadd(rtp->rxcore, ts);
685 }
686
687 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
688 {
689         int res;
690         struct sockaddr_in sin;
691         socklen_t len;
692         unsigned int seqno;
693         int version;
694         int payloadtype;
695         int hdrlen = 12;
696         int padding;
697         int mark;
698         int ext;
699         char iabuf[INET_ADDRSTRLEN];
700         unsigned int ssrc;
701         unsigned int timestamp;
702         unsigned int *rtpheader;
703         struct rtpPayloadType rtpPT;
704         
705         len = sizeof(sin);
706         
707         /* Cache where the header will go */
708         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
709                                         0, (struct sockaddr *)&sin, &len);
710
711         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
712         if (res < 0) {
713                 if (errno != EAGAIN)
714                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
715                 if (errno == EBADF)
716                         CRASH;
717                 return &ast_null_frame;
718         }
719         if (res < hdrlen) {
720                 ast_log(LOG_WARNING, "RTP Read too short\n");
721                 return &ast_null_frame;
722         }
723
724         /* Get fields */
725         seqno = ntohl(rtpheader[0]);
726
727         /* Check RTP version */
728         version = (seqno & 0xC0000000) >> 30;
729         if (!version) {
730                 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) &&
731                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
732                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
733                 }
734                 return &ast_null_frame;
735         }
736
737         if (version != 2)
738                 return &ast_null_frame;
739         /* Ignore if the other side hasn't been given an address
740            yet.  */
741         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
742                 return &ast_null_frame;
743
744         if (rtp->nat) {
745                 /* Send to whoever sent to us */
746                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
747                     (rtp->them.sin_port != sin.sin_port)) {
748                         rtp->them = sin;
749                         rtp->rxseqno = 0;
750                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
751                         if (option_debug || rtpdebug)
752                                 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));
753                 }
754         }
755
756         payloadtype = (seqno & 0x7f0000) >> 16;
757         padding = seqno & (1 << 29);
758         mark = seqno & (1 << 23);
759         ext = seqno & (1 << 28);
760         seqno &= 0xffff;
761         timestamp = ntohl(rtpheader[1]);
762         ssrc = ntohl(rtpheader[2]);
763         
764         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
765                 if (option_verbose > 1)
766                         ast_verbose(VERBOSE_PREFIX_2 "Forcing Marker bit, because SSRC has changed\n");
767                 mark = 1;
768         }
769
770         rtp->rxssrc = ssrc;
771         
772         if (padding) {
773                 /* Remove padding bytes */
774                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
775         }
776         
777         if (ext) {
778                 /* RTP Extension present */
779                 hdrlen += 4;
780                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
781         }
782
783         if (res < hdrlen) {
784                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
785                 return &ast_null_frame;
786         }
787
788         if(rtp_debug_test_addr(&sin))
789                 ast_verbose("Got  RTP packet from %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
790                         ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
791
792         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
793         if (!rtpPT.isAstFormat) {
794                 struct ast_frame *f = NULL;
795
796                 /* This is special in-band data that's not one of our codecs */
797                 if (rtpPT.code == AST_RTP_DTMF) {
798                         /* It's special -- rfc2833 process it */
799                         if(rtp_debug_test_addr(&sin)) {
800                                 unsigned char *data;
801                                 unsigned int event;
802                                 unsigned int event_end;
803                                 unsigned int duration;
804                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
805                                 event = ntohl(*((unsigned int *)(data)));
806                                 event >>= 24;
807                                 event_end = ntohl(*((unsigned int *)(data)));
808                                 event_end <<= 8;
809                                 event_end >>= 24;
810                                 duration = ntohl(*((unsigned int *)(data)));
811                                 duration &= 0xFFFF;
812                                 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);
813                         }
814                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
815                                 f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno);
816                                 rtp->lasteventseqn = seqno;
817                         }
818                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
819                         /* It's really special -- process it the Cisco way */
820                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
821                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
822                                 rtp->lasteventseqn = seqno;
823                         }
824                 } else if (rtpPT.code == AST_RTP_CN) {
825                         /* Comfort Noise */
826                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
827                 } else {
828                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
829                 }
830                 return f ? f : &ast_null_frame;
831         }
832         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
833         rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO;
834
835         if (!rtp->lastrxts)
836                 rtp->lastrxts = timestamp;
837
838         rtp->rxseqno = seqno;
839
840         if (rtp->dtmfcount) {
841 #if 0
842                 printf("dtmfcount was %d\n", rtp->dtmfcount);
843 #endif          
844                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
845                 if (rtp->dtmfcount < 0)
846                         rtp->dtmfcount = 0;
847 #if 0
848                 if (dtmftimeout != rtp->dtmfcount)
849                         printf("dtmfcount is %d\n", rtp->dtmfcount);
850 #endif
851         }
852         rtp->lastrxts = timestamp;
853
854         /* Send any pending DTMF */
855         if (rtp->resp && !rtp->dtmfcount) {
856                 if (option_debug)
857                         ast_log(LOG_DEBUG, "Sending pending DTMF\n");
858                 return send_dtmf(rtp);
859         }
860         rtp->f.mallocd = 0;
861         rtp->f.datalen = res - hdrlen;
862         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
863         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
864         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
865                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
866                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
867                         ast_frame_byteswap_be(&rtp->f);
868                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
869                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
870                 rtp->f.has_timing_info = 1;
871                 rtp->f.ts = timestamp / 8;
872                 rtp->f.len = rtp->f.samples / 8;
873                 rtp->f.seqno = seqno;
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         ast_set_flag(rtp, FLAG_HAS_DTMF);
1348         if (rtp->s < 0) {
1349                 free(rtp);
1350                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1351                 return NULL;
1352         }
1353         if (sched && rtcpenable) {
1354                 rtp->sched = sched;
1355                 rtp->rtcp = ast_rtcp_new();
1356         }
1357         
1358         /* Select a random port number in the range of possible RTP */
1359         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1360         x = x & ~1;
1361         /* Save it for future references. */
1362         startplace = x;
1363         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1364         for (;;) {
1365                 /* Must be an even port number by RTP spec */
1366                 rtp->us.sin_port = htons(x);
1367                 rtp->us.sin_addr = addr;
1368                 /* If there's rtcp, initialize it as well. */
1369                 if (rtp->rtcp)
1370                         rtp->rtcp->us.sin_port = htons(x + 1);
1371                 /* Try to bind it/them. */
1372                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1373                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1374                         break;
1375                 if (!first) {
1376                         /* Primary bind succeeded! Gotta recreate it */
1377                         close(rtp->s);
1378                         rtp->s = rtp_socket();
1379                 }
1380                 if (errno != EADDRINUSE) {
1381                         /* We got an error that wasn't expected, abort! */
1382                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1383                         close(rtp->s);
1384                         if (rtp->rtcp) {
1385                                 close(rtp->rtcp->s);
1386                                 free(rtp->rtcp);
1387                         }
1388                         free(rtp);
1389                         return NULL;
1390                 }
1391                 /* The port was used, increment it (by two). */
1392                 x += 2;
1393                 /* Did we go over the limit ? */
1394                 if (x > rtpend)
1395                         /* then, start from the begingig. */
1396                         x = (rtpstart + 1) & ~1;
1397                 /* Check if we reached the place were we started. */
1398                 if (x == startplace) {
1399                         /* If so, there's no ports available. */
1400                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1401                         close(rtp->s);
1402                         if (rtp->rtcp) {
1403                                 close(rtp->rtcp->s);
1404                                 free(rtp->rtcp);
1405                         }
1406                         free(rtp);
1407                         return NULL;
1408                 }
1409         }
1410         if (io && sched && callbackmode) {
1411                 /* Operate this one in a callback mode */
1412                 rtp->sched = sched;
1413                 rtp->io = io;
1414                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1415         }
1416         ast_rtp_pt_default(rtp);
1417         return rtp;
1418 }
1419
1420 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1421 {
1422         struct in_addr ia;
1423
1424         memset(&ia, 0, sizeof(ia));
1425         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1426 }
1427
1428 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1429 {
1430         int res;
1431
1432         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
1433                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1434         return res;
1435 }
1436
1437 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1438 {
1439         rtp->them.sin_port = them->sin_port;
1440         rtp->them.sin_addr = them->sin_addr;
1441         if (rtp->rtcp) {
1442                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1443                 rtp->rtcp->them.sin_addr = them->sin_addr;
1444         }
1445         rtp->rxseqno = 0;
1446 }
1447
1448 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1449 {
1450         if ((them->sin_family != AF_INET) ||
1451                 (them->sin_port != rtp->them.sin_port) ||
1452                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
1453                 them->sin_family = AF_INET;
1454                 them->sin_port = rtp->them.sin_port;
1455                 them->sin_addr = rtp->them.sin_addr;
1456                 return 1;
1457         }
1458         return 0;
1459 }
1460
1461 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
1462 {
1463         *us = rtp->us;
1464 }
1465
1466 void ast_rtp_stop(struct ast_rtp *rtp)
1467 {
1468         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1469         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1470         if (rtp->rtcp) {
1471                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1472                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1473         }
1474 }
1475
1476 void ast_rtp_reset(struct ast_rtp *rtp)
1477 {
1478         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1479         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1480         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1481         rtp->lastts = 0;
1482         rtp->lastdigitts = 0;
1483         rtp->lastrxts = 0;
1484         rtp->lastividtimestamp = 0;
1485         rtp->lastovidtimestamp = 0;
1486         rtp->lasteventseqn = 0;
1487         rtp->lasteventendseqn = 0;
1488         rtp->lasttxformat = 0;
1489         rtp->lastrxformat = 0;
1490         rtp->dtmfcount = 0;
1491         rtp->dtmfduration = 0;
1492         rtp->seqno = 0;
1493         rtp->rxseqno = 0;
1494 }
1495
1496 void ast_rtp_destroy(struct ast_rtp *rtp)
1497 {
1498         if (rtp->smoother)
1499                 ast_smoother_free(rtp->smoother);
1500         if (rtp->ioid)
1501                 ast_io_remove(rtp->io, rtp->ioid);
1502         if (rtp->s > -1)
1503                 close(rtp->s);
1504         if (rtp->rtcp) {
1505                 close(rtp->rtcp->s);
1506                 free(rtp->rtcp);
1507         }
1508         free(rtp);
1509 }
1510
1511 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
1512 {
1513         struct timeval t;
1514         long ms;
1515         if (ast_tvzero(rtp->txcore)) {
1516                 rtp->txcore = ast_tvnow();
1517                 /* Round to 20ms for nice, pretty timestamps */
1518                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
1519         }
1520         /* Use previous txcore if available */
1521         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
1522         ms = ast_tvdiff_ms(t, rtp->txcore);
1523         if (ms < 0)
1524                 ms = 0;
1525         /* Use what we just got for next time */
1526         rtp->txcore = t;
1527         return (unsigned int) ms;
1528 }
1529
1530 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
1531 {
1532         unsigned int *rtpheader;
1533         int hdrlen = 12;
1534         int res;
1535         int x;
1536         int payload;
1537         char data[256];
1538         char iabuf[INET_ADDRSTRLEN];
1539
1540         if ((digit <= '9') && (digit >= '0'))
1541                 digit -= '0';
1542         else if (digit == '*')
1543                 digit = 10;
1544         else if (digit == '#')
1545                 digit = 11;
1546         else if ((digit >= 'A') && (digit <= 'D')) 
1547                 digit = digit - 'A' + 12;
1548         else if ((digit >= 'a') && (digit <= 'd')) 
1549                 digit = digit - 'a' + 12;
1550         else {
1551                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1552                 return -1;
1553         }
1554         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
1555
1556         /* If we have no peer, return immediately */    
1557         if (!rtp->them.sin_addr.s_addr)
1558                 return 0;
1559
1560         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1561         
1562         /* Get a pointer to the header */
1563         rtpheader = (unsigned int *)data;
1564         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
1565         rtpheader[1] = htonl(rtp->lastdigitts);
1566         rtpheader[2] = htonl(rtp->ssrc); 
1567         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
1568         for (x = 0; x < 6; x++) {
1569                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1570                         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
1571                         if (res < 0) 
1572                                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
1573                                         ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
1574                                         ntohs(rtp->them.sin_port), strerror(errno));
1575                         if (rtp_debug_test_addr(&rtp->them))
1576                                 ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1577                                             ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
1578                                             ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1579                 }
1580                 /* Sequence number of last two end packets does not get incremented */
1581                 if (x < 3)
1582                         rtp->seqno++;
1583                 /* Clear marker bit and set seqno */
1584                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
1585                 /* For the last three packets, set the duration and the end bit */
1586                 if (x == 2) {
1587 #if 0
1588                         /* No, this is wrong...  Do not increment lastdigitts, that's not according
1589                            to the RFC, as best we can determine */
1590                         rtp->lastdigitts++; /* or else the SPA3000 will click instead of beeping... */
1591                         rtpheader[1] = htonl(rtp->lastdigitts);
1592 #endif                  
1593                         /* Make duration 800 (100ms) */
1594                         rtpheader[3] |= htonl((800));
1595                         /* Set the End bit */
1596                         rtpheader[3] |= htonl((1 << 23));
1597                 }
1598         }
1599         /* Increment the digit timestamp by 120ms, to ensure that digits
1600            sent sequentially with no intervening non-digit packets do not
1601            get sent with the same timestamp, and that sequential digits
1602            have some 'dead air' in between them
1603         */
1604         rtp->lastdigitts += 960;
1605         /* Increment the sequence number to reflect the last packet
1606            that was sent
1607         */
1608         rtp->seqno++;
1609         return 0;
1610 }
1611
1612 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
1613 {
1614         unsigned int *rtpheader;
1615         int hdrlen = 12;
1616         int res;
1617         int payload;
1618         char data[256];
1619         char iabuf[INET_ADDRSTRLEN];
1620         level = 127 - (level & 0x7f);
1621         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
1622
1623         /* If we have no peer, return immediately */    
1624         if (!rtp->them.sin_addr.s_addr)
1625                 return 0;
1626
1627         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1628
1629         /* Get a pointer to the header */
1630         rtpheader = (unsigned int *)data;
1631         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1632         rtpheader[1] = htonl(rtp->lastts);
1633         rtpheader[2] = htonl(rtp->ssrc); 
1634         data[12] = level;
1635         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1636                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1637                 if (res <0) 
1638                         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));
1639                 if(rtp_debug_test_addr(&rtp->them))
1640                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1641                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);              
1642                    
1643         }
1644         return 0;
1645 }
1646
1647 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
1648 {
1649         unsigned char *rtpheader;
1650         char iabuf[INET_ADDRSTRLEN];
1651         int hdrlen = 12;
1652         int res;
1653         unsigned int ms;
1654         int pred;
1655         int mark = 0;
1656
1657         ms = calc_txstamp(rtp, &f->delivery);
1658         /* Default prediction */
1659         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
1660                 pred = rtp->lastts + f->samples;
1661
1662                 /* Re-calculate last TS */
1663                 rtp->lastts = rtp->lastts + ms * 8;
1664                 if (ast_tvzero(f->delivery)) {
1665                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
1666                            and if so, go with our prediction */
1667                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
1668                                 rtp->lastts = pred;
1669                         else {
1670                                 if (option_debug > 2)
1671                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1672                                 mark = 1;
1673                         }
1674                 }
1675         } else {
1676                 mark = f->subclass & 0x1;
1677                 pred = rtp->lastovidtimestamp + f->samples;
1678                 /* Re-calculate last TS */
1679                 rtp->lastts = rtp->lastts + ms * 90;
1680                 /* If it's close to our prediction, go for it */
1681                 if (ast_tvzero(f->delivery)) {
1682                         if (abs(rtp->lastts - pred) < 7200) {
1683                                 rtp->lastts = pred;
1684                                 rtp->lastovidtimestamp += f->samples;
1685                         } else {
1686                                 if (option_debug > 2)
1687                                         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);
1688                                 rtp->lastovidtimestamp = rtp->lastts;
1689                         }
1690                 }
1691         }
1692         /* If the timestamp for non-digit packets has moved beyond the timestamp
1693            for digits, update the digit timestamp.
1694         */
1695         if (rtp->lastts > rtp->lastdigitts)
1696                 rtp->lastdigitts = rtp->lastts;
1697
1698         if (f->has_timing_info)
1699                 rtp->lastts = f->ts * 8;
1700
1701         /* Get a pointer to the header */
1702         rtpheader = (unsigned char *)(f->data - hdrlen);
1703
1704         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1705         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1706         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
1707
1708         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1709                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1710                 if (res <0) {
1711                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1712                                 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));
1713                         } else if ((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) {
1714                                 /* Only give this error message once if we are not RTP debugging */
1715                                 if (option_debug || rtpdebug)
1716                                         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));
1717                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
1718                         }
1719                 }
1720                                 
1721                 if(rtp_debug_test_addr(&rtp->them))
1722                         ast_verbose("Sent RTP packet to   %s:%d (type %d, seq %u, ts %u, len %u)\n",
1723                                 ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
1724         }
1725
1726         rtp->seqno++;
1727
1728         return 0;
1729 }
1730
1731 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1732 {
1733         struct ast_frame *f;
1734         int codec;
1735         int hdrlen = 12;
1736         int subclass;
1737         
1738
1739         /* If we have no peer, return immediately */    
1740         if (!rtp->them.sin_addr.s_addr)
1741                 return 0;
1742
1743         /* If there is no data length, return immediately */
1744         if (!_f->datalen) 
1745                 return 0;
1746         
1747         /* Make sure we have enough space for RTP header */
1748         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1749                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1750                 return -1;
1751         }
1752
1753         subclass = _f->subclass;
1754         if (_f->frametype == AST_FRAME_VIDEO)
1755                 subclass &= ~0x1;
1756
1757         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1758         if (codec < 0) {
1759                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1760                 return -1;
1761         }
1762
1763         if (rtp->lasttxformat != subclass) {
1764                 /* New format, reset the smoother */
1765                 if (option_debug)
1766                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1767                 rtp->lasttxformat = subclass;
1768                 if (rtp->smoother)
1769                         ast_smoother_free(rtp->smoother);
1770                 rtp->smoother = NULL;
1771         }
1772
1773
1774         switch(subclass) {
1775         case AST_FORMAT_SLINEAR:
1776                 if (!rtp->smoother) {
1777                         rtp->smoother = ast_smoother_new(320);
1778                 }
1779                 if (!rtp->smoother) {
1780                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1781                         return -1;
1782                 }
1783                 ast_smoother_feed_be(rtp->smoother, _f);
1784                 
1785                 while((f = ast_smoother_read(rtp->smoother)))
1786                         ast_rtp_raw_write(rtp, f, codec);
1787                 break;
1788         case AST_FORMAT_ULAW:
1789         case AST_FORMAT_ALAW:
1790                 if (!rtp->smoother) {
1791                         rtp->smoother = ast_smoother_new(160);
1792                 }
1793                 if (!rtp->smoother) {
1794                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1795                         return -1;
1796                 }
1797                 ast_smoother_feed(rtp->smoother, _f);
1798                 
1799                 while((f = ast_smoother_read(rtp->smoother)))
1800                         ast_rtp_raw_write(rtp, f, codec);
1801                 break;
1802         case AST_FORMAT_ADPCM:
1803         case AST_FORMAT_G726:
1804                 if (!rtp->smoother) {
1805                         rtp->smoother = ast_smoother_new(80);
1806                 }
1807                 if (!rtp->smoother) {
1808                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1809                         return -1;
1810                 }
1811                 ast_smoother_feed(rtp->smoother, _f);
1812                 
1813                 while((f = ast_smoother_read(rtp->smoother)))
1814                         ast_rtp_raw_write(rtp, f, codec);
1815                 break;
1816         case AST_FORMAT_G729A:
1817                 if (!rtp->smoother) {
1818                         rtp->smoother = ast_smoother_new(20);
1819                         if (rtp->smoother)
1820                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1821                 }
1822                 if (!rtp->smoother) {
1823                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1824                         return -1;
1825                 }
1826                 ast_smoother_feed(rtp->smoother, _f);
1827                 
1828                 while((f = ast_smoother_read(rtp->smoother)))
1829                         ast_rtp_raw_write(rtp, f, codec);
1830                 break;
1831         case AST_FORMAT_GSM:
1832                 if (!rtp->smoother) {
1833                         rtp->smoother = ast_smoother_new(33);
1834                 }
1835                 if (!rtp->smoother) {
1836                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1837                         return -1;
1838                 }
1839                 ast_smoother_feed(rtp->smoother, _f);
1840                 while((f = ast_smoother_read(rtp->smoother)))
1841                         ast_rtp_raw_write(rtp, f, codec);
1842                 break;
1843         case AST_FORMAT_ILBC:
1844                 if (!rtp->smoother) {
1845                         rtp->smoother = ast_smoother_new(50);
1846                 }
1847                 if (!rtp->smoother) {
1848                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1849                         return -1;
1850                 }
1851                 ast_smoother_feed(rtp->smoother, _f);
1852                 while((f = ast_smoother_read(rtp->smoother)))
1853                         ast_rtp_raw_write(rtp, f, codec);
1854                 break;
1855         default:        
1856                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1857                 /* fall through to... */
1858         case AST_FORMAT_H261:
1859         case AST_FORMAT_H263:
1860         case AST_FORMAT_H263_PLUS:
1861         case AST_FORMAT_H264:
1862         case AST_FORMAT_G723_1:
1863         case AST_FORMAT_LPC10:
1864         case AST_FORMAT_SPEEX:
1865                 /* Don't buffer outgoing frames; send them one-per-packet: */
1866                 if (_f->offset < hdrlen) {
1867                         f = ast_frdup(_f);
1868                 } else {
1869                         f = _f;
1870                 }
1871                 ast_rtp_raw_write(rtp, f, codec);
1872         }
1873                 
1874         return 0;
1875 }
1876
1877 /*! \brief Unregister interface to channel driver */
1878 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1879 {
1880         AST_LIST_LOCK(&protos);
1881         AST_LIST_REMOVE(&protos, proto, list);
1882         AST_LIST_UNLOCK(&protos);
1883 }
1884
1885 /*! \brief Register interface to channel driver */
1886 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1887 {
1888         struct ast_rtp_protocol *cur;
1889
1890         AST_LIST_LOCK(&protos);
1891         AST_LIST_TRAVERSE(&protos, cur, list) { 
1892                 if (!strcmp(cur->type, proto->type)) {
1893                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1894                         AST_LIST_UNLOCK(&protos);
1895                         return -1;
1896                 }
1897         }
1898         AST_LIST_INSERT_HEAD(&protos, proto, list);
1899         AST_LIST_UNLOCK(&protos);
1900         
1901         return 0;
1902 }
1903
1904 /*! \brief Bridge calls. If possible and allowed, initiate
1905         re-invite so the peers exchange media directly outside 
1906         of Asterisk. */
1907 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)
1908 {
1909         struct ast_frame *f;
1910         struct ast_channel *who, *other, *cs[3];
1911         struct ast_rtp *p0, *p1;                /* Audio RTP Channels */
1912         struct ast_rtp *vp0, *vp1;              /* Video RTP channels */
1913         struct ast_rtp_protocol *pr0, *pr1;
1914         struct sockaddr_in ac0, ac1;
1915         struct sockaddr_in vac0, vac1;
1916         struct sockaddr_in t0, t1;
1917         struct sockaddr_in vt0, vt1;
1918         char iabuf[INET_ADDRSTRLEN];
1919         
1920         void *pvt0, *pvt1;
1921         int codec0,codec1, oldcodec0, oldcodec1;
1922         
1923         memset(&vt0, 0, sizeof(vt0));
1924         memset(&vt1, 0, sizeof(vt1));
1925         memset(&vac0, 0, sizeof(vac0));
1926         memset(&vac1, 0, sizeof(vac1));
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
1970         if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
1971                 /* can't bridge, we are carrying DTMF for this channel and the bridge
1972                    needs it
1973                 */
1974                 ast_channel_unlock(c0);
1975                 ast_channel_unlock(c1);
1976                 return AST_BRIDGE_FAILED_NOWARN;
1977         }
1978
1979         if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
1980                 /* can't bridge, we are carrying DTMF for this channel and the bridge
1981                    needs it
1982                 */
1983                 ast_channel_unlock(c0);
1984                 ast_channel_unlock(c1);
1985                 return AST_BRIDGE_FAILED_NOWARN;
1986         }
1987
1988         /* Get codecs from both sides */
1989         codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
1990         codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
1991         if (pr0->get_codec && pr1->get_codec) {
1992                 /* Hey, we can't do reinvite if both parties speak different codecs */
1993                 if (!(codec0 & codec1)) {
1994                         if (option_debug)
1995                                 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
1996                         ast_channel_unlock(c0);
1997                         ast_channel_unlock(c1);
1998                         return AST_BRIDGE_FAILED_NOWARN;
1999                 }
2000         }
2001
2002         if (option_verbose > 2) 
2003                 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
2004
2005         /* Ok, we should be able to redirect the media. Start with one channel */
2006         if (pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE))) 
2007                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2008         else {
2009                 /* Store RTP peer */
2010                 ast_rtp_get_peer(p1, &ac1);
2011                 if (vp1)
2012                         ast_rtp_get_peer(vp1, &vac1);
2013         }
2014         /* Then test the other channel */
2015         if (pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
2016                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
2017         else {
2018                 /* Store RTP peer */
2019                 ast_rtp_get_peer(p0, &ac0);
2020                 if (vp0)
2021                         ast_rtp_get_peer(vp0, &vac0);
2022         }
2023         ast_channel_unlock(c0);
2024         ast_channel_unlock(c1);
2025         /* External RTP Bridge up, now loop and see if something happes that force us to take the
2026                 media back to Asterisk */
2027         cs[0] = c0;
2028         cs[1] = c1;
2029         cs[2] = NULL;
2030         oldcodec0 = codec0;
2031         oldcodec1 = codec1;
2032         for (;;) {
2033                 /* Check if something changed... */
2034                 if ((c0->tech_pvt != pvt0)  ||
2035                         (c1->tech_pvt != pvt1) ||
2036                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2037                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2038                                 if (c0->tech_pvt == pvt0) {
2039                                         if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0)) 
2040                                                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2041                                 }
2042                                 if (c1->tech_pvt == pvt1) {
2043                                         if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0)) 
2044                                                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2045                                 }
2046                                 return AST_BRIDGE_RETRY;
2047                 }
2048                 /* Now check if they have changed address */
2049                 ast_rtp_get_peer(p1, &t1);
2050                 ast_rtp_get_peer(p0, &t0);
2051                 if (pr0->get_codec)
2052                         codec0 = pr0->get_codec(c0);
2053                 if (pr1->get_codec)
2054                         codec1 = pr1->get_codec(c1);
2055                 if (vp1)
2056                         ast_rtp_get_peer(vp1, &vt1);
2057                 if (vp0)
2058                         ast_rtp_get_peer(vp0, &vt0);
2059                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
2060                         if (option_debug > 1) {
2061                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
2062                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t1.sin_addr), ntohs(t1.sin_port), codec1);
2063                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n", 
2064                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2065                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
2066                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2067                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
2068                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2069                         }
2070                         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))) 
2071                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2072                         memcpy(&ac1, &t1, sizeof(ac1));
2073                         memcpy(&vac1, &vt1, sizeof(vac1));
2074                         oldcodec1 = codec1;
2075                 }
2076                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
2077                         if (option_debug) {
2078                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
2079                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t0.sin_addr), ntohs(t0.sin_port), codec0);
2080                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
2081                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2082                         }
2083                         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)))
2084                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2085                         memcpy(&ac0, &t0, sizeof(ac0));
2086                         memcpy(&vac0, &vt0, sizeof(vac0));
2087                         oldcodec0 = codec0;
2088                 }
2089                 who = ast_waitfor_n(cs, 2, &timeoutms);
2090                 if (!who) {
2091                         if (!timeoutms) 
2092                                 return AST_BRIDGE_RETRY;
2093                         if (option_debug)
2094                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2095                         /* check for hangup / whentohangup */
2096                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2097                                 break;
2098                         continue;
2099                 }
2100                 f = ast_read(who);
2101                 other = (who == c0) ? c1 : c0; /* the other channel */
2102                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
2103                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
2104                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2105                         /* breaking out of the bridge. */
2106                         *fo = f;
2107                         *rc = who;
2108                         if (option_debug)
2109                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
2110                         if ((c0->tech_pvt == pvt0)) {
2111                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0)) 
2112                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2113                         }
2114                         if ((c1->tech_pvt == pvt1)) {
2115                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0)) 
2116                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2117                         }
2118                         return AST_BRIDGE_COMPLETE;
2119                 } else if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2120                         if ((f->subclass == AST_CONTROL_HOLD) || (f->subclass == AST_CONTROL_UNHOLD) ||
2121                             (f->subclass == AST_CONTROL_VIDUPDATE)) {
2122                                 ast_indicate(other, f->subclass);
2123                                 ast_frfree(f);
2124                         } else {
2125                                 *fo = f;
2126                                 *rc = who;
2127                                 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
2128                                 return AST_BRIDGE_COMPLETE;
2129                         }
2130                 } else {
2131                         if ((f->frametype == AST_FRAME_DTMF) || 
2132                                 (f->frametype == AST_FRAME_VOICE) || 
2133                                 (f->frametype == AST_FRAME_VIDEO)) {
2134                                 /* Forward voice or DTMF frames if they happen upon us */
2135                                 ast_write(other, f);
2136                         }
2137                         ast_frfree(f);
2138                 }
2139                 /* Swap priority not that it's a big deal at this point */
2140                 cs[2] = cs[0];
2141                 cs[0] = cs[1];
2142                 cs[1] = cs[2];
2143                 
2144         }
2145         return AST_BRIDGE_FAILED;
2146 }
2147
2148 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
2149 {
2150         struct hostent *hp;
2151         struct ast_hostent ahp;
2152         char iabuf[INET_ADDRSTRLEN];
2153         int port = 0;
2154         char *p, *arg;
2155
2156         if (argc != 4)
2157                 return RESULT_SHOWUSAGE;
2158         arg = argv[3];
2159         p = strstr(arg, ":");
2160         if (p) {
2161                 *p = '\0';
2162                 p++;
2163                 port = atoi(p);
2164         }
2165         hp = ast_gethostbyname(arg, &ahp);
2166         if (hp == NULL)
2167                 return RESULT_SHOWUSAGE;
2168         rtpdebugaddr.sin_family = AF_INET;
2169         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
2170         rtpdebugaddr.sin_port = htons(port);
2171         if (port == 0)
2172                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr));
2173         else
2174                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr), port);
2175         rtpdebug = 1;
2176         return RESULT_SUCCESS;
2177 }
2178
2179 static int rtp_do_debug(int fd, int argc, char *argv[])
2180 {
2181         if(argc != 2) {
2182                 if(argc != 4)
2183                         return RESULT_SHOWUSAGE;
2184                 return rtp_do_debug_ip(fd, argc, argv);
2185         }
2186         rtpdebug = 1;
2187         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
2188         ast_cli(fd, "RTP Debugging Enabled\n");
2189         return RESULT_SUCCESS;
2190 }
2191    
2192 static int rtp_no_debug(int fd, int argc, char *argv[])
2193 {
2194         if(argc !=3)
2195                 return RESULT_SHOWUSAGE;
2196         rtpdebug = 0;
2197         ast_cli(fd,"RTP Debugging Disabled\n");
2198         return RESULT_SUCCESS;
2199 }
2200
2201 static int stun_do_debug(int fd, int argc, char *argv[])
2202 {
2203         if(argc != 2) {
2204                 return RESULT_SHOWUSAGE;
2205         }
2206         stundebug = 1;
2207         ast_cli(fd, "STUN Debugging Enabled\n");
2208         return RESULT_SUCCESS;
2209 }
2210    
2211 static int stun_no_debug(int fd, int argc, char *argv[])
2212 {
2213         if(argc !=3)
2214                 return RESULT_SHOWUSAGE;
2215         stundebug = 0;
2216         ast_cli(fd,"STUN Debugging Disabled\n");
2217         return RESULT_SUCCESS;
2218 }
2219
2220
2221 static char debug_usage[] =
2222   "Usage: rtp debug [ip host[:port]]\n"
2223   "       Enable dumping of all RTP packets to and from host.\n";
2224
2225 static char no_debug_usage[] =
2226   "Usage: rtp no debug\n"
2227   "       Disable all RTP debugging\n";
2228
2229 static char stun_debug_usage[] =
2230   "Usage: stun debug\n"
2231   "       Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
2232
2233 static char stun_no_debug_usage[] =
2234   "Usage: stun no debug\n"
2235   "       Disable STUN debugging\n";
2236
2237
2238 static struct ast_cli_entry  cli_debug_ip =
2239 {{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage };
2240
2241 static struct ast_cli_entry  cli_debug =
2242 {{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage };
2243
2244 static struct ast_cli_entry  cli_no_debug =
2245 {{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage };
2246
2247 static struct ast_cli_entry  cli_stun_debug =
2248 {{ "stun", "debug", NULL } , stun_do_debug, "Enable STUN debugging", stun_debug_usage };
2249
2250 static struct ast_cli_entry  cli_stun_no_debug =
2251 {{ "stun", "no", "debug", NULL } , stun_no_debug, "Disable STUN debugging", stun_no_debug_usage };
2252
2253 int ast_rtp_reload(void)
2254 {
2255         struct ast_config *cfg;
2256         char *s;
2257
2258         rtpstart = 5000;
2259         rtpend = 31000;
2260         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2261         cfg = ast_config_load("rtp.conf");
2262         if (cfg) {
2263                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
2264                         rtpstart = atoi(s);
2265                         if (rtpstart < 1024)
2266                                 rtpstart = 1024;
2267                         if (rtpstart > 65535)
2268                                 rtpstart = 65535;
2269                 }
2270                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
2271                         rtpend = atoi(s);
2272                         if (rtpend < 1024)
2273                                 rtpend = 1024;
2274                         if (rtpend > 65535)
2275                                 rtpend = 65535;
2276                 }
2277                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
2278 #ifdef SO_NO_CHECK
2279                         if (ast_false(s))
2280                                 nochecksums = 1;
2281                         else
2282                                 nochecksums = 0;
2283 #else
2284                         if (ast_false(s))
2285                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
2286 #endif
2287                 }
2288                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
2289                         dtmftimeout = atoi(s);
2290                         if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
2291                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
2292                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
2293                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2294                         };
2295                 }
2296                 ast_config_destroy(cfg);
2297         }
2298         if (rtpstart >= rtpend) {
2299                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
2300                 rtpstart = 5000;
2301                 rtpend = 31000;
2302         }
2303         if (option_verbose > 1)
2304                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
2305         return 0;
2306 }
2307
2308 /*! \brief Initialize the RTP system in Asterisk */
2309 void ast_rtp_init(void)
2310 {
2311         ast_cli_register(&cli_debug);
2312         ast_cli_register(&cli_debug_ip);
2313         ast_cli_register(&cli_no_debug);
2314         ast_cli_register(&cli_stun_debug);
2315         ast_cli_register(&cli_stun_no_debug);
2316         ast_rtp_reload();
2317 }