?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Let's also include aclocal.m4
[asterisk-bristuff.git] / main / rtp.c
blob2fd470741f5ddd282db178d014504c356ddca68f
1 /*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * Copyright (C) 1999 - 2006, Digium, Inc.
5 *
6 * Mark Spencer <markster@digium.com>
7 *
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
13 *
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
17 */
18
19 /*!
20 * \file
21 *
22 * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
23 *
24 * \author Mark Spencer <markster@digium.com>
25 *
26 * \note RTP is defined in RFC 3550.
27 */
28
29 #include "asterisk.h"
30
31 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <sys/time.h>
37 #include <signal.h>
38 #include <errno.h>
39 #include <unistd.h>
40 #include <netinet/in.h>
41 #include <sys/time.h>
42 #include <sys/socket.h>
43 #include <arpa/inet.h>
44 #include <fcntl.h>
45
46 #include "asterisk/rtp.h"
47 #include "asterisk/frame.h"
48 #include "asterisk/logger.h"
49 #include "asterisk/options.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/acl.h"
52 #include "asterisk/channel.h"
53 #include "asterisk/config.h"
54 #include "asterisk/lock.h"
55 #include "asterisk/utils.h"
56 #include "asterisk/cli.h"
57 #include "asterisk/unaligned.h"
58 #include "asterisk/utils.h"
59
60 #define MAX_TIMESTAMP_SKEW 640
61
62 #define RTP_SEQ_MOD (1<<16) /*!< A sequence number can't be more than 16 bits */
63 #define RTCP_DEFAULT_INTERVALMS 5000 /*!< Default milli-seconds between RTCP reports we send */
64 #define RTCP_MIN_INTERVALMS 500 /*!< Min milli-seconds between RTCP reports we send */
65 #define RTCP_MAX_INTERVALMS 60000 /*!< Max milli-seconds between RTCP reports we send */
66
67 #define RTCP_PT_FUR 192
68 #define RTCP_PT_SR 200
69 #define RTCP_PT_RR 201
70 #define RTCP_PT_SDES 202
71 #define RTCP_PT_BYE 203
72 #define RTCP_PT_APP 204
73
74 #define RTP_MTU 1200
75
76 #define DEFAULT_DTMF_TIMEOUT 3000 /*!< samples */
77
78 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
79
80 static int rtpstart; /*!< First port for RTP sessions (set in rtp.conf) */
81 static int rtpend; /*!< Last port for RTP sessions (set in rtp.conf) */
82 static int rtpdebug; /*!< Are we debugging? */
83 static int rtcpdebug; /*!< Are we debugging RTCP? */
84 static int rtcpstats; /*!< Are we debugging RTCP? */
85 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
86 static int stundebug; /*!< Are we debugging stun? */
87 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
88 static struct sockaddr_in rtcpdebugaddr; /*!< Debug RTCP packets to/from this host */
89 #ifdef SO_NO_CHECK
90 static int nochecksums;
91 #endif
92
93 /* Uncomment this to enable more intense native bridging, but note: this is currently buggy */
94 /* #define P2P_INTENSE */
95
96 /*!
97 * \brief Structure representing a RTP session.
98 *
99 * RTP session is defined on page 9 of RFC 3550: "An association among a set of participants communicating with RTP. A participant may be involved in multiple RTP sessions at the same time [...]"
100 *
101 */
102 /*! \brief The value of each payload format mapping: */
103 struct rtpPayloadType {
104 int isAstFormat; /*!< whether the following code is an AST_FORMAT */
105 int code;
106 };
107
108
109 /*! \brief RTP session description */
110 struct ast_rtp {
111 int s;
112 struct ast_frame f;
113 unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
114 unsigned int ssrc; /*!< Synchronization source, RFC 3550, page 10. */
115 unsigned int themssrc; /*!< Their SSRC */
116 unsigned int rxssrc;
117 unsigned int lastts;
118 unsigned int lastrxts;
119 unsigned int lastividtimestamp;
120 unsigned int lastovidtimestamp;
121 unsigned int lasteventseqn;
122 int lastrxseqno; /*!< Last received sequence number */
123 unsigned short seedrxseqno; /*!< What sequence number did they start with?*/
124 unsigned int seedrxts; /*!< What RTP timestamp did they start with? */
125 unsigned int rxcount; /*!< How many packets have we received? */
126 unsigned int rxoctetcount; /*!< How many octets have we received? should be rxcount *160*/
127 unsigned int txcount; /*!< How many packets have we sent? */
128 unsigned int txoctetcount; /*!< How many octets have we sent? (txcount*160)*/
129 unsigned int cycles; /*!< Shifted count of sequence number cycles */
130 double rxjitter; /*!< Interarrival jitter at the moment */
131 double rxtransit; /*!< Relative transit time for previous packet */
132 int lasttxformat;
133 int lastrxformat;
134
135 int rtptimeout; /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
136 int rtpholdtimeout; /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
137 int rtpkeepalive; /*!< Send RTP comfort noice packets for keepalive */
138
139 /* DTMF Reception Variables */
140 char resp;
141 unsigned int lastevent;
142 int dtmfcount;
143 unsigned int dtmfsamples;
144 /* DTMF Transmission Variables */
145 unsigned int lastdigitts;
146 char sending_digit; /*!< boolean - are we sending digits */
147 char send_digit; /*!< digit we are sending */
148 int send_payload;
149 int send_duration;
150 int nat;
151 unsigned int flags;
152 struct sockaddr_in us; /*!< Socket representation of the local endpoint. */
153 struct sockaddr_in them; /*!< Socket representation of the remote endpoint. */
154 struct timeval rxcore;
155 struct timeval txcore;
156 double drxcore; /*!< The double representation of the first received packet */
157 struct timeval lastrx; /*!< timeval when we last received a packet */
158 struct timeval dtmfmute;
159 struct ast_smoother *smoother;
160 int *ioid;
161 unsigned short seqno; /*!< Sequence number, RFC 3550, page 13. */
162 unsigned short rxseqno;
163 struct sched_context *sched;
164 struct io_context *io;
165 void *data;
166 ast_rtp_callback callback;
167 ast_mutex_t bridge_lock;
168 struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
169 int rtp_lookup_code_cache_isAstFormat; /*!< a cache for the result of rtp_lookup_code(): */
170 int rtp_lookup_code_cache_code;
171 int rtp_lookup_code_cache_result;
172 struct ast_rtcp *rtcp;
173 struct ast_codec_pref pref;
174 struct ast_rtp *bridged; /*!< Who we are Packet bridged to */
175 int set_marker_bit:1; /*!< Whether to set the marker bit or not */
176 };
177
178 /* Forward declarations */
179 static int ast_rtcp_write(const void *data);
180 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw);
181 static int ast_rtcp_write_sr(const void *data);
182 static int ast_rtcp_write_rr(const void *data);
183 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp);
184 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp);
185 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit);
186
187 #define FLAG_3389_WARNING (1 << 0)
188 #define FLAG_NAT_ACTIVE (3 << 1)
189 #define FLAG_NAT_INACTIVE (0 << 1)
190 #define FLAG_NAT_INACTIVE_NOWARN (1 << 1)
191 #define FLAG_HAS_DTMF (1 << 3)
192 #define FLAG_P2P_SENT_MARK (1 << 4)
193 #define FLAG_P2P_NEED_DTMF (1 << 5)
194 #define FLAG_CALLBACK_MODE (1 << 6)
195 #define FLAG_DTMF_COMPENSATE (1 << 7)
196 #define FLAG_HAS_STUN (1 << 8)
197
198 /*!
199 * \brief Structure defining an RTCP session.
200 *
201 * The concept "RTCP session" is not defined in RFC 3550, but since
202 * this structure is analogous to ast_rtp, which tracks a RTP session,
203 * it is logical to think of this as a RTCP session.
204 *
205 * RTCP packet is defined on page 9 of RFC 3550.
206 *
207 */
208 struct ast_rtcp {
209 int s; /*!< Socket */
210 struct sockaddr_in us; /*!< Socket representation of the local endpoint. */
211 struct sockaddr_in them; /*!< Socket representation of the remote endpoint. */
212 unsigned int soc; /*!< What they told us */
213 unsigned int spc; /*!< What they told us */
214 unsigned int themrxlsr; /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
215 struct timeval rxlsr; /*!< Time when we got their last SR */
216 struct timeval txlsr; /*!< Time when we sent or last SR*/
217 unsigned int expected_prior; /*!< no. packets in previous interval */
218 unsigned int received_prior; /*!< no. packets received in previous interval */
219 int schedid; /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
220 unsigned int rr_count; /*!< number of RRs we've sent, not including report blocks in SR's */
221 unsigned int sr_count; /*!< number of SRs we've sent */
222 unsigned int lastsrtxcount; /*!< Transmit packet count when last SR sent */
223 double accumulated_transit; /*!< accumulated a-dlsr-lsr */
224 double rtt; /*!< Last reported rtt */
225 unsigned int reported_jitter; /*!< The contents of their last jitter entry in the RR */
226 unsigned int reported_lost; /*!< Reported lost packets in their RR */
227 char quality[AST_MAX_USER_FIELD];
228 double maxrxjitter;
229 double minrxjitter;
230 double maxrtt;
231 double minrtt;
232 int sendfur;
233 };
234
235
236 typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
237
238 /* XXX Maybe stun belongs in another file if it ever has use outside of RTP */
239 struct stun_header {
240 unsigned short msgtype;
241 unsigned short msglen;
242 stun_trans_id id;
243 unsigned char ies[0];
244 } __attribute__((packed));
245
246 struct stun_attr {
247 unsigned short attr;
248 unsigned short len;
249 unsigned char value[0];
250 } __attribute__((packed));
251
252 struct stun_addr {
253 unsigned char unused;
254 unsigned char family;
255 unsigned short port;
256 unsigned int addr;
257 } __attribute__((packed));
258
259 #define STUN_IGNORE (0)
260 #define STUN_ACCEPT (1)
261
262 #define STUN_BINDREQ 0x0001
263 #define STUN_BINDRESP 0x0101
264 #define STUN_BINDERR 0x0111
265 #define STUN_SECREQ 0x0002
266 #define STUN_SECRESP 0x0102
267 #define STUN_SECERR 0x0112
268
269 #define STUN_MAPPED_ADDRESS 0x0001
270 #define STUN_RESPONSE_ADDRESS 0x0002
271 #define STUN_CHANGE_REQUEST 0x0003
272 #define STUN_SOURCE_ADDRESS 0x0004
273 #define STUN_CHANGED_ADDRESS 0x0005
274 #define STUN_USERNAME 0x0006
275 #define STUN_PASSWORD 0x0007
276 #define STUN_MESSAGE_INTEGRITY 0x0008
277 #define STUN_ERROR_CODE 0x0009
278 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
279 #define STUN_REFLECTED_FROM 0x000b
280
281 static const char *stun_msg2str(int msg)
282 {
283 switch(msg) {
284 case STUN_BINDREQ:
285 return "Binding Request";
286 case STUN_BINDRESP:
287 return "Binding Response";
288 case STUN_BINDERR:
289 return "Binding Error Response";
290 case STUN_SECREQ:
291 return "Shared Secret Request";
292 case STUN_SECRESP:
293 return "Shared Secret Response";
294 case STUN_SECERR:
295 return "Shared Secret Error Response";
296 }
297 return "Non-RFC3489 Message";
298 }
299
300 static const char *stun_attr2str(int msg)
301 {
302 switch(msg) {
303 case STUN_MAPPED_ADDRESS:
304 return "Mapped Address";
305 case STUN_RESPONSE_ADDRESS:
306 return "Response Address";
307 case STUN_CHANGE_REQUEST:
308 return "Change Request";
309 case STUN_SOURCE_ADDRESS:
310 return "Source Address";
311 case STUN_CHANGED_ADDRESS:
312 return "Changed Address";
313 case STUN_USERNAME:
314 return "Username";
315 case STUN_PASSWORD:
316 return "Password";
317 case STUN_MESSAGE_INTEGRITY:
318 return "Message Integrity";
319 case STUN_ERROR_CODE:
320 return "Error Code";
321 case STUN_UNKNOWN_ATTRIBUTES:
322 return "Unknown Attributes";
323 case STUN_REFLECTED_FROM:
324 return "Reflected From";
325 }
326 return "Non-RFC3489 Attribute";
327 }
328
329 struct stun_state {
330 const char *username;
331 const char *password;
332 };
333
334 static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
335 {
336 if (stundebug)
337 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
338 stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
339 switch(ntohs(attr->attr)) {
340 case STUN_USERNAME:
341 state->username = (const char *) (attr->value);
342 break;
343 case STUN_PASSWORD:
344 state->password = (const char *) (attr->value);
345 break;
346 default:
347 if (stundebug)
348 ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n",
349 stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
350 }
351 return 0;
352 }
353
354 static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
355 {
356 int size = sizeof(**attr) + strlen(s);
357 if (*left > size) {
358 (*attr)->attr = htons(attrval);
359 (*attr)->len = htons(strlen(s));
360 memcpy((*attr)->value, s, strlen(s));
361 (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
362 *len += size;
363 *left -= size;
364 }
365 }
366
367 static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
368 {
369 int size = sizeof(**attr) + 8;
370 struct stun_addr *addr;
371 if (*left > size) {
372 (*attr)->attr = htons(attrval);
373 (*attr)->len = htons(8);
374 addr = (struct stun_addr *)((*attr)->value);
375 addr->unused = 0;
376 addr->family = 0x01;
377 addr->port = sin->sin_port;
378 addr->addr = sin->sin_addr.s_addr;
379 (*attr) = (struct stun_attr *)((*attr)->value + 8);
380 *len += size;
381 *left -= size;
382 }
383 }
384
385 static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
386 {
387 return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
388 (struct sockaddr *)dst, sizeof(*dst));
389 }
390
391 static void stun_req_id(struct stun_header *req)
392 {
393 int x;
394 for (x=0;x<4;x++)
395 req->id.id[x] = ast_random();
396 }
397
398 size_t ast_rtp_alloc_size(void)
399 {
400 return sizeof(struct ast_rtp);
401 }
402
403 void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
404 {
405 struct stun_header *req;
406 unsigned char reqdata[1024];
407 int reqlen, reqleft;
408 struct stun_attr *attr;
409
410 req = (struct stun_header *)reqdata;
411 stun_req_id(req);
412 reqlen = 0;
413 reqleft = sizeof(reqdata) - sizeof(struct stun_header);
414 req->msgtype = 0;
415 req->msglen = 0;
416 attr = (struct stun_attr *)req->ies;
417 if (username)
418 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
419 req->msglen = htons(reqlen);
420 req->msgtype = htons(STUN_BINDREQ);
421 stun_send(rtp->s, suggestion, req);
422 }
423
424 static int stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, size_t len)
425 {
426 struct stun_header *resp, *hdr = (struct stun_header *)data;
427 struct stun_attr *attr;
428 struct stun_state st;
429 int ret = STUN_IGNORE;
430 unsigned char respdata[1024];
431 int resplen, respleft;
432
433 if (len < sizeof(struct stun_header)) {
434 if (option_debug)
435 ast_log(LOG_DEBUG, "Runt STUN packet (only %zd, wanting at least %zd)\n", len, sizeof(struct stun_header));
436 return -1;
437 }
438 if (stundebug)
439 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), ntohs(hdr->msglen));
440 if (ntohs(hdr->msglen) > len - sizeof(struct stun_header)) {
441 if (option_debug)
442 ast_log(LOG_DEBUG, "Scrambled STUN packet length (got %d, expecting %zd)\n", ntohs(hdr->msglen), len - sizeof(struct stun_header));
443 } else
444 len = ntohs(hdr->msglen);
445 data += sizeof(struct stun_header);
446 memset(&st, 0, sizeof(st));
447 while(len) {
448 if (len < sizeof(struct stun_attr)) {
449 if (option_debug)
450 ast_log(LOG_DEBUG, "Runt Attribute (got %zd, expecting %zd)\n", len, sizeof(struct stun_attr));
451 break;
452 }
453 attr = (struct stun_attr *)data;
454 if ((ntohs(attr->len) + sizeof(struct stun_attr)) > len) {
455 if (option_debug)
456 ast_log(LOG_DEBUG, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", (int) (ntohs(attr->len) + sizeof(struct stun_attr)), (int) len);
457 break;
458 }
459 if (stun_process_attr(&st, attr)) {
460 if (option_debug)
461 ast_log(LOG_DEBUG, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
462 break;
463 }
464 /* Clear attribute in case previous entry was a string */
465 attr->attr = 0;
466 data += ntohs(attr->len) + sizeof(struct stun_attr);
467 len -= ntohs(attr->len) + sizeof(struct stun_attr);
468 }
469 /* Null terminate any string */
470 *data = '\0';
471 resp = (struct stun_header *)respdata;
472 resplen = 0;
473 respleft = sizeof(respdata) - sizeof(struct stun_header);
474 resp->id = hdr->id;
475 resp->msgtype = 0;
476 resp->msglen = 0;
477 attr = (struct stun_attr *)resp->ies;
478 if (!len) {
479 switch(ntohs(hdr->msgtype)) {
480 case STUN_BINDREQ:
481 if (stundebug)
482 ast_verbose("STUN Bind Request, username: %s\n",
483 st.username ? st.username : "<none>");
484 if (st.username)
485 append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
486 append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
487 resp->msglen = htons(resplen);
488 resp->msgtype = htons(STUN_BINDRESP);
489 stun_send(s, src, resp);
490 ret = STUN_ACCEPT;
491 break;
492 default:
493 if (stundebug)
494 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
495 }
496 }
497 return ret;
498 }
499
500 /*! \brief List of current sessions */
501 static AST_LIST_HEAD_STATIC(protos, ast_rtp_protocol);
502
503 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
504 {
505 unsigned int sec, usec, frac;
506 sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
507 usec = tv.tv_usec;
508 frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
509 *msw = sec;
510 *lsw = frac;
511 }
512
513 int ast_rtp_fd(struct ast_rtp *rtp)
514 {
515 return rtp->s;
516 }
517
518 int ast_rtcp_fd(struct ast_rtp *rtp)
519 {
520 if (rtp->rtcp)
521 return rtp->rtcp->s;
522 return -1;
523 }
524
525 unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
526 {
527 unsigned int interval;
528 /*! \todo XXX Do a more reasonable calculation on this one
529 * Look in RFC 3550 Section A.7 for an example*/
530 interval = rtcpinterval;
531 return interval;
532 }
533
534 /* \brief Put RTP timeout timers on hold during another transaction, like T.38 */
535 void ast_rtp_set_rtptimers_onhold(struct ast_rtp *rtp)
536 {
537 rtp->rtptimeout = (-1) * rtp->rtptimeout;
538 rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout;
539 }
540
541 /*! \brief Set rtp timeout */
542 void ast_rtp_set_rtptimeout(struct ast_rtp *rtp, int timeout)
543 {
544 rtp->rtptimeout = timeout;
545 }
546
547 /*! \brief Set rtp hold timeout */
548 void ast_rtp_set_rtpholdtimeout(struct ast_rtp *rtp, int timeout)
549 {
550 rtp->rtpholdtimeout = timeout;
551 }
552
553 /*! \brief set RTP keepalive interval */
554 void ast_rtp_set_rtpkeepalive(struct ast_rtp *rtp, int period)
555 {
556 rtp->rtpkeepalive = period;
557 }
558
559 /*! \brief Get rtp timeout */
560 int ast_rtp_get_rtptimeout(struct ast_rtp *rtp)
561 {
562 if (rtp->rtptimeout < 0) /* We're not checking, but remembering the setting (during T.38 transmission) */
563 return 0;
564 return rtp->rtptimeout;
565 }
566
567 /*! \brief Get rtp hold timeout */
568 int ast_rtp_get_rtpholdtimeout(struct ast_rtp *rtp)
569 {
570 if (rtp->rtptimeout < 0) /* We're not checking, but remembering the setting (during T.38 transmission) */
571 return 0;
572 return rtp->rtpholdtimeout;
573 }
574
575 /*! \brief Get RTP keepalive interval */
576 int ast_rtp_get_rtpkeepalive(struct ast_rtp *rtp)
577 {
578 return rtp->rtpkeepalive;
579 }
580
581 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
582 {
583 rtp->data = data;
584 }
585
586 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
587 {
588 rtp->callback = callback;
589 }
590
591 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
592 {
593 rtp->nat = nat;
594 }
595
596 int ast_rtp_getnat(struct ast_rtp *rtp)
597 {
598 return ast_test_flag(rtp, FLAG_NAT_ACTIVE);
599 }
600
601 void ast_rtp_setdtmf(struct ast_rtp *rtp, int dtmf)
602 {
603 ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF);
604 }
605
606 void ast_rtp_setdtmfcompensate(struct ast_rtp *rtp, int compensate)
607 {
608 ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE);
609 }
610
611 void ast_rtp_setstun(struct ast_rtp *rtp, int stun_enable)
612 {
613 ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN);
614 }
615
616 static struct ast_frame *send_dtmf(struct ast_rtp *rtp, enum ast_frame_type type)
617 {
618 if (((ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && type == AST_FRAME_DTMF_END) ||
619 (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
620 if (option_debug)
621 ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(rtp->them.sin_addr));
622 rtp->resp = 0;
623 rtp->dtmfsamples = 0;
624 return &ast_null_frame;
625 }
626 if (option_debug)
627 ast_log(LOG_DEBUG, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(rtp->them.sin_addr));
628 if (rtp->resp == 'X') {
629 rtp->f.frametype = AST_FRAME_CONTROL;
630 rtp->f.subclass = AST_CONTROL_FLASH;
631 } else {
632 rtp->f.frametype = type;
633 rtp->f.subclass = rtp->resp;
634 }
635 rtp->f.datalen = 0;
636 rtp->f.samples = 0;
637 rtp->f.mallocd = 0;
638 rtp->f.src = "RTP";
639 return &rtp->f;
640
641 }
642
643 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
644 {
645 if (rtpdebug == 0)
646 return 0;
647 if (rtpdebugaddr.sin_addr.s_addr) {
648 if (((ntohs(rtpdebugaddr.sin_port) != 0)
649 && (rtpdebugaddr.sin_port != addr->sin_port))
650 || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
651 return 0;
652 }
653 return 1;
654 }
655
656 static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
657 {
658 if (rtcpdebug == 0)
659 return 0;
660 if (rtcpdebugaddr.sin_addr.s_addr) {
661 if (((ntohs(rtcpdebugaddr.sin_port) != 0)
662 && (rtcpdebugaddr.sin_port != addr->sin_port))
663 || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
664 return 0;
665 }
666 return 1;
667 }
668
669
670 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
671 {
672 unsigned int event;
673 char resp = 0;
674 struct ast_frame *f = NULL;
675 event = ntohl(*((unsigned int *)(data)));
676 event &= 0x001F;
677 if (option_debug > 2 || rtpdebug)
678 ast_log(LOG_DEBUG, "Cisco DTMF Digit: %08x (len = %d)\n", event, len);
679 if (event < 10) {
680 resp = '0' + event;
681 } else if (event < 11) {
682 resp = '*';
683 } else if (event < 12) {
684 resp = '#';
685 } else if (event < 16) {
686 resp = 'A' + (event - 12);
687 } else if (event < 17) {
688 resp = 'X';
689 }
690 if (rtp->resp && (rtp->resp != resp)) {
691 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
692 }
693 rtp->resp = resp;
694 rtp->dtmfcount = dtmftimeout;
695 return f;
696 }
697
698 /*!
699 * \brief Process RTP DTMF and events according to RFC 2833.
700 *
701 * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
702 *
703 * \param rtp
704 * \param data
705 * \param len
706 * \param seqno
707 * \returns
708 */
709 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp)
710 {
711 unsigned int event;
712 unsigned int event_end;
713 unsigned int samples;
714 char resp = 0;
715 struct ast_frame *f = NULL;
716
717 /* Figure out event, event end, and samples */
718 event = ntohl(*((unsigned int *)(data)));
719 event >>= 24;
720 event_end = ntohl(*((unsigned int *)(data)));
721 event_end <<= 8;
722 event_end >>= 24;
723 samples = ntohl(*((unsigned int *)(data)));
724 samples &= 0xFFFF;
725
726 /* Print out debug if turned on */
727 if (rtpdebug || option_debug > 2)
728 ast_log(LOG_DEBUG, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
729
730 /* Figure out what digit was pressed */
731 if (event < 10) {
732 resp = '0' + event;
733 } else if (event < 11) {
734 resp = '*';
735 } else if (event < 12) {
736 resp = '#';
737 } else if (event < 16) {
738 resp = 'A' + (event - 12);
739 } else if (event < 17) { /* Event 16: Hook flash */
740 resp = 'X';
741 } else {
742 /* Not a supported event */
743 ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
744 return &ast_null_frame;
745 }
746
747 if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
748 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
749 rtp->resp = resp;
750 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
751 f->len = 0;
752 rtp->lastevent = timestamp;
753 }
754 } else {
755 if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
756 rtp->resp = resp;
757 f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
758 } else if ((event_end & 0x80) && (rtp->lastevent != seqno) && rtp->resp) {
759 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
760 f->len = ast_tvdiff_ms(ast_samp2tv(samples, 8000), ast_tv(0, 0)); /* XXX hard coded 8kHz */
761 rtp->resp = 0;
762 rtp->lastevent = seqno;
763 }
764 }
765
766 rtp->dtmfcount = dtmftimeout;
767 rtp->dtmfsamples = samples;
768
769 return f;
770 }
771
772 /*!
773 * \brief Process Comfort Noise RTP.
774 *
775 * This is incomplete at the moment.
776 *
777 */
778 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
779 {
780 struct ast_frame *f = NULL;
781 /* Convert comfort noise into audio with various codecs. Unfortunately this doesn't
782 totally help us out becuase we don't have an engine to keep it going and we are not
783 guaranteed to have it every 20ms or anything */
784 if (rtpdebug)
785 ast_log(LOG_DEBUG, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
786
787 if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
788 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
789 ast_inet_ntoa(rtp->them.sin_addr));
790 ast_set_flag(rtp, FLAG_3389_WARNING);
791 }
792
793 /* Must have at least one byte */
794 if (!len)
795 return NULL;
796 if (len < 24) {
797 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
798 rtp->f.datalen = len - 1;
799 rtp->f.offset = AST_FRIENDLY_OFFSET;
800 memcpy(rtp->f.data, data + 1, len - 1);
801 } else {
802 rtp->f.data = NULL;
803 rtp->f.offset = 0;
804 rtp->f.datalen = 0;
805 }
806 rtp->f.frametype = AST_FRAME_CNG;
807 rtp->f.subclass = data[0] & 0x7f;
808 rtp->f.datalen = len - 1;
809 rtp->f.samples = 0;
810 rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
811 f = &rtp->f;
812 return f;
813 }
814
815 static int rtpread(int *id, int fd, short events, void *cbdata)
816 {
817 struct ast_rtp *rtp = cbdata;
818 struct ast_frame *f;
819 f = ast_rtp_read(rtp);
820 if (f) {
821 if (rtp->callback)
822 rtp->callback(rtp, f, rtp->data);
823 }
824 return 1;
825 }
826
827 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
828 {
829 socklen_t len;
830 int position, i, packetwords;
831 int res;
832 struct sockaddr_in sin;
833 unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
834 unsigned int *rtcpheader;
835 int pt;
836 struct timeval now;
837 unsigned int length;
838 int rc;
839 double rttsec;
840 uint64_t rtt = 0;
841 unsigned int dlsr;
842 unsigned int lsr;
843 unsigned int msw;
844 unsigned int lsw;
845 unsigned int comp;
846 struct ast_frame *f = &ast_null_frame;
847
848 if (!rtp || !rtp->rtcp)
849 return &ast_null_frame;
850
851 len = sizeof(sin);
852
853 res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
854 0, (struct sockaddr *)&sin, &len);
855 rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
856
857 if (res < 0) {
858 ast_assert(errno != EBADF);
859 if (errno != EAGAIN) {
860 ast_log(LOG_WARNING, "RTCP Read error: %s. Hanging up.\n", strerror(errno));
861 return NULL;
862 }
863 return &ast_null_frame;
864 }
865
866 packetwords = res / 4;
867
868 if (rtp->nat) {
869 /* Send to whoever sent to us */
870 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
871 (rtp->rtcp->them.sin_port != sin.sin_port)) {
872 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
873 if (option_debug || rtpdebug)
874 ast_log(LOG_DEBUG, "RTCP NAT: Got RTCP from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
875 }
876 }
877
878 if (option_debug)
879 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
880
881 /* Process a compound packet */
882 position = 0;
883 while (position < packetwords) {
884 i = position;
885 length = ntohl(rtcpheader[i]);
886 pt = (length & 0xff0000) >> 16;
887 rc = (length & 0x1f000000) >> 24;
888 length &= 0xffff;
889
890 if ((i + length) > packetwords) {
891 ast_log(LOG_WARNING, "RTCP Read too short\n");
892 return &ast_null_frame;
893 }
894
895 if (rtcp_debug_test_addr(&sin)) {
896 ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
897 ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
898 ast_verbose("Reception reports: %d\n", rc);
899 ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
900 }
901
902 i += 2; /* Advance past header and ssrc */
903
904 switch (pt) {
905 case RTCP_PT_SR:
906 gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
907 rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
908 rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
909 rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
910
911 if (rtcp_debug_test_addr(&sin)) {
912 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
913 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
914 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
915 }
916 i += 5;
917 if (rc < 1)
918 break;
919 /* Intentional fall through */
920 case RTCP_PT_RR:
921 /* Don't handle multiple reception reports (rc > 1) yet */
922 /* Calculate RTT per RFC */
923 gettimeofday(&now, NULL);
924 timeval2ntp(now, &msw, &lsw);
925 if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
926 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
927 lsr = ntohl(rtcpheader[i + 4]);
928 dlsr = ntohl(rtcpheader[i + 5]);
929 rtt = comp - lsr - dlsr;
930
931 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
932 sess->ee_delay = (eedelay * 1000) / 65536; */
933 if (rtt < 4294) {
934 rtt = (rtt * 1000000) >> 16;
935 } else {
936 rtt = (rtt * 1000) >> 16;
937 rtt *= 1000;
938 }
939 rtt = rtt / 1000.;
940 rttsec = rtt / 1000.;
941
942 if (comp - dlsr >= lsr) {
943 rtp->rtcp->accumulated_transit += rttsec;
944 rtp->rtcp->rtt = rttsec;
945 if (rtp->rtcp->maxrtt<rttsec)
946 rtp->rtcp->maxrtt = rttsec;
947 if (rtp->rtcp->minrtt>rttsec)
948 rtp->rtcp->minrtt = rttsec;
949 } else if (rtcp_debug_test_addr(&sin)) {
950 ast_verbose("Internal RTCP NTP clock skew detected: "
951 "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
952 "diff=%d\n",
953 lsr, comp, dlsr, dlsr / 65536,
954 (dlsr % 65536) * 1000 / 65536,
955 dlsr - (comp - lsr));
956 }
957 }
958
959 rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
960 rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
961 if (rtcp_debug_test_addr(&sin)) {
962 ast_verbose(" Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
963 ast_verbose(" Packets lost so far: %d\n", rtp->rtcp->reported_lost);
964 ast_verbose(" Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
965 ast_verbose(" Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
966 ast_verbose(" Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
967 ast_verbose(" Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
968 ast_verbose(" DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
969 if (rtt)
970 ast_verbose(" RTT: %lu(sec)\n", (unsigned long) rtt);
971 }
972 break;
973 case RTCP_PT_FUR:
974 if (rtcp_debug_test_addr(&sin))
975 ast_verbose("Received an RTCP Fast Update Request\n");
976 rtp->f.frametype = AST_FRAME_CONTROL;
977 rtp->f.subclass = AST_CONTROL_VIDUPDATE;
978 rtp->f.datalen = 0;
979 rtp->f.samples = 0;
980 rtp->f.mallocd = 0;
981 rtp->f.src = "RTP";
982 f = &rtp->f;
983 break;
984 case RTCP_PT_SDES:
985 if (rtcp_debug_test_addr(&sin))
986 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
987 break;
988 case RTCP_PT_BYE:
989 if (rtcp_debug_test_addr(&sin))
990 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
991 break;
992 default:
993 if (option_debug)
994 ast_log(LOG_DEBUG, "Unknown RTCP packet (pt=%d) received from %s:%d\n", pt, ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
995 break;
996 }
997 position += (length + 1);
998 }
999
1000 return f;
1001 }
1002
1003 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1004 {
1005 struct timeval now;
1006 double transit;
1007 double current_time;
1008 double d;
1009 double dtv;
1010 double prog;
1011
1012 if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1013 gettimeofday(&rtp->rxcore, NULL);
1014 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1015 /* map timestamp to a real time */
1016 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1017 rtp->rxcore.tv_sec -= timestamp / 8000;
1018 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
1019 /* Round to 0.1ms for nice, pretty timestamps */
1020 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1021 if (rtp->rxcore.tv_usec < 0) {
1022 /* Adjust appropriately if necessary */
1023 rtp->rxcore.tv_usec += 1000000;
1024 rtp->rxcore.tv_sec -= 1;
1025 }
1026 }
1027
1028 gettimeofday(&now,NULL);
1029 /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1030 tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
1031 tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
1032 if (tv->tv_usec >= 1000000) {
1033 tv->tv_usec -= 1000000;
1034 tv->tv_sec += 1;
1035 }
1036 prog = (double)((timestamp-rtp->seedrxts)/8000.);
1037 dtv = (double)rtp->drxcore + (double)(prog);
1038 current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1039 transit = current_time - dtv;
1040 d = transit - rtp->rxtransit;
1041 rtp->rxtransit = transit;
1042 if (d<0)
1043 d=-d;
1044 rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1045 if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
1046 rtp->rtcp->maxrxjitter = rtp->rxjitter;
1047 if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1048 rtp->rtcp->minrxjitter = rtp->rxjitter;
1049 }
1050
1051 /*! \brief Perform a Packet2Packet RTP write */
1052 static int bridge_p2p_rtp_write(struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
1053 {
1054 int res = 0, payload = 0, bridged_payload = 0, mark;
1055 struct rtpPayloadType rtpPT;
1056 int reconstruct = ntohl(rtpheader[0]);
1057
1058 /* Get fields from packet */
1059 payload = (reconstruct & 0x7f0000) >> 16;
1060 mark = (((reconstruct & 0x800000) >> 23) != 0);
1061
1062 /* Check what the payload value should be */
1063 rtpPT = ast_rtp_lookup_pt(rtp, payload);
1064
1065 /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1066 if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
1067 return -1;
1068
1069 /* Otherwise adjust bridged payload to match */
1070 bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
1071
1072 /* If the payload coming in is not one of the negotiated ones then send it to the core, this will cause formats to change and the bridge to break */
1073 if (!bridged->current_RTP_PT[bridged_payload].code)
1074 return -1;
1075
1076
1077 /* If the mark bit has not been sent yet... do it now */
1078 if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
1079 mark = 1;
1080 ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
1081 }
1082
1083 /* Reconstruct part of the packet */
1084 reconstruct &= 0xFF80FFFF;
1085 reconstruct |= (bridged_payload << 16);
1086 reconstruct |= (mark << 23);
1087 rtpheader[0] = htonl(reconstruct);
1088
1089 /* Send the packet back out */
1090 res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
1091 if (res < 0) {
1092 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1093 ast_log(LOG_DEBUG, "RTP Transmission error of packet to %s:%d: %s\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), strerror(errno));
1094 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1095 if (option_debug || rtpdebug)
1096 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(bridged->them.sin_addr), ntohs(bridged->them.sin_port));
1097 ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1098 }
1099 return 0;
1100 } else if (rtp_debug_test_addr(&bridged->them))
1101 ast_verbose("Sent RTP P2P packet to %s:%u (type %-2.2d, len %-6.6u)\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), bridged_payload, len - hdrlen);
1102
1103 return 0;
1104 }
1105
1106 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
1107 {
1108 int res;
1109 struct sockaddr_in sin;
1110 socklen_t len;
1111 unsigned int seqno;
1112 int version;
1113 int payloadtype;
1114 int hdrlen = 12;
1115 int padding;
1116 int mark;
1117 int ext;
1118 int cc;
1119 unsigned int ssrc;
1120 unsigned int timestamp;
1121 unsigned int *rtpheader;
1122 struct rtpPayloadType rtpPT;
1123 struct ast_rtp *bridged = NULL;
1124
1125 /* If time is up, kill it */
1126 if (rtp->sending_digit)
1127 ast_rtp_senddigit_continuation(rtp);
1128
1129 len = sizeof(sin);
1130
1131 /* Cache where the header will go */
1132 res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
1133 0, (struct sockaddr *)&sin, &len);
1134
1135 rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
1136 if (res < 0) {
1137 ast_assert(errno != EBADF);
1138 if (errno != EAGAIN) {
1139 ast_log(LOG_WARNING, "RTP Read error: %s. Hanging up.\n", strerror(errno));
1140 return NULL;
1141 }
1142 return &ast_null_frame;
1143 }
1144
1145 if (res < hdrlen) {
1146 ast_log(LOG_WARNING, "RTP Read too short\n");
1147 return &ast_null_frame;
1148 }
1149
1150 /* Get fields */
1151 seqno = ntohl(rtpheader[0]);
1152
1153 /* Check RTP version */
1154 version = (seqno & 0xC0000000) >> 30;
1155 if (!version) {
1156 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) &&
1157 (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
1158 memcpy(&rtp->them, &sin, sizeof(rtp->them));
1159 }
1160 return &ast_null_frame;
1161 }
1162
1163 #if 0 /* Allow to receive RTP stream with closed transmission path */
1164 /* If we don't have the other side's address, then ignore this */
1165 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1166 return &ast_null_frame;
1167 #endif
1168
1169 /* Send to whoever send to us if NAT is turned on */
1170 if (rtp->nat) {
1171 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1172 (rtp->them.sin_port != sin.sin_port)) {
1173 rtp->them = sin;
1174 if (rtp->rtcp) {
1175 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1176 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1);
1177 }
1178 rtp->rxseqno = 0;
1179 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1180 if (option_debug || rtpdebug)
1181 ast_log(LOG_DEBUG, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
1182 }
1183 }
1184
1185 /* If we are bridged to another RTP stream, send direct */
1186 if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen))
1187 return &ast_null_frame;
1188
1189 if (version != 2)
1190 return &ast_null_frame;
1191
1192 payloadtype = (seqno & 0x7f0000) >> 16;
1193 padding = seqno & (1 << 29);
1194 mark = seqno & (1 << 23);
1195 ext = seqno & (1 << 28);
1196 cc = (seqno & 0xF000000) >> 24;
1197 seqno &= 0xffff;
1198 timestamp = ntohl(rtpheader[1]);
1199 ssrc = ntohl(rtpheader[2]);
1200
1201 if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1202 if (option_debug || rtpdebug)
1203 ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n");
1204 mark = 1;
1205 }
1206
1207 rtp->rxssrc = ssrc;
1208
1209 if (padding) {
1210 /* Remove padding bytes */
1211 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1212 }
1213
1214 if (cc) {
1215 /* CSRC fields present */
1216 hdrlen += cc*4;
1217 }
1218
1219 if (ext) {
1220 /* RTP Extension present */
1221 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
1222 hdrlen += 4;
1223 }
1224
1225 if (res < hdrlen) {
1226 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1227 return &ast_null_frame;
1228 }
1229
1230 rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1231
1232 if (rtp->rxcount==1) {
1233 /* This is the first RTP packet successfully received from source */
1234 rtp->seedrxseqno = seqno;
1235 }
1236
1237 /* Do not schedule RR if RTCP isn't run */
1238 if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1239 /* Schedule transmission of Receiver Report */
1240 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1241 }
1242 if ( (int)rtp->lastrxseqno - (int)seqno > 100) /* if so it would indicate that the sender cycled; allow for misordering */
1243 rtp->cycles += RTP_SEQ_MOD;
1244
1245 rtp->lastrxseqno = seqno;
1246
1247 if (rtp->themssrc==0)
1248 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1249
1250 if (rtp_debug_test_addr(&sin))
1251 ast_verbose("Got RTP packet from %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1252 ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1253
1254 rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1255 if (!rtpPT.isAstFormat) {
1256 struct ast_frame *f = NULL;
1257
1258 /* This is special in-band data that's not one of our codecs */
1259 if (rtpPT.code == AST_RTP_DTMF) {
1260 /* It's special -- rfc2833 process it */
1261 if (rtp_debug_test_addr(&sin)) {
1262 unsigned char *data;
1263 unsigned int event;
1264 unsigned int event_end;
1265 unsigned int duration;
1266 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1267 event = ntohl(*((unsigned int *)(data)));
1268 event >>= 24;
1269 event_end = ntohl(*((unsigned int *)(data)));
1270 event_end <<= 8;
1271 event_end >>= 24;
1272 duration = ntohl(*((unsigned int *)(data)));
1273 duration &= 0xFFFF;
1274 ast_verbose("Got RTP RFC2833 from %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration);
1275 }
1276 f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp);
1277 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1278 /* It's really special -- process it the Cisco way */
1279 if (rtp->lastevent <= seqno || (rtp->lastevent >= 65530 && seqno <= 6)) {
1280 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1281 rtp->lastevent = seqno;
1282 }
1283 } else if (rtpPT.code == AST_RTP_CN) {
1284 /* Comfort Noise */
1285 f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1286 } else {
1287 ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1288 }
1289 return f ? f : &ast_null_frame;
1290 }
1291 rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1292 rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO;
1293
1294 if (!rtp->lastrxts)
1295 rtp->lastrxts = timestamp;
1296
1297 rtp->rxseqno = seqno;
1298
1299 /* Record received timestamp as last received now */
1300 rtp->lastrxts = timestamp;
1301
1302 rtp->f.mallocd = 0;
1303 rtp->f.datalen = res - hdrlen;
1304 rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1305 rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1306 rtp->f.seqno = seqno;
1307 if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
1308 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1309 if (rtp->f.subclass == AST_FORMAT_SLINEAR)
1310 ast_frame_byteswap_be(&rtp->f);
1311 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1312 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1313 ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
1314 rtp->f.ts = timestamp / 8;
1315 rtp->f.len = rtp->f.samples / (ast_format_rate(rtp->f.subclass) / 1000);
1316 } else {
1317 /* Video -- samples is # of samples vs. 90000 */
1318 if (!rtp->lastividtimestamp)
1319 rtp->lastividtimestamp = timestamp;
1320 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1321 rtp->lastividtimestamp = timestamp;
1322 rtp->f.delivery.tv_sec = 0;
1323 rtp->f.delivery.tv_usec = 0;
1324 if (mark)
1325 rtp->f.subclass |= 0x1;
1326
1327 }
1328 rtp->f.src = "RTP";
1329 return &rtp->f;
1330 }
1331
1332 /* The following array defines the MIME Media type (and subtype) for each
1333 of our codecs, or RTP-specific data type. */
1334 static struct {
1335 struct rtpPayloadType payloadType;
1336 char* type;
1337 char* subtype;
1338 } mimeTypes[] = {
1339 {{1, AST_FORMAT_G723_1}, "audio", "G723"},
1340 {{1, AST_FORMAT_GSM}, "audio", "GSM"},
1341 {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
1342 {{1, AST_FORMAT_ULAW}, "audio", "G711U"},
1343 {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
1344 {{1, AST_FORMAT_ALAW}, "audio", "G711A"},
1345 {{1, AST_FORMAT_G726}, "audio", "G726-32"},
1346 {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
1347 {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
1348 {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
1349 {{1, AST_FORMAT_G729A}, "audio", "G729"},
1350 {{1, AST_FORMAT_G729A}, "audio", "G729A"},
1351 {{1, AST_FORMAT_G729A}, "audio", "G.729"},
1352 {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
1353 {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1354 {{1, AST_FORMAT_G722}, "audio", "G722"},
1355 {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1356 {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1357 {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1358 {{0, AST_RTP_CN}, "audio", "CN"},
1359 {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1360 {{1, AST_FORMAT_PNG}, "video", "PNG"},
1361 {{1, AST_FORMAT_H261}, "video", "H261"},
1362 {{1, AST_FORMAT_H263}, "video", "H263"},
1363 {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1364 {{1, AST_FORMAT_H264}, "video", "H264"},
1365 };
1366
1367 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1368 also, our own choices for dynamic payload types. This is our master
1369 table for transmission */
1370 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1371 [0] = {1, AST_FORMAT_ULAW},
1372 #ifdef USE_DEPRECATED_G726
1373 [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1374 #endif
1375 [3] = {1, AST_FORMAT_GSM},
1376 [4] = {1, AST_FORMAT_G723_1},
1377 [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1378 [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1379 [7] = {1, AST_FORMAT_LPC10},
1380 [8] = {1, AST_FORMAT_ALAW},
1381 [9] = {1, AST_FORMAT_G722},
1382 [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1383 [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1384 [13] = {0, AST_RTP_CN},
1385 [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1386 [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1387 [18] = {1, AST_FORMAT_G729A},
1388 [19] = {0, AST_RTP_CN}, /* Also used for CN */
1389 [26] = {1, AST_FORMAT_JPEG},
1390 [31] = {1, AST_FORMAT_H261},
1391 [34] = {1, AST_FORMAT_H263},
1392 [103] = {1, AST_FORMAT_H263_PLUS},
1393 [97] = {1, AST_FORMAT_ILBC},
1394 [99] = {1, AST_FORMAT_H264},
1395 [101] = {0, AST_RTP_DTMF},
1396 [110] = {1, AST_FORMAT_SPEEX},
1397 [111] = {1, AST_FORMAT_G726},
1398 [112] = {1, AST_FORMAT_G726_AAL2},
1399 [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1400 };
1401
1402 void ast_rtp_pt_clear(struct ast_rtp* rtp)
1403 {
1404 int i;
1405
1406 if (!rtp)
1407 return;
1408
1409 ast_mutex_lock(&rtp->bridge_lock);
1410
1411 for (i = 0; i < MAX_RTP_PT; ++i) {
1412 rtp->current_RTP_PT[i].isAstFormat = 0;
1413 rtp->current_RTP_PT[i].code = 0;
1414 }
1415
1416 rtp->rtp_lookup_code_cache_isAstFormat = 0;
1417 rtp->rtp_lookup_code_cache_code = 0;
1418 rtp->rtp_lookup_code_cache_result = 0;
1419
1420 ast_mutex_unlock(&rtp->bridge_lock);
1421 }
1422
1423 void ast_rtp_pt_default(struct ast_rtp* rtp)
1424 {
1425 int i;
1426
1427 ast_mutex_lock(&rtp->bridge_lock);
1428
1429 /* Initialize to default payload types */
1430 for (i = 0; i < MAX_RTP_PT; ++i) {
1431 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1432 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1433 }
1434
1435 rtp->rtp_lookup_code_cache_isAstFormat = 0;
1436 rtp->rtp_lookup_code_cache_code = 0;
1437 rtp->rtp_lookup_code_cache_result = 0;
1438
1439 ast_mutex_unlock(&rtp->bridge_lock);
1440 }
1441
1442 void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
1443 {
1444 unsigned int i;
1445
1446 ast_mutex_lock(&dest->bridge_lock);
1447 ast_mutex_lock(&src->bridge_lock);
1448
1449 for (i=0; i < MAX_RTP_PT; ++i) {
1450 dest->current_RTP_PT[i].isAstFormat =
1451 src->current_RTP_PT[i].isAstFormat;
1452 dest->current_RTP_PT[i].code =
1453 src->current_RTP_PT[i].code;
1454 }
1455 dest->rtp_lookup_code_cache_isAstFormat = 0;
1456 dest->rtp_lookup_code_cache_code = 0;
1457 dest->rtp_lookup_code_cache_result = 0;
1458
1459 ast_mutex_unlock(&src->bridge_lock);
1460 ast_mutex_unlock(&dest->bridge_lock);
1461 }
1462
1463 /*! \brief Get channel driver interface structure */
1464 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1465 {
1466 struct ast_rtp_protocol *cur = NULL;
1467
1468 AST_LIST_LOCK(&protos);
1469 AST_LIST_TRAVERSE(&protos, cur, list) {
1470 if (cur->type == chan->tech->type)
1471 break;
1472 }
1473 AST_LIST_UNLOCK(&protos);
1474
1475 return cur;
1476 }
1477
1478 int ast_rtp_early_bridge(struct ast_channel *dest, struct ast_channel *src)
1479 {
1480 struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */
1481 struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */
1482 struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1483 enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1484 enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED;
1485 int srccodec, destcodec, nat_active = 0;
1486
1487 /* Lock channels */
1488 ast_channel_lock(dest);
1489 if (src) {
1490 while(ast_channel_trylock(src)) {
1491 ast_channel_unlock(dest);
1492 usleep(1);
1493 ast_channel_lock(dest);
1494 }
1495 }
1496
1497 /* Find channel driver interfaces */
1498 destpr = get_proto(dest);
1499 if (src)
1500 srcpr = get_proto(src);
1501 if (!destpr) {
1502 if (option_debug)
1503 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1504 ast_channel_unlock(dest);
1505 if (src)
1506 ast_channel_unlock(src);
1507 return 0;
1508 }
1509 if (!srcpr) {
1510 if (option_debug)
1511 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src ? src->name : "<unspecified>");
1512 ast_channel_unlock(dest);
1513 if (src)
1514 ast_channel_unlock(src);
1515 return 0;
1516 }
1517
1518 /* Get audio and video interface (if native bridge is possible) */
1519 audio_dest_res = destpr->get_rtp_info(dest, &destp);
1520 video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1521 if (srcpr) {
1522 audio_src_res = srcpr->get_rtp_info(src, &srcp);
1523 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1524 }
1525
1526 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1527 if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1528 /* Somebody doesn't want to play... */
1529 ast_channel_unlock(dest);
1530 if (src)
1531 ast_channel_unlock(src);
1532 return 0;
1533 }
1534 if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1535 srccodec = srcpr->get_codec(src);
1536 else
1537 srccodec = 0;
1538 if (audio_dest_res == AST_RTP_TRY_NATIVE && destpr->get_codec)
1539 destcodec = destpr->get_codec(dest);
1540 else
1541 destcodec = 0;
1542 /* Ensure we have at least one matching codec */
1543 if (!(srccodec & destcodec)) {
1544 ast_channel_unlock(dest);
1545 if (src)
1546 ast_channel_unlock(src);
1547 return 0;
1548 }
1549 /* Consider empty media as non-existant */
1550 if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1551 srcp = NULL;
1552 /* If the client has NAT stuff turned on then just safe NAT is active */
1553 if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1554 nat_active = 1;
1555 /* Bridge media early */
1556 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, nat_active))
1557 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src ? src->name : "<unspecified>");
1558 ast_channel_unlock(dest);
1559 if (src)
1560 ast_channel_unlock(src);
1561 if (option_debug)
1562 ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", dest->name, src ? src->name : "<unspecified>");
1563 return 1;
1564 }
1565
1566 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1567 {
1568 struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */
1569 struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */
1570 struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1571 enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1572 enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED;
1573 int srccodec, destcodec;
1574
1575 /* Lock channels */
1576 ast_channel_lock(dest);
1577 while(ast_channel_trylock(src)) {
1578 ast_channel_unlock(dest);
1579 usleep(1);
1580 ast_channel_lock(dest);
1581 }
1582
1583 /* Find channel driver interfaces */
1584 if (!(destpr = get_proto(dest))) {
1585 if (option_debug)
1586 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1587 ast_channel_unlock(dest);
1588 ast_channel_unlock(src);
1589 return 0;
1590 }
1591 if (!(srcpr = get_proto(src))) {
1592 if (option_debug)
1593 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1594 ast_channel_unlock(dest);
1595 ast_channel_unlock(src);
1596 return 0;
1597 }
1598
1599 /* Get audio and video interface (if native bridge is possible) */
1600 audio_dest_res = destpr->get_rtp_info(dest, &destp);
1601 video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1602 audio_src_res = srcpr->get_rtp_info(src, &srcp);
1603 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1604
1605 /* Ensure we have at least one matching codec */
1606 if (srcpr->get_codec)
1607 srccodec = srcpr->get_codec(src);
1608 else
1609 srccodec = 0;
1610 if (destpr->get_codec)
1611 destcodec = destpr->get_codec(dest);
1612 else
1613 destcodec = 0;
1614
1615 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1616 if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE || !(srccodec & destcodec)) {
1617 /* Somebody doesn't want to play... */
1618 ast_channel_unlock(dest);
1619 ast_channel_unlock(src);
1620 return 0;
1621 }
1622 ast_rtp_pt_copy(destp, srcp);
1623 if (vdestp && vsrcp)
1624 ast_rtp_pt_copy(vdestp, vsrcp);
1625 if (media) {
1626 /* Bridge early */
1627 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1628 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1629 }
1630 ast_channel_unlock(dest);
1631 ast_channel_unlock(src);
1632 if (option_debug)
1633 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1634 return 1;
1635 }
1636
1637 /*! \brief Make a note of a RTP payload type that was seen in a SDP "m=" line.
1638 * By default, use the well-known value for this type (although it may
1639 * still be set to a different value by a subsequent "a=rtpmap:" line)
1640 */
1641 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt)
1642 {
1643 if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0)
1644 return; /* bogus payload type */
1645
1646 ast_mutex_lock(&rtp->bridge_lock);
1647 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1648 ast_mutex_unlock(&rtp->bridge_lock);
1649 }
1650
1651 /*! \brief remove setting from payload type list if the rtpmap header indicates
1652 an unknown media type */
1653 void ast_rtp_unset_m_type(struct ast_rtp* rtp, int pt)
1654 {
1655 if (pt < 0 || pt > MAX_RTP_PT)
1656 return; /* bogus payload type */
1657
1658 ast_mutex_lock(&rtp->bridge_lock);
1659 rtp->current_RTP_PT[pt].isAstFormat = 0;
1660 rtp->current_RTP_PT[pt].code = 0;
1661 ast_mutex_unlock(&rtp->bridge_lock);
1662 }
1663
1664 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1665 * an SDP "a=rtpmap:" line.
1666 * \return 0 if the MIME type was found and set, -1 if it wasn't found
1667 */
1668 int ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1669 char *mimeType, char *mimeSubtype,
1670 enum ast_rtp_options options)
1671 {
1672 unsigned int i;
1673 int found = 0;
1674
1675 if (pt < 0 || pt > MAX_RTP_PT)
1676 return -1; /* bogus payload type */
1677
1678 ast_mutex_lock(&rtp->bridge_lock);
1679
1680 for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1681 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1682 strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1683 found = 1;
1684 rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1685 if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1686 mimeTypes[i].payloadType.isAstFormat &&
1687 (options & AST_RTP_OPT_G726_NONSTANDARD))
1688 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1689 break;
1690 }
1691 }
1692
1693 ast_mutex_unlock(&rtp->bridge_lock);
1694
1695 return (found ? 0 : -1);
1696 }
1697
1698 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls
1699 * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1700 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1701 int* astFormats, int* nonAstFormats)
1702 {
1703 int pt;
1704
1705 ast_mutex_lock(&rtp->bridge_lock);
1706
1707 *astFormats = *nonAstFormats = 0;
1708 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1709 if (rtp->current_RTP_PT[pt].isAstFormat) {
1710 *astFormats |= rtp->current_RTP_PT[pt].code;
1711 } else {
1712 *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1713 }
1714 }
1715
1716 ast_mutex_unlock(&rtp->bridge_lock);
1717
1718 return;
1719 }
1720
1721 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt)
1722 {
1723 struct rtpPayloadType result;
1724
1725 result.isAstFormat = result.code = 0;
1726
1727 if (pt < 0 || pt > MAX_RTP_PT)
1728 return result; /* bogus payload type */
1729
1730 /* Start with negotiated codecs */
1731 ast_mutex_lock(&rtp->bridge_lock);
1732 result = rtp->current_RTP_PT[pt];
1733 ast_mutex_unlock(&rtp->bridge_lock);
1734
1735 /* If it doesn't exist, check our static RTP type list, just in case */
1736 if (!result.code)
1737 result = static_RTP_PT[pt];
1738
1739 return result;
1740 }
1741
1742 /*! \brief Looks up an RTP code out of our *static* outbound list */
1743 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
1744 {
1745 int pt = 0;
1746
1747 ast_mutex_lock(&rtp->bridge_lock);
1748
1749 if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1750 code == rtp->rtp_lookup_code_cache_code) {
1751 /* Use our cached mapping, to avoid the overhead of the loop below */
1752 pt = rtp->rtp_lookup_code_cache_result;
1753 ast_mutex_unlock(&rtp->bridge_lock);
1754 return pt;
1755 }
1756
1757 /* Check the dynamic list first */
1758 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1759 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1760 rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1761 rtp->rtp_lookup_code_cache_code = code;
1762 rtp->rtp_lookup_code_cache_result = pt;
1763 ast_mutex_unlock(&rtp->bridge_lock);
1764 return pt;
1765 }
1766 }
1767
1768 /* Then the static list */
1769 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1770 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1771 rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1772 rtp->rtp_lookup_code_cache_code = code;
1773 rtp->rtp_lookup_code_cache_result = pt;
1774 ast_mutex_unlock(&rtp->bridge_lock);
1775 return pt;
1776 }
1777 }
1778
1779 ast_mutex_unlock(&rtp->bridge_lock);
1780
1781 return -1;
1782 }
1783
1784 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
1785 enum ast_rtp_options options)
1786 {
1787 unsigned int i;
1788
1789 for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1790 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
1791 if (isAstFormat &&
1792 (code == AST_FORMAT_G726_AAL2) &&
1793 (options & AST_RTP_OPT_G726_NONSTANDARD))
1794 return "G726-32";
1795 else
1796 return mimeTypes[i].subtype;
1797 }
1798 }
1799
1800 return "";
1801 }
1802
1803 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
1804 const int isAstFormat, enum ast_rtp_options options)
1805 {
1806 int format;
1807 unsigned len;
1808 char *end = buf;
1809 char *start = buf;
1810
1811 if (!buf || !size)
1812 return NULL;
1813
1814 snprintf(end, size, "0x%x (", capability);
1815
1816 len = strlen(end);
1817 end += len;
1818 size -= len;
1819 start = end;
1820
1821 for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1822 if (capability & format) {
1823 const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
1824
1825 snprintf(end, size, "%s|", name);
1826 len = strlen(end);
1827 end += len;
1828 size -= len;
1829 }
1830 }
1831
1832 if (start == end)
1833 snprintf(start, size, "nothing)");
1834 else if (size > 1)
1835 *(end -1) = ')';
1836
1837 return buf;
1838 }
1839
1840 static int rtp_socket(void)
1841 {
1842 int s;
1843 long flags;
1844 s = socket(AF_INET, SOCK_DGRAM, 0);
1845 if (s > -1) {
1846 flags = fcntl(s, F_GETFL);
1847 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1848 #ifdef SO_NO_CHECK
1849 if (nochecksums)
1850 setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1851 #endif
1852 }
1853 return s;
1854 }
1855
1856 /*!
1857 * \brief Initialize a new RTCP session.
1858 *
1859 * \returns The newly initialized RTCP session.
1860 */
1861 static struct ast_rtcp *ast_rtcp_new(void)
1862 {
1863 struct ast_rtcp *rtcp;
1864
1865 if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1866 return NULL;
1867 rtcp->s = rtp_socket();
1868 rtcp->us.sin_family = AF_INET;
1869 rtcp->them.sin_family = AF_INET;
1870 rtcp->schedid = -1;
1871
1872 if (rtcp->s < 0) {
1873 free(rtcp);
1874 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
1875 return NULL;
1876 }
1877
1878 return rtcp;
1879 }
1880
1881 /*!
1882 * \brief Initialize a new RTP structure.
1883 *
1884 */
1885 void ast_rtp_new_init(struct ast_rtp *rtp)
1886 {
1887 ast_mutex_init(&rtp->bridge_lock);
1888
1889 rtp->them.sin_family = AF_INET;
1890 rtp->us.sin_family = AF_INET;
1891 rtp->ssrc = ast_random();
1892 rtp->seqno = ast_random() & 0xffff;
1893 ast_set_flag(rtp, FLAG_HAS_DTMF);
1894
1895 return;
1896 }
1897
1898 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1899 {
1900 struct ast_rtp *rtp;
1901 int x;
1902 int first;
1903 int startplace;
1904
1905 if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1906 return NULL;
1907
1908 ast_rtp_new_init(rtp);
1909
1910 rtp->s = rtp_socket();
1911 if (rtp->s < 0) {
1912 free(rtp);
1913 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1914 return NULL;
1915 }
1916 if (sched && rtcpenable) {
1917 rtp->sched = sched;
1918 rtp->rtcp = ast_rtcp_new();
1919 }
1920
1921 /* Select a random port number in the range of possible RTP */
1922 x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1923 x = x & ~1;
1924 /* Save it for future references. */
1925 startplace = x;
1926 /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1927 for (;;) {
1928 /* Must be an even port number by RTP spec */
1929 rtp->us.sin_port = htons(x);
1930 rtp->us.sin_addr = addr;
1931 /* If there's rtcp, initialize it as well. */
1932 if (rtp->rtcp) {
1933 rtp->rtcp->us.sin_port = htons(x + 1);
1934 rtp->rtcp->us.sin_addr = addr;
1935 }
1936 /* Try to bind it/them. */
1937 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1938 (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1939 break;
1940 if (!first) {
1941 /* Primary bind succeeded! Gotta recreate it */
1942 close(rtp->s);
1943 rtp->s = rtp_socket();
1944 }
1945 if (errno != EADDRINUSE) {
1946 /* We got an error that wasn't expected, abort! */
1947 ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1948 close(rtp->s);
1949 if (rtp->rtcp) {
1950 close(rtp->rtcp->s);
1951 free(rtp->rtcp);
1952 }
1953 free(rtp);
1954 return NULL;
1955 }
1956 /* The port was used, increment it (by two). */
1957 x += 2;
1958 /* Did we go over the limit ? */
1959 if (x > rtpend)
1960 /* then, start from the begingig. */
1961 x = (rtpstart + 1) & ~1;
1962 /* Check if we reached the place were we started. */
1963 if (x == startplace) {
1964 /* If so, there's no ports available. */
1965 ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1966 close(rtp->s);
1967 if (rtp->rtcp) {
1968 close(rtp->rtcp->s);
1969 free(rtp->rtcp);
1970 }
1971 free(rtp);
1972 return NULL;
1973 }
1974 }
1975 rtp->sched = sched;
1976 rtp->io = io;
1977 if (callbackmode) {
1978 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1979 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
1980 }
1981 ast_rtp_pt_default(rtp);
1982 return rtp;
1983 }
1984
1985 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1986 {
1987 struct in_addr ia;
1988
1989 memset(&ia, 0, sizeof(ia));
1990 return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1991 }
1992
1993 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1994 {
1995 int res;
1996
1997 if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos))))
1998 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1999 return res;
2000 }
2001
2002 void ast_rtp_new_source(struct ast_rtp *rtp)
2003 {
2004 if (rtp) {
2005 rtp->set_marker_bit = 1;
2006 }
2007 return;
2008 }
2009
2010 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2011 {
2012 rtp->them.sin_port = them->sin_port;
2013 rtp->them.sin_addr = them->sin_addr;
2014 if (rtp->rtcp) {
2015 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
2016 rtp->rtcp->them.sin_addr = them->sin_addr;
2017 }
2018 rtp->rxseqno = 0;
2019 }
2020
2021 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2022 {
2023 if ((them->sin_family != AF_INET) ||
2024 (them->sin_port != rtp->them.sin_port) ||
2025 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2026 them->sin_family = AF_INET;
2027 them->sin_port = rtp->them.sin_port;
2028 them->sin_addr = rtp->them.sin_addr;
2029 return 1;
2030 }
2031 return 0;
2032 }
2033
2034 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2035 {
2036 *us = rtp->us;
2037 }
2038
2039 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2040 {
2041 struct ast_rtp *bridged = NULL;
2042
2043 ast_mutex_lock(&rtp->bridge_lock);
2044 bridged = rtp->bridged;
2045 ast_mutex_unlock(&rtp->bridge_lock);
2046
2047 return bridged;
2048 }
2049
2050 void ast_rtp_stop(struct ast_rtp *rtp)
2051 {
2052 if (rtp->rtcp) {
2053 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2054 }
2055
2056 memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2057 memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2058 if (rtp->rtcp) {
2059 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2060 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2061 }
2062
2063 ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2064 }
2065
2066 void ast_rtp_reset(struct ast_rtp *rtp)
2067 {
2068 memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2069 memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2070 memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2071 rtp->lastts = 0;
2072 rtp->lastdigitts = 0;
2073 rtp->lastrxts = 0;
2074 rtp->lastividtimestamp = 0;
2075 rtp->lastovidtimestamp = 0;
2076 rtp->lasteventseqn = 0;
2077 rtp->lastevent = 0;
2078 rtp->lasttxformat = 0;
2079 rtp->lastrxformat = 0;
2080 rtp->dtmfcount = 0;
2081 rtp->dtmfsamples = 0;
2082 rtp->seqno = 0;
2083 rtp->rxseqno = 0;
2084 }
2085
2086 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2087 {
2088 /*
2089 *ssrc our ssrc
2090 *themssrc their ssrc
2091 *lp lost packets
2092 *rxjitter our calculated jitter(rx)
2093 *rxcount no. received packets
2094 *txjitter reported jitter of the other end
2095 *txcount transmitted packets
2096 *rlp remote lost packets
2097 *rtt round trip time
2098 */
2099
2100 if (qual && rtp) {
2101 qual->local_ssrc = rtp->ssrc;
2102 qual->local_jitter = rtp->rxjitter;
2103 qual->local_count = rtp->rxcount;
2104 qual->remote_ssrc = rtp->themssrc;
2105 qual->remote_count = rtp->txcount;
2106 if (rtp->rtcp) {
2107 qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2108 qual->remote_lostpackets = rtp->rtcp->reported_lost;
2109 qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2110 qual->rtt = rtp->rtcp->rtt;
2111 }
2112 }
2113 if (rtp->rtcp) {
2114 snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality),
2115 "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f",
2116 rtp->ssrc,
2117 rtp->themssrc,
2118 rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2119 rtp->rxjitter,
2120 rtp->rxcount,
2121 (double)rtp->rtcp->reported_jitter / 65536.0,
2122 rtp->txcount,
2123 rtp->rtcp->reported_lost,
2124 rtp->rtcp->rtt);
2125 return rtp->rtcp->quality;
2126 } else
2127 return "<Unknown> - RTP/RTCP has already been destroyed";
2128 }
2129
2130 void ast_rtp_destroy(struct ast_rtp *rtp)
2131 {
2132 if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2133 /*Print some info on the call here */
2134 ast_verbose(" RTP-stats\n");
2135 ast_verbose("* Our Receiver:\n");
2136 ast_verbose(" SSRC: %u\n", rtp->themssrc);
2137 ast_verbose(" Received packets: %u\n", rtp->rxcount);
2138 ast_verbose(" Lost packets: %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2139 ast_verbose(" Jitter: %.4f\n", rtp->rxjitter);
2140 ast_verbose(" Transit: %.4f\n", rtp->rxtransit);
2141 ast_verbose(" RR-count: %u\n", rtp->rtcp->rr_count);
2142 ast_verbose("* Our Sender:\n");
2143 ast_verbose(" SSRC: %u\n", rtp->ssrc);
2144 ast_verbose(" Sent packets: %u\n", rtp->txcount);
2145 ast_verbose(" Lost packets: %u\n", rtp->rtcp->reported_lost);
2146 ast_verbose(" Jitter: %u\n", rtp->rtcp->reported_jitter / (unsigned int)65536.0);
2147 ast_verbose(" SR-count: %u\n", rtp->rtcp->sr_count);
2148 ast_verbose(" RTT: %f\n", rtp->rtcp->rtt);
2149 }
2150
2151 if (rtp->smoother)
2152 ast_smoother_free(rtp->smoother);
2153 if (rtp->ioid)
2154 ast_io_remove(rtp->io, rtp->ioid);
2155 if (rtp->s > -1)
2156 close(rtp->s);
2157 if (rtp->rtcp) {
2158 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2159 close(rtp->rtcp->s);
2160 free(rtp->rtcp);
2161 rtp->rtcp=NULL;
2162 }
2163
2164 ast_mutex_destroy(&rtp->bridge_lock);
2165
2166 free(rtp);
2167 }
2168
2169 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2170 {
2171 struct timeval t;
2172 long ms;
2173 if (ast_tvzero(rtp->txcore)) {
2174 rtp->txcore = ast_tvnow();
2175 /* Round to 20ms for nice, pretty timestamps */
2176 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2177 }
2178 /* Use previous txcore if available */
2179 t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2180 ms = ast_tvdiff_ms(t, rtp->txcore);
2181 if (ms < 0)
2182 ms = 0;
2183 /* Use what we just got for next time */
2184 rtp->txcore = t;
2185 return (unsigned int) ms;
2186 }
2187
2188 /*! \brief Send begin frames for DTMF */
2189 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2190 {
2191 unsigned int *rtpheader;
2192 int hdrlen = 12, res = 0, i = 0, payload = 0;
2193 char data[256];
2194
2195 if ((digit <= '9') && (digit >= '0'))
2196 digit -= '0';
2197 else if (digit == '*')
2198 digit = 10;
2199 else if (digit == '#')
2200 digit = 11;
2201 else if ((digit >= 'A') && (digit <= 'D'))
2202 digit = digit - 'A' + 12;
2203 else if ((digit >= 'a') && (digit <= 'd'))
2204 digit = digit - 'a' + 12;
2205 else {
2206 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2207 return 0;
2208 }
2209
2210 /* If we have no peer, return immediately */
2211 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2212 return 0;
2213
2214 payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2215
2216 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2217 rtp->send_duration = 160;
2218
2219 /* Get a pointer to the header */
2220 rtpheader = (unsigned int *)data;
2221 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2222 rtpheader[1] = htonl(rtp->lastdigitts);
2223 rtpheader[2] = htonl(rtp->ssrc);
2224
2225 for (i = 0; i < 2; i++) {
2226 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2227 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2228 if (res < 0)
2229 ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2230 ast_inet_ntoa(rtp->them.sin_addr),
2231 ntohs(rtp->them.sin_port), strerror(errno));
2232 if (rtp_debug_test_addr(&rtp->them))
2233 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2234 ast_inet_ntoa(rtp->them.sin_addr),
2235 ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2236 /* Increment sequence number */
2237 rtp->seqno++;
2238 /* Increment duration */
2239 rtp->send_duration += 160;
2240 /* Clear marker bit and set seqno */
2241 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2242 }
2243
2244 /* Since we received a begin, we can safely store the digit and disable any compensation */
2245 rtp->sending_digit = 1;
2246 rtp->send_digit = digit;
2247 rtp->send_payload = payload;
2248
2249 return 0;
2250 }
2251
2252 /*! \brief Send continuation frame for DTMF */
2253 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2254 {
2255 unsigned int *rtpheader;
2256 int hdrlen = 12, res = 0;
2257 char data[256];
2258
2259 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2260 return 0;
2261
2262 /* Setup packet to send */
2263 rtpheader = (unsigned int *)data;
2264 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2265 rtpheader[1] = htonl(rtp->lastdigitts);
2266 rtpheader[2] = htonl(rtp->ssrc);
2267 rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2268 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2269
2270 /* Transmit */
2271 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2272 if (res < 0)
2273 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2274 ast_inet_ntoa(rtp->them.sin_addr),
2275 ntohs(rtp->them.sin_port), strerror(errno));
2276 if (rtp_debug_test_addr(&rtp->them))
2277 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2278 ast_inet_ntoa(rtp->them.sin_addr),
2279 ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2280
2281 /* Increment sequence number */
2282 rtp->seqno++;
2283 /* Increment duration */
2284 rtp->send_duration += 160;
2285
2286 return 0;
2287 }
2288
2289 /*! \brief Send end packets for DTMF */
2290 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2291 {
2292 unsigned int *rtpheader;
2293 int hdrlen = 12, res = 0, i = 0;
2294 char data[256];
2295
2296 /* If no address, then bail out */
2297 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2298 return 0;
2299
2300 if ((digit <= '9') && (digit >= '0'))
2301 digit -= '0';
2302 else if (digit == '*')
2303 digit = 10;
2304 else if (digit == '#')
2305 digit = 11;
2306 else if ((digit >= 'A') && (digit <= 'D'))
2307 digit = digit - 'A' + 12;
2308 else if ((digit >= 'a') && (digit <= 'd'))
2309 digit = digit - 'a' + 12;
2310 else {
2311 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2312 return 0;
2313 }
2314
2315 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2316
2317 rtpheader = (unsigned int *)data;
2318 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2319 rtpheader[1] = htonl(rtp->lastdigitts);
2320 rtpheader[2] = htonl(rtp->ssrc);
2321 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2322 /* Set end bit */
2323 rtpheader[3] |= htonl((1 << 23));
2324 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2325 /* Send 3 termination packets */
2326 for (i = 0; i < 3; i++) {
2327 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2328 if (res < 0)
2329 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2330 ast_inet_ntoa(rtp->them.sin_addr),
2331 ntohs(rtp->them.sin_port), strerror(errno));
2332 if (rtp_debug_test_addr(&rtp->them))
2333 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2334 ast_inet_ntoa(rtp->them.sin_addr),
2335 ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2336 }
2337 rtp->sending_digit = 0;
2338 rtp->send_digit = 0;
2339 /* Increment lastdigitts */
2340 rtp->lastdigitts += 960;
2341 rtp->seqno++;
2342
2343 return res;
2344 }
2345
2346 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2347 int ast_rtcp_send_h261fur(void *data)
2348 {
2349 struct ast_rtp *rtp = data;
2350 int res;
2351
2352 rtp->rtcp->sendfur = 1;
2353 res = ast_rtcp_write(data);
2354
2355 return res;
2356 }
2357
2358 /*! \brief Send RTCP sender's report */
2359 static int ast_rtcp_write_sr(const void *data)
2360 {
2361 struct ast_rtp *rtp = (struct ast_rtp *)data;
2362 int res;
2363 int len = 0;
2364 struct timeval now;
2365 unsigned int now_lsw;
2366 unsigned int now_msw;
2367 unsigned int *rtcpheader;
2368 unsigned int lost;
2369 unsigned int extended;
2370 unsigned int expected;
2371 unsigned int expected_interval;
2372 unsigned int received_interval;
2373 int lost_interval;
2374 int fraction;
2375 struct timeval dlsr;
2376 char bdata[512];
2377
2378 /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2379 if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2380 return 0;
2381
2382 if (!rtp->rtcp->them.sin_addr.s_addr) { /* This'll stop rtcp for this rtp session */
2383 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2384 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2385 return 0;
2386 }
2387
2388 gettimeofday(&now, NULL);
2389 timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2390 rtcpheader = (unsigned int *)bdata;
2391 rtcpheader[1] = htonl(rtp->ssrc); /* Our SSRC */
2392 rtcpheader[2] = htonl(now_msw); /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2393 rtcpheader[3] = htonl(now_lsw); /* now, LSW */
2394 rtcpheader[4] = htonl(rtp->lastts); /* FIXME shouldn't be that, it should be now */
2395 rtcpheader[5] = htonl(rtp->txcount); /* No. packets sent */
2396 rtcpheader[6] = htonl(rtp->txoctetcount); /* No. bytes sent */
2397 len += 28;
2398
2399 extended = rtp->cycles + rtp->lastrxseqno;
2400 expected = extended - rtp->seedrxseqno + 1;
2401 if (rtp->rxcount > expected)
2402 expected += rtp->rxcount - expected;
2403 lost = expected - rtp->rxcount;
2404 expected_interval = expected - rtp->rtcp->expected_prior;
2405 rtp->rtcp->expected_prior = expected;
2406 received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2407 rtp->rtcp->received_prior = rtp->rxcount;
2408 lost_interval = expected_interval - received_interval;
2409 if (expected_interval == 0 || lost_interval <= 0)
2410 fraction = 0;
2411 else
2412 fraction = (lost_interval << 8) / expected_interval;
2413 timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2414 rtcpheader[7] = htonl(rtp->themssrc);
2415 rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2416 rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2417 rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2418 rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2419 rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2420 len += 24;
2421
2422 rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2423
2424 if (rtp->rtcp->sendfur) {
2425 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2426 rtcpheader[14] = htonl(rtp->ssrc); /* Our SSRC */
2427 len += 8;
2428 rtp->rtcp->sendfur = 0;
2429 }
2430
2431 /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */
2432 /* it can change mid call, and SDES can't) */
2433 rtcpheader[len/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2434 rtcpheader[(len/4)+1] = htonl(rtp->ssrc); /* Our SSRC */
2435 rtcpheader[(len/4)+2] = htonl(0x01 << 24); /* Empty for the moment */
2436 len += 12;
2437
2438 res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2439 if (res < 0) {
2440 ast_log(LOG_ERROR, "RTCP SR transmission error to %s:%d, rtcp halted %s\n",ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port), strerror(errno));
2441 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2442 return 0;
2443 }
2444
2445 /* FIXME Don't need to get a new one */
2446 gettimeofday(&rtp->rtcp->txlsr, NULL);
2447 rtp->rtcp->sr_count++;
2448
2449 rtp->rtcp->lastsrtxcount = rtp->txcount;
2450
2451 if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2452 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2453 ast_verbose(" Our SSRC: %u\n", rtp->ssrc);
2454 ast_verbose(" Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2455 ast_verbose(" Sent(RTP): %u\n", rtp->lastts);
2456 ast_verbose(" Sent packets: %u\n", rtp->txcount);
2457 ast_verbose(" Sent octets: %u\n", rtp->txoctetcount);
2458 ast_verbose(" Report block:\n");
2459 ast_verbose(" Fraction lost: %u\n", fraction);
2460 ast_verbose(" Cumulative loss: %u\n", lost);
2461 ast_verbose(" IA jitter: %.4f\n", rtp->rxjitter);
2462 ast_verbose(" Their last SR: %u\n", rtp->rtcp->themrxlsr);
2463 ast_verbose(" DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2464 }
2465 return res;
2466 }
2467
2468 /*! \brief Send RTCP recepient's report */
2469 static int ast_rtcp_write_rr(const void *data)
2470 {
2471 struct ast_rtp *rtp = (struct ast_rtp *)data;
2472 int res;
2473 int len = 32;
2474 unsigned int lost;
2475 unsigned int extended;
2476 unsigned int expected;
2477 unsigned int expected_interval;
2478 unsigned int received_interval;
2479 int lost_interval;
2480 struct timeval now;
2481 unsigned int *rtcpheader;
2482 char bdata[1024];
2483 struct timeval dlsr;
2484 int fraction;
2485
2486 if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2487 return 0;
2488
2489 if (!rtp->rtcp->them.sin_addr.s_addr) {
2490 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2491 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2492 return 0;
2493 }
2494
2495 extended = rtp->cycles + rtp->lastrxseqno;
2496 expected = extended - rtp->seedrxseqno + 1;
2497 lost = expected - rtp->rxcount;
2498 expected_interval = expected - rtp->rtcp->expected_prior;
2499 rtp->rtcp->expected_prior = expected;
2500 received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2501 rtp->rtcp->received_prior = rtp->rxcount;
2502 lost_interval = expected_interval - received_interval;
2503 if (expected_interval == 0 || lost_interval <= 0)
2504 fraction = 0;
2505 else
2506 fraction = (lost_interval << 8) / expected_interval;
2507 gettimeofday(&now, NULL);
2508 timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2509 rtcpheader = (unsigned int *)bdata;
2510 rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2511 rtcpheader[1] = htonl(rtp->ssrc);
2512 rtcpheader[2] = htonl(rtp->themssrc);
2513 rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2514 rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2515 rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2516 rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2517 rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2518
2519 if (rtp->rtcp->sendfur) {
2520 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2521 rtcpheader[9] = htonl(rtp->ssrc); /* Our SSRC */
2522 len += 8;
2523 rtp->rtcp->sendfur = 0;
2524 }
2525
2526 /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos
2527 it can change mid call, and SDES can't) */
2528 rtcpheader[len/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2529 rtcpheader[(len/4)+1] = htonl(rtp->ssrc); /* Our SSRC */
2530 rtcpheader[(len/4)+2] = htonl(0x01 << 24); /* Empty for the moment */
2531 len += 12;
2532
2533 res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2534
2535 if (res < 0) {
2536 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2537 /* Remove the scheduler */
2538 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2539 return 0;
2540 }
2541
2542 rtp->rtcp->rr_count++;
2543
2544 if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2545 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2546 " Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n"
2547 " IA jitter: %.4f\n"
2548 " Their last SR: %u\n"
2549 " DLSR: %4.4f (sec)\n\n",
2550 ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2551 ntohs(rtp->rtcp->them.sin_port),
2552 rtp->ssrc, rtp->themssrc, fraction, lost,
2553 rtp->rxjitter,
2554 rtp->rtcp->themrxlsr,
2555 (double)(ntohl(rtcpheader[7])/65536.0));
2556 }
2557
2558 return res;
2559 }
2560
2561 /*! \brief Write and RTCP packet to the far end
2562 * \note Decide if we are going to send an SR (with Reception Block) or RR
2563 * RR is sent if we have not sent any rtp packets in the previous interval */
2564 static int ast_rtcp_write(const void *data)
2565 {
2566 struct ast_rtp *rtp = (struct ast_rtp *)data;
2567 int res;
2568
2569 if (!rtp || !rtp->rtcp)
2570 return 0;
2571
2572 if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2573 res = ast_rtcp_write_sr(data);
2574 else
2575 res = ast_rtcp_write_rr(data);
2576
2577 return res;
2578 }
2579
2580 /*! \brief generate comfort noice (CNG) */
2581 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2582 {
2583 unsigned int *rtpheader;
2584 int hdrlen = 12;
2585 int res;
2586 int payload;
2587 char data[256];
2588 level = 127 - (level & 0x7f);
2589 payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2590
2591 /* If we have no peer, return immediately */
2592 if (!rtp->them.sin_addr.s_addr)
2593 return 0;
2594
2595 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2596
2597 /* Get a pointer to the header */
2598 rtpheader = (unsigned int *)data;
2599 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2600 rtpheader[1] = htonl(rtp->lastts);
2601 rtpheader[2] = htonl(rtp->ssrc);
2602 data[12] = level;
2603 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2604 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2605 if (res <0)
2606 ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s:%d: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
2607 if (rtp_debug_test_addr(&rtp->them))
2608 ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2609 , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);
2610
2611 }
2612 return 0;
2613 }
2614
2615 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2616 {
2617 unsigned char *rtpheader;
2618 int hdrlen = 12;
2619 int res;
2620 unsigned int ms;
2621 int pred;
2622 int mark = 0;
2623
2624 ms = calc_txstamp(rtp, &f->delivery);
2625 /* Default prediction */
2626 if (f->frametype == AST_FRAME_VOICE) {
2627 pred = rtp->lastts + f->samples;
2628
2629 /* Re-calculate last TS */
2630 rtp->lastts = rtp->lastts + ms * 8;
2631 if (ast_tvzero(f->delivery)) {
2632 /* If this isn't an absolute delivery time, Check if it is close to our prediction,
2633 and if so, go with our prediction */
2634 if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2635 rtp->lastts = pred;
2636 else {
2637 if (option_debug > 2)
2638 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2639 mark = 1;
2640 }
2641 }
2642 } else if (f->frametype == AST_FRAME_VIDEO) {
2643 mark = f->subclass & 0x1;
2644 pred = rtp->lastovidtimestamp + f->samples;
2645 /* Re-calculate last TS */
2646 rtp->lastts = rtp->lastts + ms * 90;
2647 /* If it's close to our prediction, go for it */
2648 if (ast_tvzero(f->delivery)) {
2649 if (abs(rtp->lastts - pred) < 7200) {
2650 rtp->lastts = pred;
2651 rtp->lastovidtimestamp += f->samples;
2652 } else {
2653 if (option_debug > 2)
2654 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);
2655 rtp->lastovidtimestamp = rtp->lastts;
2656 }
2657 }
2658 }
2659
2660 /* If we have been explicitly told to set the marker bit do so */
2661 if (rtp->set_marker_bit) {
2662 mark = 1;
2663 rtp->set_marker_bit = 0;
2664 }
2665
2666 /* If the timestamp for non-digit packets has moved beyond the timestamp
2667 for digits, update the digit timestamp.
2668 */
2669 if (rtp->lastts > rtp->lastdigitts)
2670 rtp->lastdigitts = rtp->lastts;
2671
2672 if (ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO))
2673 rtp->lastts = f->ts * 8;
2674
2675 /* Get a pointer to the header */
2676 rtpheader = (unsigned char *)(f->data - hdrlen);
2677
2678 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2679 put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2680 put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
2681
2682 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2683 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2684 if (res <0) {
2685 if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2686 ast_log(LOG_DEBUG, "RTP Transmission error of packet %d to %s:%d: %s\n", rtp->seqno, ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
2687 } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2688 /* Only give this error message once if we are not RTP debugging */
2689 if (option_debug || rtpdebug)
2690 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(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
2691 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2692 }
2693 } else {
2694 rtp->txcount++;
2695 rtp->txoctetcount +=(res - hdrlen);
2696
2697 if (rtp->rtcp && rtp->rtcp->schedid < 1)
2698 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2699 }
2700
2701 if (rtp_debug_test_addr(&rtp->them))
2702 ast_verbose("Sent RTP packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2703 ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2704 }
2705
2706 rtp->seqno++;
2707
2708 return 0;
2709 }
2710
2711 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
2712 {
2713 int x;
2714 for (x = 0; x < 32; x++) { /* Ugly way */
2715 rtp->pref.order[x] = prefs->order[x];
2716 rtp->pref.framing[x] = prefs->framing[x];
2717 }
2718 if (rtp->smoother)
2719 ast_smoother_free(rtp->smoother);
2720 rtp->smoother = NULL;
2721 return 0;
2722 }
2723
2724 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
2725 {
2726 return &rtp->pref;
2727 }
2728
2729 int ast_rtp_codec_getformat(int pt)
2730 {
2731 if (pt < 0 || pt > MAX_RTP_PT)
2732 return 0; /* bogus payload type */
2733
2734 if (static_RTP_PT[pt].isAstFormat)
2735 return static_RTP_PT[pt].code;
2736 else
2737 return 0;
2738 }
2739
2740 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2741 {
2742 struct ast_frame *f;
2743 int codec;
2744 int hdrlen = 12;
2745 int subclass;
2746
2747
2748 /* If we have no peer, return immediately */
2749 if (!rtp->them.sin_addr.s_addr)
2750 return 0;
2751
2752 /* If there is no data length, return immediately */
2753 if (!_f->datalen)
2754 return 0;
2755
2756 /* Make sure we have enough space for RTP header */
2757 if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
2758 ast_log(LOG_WARNING, "RTP can only send voice and video\n");
2759 return -1;
2760 }
2761
2762 subclass = _f->subclass;
2763 if (_f->frametype == AST_FRAME_VIDEO)
2764 subclass &= ~0x1;
2765
2766 codec = ast_rtp_lookup_code(rtp, 1, subclass);
2767 if (codec < 0) {
2768 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2769 return -1;
2770 }
2771
2772 if (rtp->lasttxformat != subclass) {
2773 /* New format, reset the smoother */
2774 if (option_debug)
2775 ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2776 rtp->lasttxformat = subclass;
2777 if (rtp->smoother)
2778 ast_smoother_free(rtp->smoother);
2779 rtp->smoother = NULL;
2780 }
2781
2782 if (!rtp->smoother && subclass != AST_FORMAT_SPEEX && subclass != AST_FORMAT_G723_1) {
2783 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
2784 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
2785 if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2786 ast_log(LOG_WARNING, "Unable to create smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
2787 return -1;
2788 }
2789 if (fmt.flags)
2790 ast_smoother_set_flags(rtp->smoother, fmt.flags);
2791 if (option_debug)
2792 ast_log(LOG_DEBUG, "Created smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
2793 }
2794 }
2795 if (rtp->smoother) {
2796 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
2797 ast_smoother_feed_be(rtp->smoother, _f);
2798 } else {
2799 ast_smoother_feed(rtp->smoother, _f);
2800 }
2801
2802 while ((f = ast_smoother_read(rtp->smoother)) && (f->data)) {
2803 if (f->subclass == AST_FORMAT_G722) {
2804 /* G.722 is silllllllllllllly */
2805 f->samples /= 2;
2806 }
2807
2808 ast_rtp_raw_write(rtp, f, codec);
2809 }
2810 } else {
2811 /* Don't buffer outgoing frames; send them one-per-packet: */
2812 if (_f->offset < hdrlen) {
2813 f = ast_frdup(_f);
2814 } else {
2815 f = _f;
2816 }
2817 if (f->data) {
2818 if (f->subclass == AST_FORMAT_G722) {
2819 /* G.722 is silllllllllllllly */
2820 f->samples /= 2;
2821 }
2822 ast_rtp_raw_write(rtp, f, codec);
2823 }
2824 if (f != _f)
2825 ast_frfree(f);
2826 }
2827
2828 return 0;
2829 }
2830
2831 /*! \brief Unregister interface to channel driver */
2832 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2833 {
2834 AST_LIST_LOCK(&protos);
2835 AST_LIST_REMOVE(&protos, proto, list);
2836 AST_LIST_UNLOCK(&protos);
2837 }
2838
2839 /*! \brief Register interface to channel driver */
2840 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2841 {
2842 struct ast_rtp_protocol *cur;
2843
2844 AST_LIST_LOCK(&protos);
2845 AST_LIST_TRAVERSE(&protos, cur, list) {
2846 if (!strcmp(cur->type, proto->type)) {
2847 ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2848 AST_LIST_UNLOCK(&protos);
2849 return -1;
2850 }
2851 }
2852 AST_LIST_INSERT_HEAD(&protos, proto, list);
2853 AST_LIST_UNLOCK(&protos);
2854
2855 return 0;
2856 }
2857
2858 /*! \brief Bridge loop for true native bridge (reinvite) */
2859 static enum ast_bridge_result bridge_native_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, struct ast_rtp *vp0, struct ast_rtp *vp1, struct ast_rtp_protocol *pr0, struct ast_rtp_protocol *pr1, int codec0, int codec1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
2860 {
2861 struct ast_frame *fr = NULL;
2862 struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2863 int oldcodec0 = codec0, oldcodec1 = codec1;
2864 struct sockaddr_in ac1 = {0,}, vac1 = {0,}, ac0 = {0,}, vac0 = {0,};
2865 struct sockaddr_in t1 = {0,}, vt1 = {0,}, t0 = {0,}, vt0 = {0,};
2866
2867 /* Set it up so audio goes directly between the two endpoints */
2868
2869 /* Test the first channel */
2870 if (!(pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
2871 ast_rtp_get_peer(p1, &ac1);
2872 if (vp1)
2873 ast_rtp_get_peer(vp1, &vac1);
2874 } else
2875 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2876
2877 /* Test the second channel */
2878 if (!(pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
2879 ast_rtp_get_peer(p0, &ac0);
2880 if (vp0)
2881 ast_rtp_get_peer(vp0, &vac0);
2882 } else
2883 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
2884
2885 /* Now we can unlock and move into our loop */
2886 ast_channel_unlock(c0);
2887 ast_channel_unlock(c1);
2888
2889 /* Throw our channels into the structure and enter the loop */
2890 cs[0] = c0;
2891 cs[1] = c1;
2892 cs[2] = NULL;
2893 for (;;) {
2894 /* Check if anything changed */
2895 if ((c0->tech_pvt != pvt0) ||
2896 (c1->tech_pvt != pvt1) ||
2897 (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
2898 (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
2899 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2900 if (c0->tech_pvt == pvt0)
2901 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2902 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2903 if (c1->tech_pvt == pvt1)
2904 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2905 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2906 return AST_BRIDGE_RETRY;
2907 }
2908
2909 /* Check if they have changed their address */
2910 ast_rtp_get_peer(p1, &t1);
2911 if (vp1)
2912 ast_rtp_get_peer(vp1, &vt1);
2913 if (pr1->get_codec)
2914 codec1 = pr1->get_codec(c1);
2915 ast_rtp_get_peer(p0, &t0);
2916 if (vp0)
2917 ast_rtp_get_peer(vp0, &vt0);
2918 if (pr0->get_codec)
2919 codec0 = pr0->get_codec(c0);
2920 if ((inaddrcmp(&t1, &ac1)) ||
2921 (vp1 && inaddrcmp(&vt1, &vac1)) ||
2922 (codec1 != oldcodec1)) {
2923 if (option_debug > 1) {
2924 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2925 c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
2926 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2927 c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2928 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2929 c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2930 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2931 c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2932 }
2933 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)))
2934 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2935 memcpy(&ac1, &t1, sizeof(ac1));
2936 memcpy(&vac1, &vt1, sizeof(vac1));
2937 oldcodec1 = codec1;
2938 }
2939 if ((inaddrcmp(&t0, &ac0)) ||
2940 (vp0 && inaddrcmp(&vt0, &vac0))) {
2941 if (option_debug > 1) {
2942 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2943 c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
2944 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2945 c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2946 }
2947 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)))
2948 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2949 memcpy(&ac0, &t0, sizeof(ac0));
2950 memcpy(&vac0, &vt0, sizeof(vac0));
2951 oldcodec0 = codec0;
2952 }
2953
2954 /* Wait for frame to come in on the channels */
2955 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2956 if (!timeoutms) {
2957 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2958 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2959 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2960 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2961 return AST_BRIDGE_RETRY;
2962 }
2963 if (option_debug)
2964 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2965 if (ast_check_hangup(c0) || ast_check_hangup(c1))
2966 break;
2967 continue;
2968 }
2969 fr = ast_read(who);
2970 other = (who == c0) ? c1 : c0;
2971 if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
2972 (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
2973 ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2974 /* Break out of bridge */
2975 *fo = fr;
2976 *rc = who;
2977 if (option_debug)
2978 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2979 if (c0->tech_pvt == pvt0)
2980 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2981 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2982 if (c1->tech_pvt == pvt1)
2983 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2984 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2985 return AST_BRIDGE_COMPLETE;
2986 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2987 if ((fr->subclass == AST_CONTROL_HOLD) ||
2988 (fr->subclass == AST_CONTROL_UNHOLD) ||
2989 (fr->subclass == AST_CONTROL_VIDUPDATE) ||
2990 (fr->subclass == AST_CONTROL_SRCUPDATE)) {
2991 if (fr->subclass == AST_CONTROL_HOLD) {
2992 /* If we someone went on hold we want the other side to reinvite back to us */
2993 if (who == c0)
2994 pr1->set_rtp_peer(c1, NULL, NULL, 0, 0);
2995 else
2996 pr0->set_rtp_peer(c0, NULL, NULL, 0, 0);
2997 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
2998 /* If they went off hold they should go back to being direct */
2999 if (who == c0)
3000 pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE));
3001 else
3002 pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE));
3003 }
3004 /* Update local address information */
3005 ast_rtp_get_peer(p0, &t0);
3006 memcpy(&ac0, &t0, sizeof(ac0));
3007 ast_rtp_get_peer(p1, &t1);
3008 memcpy(&ac1, &t1, sizeof(ac1));
3009 /* Update codec information */
3010 if (pr0->get_codec && c0->tech_pvt)
3011 oldcodec0 = codec0 = pr0->get_codec(c0);
3012 if (pr1->get_codec && c1->tech_pvt)
3013 oldcodec1 = codec1 = pr1->get_codec(c1);
3014 ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
3015 ast_frfree(fr);
3016 } else {
3017 *fo = fr;
3018 *rc = who;
3019 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3020 return AST_BRIDGE_COMPLETE;
3021 }
3022 } else {
3023 if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
3024 (fr->frametype == AST_FRAME_DTMF_END) ||
3025 (fr->frametype == AST_FRAME_VOICE) ||
3026 (fr->frametype == AST_FRAME_VIDEO) ||
3027 (fr->frametype == AST_FRAME_IMAGE) ||
3028 (fr->frametype == AST_FRAME_HTML) ||
3029 (fr->frametype == AST_FRAME_MODEM) ||
3030 (fr->frametype == AST_FRAME_TEXT)) {
3031 ast_write(other, fr);
3032 }
3033 ast_frfree(fr);
3034 }
3035 /* Swap priority */
3036 cs[2] = cs[0];
3037 cs[0] = cs[1];
3038 cs[1] = cs[2];
3039 }
3040
3041 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
3042 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3043 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
3044 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3045
3046 return AST_BRIDGE_FAILED;
3047 }
3048
3049 /*! \brief P2P RTP Callback */
3050 #ifdef P2P_INTENSE
3051 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
3052 {
3053 int res = 0, hdrlen = 12;
3054 struct sockaddr_in sin;
3055 socklen_t len;
3056 unsigned int *header;
3057 struct ast_rtp *rtp = cbdata, *bridged = NULL;
3058
3059 if (!rtp)
3060 return 1;
3061
3062 len = sizeof(sin);
3063 if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
3064 return 1;
3065
3066 header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
3067
3068 /* If NAT support is turned on, then see if we need to change their address */
3069 if ((rtp->nat) &&
3070 ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
3071 (rtp->them.sin_port != sin.sin_port))) {
3072 rtp->them = sin;
3073 rtp->rxseqno = 0;
3074 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
3075 if (option_debug || rtpdebug)
3076 ast_log(LOG_DEBUG, "P2P RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
3077 }
3078
3079 /* Write directly out to other RTP stream if bridged */
3080 if ((bridged = ast_rtp_get_bridged(rtp)))
3081 bridge_p2p_rtp_write(rtp, bridged, header, res, hdrlen);
3082
3083 return 1;
3084 }
3085
3086 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
3087 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
3088 {
3089 /* If we need DTMF, are looking for STUN, or we have no IO structure then we can't do direct callback */
3090 if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || ast_test_flag(rtp, FLAG_HAS_STUN) || !rtp->io)
3091 return 0;
3092
3093 /* If the RTP structure is already in callback mode, remove it temporarily */
3094 if (rtp->ioid) {
3095 ast_io_remove(rtp->io, rtp->ioid);
3096 rtp->ioid = NULL;
3097 }
3098
3099 /* Steal the file descriptors from the channel and stash them away */
3100 fds[0] = chan->fds[0];
3101 chan->fds[0] = -1;
3102
3103 /* Now, fire up callback mode */
3104 iod[0] = ast_io_add(rtp->io, fds[0], p2p_rtp_callback, AST_IO_IN, rtp);
3105
3106 return 1;
3107 }
3108 #else
3109 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
3110 {
3111 return 0;
3112 }
3113 #endif
3114
3115 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
3116 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
3117 {
3118 ast_channel_lock(chan);
3119
3120 /* Remove the callback from the IO context */
3121 ast_io_remove(rtp->io, iod[0]);
3122
3123 /* Restore file descriptors */
3124 chan->fds[0] = fds[0];
3125 ast_channel_unlock(chan);
3126
3127 /* Restore callback mode if previously used */
3128 if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
3129 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
3130
3131 return 0;
3132 }
3133
3134 /*! \brief Helper function that sets what an RTP structure is bridged to */
3135 static void p2p_set_bridge(struct ast_rtp *rtp0, struct ast_rtp *rtp1)
3136 {
3137 ast_mutex_lock(&rtp0->bridge_lock);
3138 rtp0->bridged = rtp1;
3139 ast_mutex_unlock(&rtp0->bridge_lock);
3140
3141 return;
3142 }
3143
3144 /*! \brief Bridge loop for partial native bridge (packet2packet) */
3145 static enum ast_bridge_result bridge_p2p_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
3146 {
3147 struct ast_frame *fr = NULL;
3148 struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
3149 int p0_fds[2] = {-1, -1}, p1_fds[2] = {-1, -1};
3150 int *p0_iod[2] = {NULL, NULL}, *p1_iod[2] = {NULL, NULL};
3151 int p0_callback = 0, p1_callback = 0;
3152 enum ast_bridge_result res = AST_BRIDGE_FAILED;
3153
3154 /* Okay, setup each RTP structure to do P2P forwarding */
3155 ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3156 p2p_set_bridge(p0, p1);
3157 ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3158 p2p_set_bridge(p1, p0);
3159
3160 /* Activate callback modes if possible */
3161 p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
3162 p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
3163
3164 /* Now let go of the channel locks and be on our way */
3165 ast_channel_unlock(c0);
3166 ast_channel_unlock(c1);
3167
3168 /* Go into a loop forwarding frames until we don't need to anymore */
3169 cs[0] = c0;
3170 cs[1] = c1;
3171 cs[2] = NULL;
3172 for (;;) {
3173 /* If the underlying formats have changed force this bridge to break */
3174 if ((c0->rawreadformat != c1->rawwriteformat) || (c1->rawreadformat != c0->rawwriteformat)) {
3175 ast_log(LOG_DEBUG, "Oooh, formats changed, backing out\n");
3176 res = AST_BRIDGE_FAILED_NOWARN;
3177 break;
3178 }
3179 /* Check if anything changed */
3180 if ((c0->tech_pvt != pvt0) ||
3181 (c1->tech_pvt != pvt1) ||
3182 (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
3183 (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
3184 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
3185 if ((c0->masq || c0->masqr) && (fr = ast_read(c0)))
3186 ast_frfree(fr);
3187 if ((c1->masq || c1->masqr) && (fr = ast_read(c1)))
3188 ast_frfree(fr);
3189 res = AST_BRIDGE_RETRY;
3190 break;
3191 }
3192 /* Wait on a channel to feed us a frame */
3193 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
3194 if (!timeoutms) {
3195 res = AST_BRIDGE_RETRY;
3196 break;
3197 }
3198 if (option_debug)
3199 ast_log(LOG_NOTICE, "Ooh, empty read...\n");
3200 if (ast_check_hangup(c0) || ast_check_hangup(c1))
3201 break;
3202 continue;
3203 }
3204 /* Read in frame from channel */
3205 fr = ast_read(who);
3206 other = (who == c0) ? c1 : c0;
3207 /* Dependong on the frame we may need to break out of our bridge */
3208 if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
3209 ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
3210 ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
3211 /* Record received frame and who */
3212 *fo = fr;
3213 *rc = who;
3214 if (option_debug)
3215 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
3216 res = AST_BRIDGE_COMPLETE;
3217 break;
3218 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3219 if ((fr->subclass == AST_CONTROL_HOLD) ||
3220 (fr->subclass == AST_CONTROL_UNHOLD) ||
3221 (fr->subclass == AST_CONTROL_VIDUPDATE) ||
3222 (fr->subclass == AST_CONTROL_SRCUPDATE)) {
3223 /* If we are going on hold, then break callback mode and P2P bridging */
3224 if (fr->subclass == AST_CONTROL_HOLD) {
3225 if (p0_callback)
3226 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3227 if (p1_callback)
3228 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3229 p2p_set_bridge(p0, NULL);
3230 p2p_set_bridge(p1, NULL);
3231 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3232 /* If we are off hold, then go back to callback mode and P2P bridging */
3233 ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3234 p2p_set_bridge(p0, p1);
3235 ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3236 p2p_set_bridge(p1, p0);
3237 p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
3238 p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
3239 }
3240 ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
3241 ast_frfree(fr);
3242 } else {
3243 *fo = fr;
3244 *rc = who;
3245 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3246 res = AST_BRIDGE_COMPLETE;
3247 break;
3248 }
3249 } else {
3250 if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
3251 (fr->frametype == AST_FRAME_DTMF_END) ||
3252 (fr->frametype == AST_FRAME_VOICE) ||
3253 (fr->frametype == AST_FRAME_VIDEO) ||
3254 (fr->frametype == AST_FRAME_IMAGE) ||
3255 (fr->frametype == AST_FRAME_HTML) ||
3256 (fr->frametype == AST_FRAME_MODEM) ||
3257 (fr->frametype == AST_FRAME_TEXT)) {
3258 ast_write(other, fr);
3259 }
3260
3261 ast_frfree(fr);
3262 }
3263 /* Swap priority */
3264 cs[2] = cs[0];
3265 cs[0] = cs[1];
3266 cs[1] = cs[2];
3267 }
3268
3269 /* If we are totally avoiding the core, then restore our link to it */
3270 if (p0_callback)
3271 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3272 if (p1_callback)
3273 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3274
3275 /* Break out of the direct bridge */
3276 p2p_set_bridge(p0, NULL);
3277 p2p_set_bridge(p1, NULL);
3278
3279 return res;
3280 }
3281
3282 /*! \brief Bridge calls. If possible and allowed, initiate
3283 re-invite so the peers exchange media directly outside
3284 of Asterisk. */
3285 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)
3286 {
3287 struct ast_rtp *p0 = NULL, *p1 = NULL; /* Audio RTP Channels */
3288 struct ast_rtp *vp0 = NULL, *vp1 = NULL; /* Video RTP channels */
3289 struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL;
3290 enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED;
3291 enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED;
3292 enum ast_bridge_result res = AST_BRIDGE_FAILED;
3293 int codec0 = 0, codec1 = 0;
3294 void *pvt0 = NULL, *pvt1 = NULL;
3295
3296 /* Lock channels */
3297 ast_channel_lock(c0);
3298 while(ast_channel_trylock(c1)) {
3299 ast_channel_unlock(c0);
3300 usleep(1);
3301 ast_channel_lock(c0);
3302 }
3303
3304 /* Ensure neither channel got hungup during lock avoidance */
3305 if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
3306 ast_log(LOG_WARNING, "Got hangup while attempting to bridge '%s' and '%s'\n", c0->name, c1->name);
3307 ast_channel_unlock(c0);
3308 ast_channel_unlock(c1);
3309 return AST_BRIDGE_FAILED;
3310 }
3311
3312 /* Find channel driver interfaces */
3313 if (!(pr0 = get_proto(c0))) {
3314 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
3315 ast_channel_unlock(c0);
3316 ast_channel_unlock(c1);
3317 return AST_BRIDGE_FAILED;
3318 }
3319 if (!(pr1 = get_proto(c1))) {
3320 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
3321 ast_channel_unlock(c0);
3322 ast_channel_unlock(c1);
3323 return AST_BRIDGE_FAILED;
3324 }
3325
3326 /* Get channel specific interface structures */
3327 pvt0 = c0->tech_pvt;
3328 pvt1 = c1->tech_pvt;
3329
3330 /* Get audio and video interface (if native bridge is possible) */
3331 audio_p0_res = pr0->get_rtp_info(c0, &p0);
3332 video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED;
3333 audio_p1_res = pr1->get_rtp_info(c1, &p1);
3334 video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED;
3335
3336 /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */
3337 if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE))
3338 audio_p0_res = AST_RTP_GET_FAILED;
3339 if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE))
3340 audio_p1_res = AST_RTP_GET_FAILED;
3341
3342 /* Check if a bridge is possible (partial/native) */
3343 if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) {
3344 /* Somebody doesn't want to play... */
3345 ast_channel_unlock(c0);
3346 ast_channel_unlock(c1);
3347 return AST_BRIDGE_FAILED_NOWARN;
3348 }
3349
3350 /* If we need to feed DTMF frames into the core then only do a partial native bridge */
3351 if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
3352 ast_set_flag(p0, FLAG_P2P_NEED_DTMF);
3353 audio_p0_res = AST_RTP_TRY_PARTIAL;
3354 }
3355
3356 if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
3357 ast_set_flag(p1, FLAG_P2P_NEED_DTMF);
3358 audio_p1_res = AST_RTP_TRY_PARTIAL;
3359 }
3360
3361 /* If both sides are not using the same method of DTMF transmission
3362 * (ie: one is RFC2833, other is INFO... then we can not do direct media.
3363 * --------------------------------------------------
3364 * | DTMF Mode | HAS_DTMF | Accepts Begin Frames |
3365 * |-----------|------------|-----------------------|
3366 * | Inband | False | True |
3367 * | RFC2833 | True | True |
3368 * | SIP INFO | False | False |
3369 * --------------------------------------------------
3370 * However, if DTMF from both channels is being monitored by the core, then
3371 * we can still do packet-to-packet bridging, because passing through the
3372 * core will handle DTMF mode translation.
3373 */
3374 if ( (ast_test_flag(p0, FLAG_HAS_DTMF) != ast_test_flag(p1, FLAG_HAS_DTMF)) ||
3375 (!c0->tech->send_digit_begin != !c1->tech->send_digit_begin)) {
3376 if (!ast_test_flag(p0, FLAG_P2P_NEED_DTMF) || !ast_test_flag(p1, FLAG_P2P_NEED_DTMF)) {
3377 ast_channel_unlock(c0);
3378 ast_channel_unlock(c1);
3379 return AST_BRIDGE_FAILED_NOWARN;
3380 }
3381 audio_p0_res = AST_RTP_TRY_PARTIAL;
3382 audio_p1_res = AST_RTP_TRY_PARTIAL;
3383 }
3384
3385 /* If we need to feed frames into the core don't do a P2P bridge */
3386 if ((audio_p0_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p0, FLAG_P2P_NEED_DTMF)) ||
3387 (audio_p1_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p1, FLAG_P2P_NEED_DTMF))) {
3388 ast_channel_unlock(c0);
3389 ast_channel_unlock(c1);
3390 return AST_BRIDGE_FAILED_NOWARN;
3391 }
3392
3393 /* Get codecs from both sides */
3394 codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
3395 codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
3396 if (codec0 && codec1 && !(codec0 & codec1)) {
3397 /* Hey, we can't do native bridging if both parties speak different codecs */
3398 if (option_debug)
3399 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
3400 ast_channel_unlock(c0);
3401 ast_channel_unlock(c1);
3402 return AST_BRIDGE_FAILED_NOWARN;
3403 }
3404
3405 /* If either side can only do a partial bridge, then don't try for a true native bridge */
3406 if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) {
3407 struct ast_format_list fmt0, fmt1;
3408
3409 /* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */
3410 if (c0->rawreadformat != c1->rawwriteformat || c1->rawreadformat != c0->rawwriteformat) {
3411 if (option_debug)
3412 ast_log(LOG_DEBUG, "Cannot packet2packet bridge - raw formats are incompatible\n");
3413 ast_channel_unlock(c0);
3414 ast_channel_unlock(c1);
3415 return AST_BRIDGE_FAILED_NOWARN;
3416 }
3417 /* They must also be using the same packetization */
3418 fmt0 = ast_codec_pref_getsize(&p0->pref, c0->rawreadformat);
3419 fmt1 = ast_codec_pref_getsize(&p1->pref, c1->rawreadformat);
3420 if (fmt0.cur_ms != fmt1.cur_ms) {
3421 if (option_debug)
3422 ast_log(LOG_DEBUG, "Cannot packet2packet bridge - packetization settings prevent it\n");
3423 ast_channel_unlock(c0);
3424 ast_channel_unlock(c1);
3425 return AST_BRIDGE_FAILED_NOWARN;
3426 }
3427
3428 if (option_verbose > 2)
3429 ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name);
3430 res = bridge_p2p_loop(c0, c1, p0, p1, timeoutms, flags, fo, rc, pvt0, pvt1);
3431 } else {
3432 if (option_verbose > 2)
3433 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
3434 res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1);
3435 }
3436
3437 return res;
3438 }
3439
3440 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
3441 {
3442 struct hostent *hp;
3443 struct ast_hostent ahp;
3444 int port = 0;
3445 char *p, *arg;
3446
3447 if (argc != 4)
3448 return RESULT_SHOWUSAGE;
3449 arg = argv[3];
3450 p = strstr(arg, ":");
3451 if (p) {
3452 *p = '\0';
3453 p++;
3454 port = atoi(p);
3455 }
3456 hp = ast_gethostbyname(arg, &ahp);
3457 if (hp == NULL)
3458 return RESULT_SHOWUSAGE;
3459 rtpdebugaddr.sin_family = AF_INET;
3460 memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
3461 rtpdebugaddr.sin_port = htons(port);
3462 if (port == 0)
3463 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
3464 else
3465 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
3466 rtpdebug = 1;
3467 return RESULT_SUCCESS;
3468 }
3469
3470 static int rtcp_do_debug_ip_deprecated(int fd, int argc, char *argv[])
3471 {
3472 struct hostent *hp;
3473 struct ast_hostent ahp;
3474 int port = 0;
3475 char *p, *arg;
3476 if (argc != 5)
3477 return RESULT_SHOWUSAGE;
3478
3479 arg = argv[4];
3480 p = strstr(arg, ":");
3481 if (p) {
3482 *p = '\0';
3483 p++;
3484 port = atoi(p);
3485 }
3486 hp = ast_gethostbyname(arg, &ahp);
3487 if (hp == NULL)
3488 return RESULT_SHOWUSAGE;
3489 rtcpdebugaddr.sin_family = AF_INET;
3490 memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
3491 rtcpdebugaddr.sin_port = htons(port);
3492 if (port == 0)
3493 ast_cli(fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
3494 else
3495 ast_cli(fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
3496 rtcpdebug = 1;
3497 return RESULT_SUCCESS;
3498 }
3499
3500 static int rtcp_do_debug_ip(int fd, int argc, char *argv[])
3501 {
3502 struct hostent *hp;
3503 struct ast_hostent ahp;
3504 int port = 0;
3505 char *p, *arg;
3506 if (argc != 4)
3507 return RESULT_SHOWUSAGE;
3508
3509 arg = argv[3];
3510 p = strstr(arg, ":");
3511 if (p) {
3512 *p = '\0';
3513 p++;
3514 port = atoi(p);
3515 }
3516 hp = ast_gethostbyname(arg, &ahp);
3517 if (hp == NULL)
3518 return RESULT_SHOWUSAGE;
3519 rtcpdebugaddr.sin_family = AF_INET;
3520 memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
3521 rtcpdebugaddr.sin_port = htons(port);
3522 if (port == 0)
3523 ast_cli(fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
3524 else
3525 ast_cli(fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
3526 rtcpdebug = 1;
3527 return RESULT_SUCCESS;
3528 }
3529
3530 static int rtp_do_debug(int fd, int argc, char *argv[])
3531 {
3532 if (argc != 2) {
3533 if (argc != 4)
3534 return RESULT_SHOWUSAGE;
3535 return rtp_do_debug_ip(fd, argc, argv);
3536 }
3537 rtpdebug = 1;
3538 memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
3539 ast_cli(fd, "RTP Debugging Enabled\n");
3540 return RESULT_SUCCESS;
3541 }
3542
3543 static int rtcp_do_debug_deprecated(int fd, int argc, char *argv[]) {
3544 if (argc != 3) {
3545 if (argc != 5)
3546 return RESULT_SHOWUSAGE;
3547 return rtcp_do_debug_ip_deprecated(fd, argc, argv);
3548 }
3549 rtcpdebug = 1;
3550 memset(&rtcpdebugaddr,0,sizeof(rtcpdebugaddr));
3551 ast_cli(fd, "RTCP Debugging Enabled\n");
3552 return RESULT_SUCCESS;
3553 }
3554
3555 static int rtcp_do_debug(int fd, int argc, char *argv[]) {
3556 if (argc != 2) {
3557 if (argc != 4)
3558 return RESULT_SHOWUSAGE;
3559 return rtcp_do_debug_ip(fd, argc, argv);
3560 }
3561 rtcpdebug = 1;
3562 memset(&rtcpdebugaddr,0,sizeof(rtcpdebugaddr));
3563 ast_cli(fd, "RTCP Debugging Enabled\n");
3564 return RESULT_SUCCESS;
3565 }
3566
3567 static int rtcp_do_stats_deprecated(int fd, int argc, char *argv[]) {
3568 if (argc != 3) {
3569 return RESULT_SHOWUSAGE;
3570 }
3571 rtcpstats = 1;
3572 ast_cli(fd, "RTCP Stats Enabled\n");
3573 return RESULT_SUCCESS;
3574 }
3575
3576 static int rtcp_do_stats(int fd, int argc, char *argv[]) {
3577 if (argc != 2) {
3578 return RESULT_SHOWUSAGE;
3579 }
3580 rtcpstats = 1;
3581 ast_cli(fd, "RTCP Stats Enabled\n");
3582 return RESULT_SUCCESS;
3583 }
3584
3585 static int rtp_no_debug(int fd, int argc, char *argv[])
3586 {
3587 if (argc != 3)
3588 return RESULT_SHOWUSAGE;
3589 rtpdebug = 0;
3590 ast_cli(fd,"RTP Debugging Disabled\n");
3591 return RESULT_SUCCESS;
3592 }
3593
3594 static int rtcp_no_debug_deprecated(int fd, int argc, char *argv[])
3595 {
3596 if (argc != 4)
3597 return RESULT_SHOWUSAGE;
3598 rtcpdebug = 0;
3599 ast_cli(fd,"RTCP Debugging Disabled\n");
3600 return RESULT_SUCCESS;
3601 }
3602
3603 static int rtcp_no_debug(int fd, int argc, char *argv[])
3604 {
3605 if (argc != 3)
3606 return RESULT_SHOWUSAGE;
3607 rtcpdebug = 0;
3608 ast_cli(fd,"RTCP Debugging Disabled\n");
3609 return RESULT_SUCCESS;
3610 }
3611
3612 static int rtcp_no_stats_deprecated(int fd, int argc, char *argv[])
3613 {
3614 if (argc != 4)
3615 return RESULT_SHOWUSAGE;
3616 rtcpstats = 0;
3617 ast_cli(fd,"RTCP Stats Disabled\n");
3618 return RESULT_SUCCESS;
3619 }
3620
3621 static int rtcp_no_stats(int fd, int argc, char *argv[])
3622 {
3623 if (argc != 3)
3624 return RESULT_SHOWUSAGE;
3625 rtcpstats = 0;
3626 ast_cli(fd,"RTCP Stats Disabled\n");
3627 return RESULT_SUCCESS;
3628 }
3629
3630 static int stun_do_debug(int fd, int argc, char *argv[])
3631 {
3632 if (argc != 2) {
3633 return RESULT_SHOWUSAGE;
3634 }
3635 stundebug = 1;
3636 ast_cli(fd, "STUN Debugging Enabled\n");
3637 return RESULT_SUCCESS;
3638 }
3639
3640 static int stun_no_debug(int fd, int argc, char *argv[])
3641 {
3642 if (argc != 3)
3643 return RESULT_SHOWUSAGE;
3644 stundebug = 0;
3645 ast_cli(fd, "STUN Debugging Disabled\n");
3646 return RESULT_SUCCESS;
3647 }
3648
3649 static char debug_usage[] =
3650 "Usage: rtp debug [ip host[:port]]\n"
3651 " Enable dumping of all RTP packets to and from host.\n";
3652
3653 static char no_debug_usage[] =
3654 "Usage: rtp debug off\n"
3655 " Disable all RTP debugging\n";
3656
3657 static char stun_debug_usage[] =
3658 "Usage: stun debug\n"
3659 " Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
3660
3661 static char stun_no_debug_usage[] =
3662 "Usage: stun debug off\n"
3663 " Disable STUN debugging\n";
3664
3665 static char rtcp_debug_usage[] =
3666 "Usage: rtcp debug [ip host[:port]]\n"
3667 " Enable dumping of all RTCP packets to and from host.\n";
3668
3669 static char rtcp_no_debug_usage[] =
3670 "Usage: rtcp debug off\n"
3671 " Disable all RTCP debugging\n";
3672
3673 static char rtcp_stats_usage[] =
3674 "Usage: rtcp stats\n"
3675 " Enable dumping of RTCP stats.\n";
3676
3677 static char rtcp_no_stats_usage[] =
3678 "Usage: rtcp stats off\n"
3679 " Disable all RTCP stats\n";
3680
3681 static struct ast_cli_entry cli_rtp_no_debug_deprecated = {
3682 { "rtp", "no", "debug", NULL },
3683 rtp_no_debug, NULL,
3684 NULL };
3685
3686 static struct ast_cli_entry cli_rtp_rtcp_debug_ip_deprecated = {
3687 { "rtp", "rtcp", "debug", "ip", NULL },
3688 rtcp_do_debug_deprecated, NULL,
3689 NULL };
3690
3691 static struct ast_cli_entry cli_rtp_rtcp_debug_deprecated = {
3692 { "rtp", "rtcp", "debug", NULL },
3693 rtcp_do_debug_deprecated, NULL,
3694 NULL };
3695
3696 static struct ast_cli_entry cli_rtp_rtcp_no_debug_deprecated = {
3697 { "rtp", "rtcp", "no", "debug", NULL },
3698 rtcp_no_debug_deprecated, NULL,
3699 NULL };
3700
3701 static struct ast_cli_entry cli_rtp_rtcp_stats_deprecated = {
3702 { "rtp", "rtcp", "stats", NULL },
3703 rtcp_do_stats_deprecated, NULL,
3704 NULL };
3705
3706 static struct ast_cli_entry cli_rtp_rtcp_no_stats_deprecated = {
3707 { "rtp", "rtcp", "no", "stats", NULL },
3708 rtcp_no_stats_deprecated, NULL,
3709 NULL };
3710
3711 static struct ast_cli_entry cli_stun_no_debug_deprecated = {
3712 { "stun", "no", "debug", NULL },
3713 stun_no_debug, NULL,
3714 NULL };
3715
3716 static struct ast_cli_entry cli_rtp[] = {
3717 { { "rtp", "debug", "ip", NULL },
3718 rtp_do_debug, "Enable RTP debugging on IP",
3719 debug_usage },
3720
3721 { { "rtp", "debug", NULL },
3722 rtp_do_debug, "Enable RTP debugging",
3723 debug_usage },
3724
3725 { { "rtp", "debug", "off", NULL },
3726 rtp_no_debug, "Disable RTP debugging",
3727 no_debug_usage, NULL, &cli_rtp_no_debug_deprecated },
3728
3729 { { "rtcp", "debug", "ip", NULL },
3730 rtcp_do_debug, "Enable RTCP debugging on IP",
3731 rtcp_debug_usage, NULL, &cli_rtp_rtcp_debug_ip_deprecated },
3732
3733 { { "rtcp", "debug", NULL },
3734 rtcp_do_debug, "Enable RTCP debugging",
3735 rtcp_debug_usage, NULL, &cli_rtp_rtcp_debug_deprecated },
3736
3737 { { "rtcp", "debug", "off", NULL },
3738 rtcp_no_debug, "Disable RTCP debugging",
3739 rtcp_no_debug_usage, NULL, &cli_rtp_rtcp_no_debug_deprecated },
3740
3741 { { "rtcp", "stats", NULL },
3742 rtcp_do_stats, "Enable RTCP stats",
3743 rtcp_stats_usage, NULL, &cli_rtp_rtcp_stats_deprecated },
3744
3745 { { "rtcp", "stats", "off", NULL },
3746 rtcp_no_stats, "Disable RTCP stats",
3747 rtcp_no_stats_usage, NULL, &cli_rtp_rtcp_no_stats_deprecated },
3748
3749 { { "stun", "debug", NULL },
3750 stun_do_debug, "Enable STUN debugging",
3751 stun_debug_usage },
3752
3753 { { "stun", "debug", "off", NULL },
3754 stun_no_debug, "Disable STUN debugging",
3755 stun_no_debug_usage, NULL, &cli_stun_no_debug_deprecated },
3756 };
3757
3758 int ast_rtp_reload(void)
3759 {
3760 struct ast_config *cfg;
3761 const char *s;
3762
3763 rtpstart = 5000;
3764 rtpend = 31000;
3765 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3766 cfg = ast_config_load("rtp.conf");
3767 if (cfg) {
3768 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
3769 rtpstart = atoi(s);
3770 if (rtpstart < 1024)
3771 rtpstart = 1024;
3772 if (rtpstart > 65535)
3773 rtpstart = 65535;
3774 }
3775 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
3776 rtpend = atoi(s);
3777 if (rtpend < 1024)
3778 rtpend = 1024;
3779 if (rtpend > 65535)
3780 rtpend = 65535;
3781 }
3782 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
3783 rtcpinterval = atoi(s);
3784 if (rtcpinterval == 0)
3785 rtcpinterval = 0; /* Just so we're clear... it's zero */
3786 if (rtcpinterval < RTCP_MIN_INTERVALMS)
3787 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
3788 if (rtcpinterval > RTCP_MAX_INTERVALMS)
3789 rtcpinterval = RTCP_MAX_INTERVALMS;
3790 }
3791 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
3792 #ifdef SO_NO_CHECK
3793 if (ast_false(s))
3794 nochecksums = 1;
3795 else
3796 nochecksums = 0;
3797 #else
3798 if (ast_false(s))
3799 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
3800 #endif
3801 }
3802 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
3803 dtmftimeout = atoi(s);
3804 if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
3805 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
3806 dtmftimeout, DEFAULT_DTMF_TIMEOUT);
3807 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3808 };
3809 }
3810 ast_config_destroy(cfg);
3811 }
3812 if (rtpstart >= rtpend) {
3813 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
3814 rtpstart = 5000;
3815 rtpend = 31000;
3816 }
3817 if (option_verbose > 1)
3818 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
3819 return 0;
3820 }
3821
3822 /*! \brief Initialize the RTP system in Asterisk */
3823 void ast_rtp_init(void)
3824 {
3825 ast_cli_register_multiple(cli_rtp, sizeof(cli_rtp) / sizeof(struct ast_cli_entry));
3826 ast_rtp_reload();
3827 }
3828
Open Source Private Branch Exchange (PBX)