?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
officially deprecate the 'roundrobin' queue strategy in favor of 'rrmemory'
[asterisk-bristuff.git] / rtp.c
blobbfb2262038c09df6d221a27b8f1b72ab7163e05c
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 int x;
700 char iabuf[INET_ADDRSTRLEN];
701 unsigned int ssrc;
702 unsigned int timestamp;
703 unsigned int *rtpheader;
704 struct rtpPayloadType rtpPT;
705
706 len = sizeof(sin);
707
708 /* Cache where the header will go */
709 res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
710 0, (struct sockaddr *)&sin, &len);
711
712 rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
713 if (res < 0) {
714 if (errno != EAGAIN)
715 ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
716 if (errno == EBADF)
717 CRASH;
718 return &ast_null_frame;
719 }
720 if (res < hdrlen) {
721 ast_log(LOG_WARNING, "RTP Read too short\n");
722 return &ast_null_frame;
723 }
724
725 /* Get fields */
726 seqno = ntohl(rtpheader[0]);
727
728 /* Check RTP version */
729 version = (seqno & 0xC0000000) >> 30;
730 if (!version) {
731 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) &&
732 (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
733 memcpy(&rtp->them, &sin, sizeof(rtp->them));
734 }
735 return &ast_null_frame;
736 }
737
738 if (version != 2)
739 return &ast_null_frame;
740 /* Ignore if the other side hasn't been given an address
741 yet. */
742 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
743 return &ast_null_frame;
744
745 if (rtp->nat) {
746 /* Send to whoever sent to us */
747 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
748 (rtp->them.sin_port != sin.sin_port)) {
749 rtp->them = sin;
750 rtp->rxseqno = 0;
751 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
752 if (option_debug || rtpdebug)
753 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));
754 }
755 }
756
757 payloadtype = (seqno & 0x7f0000) >> 16;
758 padding = seqno & (1 << 29);
759 mark = seqno & (1 << 23);
760 ext = seqno & (1 << 28);
761 seqno &= 0xffff;
762 timestamp = ntohl(rtpheader[1]);
763 ssrc = ntohl(rtpheader[2]);
764
765 if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
766 ast_log(LOG_WARNING, "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 %d, seq %d, ts %d, len %d)\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 if (rtp->rxseqno) {
839 for (x=rtp->rxseqno + 1; x < seqno; x++) {
840 /* Queue empty frames */
841 rtp->f.mallocd = 0;
842 rtp->f.datalen = 0;
843 rtp->f.data = NULL;
844 rtp->f.offset = 0;
845 rtp->f.samples = 0;
846 rtp->f.src = "RTPMissedFrame";
847 }
848 }
849 rtp->rxseqno = seqno;
850
851 if (rtp->dtmfcount) {
852 #if 0
853 printf("dtmfcount was %d\n", rtp->dtmfcount);
854 #endif
855 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
856 if (rtp->dtmfcount < 0)
857 rtp->dtmfcount = 0;
858 #if 0
859 if (dtmftimeout != rtp->dtmfcount)
860 printf("dtmfcount is %d\n", rtp->dtmfcount);
861 #endif
862 }
863 rtp->lastrxts = timestamp;
864
865 /* Send any pending DTMF */
866 if (rtp->resp && !rtp->dtmfcount) {
867 if (option_debug)
868 ast_log(LOG_DEBUG, "Sending pending DTMF\n");
869 return send_dtmf(rtp);
870 }
871 rtp->f.mallocd = 0;
872 rtp->f.datalen = res - hdrlen;
873 rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
874 rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
875 if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
876 rtp->f.samples = ast_codec_get_samples(&rtp->f);
877 if (rtp->f.subclass == AST_FORMAT_SLINEAR)
878 ast_frame_byteswap_be(&rtp->f);
879 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
880 } else {
881 /* Video -- samples is # of samples vs. 90000 */
882 if (!rtp->lastividtimestamp)
883 rtp->lastividtimestamp = timestamp;
884 rtp->f.samples = timestamp - rtp->lastividtimestamp;
885 rtp->lastividtimestamp = timestamp;
886 rtp->f.delivery.tv_sec = 0;
887 rtp->f.delivery.tv_usec = 0;
888 if (mark)
889 rtp->f.subclass |= 0x1;
890
891 }
892 rtp->f.src = "RTP";
893 return &rtp->f;
894 }
895
896 /* The following array defines the MIME Media type (and subtype) for each
897 of our codecs, or RTP-specific data type. */
898 static struct {
899 struct rtpPayloadType payloadType;
900 char* type;
901 char* subtype;
902 } mimeTypes[] = {
903 {{1, AST_FORMAT_G723_1}, "audio", "G723"},
904 {{1, AST_FORMAT_GSM}, "audio", "GSM"},
905 {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
906 {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
907 {{1, AST_FORMAT_G726}, "audio", "G726-32"},
908 {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
909 {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
910 {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
911 {{1, AST_FORMAT_G729A}, "audio", "G729"},
912 {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
913 {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
914 {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
915 {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
916 {{0, AST_RTP_CN}, "audio", "CN"},
917 {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
918 {{1, AST_FORMAT_PNG}, "video", "PNG"},
919 {{1, AST_FORMAT_H261}, "video", "H261"},
920 {{1, AST_FORMAT_H263}, "video", "H263"},
921 {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
922 {{1, AST_FORMAT_H264}, "video", "H264"},
923 };
924
925 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
926 also, our own choices for dynamic payload types. This is our master
927 table for transmission */
928 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
929 [0] = {1, AST_FORMAT_ULAW},
930 #ifdef USE_DEPRECATED_G726
931 [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
932 #endif
933 [3] = {1, AST_FORMAT_GSM},
934 [4] = {1, AST_FORMAT_G723_1},
935 [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
936 [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
937 [7] = {1, AST_FORMAT_LPC10},
938 [8] = {1, AST_FORMAT_ALAW},
939 [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
940 [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
941 [13] = {0, AST_RTP_CN},
942 [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
943 [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
944 [18] = {1, AST_FORMAT_G729A},
945 [19] = {0, AST_RTP_CN}, /* Also used for CN */
946 [26] = {1, AST_FORMAT_JPEG},
947 [31] = {1, AST_FORMAT_H261},
948 [34] = {1, AST_FORMAT_H263},
949 [103] = {1, AST_FORMAT_H263_PLUS},
950 [97] = {1, AST_FORMAT_ILBC},
951 [99] = {1, AST_FORMAT_H264},
952 [101] = {0, AST_RTP_DTMF},
953 [110] = {1, AST_FORMAT_SPEEX},
954 [111] = {1, AST_FORMAT_G726},
955 [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
956 };
957
958 void ast_rtp_pt_clear(struct ast_rtp* rtp)
959 {
960 int i;
961 if (!rtp)
962 return;
963
964 for (i = 0; i < MAX_RTP_PT; ++i) {
965 rtp->current_RTP_PT[i].isAstFormat = 0;
966 rtp->current_RTP_PT[i].code = 0;
967 }
968
969 rtp->rtp_lookup_code_cache_isAstFormat = 0;
970 rtp->rtp_lookup_code_cache_code = 0;
971 rtp->rtp_lookup_code_cache_result = 0;
972 }
973
974 void ast_rtp_pt_default(struct ast_rtp* rtp)
975 {
976 int i;
977
978 /* Initialize to default payload types */
979 for (i = 0; i < MAX_RTP_PT; ++i) {
980 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
981 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
982 }
983
984 rtp->rtp_lookup_code_cache_isAstFormat = 0;
985 rtp->rtp_lookup_code_cache_code = 0;
986 rtp->rtp_lookup_code_cache_result = 0;
987 }
988
989 static void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
990 {
991 int i;
992 /* Copy payload types from source to destination */
993 for (i=0; i < MAX_RTP_PT; ++i) {
994 dest->current_RTP_PT[i].isAstFormat =
995 src->current_RTP_PT[i].isAstFormat;
996 dest->current_RTP_PT[i].code =
997 src->current_RTP_PT[i].code;
998 }
999 dest->rtp_lookup_code_cache_isAstFormat = 0;
1000 dest->rtp_lookup_code_cache_code = 0;
1001 dest->rtp_lookup_code_cache_result = 0;
1002 }
1003
1004 /*! \brief Get channel driver interface structure */
1005 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1006 {
1007 struct ast_rtp_protocol *cur = NULL;
1008
1009 AST_LIST_LOCK(&protos);
1010 AST_LIST_TRAVERSE(&protos, cur, list) {
1011 if (cur->type == chan->tech->type)
1012 break;
1013 }
1014 AST_LIST_UNLOCK(&protos);
1015
1016 return cur;
1017 }
1018
1019 int ast_rtp_early_media(struct ast_channel *dest, struct ast_channel *src)
1020 {
1021 struct ast_rtp *destp, *srcp=NULL; /* Audio RTP Channels */
1022 struct ast_rtp *vdestp, *vsrcp=NULL; /* Video RTP channels */
1023 struct ast_rtp_protocol *destpr, *srcpr=NULL;
1024 int srccodec;
1025 /* Lock channels */
1026 ast_channel_lock(dest);
1027 if (src) {
1028 while(ast_channel_trylock(src)) {
1029 ast_channel_unlock(dest);
1030 usleep(1);
1031 ast_channel_lock(dest);
1032 }
1033 }
1034
1035 /* Find channel driver interfaces */
1036 destpr = get_proto(dest);
1037 if (src)
1038 srcpr = get_proto(src);
1039 if (!destpr) {
1040 if (option_debug)
1041 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1042 ast_channel_unlock(dest);
1043 if (src)
1044 ast_channel_unlock(src);
1045 return 0;
1046 }
1047 if (!srcpr) {
1048 if (option_debug)
1049 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src ? src->name : "<unspecified>");
1050 ast_channel_unlock(dest);
1051 if (src)
1052 ast_channel_unlock(src);
1053 return 0;
1054 }
1055
1056 /* Get audio and video interface (if native bridge is possible) */
1057 destp = destpr->get_rtp_info(dest);
1058 vdestp = (destpr->get_vrtp_info) ? destpr->get_vrtp_info(dest) : NULL;
1059 if (srcpr) {
1060 srcp = srcpr->get_rtp_info(src);
1061 vsrcp = (srcpr->get_vrtp_info) ? srcpr->get_vrtp_info(src) : NULL;
1062 }
1063
1064 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1065 if (!destp) {
1066 /* Somebody doesn't want to play... */
1067 ast_channel_unlock(dest);
1068 if (src)
1069 ast_channel_unlock(src);
1070 return 0;
1071 }
1072 if (srcpr && srcpr->get_codec)
1073 srccodec = srcpr->get_codec(src);
1074 else
1075 srccodec = 0;
1076 /* Consider empty media as non-existant */
1077 if (srcp && !srcp->them.sin_addr.s_addr)
1078 srcp = NULL;
1079 /* Bridge early media */
1080 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, srcp ? ast_test_flag(srcp, FLAG_NAT_ACTIVE) : 0))
1081 ast_log(LOG_WARNING, "Channel '%s' failed to send early media to '%s'\n", dest->name, src ? src->name : "<unspecified>");
1082 ast_channel_unlock(dest);
1083 if (src)
1084 ast_channel_unlock(src);
1085 if (option_debug)
1086 ast_log(LOG_DEBUG, "Setting early media SDP of '%s' with that of '%s'\n", dest->name, src ? src->name : "<unspecified>");
1087 return 1;
1088 }
1089
1090 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1091 {
1092 struct ast_rtp *destp, *srcp; /* Audio RTP Channels */
1093 struct ast_rtp *vdestp, *vsrcp; /* Video RTP channels */
1094 struct ast_rtp_protocol *destpr, *srcpr;
1095 int srccodec;
1096 /* Lock channels */
1097 ast_channel_lock(dest);
1098 while(ast_channel_trylock(src)) {
1099 ast_channel_unlock(dest);
1100 usleep(1);
1101 ast_channel_lock(dest);
1102 }
1103
1104 /* Find channel driver interfaces */
1105 destpr = get_proto(dest);
1106 srcpr = get_proto(src);
1107 if (!destpr) {
1108 if (option_debug)
1109 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1110 ast_channel_unlock(dest);
1111 ast_channel_unlock(src);
1112 return 0;
1113 }
1114 if (!srcpr) {
1115 if (option_debug)
1116 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1117 ast_channel_unlock(dest);
1118 ast_channel_unlock(src);
1119 return 0;
1120 }
1121
1122 /* Get audio and video interface (if native bridge is possible) */
1123 destp = destpr->get_rtp_info(dest);
1124 vdestp = (destpr->get_vrtp_info) ? destpr->get_vrtp_info(dest) : NULL;
1125 srcp = srcpr->get_rtp_info(src);
1126 vsrcp = (srcpr->get_vrtp_info) ? srcpr->get_vrtp_info(src) : NULL;
1127
1128 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1129 if (!destp || !srcp) {
1130 /* Somebody doesn't want to play... */
1131 ast_channel_unlock(dest);
1132 ast_channel_unlock(src);
1133 return 0;
1134 }
1135 ast_rtp_pt_copy(destp, srcp);
1136 if (vdestp && vsrcp)
1137 ast_rtp_pt_copy(vdestp, vsrcp);
1138 if (srcpr->get_codec)
1139 srccodec = srcpr->get_codec(src);
1140 else
1141 srccodec = 0;
1142 if (media) {
1143 /* Bridge early media */
1144 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1145 ast_log(LOG_WARNING, "Channel '%s' failed to send early media to '%s'\n", dest->name, src->name);
1146 }
1147 ast_channel_unlock(dest);
1148 ast_channel_unlock(src);
1149 if (option_debug)
1150 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1151 return 1;
1152 }
1153
1154 /*! \brief Make a note of a RTP paymoad type that was seen in a SDP "m=" line.
1155 * By default, use the well-known value for this type (although it may
1156 * still be set to a different value by a subsequent "a=rtpmap:" line)
1157 */
1158 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt)
1159 {
1160 if (pt < 0 || pt > MAX_RTP_PT)
1161 return; /* bogus payload type */
1162
1163 if (static_RTP_PT[pt].code != 0) {
1164 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1165 }
1166 }
1167
1168 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1169 a SDP "a=rtpmap:" line. */
1170 void ast_rtp_set_rtpmap_type(struct ast_rtp* rtp, int pt,
1171 char* mimeType, char* mimeSubtype)
1172 {
1173 int i;
1174
1175 if (pt < 0 || pt > MAX_RTP_PT)
1176 return; /* bogus payload type */
1177
1178 for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
1179 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1180 strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1181 rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1182 return;
1183 }
1184 }
1185 }
1186
1187 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls
1188 * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1189 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1190 int* astFormats, int* nonAstFormats) {
1191 int pt;
1192
1193 *astFormats = *nonAstFormats = 0;
1194 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1195 if (rtp->current_RTP_PT[pt].isAstFormat) {
1196 *astFormats |= rtp->current_RTP_PT[pt].code;
1197 } else {
1198 *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1199 }
1200 }
1201 }
1202
1203 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt)
1204 {
1205 struct rtpPayloadType result;
1206
1207 result.isAstFormat = result.code = 0;
1208 if (pt < 0 || pt > MAX_RTP_PT)
1209 return result; /* bogus payload type */
1210
1211 /* Start with the negotiated codecs */
1212 result = rtp->current_RTP_PT[pt];
1213
1214 /* If it doesn't exist, check our static RTP type list, just in case */
1215 if (!result.code)
1216 result = static_RTP_PT[pt];
1217 return result;
1218 }
1219
1220 /*! \brief Looks up an RTP code out of our *static* outbound list */
1221 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code) {
1222
1223 int pt;
1224
1225 if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1226 code == rtp->rtp_lookup_code_cache_code) {
1227
1228 /* Use our cached mapping, to avoid the overhead of the loop below */
1229 return rtp->rtp_lookup_code_cache_result;
1230 }
1231
1232 /* Check the dynamic list first */
1233 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1234 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1235 rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1236 rtp->rtp_lookup_code_cache_code = code;
1237 rtp->rtp_lookup_code_cache_result = pt;
1238 return pt;
1239 }
1240 }
1241
1242 /* Then the static list */
1243 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1244 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1245 rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1246 rtp->rtp_lookup_code_cache_code = code;
1247 rtp->rtp_lookup_code_cache_result = pt;
1248 return pt;
1249 }
1250 }
1251 return -1;
1252 }
1253
1254 char* ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code)
1255 {
1256
1257 int i;
1258
1259 for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
1260 if (mimeTypes[i].payloadType.code == code && mimeTypes[i].payloadType.isAstFormat == isAstFormat)
1261 return mimeTypes[i].subtype;
1262 }
1263 return "";
1264 }
1265
1266 char *ast_rtp_lookup_mime_multiple(char *buf, int size, const int capability, const int isAstFormat)
1267 {
1268 int format;
1269 unsigned len;
1270 char *end = buf;
1271 char *start = buf;
1272
1273 if (!buf || !size)
1274 return NULL;
1275
1276 snprintf(end, size, "0x%x (", capability);
1277
1278 len = strlen(end);
1279 end += len;
1280 size -= len;
1281 start = end;
1282
1283 for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1284 if (capability & format) {
1285 const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format);
1286 snprintf(end, size, "%s|", name);
1287 len = strlen(end);
1288 end += len;
1289 size -= len;
1290 }
1291 }
1292
1293 if (start == end)
1294 snprintf(start, size, "nothing)");
1295 else if (size > 1)
1296 *(end -1) = ')';
1297
1298 return buf;
1299 }
1300
1301 static int rtp_socket(void)
1302 {
1303 int s;
1304 long flags;
1305 s = socket(AF_INET, SOCK_DGRAM, 0);
1306 if (s > -1) {
1307 flags = fcntl(s, F_GETFL);
1308 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1309 #ifdef SO_NO_CHECK
1310 if (nochecksums)
1311 setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1312 #endif
1313 }
1314 return s;
1315 }
1316
1317 /*!
1318 * \brief Initialize a new RTCP session.
1319 *
1320 * \returns The newly initialized RTCP session.
1321 */
1322 static struct ast_rtcp *ast_rtcp_new(void)
1323 {
1324 struct ast_rtcp *rtcp;
1325
1326 if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1327 return NULL;
1328 rtcp->s = rtp_socket();
1329 rtcp->us.sin_family = AF_INET;
1330 if (rtcp->s < 0) {
1331 free(rtcp);
1332 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
1333 return NULL;
1334 }
1335
1336 return rtcp;
1337 }
1338
1339 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1340 {
1341 struct ast_rtp *rtp;
1342 int x;
1343 int first;
1344 int startplace;
1345
1346 if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1347 return NULL;
1348 rtp->them.sin_family = AF_INET;
1349 rtp->us.sin_family = AF_INET;
1350 rtp->s = rtp_socket();
1351 rtp->ssrc = ast_random();
1352 rtp->seqno = ast_random() & 0xffff;
1353 ast_set_flag(rtp, FLAG_HAS_DTMF);
1354 if (rtp->s < 0) {
1355 free(rtp);
1356 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1357 return NULL;
1358 }
1359 if (sched && rtcpenable) {
1360 rtp->sched = sched;
1361 rtp->rtcp = ast_rtcp_new();
1362 }
1363
1364 /* Select a random port number in the range of possible RTP */
1365 x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1366 x = x & ~1;
1367 /* Save it for future references. */
1368 startplace = x;
1369 /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1370 for (;;) {
1371 /* Must be an even port number by RTP spec */
1372 rtp->us.sin_port = htons(x);
1373 rtp->us.sin_addr = addr;
1374 /* If there's rtcp, initialize it as well. */
1375 if (rtp->rtcp)
1376 rtp->rtcp->us.sin_port = htons(x + 1);
1377 /* Try to bind it/them. */
1378 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1379 (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1380 break;
1381 if (!first) {
1382 /* Primary bind succeeded! Gotta recreate it */
1383 close(rtp->s);
1384 rtp->s = rtp_socket();
1385 }
1386 if (errno != EADDRINUSE) {
1387 /* We got an error that wasn't expected, abort! */
1388 ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1389 close(rtp->s);
1390 if (rtp->rtcp) {
1391 close(rtp->rtcp->s);
1392 free(rtp->rtcp);
1393 }
1394 free(rtp);
1395 return NULL;
1396 }
1397 /* The port was used, increment it (by two). */
1398 x += 2;
1399 /* Did we go over the limit ? */
1400 if (x > rtpend)
1401 /* then, start from the begingig. */
1402 x = (rtpstart + 1) & ~1;
1403 /* Check if we reached the place were we started. */
1404 if (x == startplace) {
1405 /* If so, there's no ports available. */
1406 ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1407 close(rtp->s);
1408 if (rtp->rtcp) {
1409 close(rtp->rtcp->s);
1410 free(rtp->rtcp);
1411 }
1412 free(rtp);
1413 return NULL;
1414 }
1415 }
1416 if (io && sched && callbackmode) {
1417 /* Operate this one in a callback mode */
1418 rtp->sched = sched;
1419 rtp->io = io;
1420 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1421 }
1422 ast_rtp_pt_default(rtp);
1423 return rtp;
1424 }
1425
1426 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1427 {
1428 struct in_addr ia;
1429
1430 memset(&ia, 0, sizeof(ia));
1431 return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1432 }
1433
1434 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1435 {
1436 int res;
1437
1438 if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos))))
1439 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1440 return res;
1441 }
1442
1443 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1444 {
1445 rtp->them.sin_port = them->sin_port;
1446 rtp->them.sin_addr = them->sin_addr;
1447 if (rtp->rtcp) {
1448 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1449 rtp->rtcp->them.sin_addr = them->sin_addr;
1450 }
1451 rtp->rxseqno = 0;
1452 }
1453
1454 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1455 {
1456 if ((them->sin_family != AF_INET) ||
1457 (them->sin_port != rtp->them.sin_port) ||
1458 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
1459 them->sin_family = AF_INET;
1460 them->sin_port = rtp->them.sin_port;
1461 them->sin_addr = rtp->them.sin_addr;
1462 return 1;
1463 }
1464 return 0;
1465 }
1466
1467 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
1468 {
1469 *us = rtp->us;
1470 }
1471
1472 void ast_rtp_stop(struct ast_rtp *rtp)
1473 {
1474 memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1475 memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1476 if (rtp->rtcp) {
1477 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1478 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1479 }
1480 }
1481
1482 void ast_rtp_reset(struct ast_rtp *rtp)
1483 {
1484 memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1485 memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1486 memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1487 rtp->lastts = 0;
1488 rtp->lastdigitts = 0;
1489 rtp->lastrxts = 0;
1490 rtp->lastividtimestamp = 0;
1491 rtp->lastovidtimestamp = 0;
1492 rtp->lasteventseqn = 0;
1493 rtp->lasteventendseqn = 0;
1494 rtp->lasttxformat = 0;
1495 rtp->lastrxformat = 0;
1496 rtp->dtmfcount = 0;
1497 rtp->dtmfduration = 0;
1498 rtp->seqno = 0;
1499 rtp->rxseqno = 0;
1500 }
1501
1502 void ast_rtp_destroy(struct ast_rtp *rtp)
1503 {
1504 if (rtp->smoother)
1505 ast_smoother_free(rtp->smoother);
1506 if (rtp->ioid)
1507 ast_io_remove(rtp->io, rtp->ioid);
1508 if (rtp->s > -1)
1509 close(rtp->s);
1510 if (rtp->rtcp) {
1511 close(rtp->rtcp->s);
1512 free(rtp->rtcp);
1513 }
1514 free(rtp);
1515 }
1516
1517 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
1518 {
1519 struct timeval t;
1520 long ms;
1521 if (ast_tvzero(rtp->txcore)) {
1522 rtp->txcore = ast_tvnow();
1523 /* Round to 20ms for nice, pretty timestamps */
1524 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
1525 }
1526 /* Use previous txcore if available */
1527 t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
1528 ms = ast_tvdiff_ms(t, rtp->txcore);
1529 if (ms < 0)
1530 ms = 0;
1531 /* Use what we just got for next time */
1532 rtp->txcore = t;
1533 return (unsigned int) ms;
1534 }
1535
1536 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
1537 {
1538 unsigned int *rtpheader;
1539 int hdrlen = 12;
1540 int res;
1541 int x;
1542 int payload;
1543 char data[256];
1544 char iabuf[INET_ADDRSTRLEN];
1545
1546 if ((digit <= '9') && (digit >= '0'))
1547 digit -= '0';
1548 else if (digit == '*')
1549 digit = 10;
1550 else if (digit == '#')
1551 digit = 11;
1552 else if ((digit >= 'A') && (digit <= 'D'))
1553 digit = digit - 'A' + 12;
1554 else if ((digit >= 'a') && (digit <= 'd'))
1555 digit = digit - 'a' + 12;
1556 else {
1557 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1558 return -1;
1559 }
1560 payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
1561
1562 /* If we have no peer, return immediately */
1563 if (!rtp->them.sin_addr.s_addr)
1564 return 0;
1565
1566 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1567
1568 /* Get a pointer to the header */
1569 rtpheader = (unsigned int *)data;
1570 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
1571 rtpheader[1] = htonl(rtp->lastdigitts);
1572 rtpheader[2] = htonl(rtp->ssrc);
1573 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
1574 for (x = 0; x < 6; x++) {
1575 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1576 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
1577 if (res < 0)
1578 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
1579 ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
1580 ntohs(rtp->them.sin_port), strerror(errno));
1581 if (rtp_debug_test_addr(&rtp->them))
1582 ast_verbose("Sent RTP packet to %s:%d (type %d, seq %u, ts %u, len %u)\n",
1583 ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
1584 ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1585 }
1586 /* Sequence number of last two end packets does not get incremented */
1587 if (x < 3)
1588 rtp->seqno++;
1589 /* Clear marker bit and set seqno */
1590 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
1591 /* For the last three packets, set the duration and the end bit */
1592 if (x == 2) {
1593 #if 0
1594 /* No, this is wrong... Do not increment lastdigitts, that's not according
1595 to the RFC, as best we can determine */
1596 rtp->lastdigitts++; /* or else the SPA3000 will click instead of beeping... */
1597 rtpheader[1] = htonl(rtp->lastdigitts);
1598 #endif
1599 /* Make duration 800 (100ms) */
1600 rtpheader[3] |= htonl((800));
1601 /* Set the End bit */
1602 rtpheader[3] |= htonl((1 << 23));
1603 }
1604 }
1605 /* Increment the digit timestamp by 120ms, to ensure that digits
1606 sent sequentially with no intervening non-digit packets do not
1607 get sent with the same timestamp, and that sequential digits
1608 have some 'dead air' in between them
1609 */
1610 rtp->lastdigitts += 960;
1611 /* Increment the sequence number to reflect the last packet
1612 that was sent
1613 */
1614 rtp->seqno++;
1615 return 0;
1616 }
1617
1618 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
1619 {
1620 unsigned int *rtpheader;
1621 int hdrlen = 12;
1622 int res;
1623 int payload;
1624 char data[256];
1625 char iabuf[INET_ADDRSTRLEN];
1626 level = 127 - (level & 0x7f);
1627 payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
1628
1629 /* If we have no peer, return immediately */
1630 if (!rtp->them.sin_addr.s_addr)
1631 return 0;
1632
1633 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1634
1635 /* Get a pointer to the header */
1636 rtpheader = (unsigned int *)data;
1637 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1638 rtpheader[1] = htonl(rtp->lastts);
1639 rtpheader[2] = htonl(rtp->ssrc);
1640 data[12] = level;
1641 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1642 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1643 if (res <0)
1644 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));
1645 if(rtp_debug_test_addr(&rtp->them))
1646 ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1647 , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);
1648
1649 }
1650 return 0;
1651 }
1652
1653 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
1654 {
1655 unsigned char *rtpheader;
1656 char iabuf[INET_ADDRSTRLEN];
1657 int hdrlen = 12;
1658 int res;
1659 unsigned int ms;
1660 int pred;
1661 int mark = 0;
1662
1663 ms = calc_txstamp(rtp, &f->delivery);
1664 /* Default prediction */
1665 if (f->subclass < AST_FORMAT_MAX_AUDIO) {
1666 pred = rtp->lastts + f->samples;
1667
1668 /* Re-calculate last TS */
1669 rtp->lastts = rtp->lastts + ms * 8;
1670 if (ast_tvzero(f->delivery)) {
1671 /* If this isn't an absolute delivery time, Check if it is close to our prediction,
1672 and if so, go with our prediction */
1673 if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
1674 rtp->lastts = pred;
1675 else {
1676 if (option_debug > 2)
1677 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1678 mark = 1;
1679 }
1680 }
1681 } else {
1682 mark = f->subclass & 0x1;
1683 pred = rtp->lastovidtimestamp + f->samples;
1684 /* Re-calculate last TS */
1685 rtp->lastts = rtp->lastts + ms * 90;
1686 /* If it's close to our prediction, go for it */
1687 if (ast_tvzero(f->delivery)) {
1688 if (abs(rtp->lastts - pred) < 7200) {
1689 rtp->lastts = pred;
1690 rtp->lastovidtimestamp += f->samples;
1691 } else {
1692 if (option_debug > 2)
1693 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);
1694 rtp->lastovidtimestamp = rtp->lastts;
1695 }
1696 }
1697 }
1698 /* If the timestamp for non-digit packets has moved beyond the timestamp
1699 for digits, update the digit timestamp.
1700 */
1701 if (rtp->lastts > rtp->lastdigitts)
1702 rtp->lastdigitts = rtp->lastts;
1703
1704 /* Get a pointer to the header */
1705 rtpheader = (unsigned char *)(f->data - hdrlen);
1706
1707 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1708 put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1709 put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
1710
1711 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1712 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1713 if (res <0) {
1714 if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1715 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));
1716 } else if ((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) {
1717 /* Only give this error message once if we are not RTP debugging */
1718 if (option_debug || rtpdebug)
1719 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));
1720 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
1721 }
1722 }
1723
1724 if(rtp_debug_test_addr(&rtp->them))
1725 ast_verbose("Sent RTP packet to %s:%d (type %d, seq %u, ts %u, len %u)\n"
1726 , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
1727 }
1728
1729 rtp->seqno++;
1730
1731 return 0;
1732 }
1733
1734 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1735 {
1736 struct ast_frame *f;
1737 int codec;
1738 int hdrlen = 12;
1739 int subclass;
1740
1741
1742 /* If we have no peer, return immediately */
1743 if (!rtp->them.sin_addr.s_addr)
1744 return 0;
1745
1746 /* If there is no data length, return immediately */
1747 if (!_f->datalen)
1748 return 0;
1749
1750 /* Make sure we have enough space for RTP header */
1751 if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1752 ast_log(LOG_WARNING, "RTP can only send voice\n");
1753 return -1;
1754 }
1755
1756 subclass = _f->subclass;
1757 if (_f->frametype == AST_FRAME_VIDEO)
1758 subclass &= ~0x1;
1759
1760 codec = ast_rtp_lookup_code(rtp, 1, subclass);
1761 if (codec < 0) {
1762 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1763 return -1;
1764 }
1765
1766 if (rtp->lasttxformat != subclass) {
1767 /* New format, reset the smoother */
1768 if (option_debug)
1769 ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1770 rtp->lasttxformat = subclass;
1771 if (rtp->smoother)
1772 ast_smoother_free(rtp->smoother);
1773 rtp->smoother = NULL;
1774 }
1775
1776
1777 switch(subclass) {
1778 case AST_FORMAT_SLINEAR:
1779 if (!rtp->smoother) {
1780 rtp->smoother = ast_smoother_new(320);
1781 }
1782 if (!rtp->smoother) {
1783 ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1784 return -1;
1785 }
1786 ast_smoother_feed_be(rtp->smoother, _f);
1787
1788 while((f = ast_smoother_read(rtp->smoother)))
1789 ast_rtp_raw_write(rtp, f, codec);
1790 break;
1791 case AST_FORMAT_ULAW:
1792 case AST_FORMAT_ALAW:
1793 if (!rtp->smoother) {
1794 rtp->smoother = ast_smoother_new(160);
1795 }
1796 if (!rtp->smoother) {
1797 ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1798 return -1;
1799 }
1800 ast_smoother_feed(rtp->smoother, _f);
1801
1802 while((f = ast_smoother_read(rtp->smoother)))
1803 ast_rtp_raw_write(rtp, f, codec);
1804 break;
1805 case AST_FORMAT_ADPCM:
1806 case AST_FORMAT_G726:
1807 if (!rtp->smoother) {
1808 rtp->smoother = ast_smoother_new(80);
1809 }
1810 if (!rtp->smoother) {
1811 ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1812 return -1;
1813 }
1814 ast_smoother_feed(rtp->smoother, _f);
1815
1816 while((f = ast_smoother_read(rtp->smoother)))
1817 ast_rtp_raw_write(rtp, f, codec);
1818 break;
1819 case AST_FORMAT_G729A:
1820 if (!rtp->smoother) {
1821 rtp->smoother = ast_smoother_new(20);
1822 if (rtp->smoother)
1823 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1824 }
1825 if (!rtp->smoother) {
1826 ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1827 return -1;
1828 }
1829 ast_smoother_feed(rtp->smoother, _f);
1830
1831 while((f = ast_smoother_read(rtp->smoother)))
1832 ast_rtp_raw_write(rtp, f, codec);
1833 break;
1834 case AST_FORMAT_GSM:
1835 if (!rtp->smoother) {
1836 rtp->smoother = ast_smoother_new(33);
1837 }
1838 if (!rtp->smoother) {
1839 ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1840 return -1;
1841 }
1842 ast_smoother_feed(rtp->smoother, _f);
1843 while((f = ast_smoother_read(rtp->smoother)))
1844 ast_rtp_raw_write(rtp, f, codec);
1845 break;
1846 case AST_FORMAT_ILBC:
1847 if (!rtp->smoother) {
1848 rtp->smoother = ast_smoother_new(50);
1849 }
1850 if (!rtp->smoother) {
1851 ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1852 return -1;
1853 }
1854 ast_smoother_feed(rtp->smoother, _f);
1855 while((f = ast_smoother_read(rtp->smoother)))
1856 ast_rtp_raw_write(rtp, f, codec);
1857 break;
1858 default:
1859 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1860 /* fall through to... */
1861 case AST_FORMAT_H261:
1862 case AST_FORMAT_H263:
1863 case AST_FORMAT_H263_PLUS:
1864 case AST_FORMAT_H264:
1865 case AST_FORMAT_G723_1:
1866 case AST_FORMAT_LPC10:
1867 case AST_FORMAT_SPEEX:
1868 /* Don't buffer outgoing frames; send them one-per-packet: */
1869 if (_f->offset < hdrlen) {
1870 f = ast_frdup(_f);
1871 } else {
1872 f = _f;
1873 }
1874 ast_rtp_raw_write(rtp, f, codec);
1875 }
1876
1877 return 0;
1878 }
1879
1880 /*! \brief Unregister interface to channel driver */
1881 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1882 {
1883 AST_LIST_LOCK(&protos);
1884 AST_LIST_REMOVE(&protos, proto, list);
1885 AST_LIST_UNLOCK(&protos);
1886 }
1887
1888 /*! \brief Register interface to channel driver */
1889 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1890 {
1891 struct ast_rtp_protocol *cur;
1892
1893 AST_LIST_LOCK(&protos);
1894 AST_LIST_TRAVERSE(&protos, cur, list) {
1895 if (!strcmp(cur->type, proto->type)) {
1896 ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1897 AST_LIST_UNLOCK(&protos);
1898 return -1;
1899 }
1900 }
1901 AST_LIST_INSERT_HEAD(&protos, proto, list);
1902 AST_LIST_UNLOCK(&protos);
1903
1904 return 0;
1905 }
1906
1907 /*! \brief Bridge calls. If possible and allowed, initiate
1908 re-invite so the peers exchange media directly outside
1909 of Asterisk. */
1910 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)
1911 {
1912 struct ast_frame *f;
1913 struct ast_channel *who, *other, *cs[3];
1914 struct ast_rtp *p0, *p1; /* Audio RTP Channels */
1915 struct ast_rtp *vp0, *vp1; /* Video RTP channels */
1916 struct ast_rtp_protocol *pr0, *pr1;
1917 struct sockaddr_in ac0, ac1;
1918 struct sockaddr_in vac0, vac1;
1919 struct sockaddr_in t0, t1;
1920 struct sockaddr_in vt0, vt1;
1921 char iabuf[INET_ADDRSTRLEN];
1922
1923 void *pvt0, *pvt1;
1924 int codec0,codec1, oldcodec0, oldcodec1;
1925
1926 memset(&vt0, 0, sizeof(vt0));
1927 memset(&vt1, 0, sizeof(vt1));
1928 memset(&vac0, 0, sizeof(vac0));
1929 memset(&vac1, 0, sizeof(vac1));
1930
1931 /* Lock channels */
1932 ast_channel_lock(c0);
1933 while(ast_channel_trylock(c1)) {
1934 ast_channel_unlock(c0);
1935 usleep(1);
1936 ast_channel_lock(c0);
1937 }
1938
1939 /* Find channel driver interfaces */
1940 pr0 = get_proto(c0);
1941 pr1 = get_proto(c1);
1942 if (!pr0) {
1943 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1944 ast_channel_unlock(c0);
1945 ast_channel_unlock(c1);
1946 return AST_BRIDGE_FAILED;
1947 }
1948 if (!pr1) {
1949 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1950 ast_channel_unlock(c0);
1951 ast_channel_unlock(c1);
1952 return AST_BRIDGE_FAILED;
1953 }
1954
1955 /* Get channel specific interface structures */
1956 pvt0 = c0->tech_pvt;
1957 pvt1 = c1->tech_pvt;
1958
1959 /* Get audio and video interface (if native bridge is possible) */
1960 p0 = pr0->get_rtp_info(c0);
1961 vp0 = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0) : NULL;
1962 p1 = pr1->get_rtp_info(c1);
1963 vp1 = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1) : NULL;
1964
1965 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1966 if (!p0 || !p1) {
1967 /* Somebody doesn't want to play... */
1968 ast_channel_unlock(c0);
1969 ast_channel_unlock(c1);
1970 return AST_BRIDGE_FAILED_NOWARN;
1971 }
1972
1973 if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
1974 /* can't bridge, we are carrying DTMF for this channel and the bridge
1975 needs it
1976 */
1977 ast_channel_unlock(c0);
1978 ast_channel_unlock(c1);
1979 return AST_BRIDGE_FAILED_NOWARN;
1980 }
1981
1982 if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
1983 /* can't bridge, we are carrying DTMF for this channel and the bridge
1984 needs it
1985 */
1986 ast_channel_unlock(c0);
1987 ast_channel_unlock(c1);
1988 return AST_BRIDGE_FAILED_NOWARN;
1989 }
1990
1991 /* Get codecs from both sides */
1992 codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
1993 codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
1994 if (pr0->get_codec && pr1->get_codec) {
1995 /* Hey, we can't do reinvite if both parties speak different codecs */
1996 if (!(codec0 & codec1)) {
1997 if (option_debug)
1998 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
1999 ast_channel_unlock(c0);
2000 ast_channel_unlock(c1);
2001 return AST_BRIDGE_FAILED_NOWARN;
2002 }
2003 }
2004
2005 if (option_verbose > 2)
2006 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
2007
2008 /* Ok, we should be able to redirect the media. Start with one channel */
2009 if (pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))
2010 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2011 else {
2012 /* Store RTP peer */
2013 ast_rtp_get_peer(p1, &ac1);
2014 if (vp1)
2015 ast_rtp_get_peer(vp1, &vac1);
2016 }
2017 /* Then test the other channel */
2018 if (pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
2019 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
2020 else {
2021 /* Store RTP peer */
2022 ast_rtp_get_peer(p0, &ac0);
2023 if (vp0)
2024 ast_rtp_get_peer(vp0, &vac0);
2025 }
2026 ast_channel_unlock(c0);
2027 ast_channel_unlock(c1);
2028 /* External RTP Bridge up, now loop and see if something happes that force us to take the
2029 media back to Asterisk */
2030 cs[0] = c0;
2031 cs[1] = c1;
2032 cs[2] = NULL;
2033 oldcodec0 = codec0;
2034 oldcodec1 = codec1;
2035 for (;;) {
2036 /* Check if something changed... */
2037 if ((c0->tech_pvt != pvt0) ||
2038 (c1->tech_pvt != pvt1) ||
2039 (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2040 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2041 if (c0->tech_pvt == pvt0) {
2042 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2043 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2044 }
2045 if (c1->tech_pvt == pvt1) {
2046 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2047 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2048 }
2049 return AST_BRIDGE_RETRY;
2050 }
2051 /* Now check if they have changed address */
2052 ast_rtp_get_peer(p1, &t1);
2053 ast_rtp_get_peer(p0, &t0);
2054 if (pr0->get_codec)
2055 codec0 = pr0->get_codec(c0);
2056 if (pr1->get_codec)
2057 codec1 = pr1->get_codec(c1);
2058 if (vp1)
2059 ast_rtp_get_peer(vp1, &vt1);
2060 if (vp0)
2061 ast_rtp_get_peer(vp0, &vt0);
2062 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
2063 if (option_debug > 1) {
2064 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2065 c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t1.sin_addr), ntohs(t1.sin_port), codec1);
2066 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2067 c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2068 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2069 c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2070 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2071 c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2072 }
2073 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)))
2074 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2075 memcpy(&ac1, &t1, sizeof(ac1));
2076 memcpy(&vac1, &vt1, sizeof(vac1));
2077 oldcodec1 = codec1;
2078 }
2079 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
2080 if (option_debug) {
2081 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2082 c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t0.sin_addr), ntohs(t0.sin_port), codec0);
2083 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2084 c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2085 }
2086 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)))
2087 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2088 memcpy(&ac0, &t0, sizeof(ac0));
2089 memcpy(&vac0, &vt0, sizeof(vac0));
2090 oldcodec0 = codec0;
2091 }
2092 who = ast_waitfor_n(cs, 2, &timeoutms);
2093 if (!who) {
2094 if (!timeoutms)
2095 return AST_BRIDGE_RETRY;
2096 if (option_debug)
2097 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2098 /* check for hangup / whentohangup */
2099 if (ast_check_hangup(c0) || ast_check_hangup(c1))
2100 break;
2101 continue;
2102 }
2103 f = ast_read(who);
2104 other = (who == c0) ? c1 : c0; /* the other channel */
2105 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
2106 (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
2107 ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2108 /* breaking out of the bridge. */
2109 *fo = f;
2110 *rc = who;
2111 if (option_debug)
2112 ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
2113 if ((c0->tech_pvt == pvt0)) {
2114 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2115 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2116 }
2117 if ((c1->tech_pvt == pvt1)) {
2118 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2119 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2120 }
2121 return AST_BRIDGE_COMPLETE;
2122 } else if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2123 if ((f->subclass == AST_CONTROL_HOLD) || (f->subclass == AST_CONTROL_UNHOLD) ||
2124 (f->subclass == AST_CONTROL_VIDUPDATE)) {
2125 ast_indicate(other, f->subclass);
2126 ast_frfree(f);
2127 } else {
2128 *fo = f;
2129 *rc = who;
2130 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
2131 return AST_BRIDGE_COMPLETE;
2132 }
2133 } else {
2134 if ((f->frametype == AST_FRAME_DTMF) ||
2135 (f->frametype == AST_FRAME_VOICE) ||
2136 (f->frametype == AST_FRAME_VIDEO)) {
2137 /* Forward voice or DTMF frames if they happen upon us */
2138 ast_write(other, f);
2139 }
2140 ast_frfree(f);
2141 }
2142 /* Swap priority not that it's a big deal at this point */
2143 cs[2] = cs[0];
2144 cs[0] = cs[1];
2145 cs[1] = cs[2];
2146
2147 }
2148 return AST_BRIDGE_FAILED;
2149 }
2150
2151 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
2152 {
2153 struct hostent *hp;
2154 struct ast_hostent ahp;
2155 char iabuf[INET_ADDRSTRLEN];
2156 int port = 0;
2157 char *p, *arg;
2158
2159 if (argc != 4)
2160 return RESULT_SHOWUSAGE;
2161 arg = argv[3];
2162 p = strstr(arg, ":");
2163 if (p) {
2164 *p = '\0';
2165 p++;
2166 port = atoi(p);
2167 }
2168 hp = ast_gethostbyname(arg, &ahp);
2169 if (hp == NULL)
2170 return RESULT_SHOWUSAGE;
2171 rtpdebugaddr.sin_family = AF_INET;
2172 memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
2173 rtpdebugaddr.sin_port = htons(port);
2174 if (port == 0)
2175 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr));
2176 else
2177 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr), port);
2178 rtpdebug = 1;
2179 return RESULT_SUCCESS;
2180 }
2181
2182 static int rtp_do_debug(int fd, int argc, char *argv[])
2183 {
2184 if(argc != 2) {
2185 if(argc != 4)
2186 return RESULT_SHOWUSAGE;
2187 return rtp_do_debug_ip(fd, argc, argv);
2188 }
2189 rtpdebug = 1;
2190 memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
2191 ast_cli(fd, "RTP Debugging Enabled\n");
2192 return RESULT_SUCCESS;
2193 }
2194
2195 static int rtp_no_debug(int fd, int argc, char *argv[])
2196 {
2197 if(argc !=3)
2198 return RESULT_SHOWUSAGE;
2199 rtpdebug = 0;
2200 ast_cli(fd,"RTP Debugging Disabled\n");
2201 return RESULT_SUCCESS;
2202 }
2203
2204 static int stun_do_debug(int fd, int argc, char *argv[])
2205 {
2206 if(argc != 2) {
2207 return RESULT_SHOWUSAGE;
2208 }
2209 stundebug = 1;
2210 ast_cli(fd, "STUN Debugging Enabled\n");
2211 return RESULT_SUCCESS;
2212 }
2213
2214 static int stun_no_debug(int fd, int argc, char *argv[])
2215 {
2216 if(argc !=3)
2217 return RESULT_SHOWUSAGE;
2218 stundebug = 0;
2219 ast_cli(fd,"STUN Debugging Disabled\n");
2220 return RESULT_SUCCESS;
2221 }
2222
2223
2224 static char debug_usage[] =
2225 "Usage: rtp debug [ip host[:port]]\n"
2226 " Enable dumping of all RTP packets to and from host.\n";
2227
2228 static char no_debug_usage[] =
2229 "Usage: rtp no debug\n"
2230 " Disable all RTP debugging\n";
2231
2232 static char stun_debug_usage[] =
2233 "Usage: stun debug\n"
2234 " Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
2235
2236 static char stun_no_debug_usage[] =
2237 "Usage: stun no debug\n"
2238 " Disable STUN debugging\n";
2239
2240
2241 static struct ast_cli_entry cli_debug_ip =
2242 {{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage };
2243
2244 static struct ast_cli_entry cli_debug =
2245 {{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage };
2246
2247 static struct ast_cli_entry cli_no_debug =
2248 {{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage };
2249
2250 static struct ast_cli_entry cli_stun_debug =
2251 {{ "stun", "debug", NULL } , stun_do_debug, "Enable STUN debugging", stun_debug_usage };
2252
2253 static struct ast_cli_entry cli_stun_no_debug =
2254 {{ "stun", "no", "debug", NULL } , stun_no_debug, "Disable STUN debugging", stun_no_debug_usage };
2255
2256 int ast_rtp_reload(void)
2257 {
2258 struct ast_config *cfg;
2259 char *s;
2260
2261 rtpstart = 5000;
2262 rtpend = 31000;
2263 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2264 cfg = ast_config_load("rtp.conf");
2265 if (cfg) {
2266 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
2267 rtpstart = atoi(s);
2268 if (rtpstart < 1024)
2269 rtpstart = 1024;
2270 if (rtpstart > 65535)
2271 rtpstart = 65535;
2272 }
2273 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
2274 rtpend = atoi(s);
2275 if (rtpend < 1024)
2276 rtpend = 1024;
2277 if (rtpend > 65535)
2278 rtpend = 65535;
2279 }
2280 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
2281 #ifdef SO_NO_CHECK
2282 if (ast_false(s))
2283 nochecksums = 1;
2284 else
2285 nochecksums = 0;
2286 #else
2287 if (ast_false(s))
2288 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
2289 #endif
2290 }
2291 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
2292 dtmftimeout = atoi(s);
2293 if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
2294 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
2295 dtmftimeout, DEFAULT_DTMF_TIMEOUT);
2296 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2297 };
2298 }
2299 ast_config_destroy(cfg);
2300 }
2301 if (rtpstart >= rtpend) {
2302 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
2303 rtpstart = 5000;
2304 rtpend = 31000;
2305 }
2306 if (option_verbose > 1)
2307 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
2308 return 0;
2309 }
2310
2311 /*! \brief Initialize the RTP system in Asterisk */
2312 void ast_rtp_init(void)
2313 {
2314 ast_cli_register(&cli_debug);
2315 ast_cli_register(&cli_debug_ip);
2316 ast_cli_register(&cli_no_debug);
2317 ast_cli_register(&cli_stun_debug);
2318 ast_cli_register(&cli_stun_no_debug);
2319 ast_rtp_reload();
2320 }
Open Source Private Branch Exchange (PBX)