?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make it build with the bristuffed libpri
[asterisk-bristuff.git] / main / rtp.c
blobbbdb9d6496fca043462abc18d4d25fc469493d0a
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_SPEEX}, "audio", "speex"},
1352 {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1353 {{1, AST_FORMAT_G722}, "audio", "G722"},
1354 {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1355 {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1356 {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1357 {{0, AST_RTP_CN}, "audio", "CN"},
1358 {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1359 {{1, AST_FORMAT_PNG}, "video", "PNG"},
1360 {{1, AST_FORMAT_H261}, "video", "H261"},
1361 {{1, AST_FORMAT_H263}, "video", "H263"},
1362 {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1363 {{1, AST_FORMAT_H264}, "video", "H264"},
1364 };
1365
1366 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1367 also, our own choices for dynamic payload types. This is our master
1368 table for transmission */
1369 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1370 [0] = {1, AST_FORMAT_ULAW},
1371 #ifdef USE_DEPRECATED_G726
1372 [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1373 #endif
1374 [3] = {1, AST_FORMAT_GSM},
1375 [4] = {1, AST_FORMAT_G723_1},
1376 [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1377 [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1378 [7] = {1, AST_FORMAT_LPC10},
1379 [8] = {1, AST_FORMAT_ALAW},
1380 [9] = {1, AST_FORMAT_G722},
1381 [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1382 [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1383 [13] = {0, AST_RTP_CN},
1384 [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1385 [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1386 [18] = {1, AST_FORMAT_G729A},
1387 [19] = {0, AST_RTP_CN}, /* Also used for CN */
1388 [26] = {1, AST_FORMAT_JPEG},
1389 [31] = {1, AST_FORMAT_H261},
1390 [34] = {1, AST_FORMAT_H263},
1391 [103] = {1, AST_FORMAT_H263_PLUS},
1392 [97] = {1, AST_FORMAT_ILBC},
1393 [99] = {1, AST_FORMAT_H264},
1394 [101] = {0, AST_RTP_DTMF},
1395 [110] = {1, AST_FORMAT_SPEEX},
1396 [111] = {1, AST_FORMAT_G726},
1397 [112] = {1, AST_FORMAT_G726_AAL2},
1398 [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1399 };
1400
1401 void ast_rtp_pt_clear(struct ast_rtp* rtp)
1402 {
1403 int i;
1404
1405 if (!rtp)
1406 return;
1407
1408 ast_mutex_lock(&rtp->bridge_lock);
1409
1410 for (i = 0; i < MAX_RTP_PT; ++i) {
1411 rtp->current_RTP_PT[i].isAstFormat = 0;
1412 rtp->current_RTP_PT[i].code = 0;
1413 }
1414
1415 rtp->rtp_lookup_code_cache_isAstFormat = 0;
1416 rtp->rtp_lookup_code_cache_code = 0;
1417 rtp->rtp_lookup_code_cache_result = 0;
1418
1419 ast_mutex_unlock(&rtp->bridge_lock);
1420 }
1421
1422 void ast_rtp_pt_default(struct ast_rtp* rtp)
1423 {
1424 int i;
1425
1426 ast_mutex_lock(&rtp->bridge_lock);
1427
1428 /* Initialize to default payload types */
1429 for (i = 0; i < MAX_RTP_PT; ++i) {
1430 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1431 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1432 }
1433
1434 rtp->rtp_lookup_code_cache_isAstFormat = 0;
1435 rtp->rtp_lookup_code_cache_code = 0;
1436 rtp->rtp_lookup_code_cache_result = 0;
1437
1438 ast_mutex_unlock(&rtp->bridge_lock);
1439 }
1440
1441 void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
1442 {
1443 unsigned int i;
1444
1445 ast_mutex_lock(&dest->bridge_lock);
1446 ast_mutex_lock(&src->bridge_lock);
1447
1448 for (i=0; i < MAX_RTP_PT; ++i) {
1449 dest->current_RTP_PT[i].isAstFormat =
1450 src->current_RTP_PT[i].isAstFormat;
1451 dest->current_RTP_PT[i].code =
1452 src->current_RTP_PT[i].code;
1453 }
1454 dest->rtp_lookup_code_cache_isAstFormat = 0;
1455 dest->rtp_lookup_code_cache_code = 0;
1456 dest->rtp_lookup_code_cache_result = 0;
1457
1458 ast_mutex_unlock(&src->bridge_lock);
1459 ast_mutex_unlock(&dest->bridge_lock);
1460 }
1461
1462 /*! \brief Get channel driver interface structure */
1463 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1464 {
1465 struct ast_rtp_protocol *cur = NULL;
1466
1467 AST_LIST_LOCK(&protos);
1468 AST_LIST_TRAVERSE(&protos, cur, list) {
1469 if (cur->type == chan->tech->type)
1470 break;
1471 }
1472 AST_LIST_UNLOCK(&protos);
1473
1474 return cur;
1475 }
1476
1477 int ast_rtp_early_bridge(struct ast_channel *dest, struct ast_channel *src)
1478 {
1479 struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */
1480 struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */
1481 struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1482 enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1483 enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED;
1484 int srccodec, destcodec, nat_active = 0;
1485
1486 /* Lock channels */
1487 ast_channel_lock(dest);
1488 if (src) {
1489 while(ast_channel_trylock(src)) {
1490 ast_channel_unlock(dest);
1491 usleep(1);
1492 ast_channel_lock(dest);
1493 }
1494 }
1495
1496 /* Find channel driver interfaces */
1497 destpr = get_proto(dest);
1498 if (src)
1499 srcpr = get_proto(src);
1500 if (!destpr) {
1501 if (option_debug)
1502 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1503 ast_channel_unlock(dest);
1504 if (src)
1505 ast_channel_unlock(src);
1506 return 0;
1507 }
1508 if (!srcpr) {
1509 if (option_debug)
1510 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src ? src->name : "<unspecified>");
1511 ast_channel_unlock(dest);
1512 if (src)
1513 ast_channel_unlock(src);
1514 return 0;
1515 }
1516
1517 /* Get audio and video interface (if native bridge is possible) */
1518 audio_dest_res = destpr->get_rtp_info(dest, &destp);
1519 video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1520 if (srcpr) {
1521 audio_src_res = srcpr->get_rtp_info(src, &srcp);
1522 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1523 }
1524
1525 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1526 if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1527 /* Somebody doesn't want to play... */
1528 ast_channel_unlock(dest);
1529 if (src)
1530 ast_channel_unlock(src);
1531 return 0;
1532 }
1533 if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1534 srccodec = srcpr->get_codec(src);
1535 else
1536 srccodec = 0;
1537 if (audio_dest_res == AST_RTP_TRY_NATIVE && destpr->get_codec)
1538 destcodec = destpr->get_codec(dest);
1539 else
1540 destcodec = 0;
1541 /* Ensure we have at least one matching codec */
1542 if (!(srccodec & destcodec)) {
1543 ast_channel_unlock(dest);
1544 if (src)
1545 ast_channel_unlock(src);
1546 return 0;
1547 }
1548 /* Consider empty media as non-existant */
1549 if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1550 srcp = NULL;
1551 /* If the client has NAT stuff turned on then just safe NAT is active */
1552 if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1553 nat_active = 1;
1554 /* Bridge media early */
1555 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, nat_active))
1556 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src ? src->name : "<unspecified>");
1557 ast_channel_unlock(dest);
1558 if (src)
1559 ast_channel_unlock(src);
1560 if (option_debug)
1561 ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", dest->name, src ? src->name : "<unspecified>");
1562 return 1;
1563 }
1564
1565 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1566 {
1567 struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */
1568 struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */
1569 struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1570 enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1571 enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED;
1572 int srccodec, destcodec;
1573
1574 /* Lock channels */
1575 ast_channel_lock(dest);
1576 while(ast_channel_trylock(src)) {
1577 ast_channel_unlock(dest);
1578 usleep(1);
1579 ast_channel_lock(dest);
1580 }
1581
1582 /* Find channel driver interfaces */
1583 if (!(destpr = get_proto(dest))) {
1584 if (option_debug)
1585 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1586 ast_channel_unlock(dest);
1587 ast_channel_unlock(src);
1588 return 0;
1589 }
1590 if (!(srcpr = get_proto(src))) {
1591 if (option_debug)
1592 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1593 ast_channel_unlock(dest);
1594 ast_channel_unlock(src);
1595 return 0;
1596 }
1597
1598 /* Get audio and video interface (if native bridge is possible) */
1599 audio_dest_res = destpr->get_rtp_info(dest, &destp);
1600 video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1601 audio_src_res = srcpr->get_rtp_info(src, &srcp);
1602 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1603
1604 /* Ensure we have at least one matching codec */
1605 if (srcpr->get_codec)
1606 srccodec = srcpr->get_codec(src);
1607 else
1608 srccodec = 0;
1609 if (destpr->get_codec)
1610 destcodec = destpr->get_codec(dest);
1611 else
1612 destcodec = 0;
1613
1614 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1615 if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE || !(srccodec & destcodec)) {
1616 /* Somebody doesn't want to play... */
1617 ast_channel_unlock(dest);
1618 ast_channel_unlock(src);
1619 return 0;
1620 }
1621 ast_rtp_pt_copy(destp, srcp);
1622 if (vdestp && vsrcp)
1623 ast_rtp_pt_copy(vdestp, vsrcp);
1624 if (media) {
1625 /* Bridge early */
1626 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1627 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1628 }
1629 ast_channel_unlock(dest);
1630 ast_channel_unlock(src);
1631 if (option_debug)
1632 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1633 return 1;
1634 }
1635
1636 /*! \brief Make a note of a RTP payload type that was seen in a SDP "m=" line.
1637 * By default, use the well-known value for this type (although it may
1638 * still be set to a different value by a subsequent "a=rtpmap:" line)
1639 */
1640 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt)
1641 {
1642 if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0)
1643 return; /* bogus payload type */
1644
1645 ast_mutex_lock(&rtp->bridge_lock);
1646 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1647 ast_mutex_unlock(&rtp->bridge_lock);
1648 }
1649
1650 /*! \brief remove setting from payload type list if the rtpmap header indicates
1651 an unknown media type */
1652 void ast_rtp_unset_m_type(struct ast_rtp* rtp, int pt)
1653 {
1654 if (pt < 0 || pt > MAX_RTP_PT)
1655 return; /* bogus payload type */
1656
1657 ast_mutex_lock(&rtp->bridge_lock);
1658 rtp->current_RTP_PT[pt].isAstFormat = 0;
1659 rtp->current_RTP_PT[pt].code = 0;
1660 ast_mutex_unlock(&rtp->bridge_lock);
1661 }
1662
1663 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1664 * an SDP "a=rtpmap:" line.
1665 * \return 0 if the MIME type was found and set, -1 if it wasn't found
1666 */
1667 int ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1668 char *mimeType, char *mimeSubtype,
1669 enum ast_rtp_options options)
1670 {
1671 unsigned int i;
1672 int found = 0;
1673
1674 if (pt < 0 || pt > MAX_RTP_PT)
1675 return -1; /* bogus payload type */
1676
1677 ast_mutex_lock(&rtp->bridge_lock);
1678
1679 for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1680 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1681 strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1682 found = 1;
1683 rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1684 if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1685 mimeTypes[i].payloadType.isAstFormat &&
1686 (options & AST_RTP_OPT_G726_NONSTANDARD))
1687 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1688 break;
1689 }
1690 }
1691
1692 ast_mutex_unlock(&rtp->bridge_lock);
1693
1694 return (found ? 0 : -1);
1695 }
1696
1697 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls
1698 * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1699 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1700 int* astFormats, int* nonAstFormats)
1701 {
1702 int pt;
1703
1704 ast_mutex_lock(&rtp->bridge_lock);
1705
1706 *astFormats = *nonAstFormats = 0;
1707 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1708 if (rtp->current_RTP_PT[pt].isAstFormat) {
1709 *astFormats |= rtp->current_RTP_PT[pt].code;
1710 } else {
1711 *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1712 }
1713 }
1714
1715 ast_mutex_unlock(&rtp->bridge_lock);
1716
1717 return;
1718 }
1719
1720 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt)
1721 {
1722 struct rtpPayloadType result;
1723
1724 result.isAstFormat = result.code = 0;
1725
1726 if (pt < 0 || pt > MAX_RTP_PT)
1727 return result; /* bogus payload type */
1728
1729 /* Start with negotiated codecs */
1730 ast_mutex_lock(&rtp->bridge_lock);
1731 result = rtp->current_RTP_PT[pt];
1732 ast_mutex_unlock(&rtp->bridge_lock);
1733
1734 /* If it doesn't exist, check our static RTP type list, just in case */
1735 if (!result.code)
1736 result = static_RTP_PT[pt];
1737
1738 return result;
1739 }
1740
1741 /*! \brief Looks up an RTP code out of our *static* outbound list */
1742 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
1743 {
1744 int pt = 0;
1745
1746 ast_mutex_lock(&rtp->bridge_lock);
1747
1748 if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1749 code == rtp->rtp_lookup_code_cache_code) {
1750 /* Use our cached mapping, to avoid the overhead of the loop below */
1751 pt = rtp->rtp_lookup_code_cache_result;
1752 ast_mutex_unlock(&rtp->bridge_lock);
1753 return pt;
1754 }
1755
1756 /* Check the dynamic list first */
1757 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1758 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1759 rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1760 rtp->rtp_lookup_code_cache_code = code;
1761 rtp->rtp_lookup_code_cache_result = pt;
1762 ast_mutex_unlock(&rtp->bridge_lock);
1763 return pt;
1764 }
1765 }
1766
1767 /* Then the static list */
1768 for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1769 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1770 rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1771 rtp->rtp_lookup_code_cache_code = code;
1772 rtp->rtp_lookup_code_cache_result = pt;
1773 ast_mutex_unlock(&rtp->bridge_lock);
1774 return pt;
1775 }
1776 }
1777
1778 ast_mutex_unlock(&rtp->bridge_lock);
1779
1780 return -1;
1781 }
1782
1783 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
1784 enum ast_rtp_options options)
1785 {
1786 unsigned int i;
1787
1788 for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1789 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
1790 if (isAstFormat &&
1791 (code == AST_FORMAT_G726_AAL2) &&
1792 (options & AST_RTP_OPT_G726_NONSTANDARD))
1793 return "G726-32";
1794 else
1795 return mimeTypes[i].subtype;
1796 }
1797 }
1798
1799 return "";
1800 }
1801
1802 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
1803 const int isAstFormat, enum ast_rtp_options options)
1804 {
1805 int format;
1806 unsigned len;
1807 char *end = buf;
1808 char *start = buf;
1809
1810 if (!buf || !size)
1811 return NULL;
1812
1813 snprintf(end, size, "0x%x (", capability);
1814
1815 len = strlen(end);
1816 end += len;
1817 size -= len;
1818 start = end;
1819
1820 for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1821 if (capability & format) {
1822 const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
1823
1824 snprintf(end, size, "%s|", name);
1825 len = strlen(end);
1826 end += len;
1827 size -= len;
1828 }
1829 }
1830
1831 if (start == end)
1832 snprintf(start, size, "nothing)");
1833 else if (size > 1)
1834 *(end -1) = ')';
1835
1836 return buf;
1837 }
1838
1839 static int rtp_socket(void)
1840 {
1841 int s;
1842 long flags;
1843 s = socket(AF_INET, SOCK_DGRAM, 0);
1844 if (s > -1) {
1845 flags = fcntl(s, F_GETFL);
1846 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1847 #ifdef SO_NO_CHECK
1848 if (nochecksums)
1849 setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1850 #endif
1851 }
1852 return s;
1853 }
1854
1855 /*!
1856 * \brief Initialize a new RTCP session.
1857 *
1858 * \returns The newly initialized RTCP session.
1859 */
1860 static struct ast_rtcp *ast_rtcp_new(void)
1861 {
1862 struct ast_rtcp *rtcp;
1863
1864 if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1865 return NULL;
1866 rtcp->s = rtp_socket();
1867 rtcp->us.sin_family = AF_INET;
1868 rtcp->them.sin_family = AF_INET;
1869 rtcp->schedid = -1;
1870
1871 if (rtcp->s < 0) {
1872 free(rtcp);
1873 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
1874 return NULL;
1875 }
1876
1877 return rtcp;
1878 }
1879
1880 /*!
1881 * \brief Initialize a new RTP structure.
1882 *
1883 */
1884 void ast_rtp_new_init(struct ast_rtp *rtp)
1885 {
1886 ast_mutex_init(&rtp->bridge_lock);
1887
1888 rtp->them.sin_family = AF_INET;
1889 rtp->us.sin_family = AF_INET;
1890 rtp->ssrc = ast_random();
1891 rtp->seqno = ast_random() & 0xffff;
1892 ast_set_flag(rtp, FLAG_HAS_DTMF);
1893
1894 return;
1895 }
1896
1897 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1898 {
1899 struct ast_rtp *rtp;
1900 int x;
1901 int first;
1902 int startplace;
1903
1904 if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1905 return NULL;
1906
1907 ast_rtp_new_init(rtp);
1908
1909 rtp->s = rtp_socket();
1910 if (rtp->s < 0) {
1911 free(rtp);
1912 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1913 return NULL;
1914 }
1915 if (sched && rtcpenable) {
1916 rtp->sched = sched;
1917 rtp->rtcp = ast_rtcp_new();
1918 }
1919
1920 /* Select a random port number in the range of possible RTP */
1921 x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1922 x = x & ~1;
1923 /* Save it for future references. */
1924 startplace = x;
1925 /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1926 for (;;) {
1927 /* Must be an even port number by RTP spec */
1928 rtp->us.sin_port = htons(x);
1929 rtp->us.sin_addr = addr;
1930 /* If there's rtcp, initialize it as well. */
1931 if (rtp->rtcp) {
1932 rtp->rtcp->us.sin_port = htons(x + 1);
1933 rtp->rtcp->us.sin_addr = addr;
1934 }
1935 /* Try to bind it/them. */
1936 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1937 (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1938 break;
1939 if (!first) {
1940 /* Primary bind succeeded! Gotta recreate it */
1941 close(rtp->s);
1942 rtp->s = rtp_socket();
1943 }
1944 if (errno != EADDRINUSE) {
1945 /* We got an error that wasn't expected, abort! */
1946 ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1947 close(rtp->s);
1948 if (rtp->rtcp) {
1949 close(rtp->rtcp->s);
1950 free(rtp->rtcp);
1951 }
1952 free(rtp);
1953 return NULL;
1954 }
1955 /* The port was used, increment it (by two). */
1956 x += 2;
1957 /* Did we go over the limit ? */
1958 if (x > rtpend)
1959 /* then, start from the begingig. */
1960 x = (rtpstart + 1) & ~1;
1961 /* Check if we reached the place were we started. */
1962 if (x == startplace) {
1963 /* If so, there's no ports available. */
1964 ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1965 close(rtp->s);
1966 if (rtp->rtcp) {
1967 close(rtp->rtcp->s);
1968 free(rtp->rtcp);
1969 }
1970 free(rtp);
1971 return NULL;
1972 }
1973 }
1974 rtp->sched = sched;
1975 rtp->io = io;
1976 if (callbackmode) {
1977 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1978 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
1979 }
1980 ast_rtp_pt_default(rtp);
1981 return rtp;
1982 }
1983
1984 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1985 {
1986 struct in_addr ia;
1987
1988 memset(&ia, 0, sizeof(ia));
1989 return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1990 }
1991
1992 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1993 {
1994 int res;
1995
1996 if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos))))
1997 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1998 return res;
1999 }
2000
2001 void ast_rtp_new_source(struct ast_rtp *rtp)
2002 {
2003 if (rtp) {
2004 rtp->set_marker_bit = 1;
2005 }
2006 return;
2007 }
2008
2009 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2010 {
2011 rtp->them.sin_port = them->sin_port;
2012 rtp->them.sin_addr = them->sin_addr;
2013 if (rtp->rtcp) {
2014 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
2015 rtp->rtcp->them.sin_addr = them->sin_addr;
2016 }
2017 rtp->rxseqno = 0;
2018 }
2019
2020 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2021 {
2022 if ((them->sin_family != AF_INET) ||
2023 (them->sin_port != rtp->them.sin_port) ||
2024 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2025 them->sin_family = AF_INET;
2026 them->sin_port = rtp->them.sin_port;
2027 them->sin_addr = rtp->them.sin_addr;
2028 return 1;
2029 }
2030 return 0;
2031 }
2032
2033 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2034 {
2035 *us = rtp->us;
2036 }
2037
2038 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2039 {
2040 struct ast_rtp *bridged = NULL;
2041
2042 ast_mutex_lock(&rtp->bridge_lock);
2043 bridged = rtp->bridged;
2044 ast_mutex_unlock(&rtp->bridge_lock);
2045
2046 return bridged;
2047 }
2048
2049 void ast_rtp_stop(struct ast_rtp *rtp)
2050 {
2051 if (rtp->rtcp) {
2052 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2053 }
2054
2055 memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2056 memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2057 if (rtp->rtcp) {
2058 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2059 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2060 }
2061
2062 ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2063 }
2064
2065 void ast_rtp_reset(struct ast_rtp *rtp)
2066 {
2067 memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2068 memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2069 memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2070 rtp->lastts = 0;
2071 rtp->lastdigitts = 0;
2072 rtp->lastrxts = 0;
2073 rtp->lastividtimestamp = 0;
2074 rtp->lastovidtimestamp = 0;
2075 rtp->lasteventseqn = 0;
2076 rtp->lastevent = 0;
2077 rtp->lasttxformat = 0;
2078 rtp->lastrxformat = 0;
2079 rtp->dtmfcount = 0;
2080 rtp->dtmfsamples = 0;
2081 rtp->seqno = 0;
2082 rtp->rxseqno = 0;
2083 }
2084
2085 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2086 {
2087 /*
2088 *ssrc our ssrc
2089 *themssrc their ssrc
2090 *lp lost packets
2091 *rxjitter our calculated jitter(rx)
2092 *rxcount no. received packets
2093 *txjitter reported jitter of the other end
2094 *txcount transmitted packets
2095 *rlp remote lost packets
2096 *rtt round trip time
2097 */
2098
2099 if (qual && rtp) {
2100 qual->local_ssrc = rtp->ssrc;
2101 qual->local_jitter = rtp->rxjitter;
2102 qual->local_count = rtp->rxcount;
2103 qual->remote_ssrc = rtp->themssrc;
2104 qual->remote_count = rtp->txcount;
2105 if (rtp->rtcp) {
2106 qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2107 qual->remote_lostpackets = rtp->rtcp->reported_lost;
2108 qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2109 qual->rtt = rtp->rtcp->rtt;
2110 }
2111 }
2112 if (rtp->rtcp) {
2113 snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality),
2114 "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f",
2115 rtp->ssrc,
2116 rtp->themssrc,
2117 rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2118 rtp->rxjitter,
2119 rtp->rxcount,
2120 (double)rtp->rtcp->reported_jitter / 65536.0,
2121 rtp->txcount,
2122 rtp->rtcp->reported_lost,
2123 rtp->rtcp->rtt);
2124 return rtp->rtcp->quality;
2125 } else
2126 return "<Unknown> - RTP/RTCP has already been destroyed";
2127 }
2128
2129 void ast_rtp_destroy(struct ast_rtp *rtp)
2130 {
2131 if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2132 /*Print some info on the call here */
2133 ast_verbose(" RTP-stats\n");
2134 ast_verbose("* Our Receiver:\n");
2135 ast_verbose(" SSRC: %u\n", rtp->themssrc);
2136 ast_verbose(" Received packets: %u\n", rtp->rxcount);
2137 ast_verbose(" Lost packets: %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2138 ast_verbose(" Jitter: %.4f\n", rtp->rxjitter);
2139 ast_verbose(" Transit: %.4f\n", rtp->rxtransit);
2140 ast_verbose(" RR-count: %u\n", rtp->rtcp->rr_count);
2141 ast_verbose("* Our Sender:\n");
2142 ast_verbose(" SSRC: %u\n", rtp->ssrc);
2143 ast_verbose(" Sent packets: %u\n", rtp->txcount);
2144 ast_verbose(" Lost packets: %u\n", rtp->rtcp->reported_lost);
2145 ast_verbose(" Jitter: %u\n", rtp->rtcp->reported_jitter / (unsigned int)65536.0);
2146 ast_verbose(" SR-count: %u\n", rtp->rtcp->sr_count);
2147 ast_verbose(" RTT: %f\n", rtp->rtcp->rtt);
2148 }
2149
2150 if (rtp->smoother)
2151 ast_smoother_free(rtp->smoother);
2152 if (rtp->ioid)
2153 ast_io_remove(rtp->io, rtp->ioid);
2154 if (rtp->s > -1)
2155 close(rtp->s);
2156 if (rtp->rtcp) {
2157 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2158 close(rtp->rtcp->s);
2159 free(rtp->rtcp);
2160 rtp->rtcp=NULL;
2161 }
2162
2163 ast_mutex_destroy(&rtp->bridge_lock);
2164
2165 free(rtp);
2166 }
2167
2168 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2169 {
2170 struct timeval t;
2171 long ms;
2172 if (ast_tvzero(rtp->txcore)) {
2173 rtp->txcore = ast_tvnow();
2174 /* Round to 20ms for nice, pretty timestamps */
2175 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2176 }
2177 /* Use previous txcore if available */
2178 t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2179 ms = ast_tvdiff_ms(t, rtp->txcore);
2180 if (ms < 0)
2181 ms = 0;
2182 /* Use what we just got for next time */
2183 rtp->txcore = t;
2184 return (unsigned int) ms;
2185 }
2186
2187 /*! \brief Send begin frames for DTMF */
2188 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2189 {
2190 unsigned int *rtpheader;
2191 int hdrlen = 12, res = 0, i = 0, payload = 0;
2192 char data[256];
2193
2194 if ((digit <= '9') && (digit >= '0'))
2195 digit -= '0';
2196 else if (digit == '*')
2197 digit = 10;
2198 else if (digit == '#')
2199 digit = 11;
2200 else if ((digit >= 'A') && (digit <= 'D'))
2201 digit = digit - 'A' + 12;
2202 else if ((digit >= 'a') && (digit <= 'd'))
2203 digit = digit - 'a' + 12;
2204 else {
2205 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2206 return 0;
2207 }
2208
2209 /* If we have no peer, return immediately */
2210 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2211 return 0;
2212
2213 payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2214
2215 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2216 rtp->send_duration = 160;
2217
2218 /* Get a pointer to the header */
2219 rtpheader = (unsigned int *)data;
2220 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2221 rtpheader[1] = htonl(rtp->lastdigitts);
2222 rtpheader[2] = htonl(rtp->ssrc);
2223
2224 for (i = 0; i < 2; i++) {
2225 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2226 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2227 if (res < 0)
2228 ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2229 ast_inet_ntoa(rtp->them.sin_addr),
2230 ntohs(rtp->them.sin_port), strerror(errno));
2231 if (rtp_debug_test_addr(&rtp->them))
2232 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2233 ast_inet_ntoa(rtp->them.sin_addr),
2234 ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2235 /* Increment sequence number */
2236 rtp->seqno++;
2237 /* Increment duration */
2238 rtp->send_duration += 160;
2239 /* Clear marker bit and set seqno */
2240 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2241 }
2242
2243 /* Since we received a begin, we can safely store the digit and disable any compensation */
2244 rtp->sending_digit = 1;
2245 rtp->send_digit = digit;
2246 rtp->send_payload = payload;
2247
2248 return 0;
2249 }
2250
2251 /*! \brief Send continuation frame for DTMF */
2252 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2253 {
2254 unsigned int *rtpheader;
2255 int hdrlen = 12, res = 0;
2256 char data[256];
2257
2258 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2259 return 0;
2260
2261 /* Setup packet to send */
2262 rtpheader = (unsigned int *)data;
2263 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2264 rtpheader[1] = htonl(rtp->lastdigitts);
2265 rtpheader[2] = htonl(rtp->ssrc);
2266 rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2267 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2268
2269 /* Transmit */
2270 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2271 if (res < 0)
2272 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2273 ast_inet_ntoa(rtp->them.sin_addr),
2274 ntohs(rtp->them.sin_port), strerror(errno));
2275 if (rtp_debug_test_addr(&rtp->them))
2276 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2277 ast_inet_ntoa(rtp->them.sin_addr),
2278 ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2279
2280 /* Increment sequence number */
2281 rtp->seqno++;
2282 /* Increment duration */
2283 rtp->send_duration += 160;
2284
2285 return 0;
2286 }
2287
2288 /*! \brief Send end packets for DTMF */
2289 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2290 {
2291 unsigned int *rtpheader;
2292 int hdrlen = 12, res = 0, i = 0;
2293 char data[256];
2294
2295 /* If no address, then bail out */
2296 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2297 return 0;
2298
2299 if ((digit <= '9') && (digit >= '0'))
2300 digit -= '0';
2301 else if (digit == '*')
2302 digit = 10;
2303 else if (digit == '#')
2304 digit = 11;
2305 else if ((digit >= 'A') && (digit <= 'D'))
2306 digit = digit - 'A' + 12;
2307 else if ((digit >= 'a') && (digit <= 'd'))
2308 digit = digit - 'a' + 12;
2309 else {
2310 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2311 return 0;
2312 }
2313
2314 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2315
2316 rtpheader = (unsigned int *)data;
2317 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2318 rtpheader[1] = htonl(rtp->lastdigitts);
2319 rtpheader[2] = htonl(rtp->ssrc);
2320 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2321 /* Set end bit */
2322 rtpheader[3] |= htonl((1 << 23));
2323 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2324 /* Send 3 termination packets */
2325 for (i = 0; i < 3; i++) {
2326 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2327 if (res < 0)
2328 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2329 ast_inet_ntoa(rtp->them.sin_addr),
2330 ntohs(rtp->them.sin_port), strerror(errno));
2331 if (rtp_debug_test_addr(&rtp->them))
2332 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2333 ast_inet_ntoa(rtp->them.sin_addr),
2334 ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2335 }
2336 rtp->sending_digit = 0;
2337 rtp->send_digit = 0;
2338 /* Increment lastdigitts */
2339 rtp->lastdigitts += 960;
2340 rtp->seqno++;
2341
2342 return res;
2343 }
2344
2345 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2346 int ast_rtcp_send_h261fur(void *data)
2347 {
2348 struct ast_rtp *rtp = data;
2349 int res;
2350
2351 rtp->rtcp->sendfur = 1;
2352 res = ast_rtcp_write(data);
2353
2354 return res;
2355 }
2356
2357 /*! \brief Send RTCP sender's report */
2358 static int ast_rtcp_write_sr(const void *data)
2359 {
2360 struct ast_rtp *rtp = (struct ast_rtp *)data;
2361 int res;
2362 int len = 0;
2363 struct timeval now;
2364 unsigned int now_lsw;
2365 unsigned int now_msw;
2366 unsigned int *rtcpheader;
2367 unsigned int lost;
2368 unsigned int extended;
2369 unsigned int expected;
2370 unsigned int expected_interval;
2371 unsigned int received_interval;
2372 int lost_interval;
2373 int fraction;
2374 struct timeval dlsr;
2375 char bdata[512];
2376
2377 /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2378 if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2379 return 0;
2380
2381 if (!rtp->rtcp->them.sin_addr.s_addr) { /* This'll stop rtcp for this rtp session */
2382 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2383 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2384 return 0;
2385 }
2386
2387 gettimeofday(&now, NULL);
2388 timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2389 rtcpheader = (unsigned int *)bdata;
2390 rtcpheader[1] = htonl(rtp->ssrc); /* Our SSRC */
2391 rtcpheader[2] = htonl(now_msw); /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2392 rtcpheader[3] = htonl(now_lsw); /* now, LSW */
2393 rtcpheader[4] = htonl(rtp->lastts); /* FIXME shouldn't be that, it should be now */
2394 rtcpheader[5] = htonl(rtp->txcount); /* No. packets sent */
2395 rtcpheader[6] = htonl(rtp->txoctetcount); /* No. bytes sent */
2396 len += 28;
2397
2398 extended = rtp->cycles + rtp->lastrxseqno;
2399 expected = extended - rtp->seedrxseqno + 1;
2400 if (rtp->rxcount > expected)
2401 expected += rtp->rxcount - expected;
2402 lost = expected - rtp->rxcount;
2403 expected_interval = expected - rtp->rtcp->expected_prior;
2404 rtp->rtcp->expected_prior = expected;
2405 received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2406 rtp->rtcp->received_prior = rtp->rxcount;
2407 lost_interval = expected_interval - received_interval;
2408 if (expected_interval == 0 || lost_interval <= 0)
2409 fraction = 0;
2410 else
2411 fraction = (lost_interval << 8) / expected_interval;
2412 timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2413 rtcpheader[7] = htonl(rtp->themssrc);
2414 rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2415 rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2416 rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2417 rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2418 rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2419 len += 24;
2420
2421 rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2422
2423 if (rtp->rtcp->sendfur) {
2424 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2425 rtcpheader[14] = htonl(rtp->ssrc); /* Our SSRC */
2426 len += 8;
2427 rtp->rtcp->sendfur = 0;
2428 }
2429
2430 /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */
2431 /* it can change mid call, and SDES can't) */
2432 rtcpheader[len/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2433 rtcpheader[(len/4)+1] = htonl(rtp->ssrc); /* Our SSRC */
2434 rtcpheader[(len/4)+2] = htonl(0x01 << 24); /* Empty for the moment */
2435 len += 12;
2436
2437 res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2438 if (res < 0) {
2439 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));
2440 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2441 return 0;
2442 }
2443
2444 /* FIXME Don't need to get a new one */
2445 gettimeofday(&rtp->rtcp->txlsr, NULL);
2446 rtp->rtcp->sr_count++;
2447
2448 rtp->rtcp->lastsrtxcount = rtp->txcount;
2449
2450 if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2451 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2452 ast_verbose(" Our SSRC: %u\n", rtp->ssrc);
2453 ast_verbose(" Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2454 ast_verbose(" Sent(RTP): %u\n", rtp->lastts);
2455 ast_verbose(" Sent packets: %u\n", rtp->txcount);
2456 ast_verbose(" Sent octets: %u\n", rtp->txoctetcount);
2457 ast_verbose(" Report block:\n");
2458 ast_verbose(" Fraction lost: %u\n", fraction);
2459 ast_verbose(" Cumulative loss: %u\n", lost);
2460 ast_verbose(" IA jitter: %.4f\n", rtp->rxjitter);
2461 ast_verbose(" Their last SR: %u\n", rtp->rtcp->themrxlsr);
2462 ast_verbose(" DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2463 }
2464 return res;
2465 }
2466
2467 /*! \brief Send RTCP recepient's report */
2468 static int ast_rtcp_write_rr(const void *data)
2469 {
2470 struct ast_rtp *rtp = (struct ast_rtp *)data;
2471 int res;
2472 int len = 32;
2473 unsigned int lost;
2474 unsigned int extended;
2475 unsigned int expected;
2476 unsigned int expected_interval;
2477 unsigned int received_interval;
2478 int lost_interval;
2479 struct timeval now;
2480 unsigned int *rtcpheader;
2481 char bdata[1024];
2482 struct timeval dlsr;
2483 int fraction;
2484
2485 if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2486 return 0;
2487
2488 if (!rtp->rtcp->them.sin_addr.s_addr) {
2489 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2490 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2491 return 0;
2492 }
2493
2494 extended = rtp->cycles + rtp->lastrxseqno;
2495 expected = extended - rtp->seedrxseqno + 1;
2496 lost = expected - rtp->rxcount;
2497 expected_interval = expected - rtp->rtcp->expected_prior;
2498 rtp->rtcp->expected_prior = expected;
2499 received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2500 rtp->rtcp->received_prior = rtp->rxcount;
2501 lost_interval = expected_interval - received_interval;
2502 if (expected_interval == 0 || lost_interval <= 0)
2503 fraction = 0;
2504 else
2505 fraction = (lost_interval << 8) / expected_interval;
2506 gettimeofday(&now, NULL);
2507 timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2508 rtcpheader = (unsigned int *)bdata;
2509 rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2510 rtcpheader[1] = htonl(rtp->ssrc);
2511 rtcpheader[2] = htonl(rtp->themssrc);
2512 rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2513 rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2514 rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2515 rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2516 rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2517
2518 if (rtp->rtcp->sendfur) {
2519 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2520 rtcpheader[9] = htonl(rtp->ssrc); /* Our SSRC */
2521 len += 8;
2522 rtp->rtcp->sendfur = 0;
2523 }
2524
2525 /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos
2526 it can change mid call, and SDES can't) */
2527 rtcpheader[len/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2528 rtcpheader[(len/4)+1] = htonl(rtp->ssrc); /* Our SSRC */
2529 rtcpheader[(len/4)+2] = htonl(0x01 << 24); /* Empty for the moment */
2530 len += 12;
2531
2532 res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2533
2534 if (res < 0) {
2535 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2536 /* Remove the scheduler */
2537 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2538 return 0;
2539 }
2540
2541 rtp->rtcp->rr_count++;
2542
2543 if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2544 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2545 " Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n"
2546 " IA jitter: %.4f\n"
2547 " Their last SR: %u\n"
2548 " DLSR: %4.4f (sec)\n\n",
2549 ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2550 ntohs(rtp->rtcp->them.sin_port),
2551 rtp->ssrc, rtp->themssrc, fraction, lost,
2552 rtp->rxjitter,
2553 rtp->rtcp->themrxlsr,
2554 (double)(ntohl(rtcpheader[7])/65536.0));
2555 }
2556
2557 return res;
2558 }
2559
2560 /*! \brief Write and RTCP packet to the far end
2561 * \note Decide if we are going to send an SR (with Reception Block) or RR
2562 * RR is sent if we have not sent any rtp packets in the previous interval */
2563 static int ast_rtcp_write(const void *data)
2564 {
2565 struct ast_rtp *rtp = (struct ast_rtp *)data;
2566 int res;
2567
2568 if (!rtp || !rtp->rtcp)
2569 return 0;
2570
2571 if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2572 res = ast_rtcp_write_sr(data);
2573 else
2574 res = ast_rtcp_write_rr(data);
2575
2576 return res;
2577 }
2578
2579 /*! \brief generate comfort noice (CNG) */
2580 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2581 {
2582 unsigned int *rtpheader;
2583 int hdrlen = 12;
2584 int res;
2585 int payload;
2586 char data[256];
2587 level = 127 - (level & 0x7f);
2588 payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2589
2590 /* If we have no peer, return immediately */
2591 if (!rtp->them.sin_addr.s_addr)
2592 return 0;
2593
2594 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2595
2596 /* Get a pointer to the header */
2597 rtpheader = (unsigned int *)data;
2598 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2599 rtpheader[1] = htonl(rtp->lastts);
2600 rtpheader[2] = htonl(rtp->ssrc);
2601 data[12] = level;
2602 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2603 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2604 if (res <0)
2605 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));
2606 if (rtp_debug_test_addr(&rtp->them))
2607 ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2608 , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);
2609
2610 }
2611 return 0;
2612 }
2613
2614 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2615 {
2616 unsigned char *rtpheader;
2617 int hdrlen = 12;
2618 int res;
2619 unsigned int ms;
2620 int pred;
2621 int mark = 0;
2622
2623 ms = calc_txstamp(rtp, &f->delivery);
2624 /* Default prediction */
2625 if (f->frametype == AST_FRAME_VOICE) {
2626 pred = rtp->lastts + f->samples;
2627
2628 /* Re-calculate last TS */
2629 rtp->lastts = rtp->lastts + ms * 8;
2630 if (ast_tvzero(f->delivery)) {
2631 /* If this isn't an absolute delivery time, Check if it is close to our prediction,
2632 and if so, go with our prediction */
2633 if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2634 rtp->lastts = pred;
2635 else {
2636 if (option_debug > 2)
2637 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2638 mark = 1;
2639 }
2640 }
2641 } else if (f->frametype == AST_FRAME_VIDEO) {
2642 mark = f->subclass & 0x1;
2643 pred = rtp->lastovidtimestamp + f->samples;
2644 /* Re-calculate last TS */
2645 rtp->lastts = rtp->lastts + ms * 90;
2646 /* If it's close to our prediction, go for it */
2647 if (ast_tvzero(f->delivery)) {
2648 if (abs(rtp->lastts - pred) < 7200) {
2649 rtp->lastts = pred;
2650 rtp->lastovidtimestamp += f->samples;
2651 } else {
2652 if (option_debug > 2)
2653 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);
2654 rtp->lastovidtimestamp = rtp->lastts;
2655 }
2656 }
2657 }
2658
2659 /* If we have been explicitly told to set the marker bit do so */
2660 if (rtp->set_marker_bit) {
2661 mark = 1;
2662 rtp->set_marker_bit = 0;
2663 }
2664
2665 /* If the timestamp for non-digit packets has moved beyond the timestamp
2666 for digits, update the digit timestamp.
2667 */
2668 if (rtp->lastts > rtp->lastdigitts)
2669 rtp->lastdigitts = rtp->lastts;
2670
2671 if (ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO))
2672 rtp->lastts = f->ts * 8;
2673
2674 /* Get a pointer to the header */
2675 rtpheader = (unsigned char *)(f->data - hdrlen);
2676
2677 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2678 put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2679 put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
2680
2681 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2682 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2683 if (res <0) {
2684 if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2685 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));
2686 } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2687 /* Only give this error message once if we are not RTP debugging */
2688 if (option_debug || rtpdebug)
2689 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));
2690 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2691 }
2692 } else {
2693 rtp->txcount++;
2694 rtp->txoctetcount +=(res - hdrlen);
2695
2696 if (rtp->rtcp && rtp->rtcp->schedid < 1)
2697 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2698 }
2699
2700 if (rtp_debug_test_addr(&rtp->them))
2701 ast_verbose("Sent RTP packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2702 ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2703 }
2704
2705 rtp->seqno++;
2706
2707 return 0;
2708 }
2709
2710 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
2711 {
2712 int x;
2713 for (x = 0; x < 32; x++) { /* Ugly way */
2714 rtp->pref.order[x] = prefs->order[x];
2715 rtp->pref.framing[x] = prefs->framing[x];
2716 }
2717 if (rtp->smoother)
2718 ast_smoother_free(rtp->smoother);
2719 rtp->smoother = NULL;
2720 return 0;
2721 }
2722
2723 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
2724 {
2725 return &rtp->pref;
2726 }
2727
2728 int ast_rtp_codec_getformat(int pt)
2729 {
2730 if (pt < 0 || pt > MAX_RTP_PT)
2731 return 0; /* bogus payload type */
2732
2733 if (static_RTP_PT[pt].isAstFormat)
2734 return static_RTP_PT[pt].code;
2735 else
2736 return 0;
2737 }
2738
2739 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2740 {
2741 struct ast_frame *f;
2742 int codec;
2743 int hdrlen = 12;
2744 int subclass;
2745
2746
2747 /* If we have no peer, return immediately */
2748 if (!rtp->them.sin_addr.s_addr)
2749 return 0;
2750
2751 /* If there is no data length, return immediately */
2752 if (!_f->datalen)
2753 return 0;
2754
2755 /* Make sure we have enough space for RTP header */
2756 if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
2757 ast_log(LOG_WARNING, "RTP can only send voice and video\n");
2758 return -1;
2759 }
2760
2761 subclass = _f->subclass;
2762 if (_f->frametype == AST_FRAME_VIDEO)
2763 subclass &= ~0x1;
2764
2765 codec = ast_rtp_lookup_code(rtp, 1, subclass);
2766 if (codec < 0) {
2767 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2768 return -1;
2769 }
2770
2771 if (rtp->lasttxformat != subclass) {
2772 /* New format, reset the smoother */
2773 if (option_debug)
2774 ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2775 rtp->lasttxformat = subclass;
2776 if (rtp->smoother)
2777 ast_smoother_free(rtp->smoother);
2778 rtp->smoother = NULL;
2779 }
2780
2781 if (!rtp->smoother && subclass != AST_FORMAT_SPEEX && subclass != AST_FORMAT_G723_1) {
2782 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
2783 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
2784 if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2785 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));
2786 return -1;
2787 }
2788 if (fmt.flags)
2789 ast_smoother_set_flags(rtp->smoother, fmt.flags);
2790 if (option_debug)
2791 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));
2792 }
2793 }
2794 if (rtp->smoother) {
2795 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
2796 ast_smoother_feed_be(rtp->smoother, _f);
2797 } else {
2798 ast_smoother_feed(rtp->smoother, _f);
2799 }
2800
2801 while ((f = ast_smoother_read(rtp->smoother)) && (f->data)) {
2802 if (f->subclass == AST_FORMAT_G722) {
2803 /* G.722 is silllllllllllllly */
2804 f->samples /= 2;
2805 }
2806
2807 ast_rtp_raw_write(rtp, f, codec);
2808 }
2809 } else {
2810 /* Don't buffer outgoing frames; send them one-per-packet: */
2811 if (_f->offset < hdrlen) {
2812 f = ast_frdup(_f);
2813 } else {
2814 f = _f;
2815 }
2816 if (f->data) {
2817 if (f->subclass == AST_FORMAT_G722) {
2818 /* G.722 is silllllllllllllly */
2819 f->samples /= 2;
2820 }
2821 ast_rtp_raw_write(rtp, f, codec);
2822 }
2823 if (f != _f)
2824 ast_frfree(f);
2825 }
2826
2827 return 0;
2828 }
2829
2830 /*! \brief Unregister interface to channel driver */
2831 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2832 {
2833 AST_LIST_LOCK(&protos);
2834 AST_LIST_REMOVE(&protos, proto, list);
2835 AST_LIST_UNLOCK(&protos);
2836 }
2837
2838 /*! \brief Register interface to channel driver */
2839 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2840 {
2841 struct ast_rtp_protocol *cur;
2842
2843 AST_LIST_LOCK(&protos);
2844 AST_LIST_TRAVERSE(&protos, cur, list) {
2845 if (!strcmp(cur->type, proto->type)) {
2846 ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2847 AST_LIST_UNLOCK(&protos);
2848 return -1;
2849 }
2850 }
2851 AST_LIST_INSERT_HEAD(&protos, proto, list);
2852 AST_LIST_UNLOCK(&protos);
2853
2854 return 0;
2855 }
2856
2857 /*! \brief Bridge loop for true native bridge (reinvite) */
2858 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)
2859 {
2860 struct ast_frame *fr = NULL;
2861 struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2862 int oldcodec0 = codec0, oldcodec1 = codec1;
2863 struct sockaddr_in ac1 = {0,}, vac1 = {0,}, ac0 = {0,}, vac0 = {0,};
2864 struct sockaddr_in t1 = {0,}, vt1 = {0,}, t0 = {0,}, vt0 = {0,};
2865
2866 /* Set it up so audio goes directly between the two endpoints */
2867
2868 /* Test the first channel */
2869 if (!(pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
2870 ast_rtp_get_peer(p1, &ac1);
2871 if (vp1)
2872 ast_rtp_get_peer(vp1, &vac1);
2873 } else
2874 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2875
2876 /* Test the second channel */
2877 if (!(pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
2878 ast_rtp_get_peer(p0, &ac0);
2879 if (vp0)
2880 ast_rtp_get_peer(vp0, &vac0);
2881 } else
2882 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
2883
2884 /* Now we can unlock and move into our loop */
2885 ast_channel_unlock(c0);
2886 ast_channel_unlock(c1);
2887
2888 /* Throw our channels into the structure and enter the loop */
2889 cs[0] = c0;
2890 cs[1] = c1;
2891 cs[2] = NULL;
2892 for (;;) {
2893 /* Check if anything changed */
2894 if ((c0->tech_pvt != pvt0) ||
2895 (c1->tech_pvt != pvt1) ||
2896 (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
2897 (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
2898 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2899 if (c0->tech_pvt == pvt0)
2900 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2901 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2902 if (c1->tech_pvt == pvt1)
2903 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2904 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2905 return AST_BRIDGE_RETRY;
2906 }
2907
2908 /* Check if they have changed their address */
2909 ast_rtp_get_peer(p1, &t1);
2910 if (vp1)
2911 ast_rtp_get_peer(vp1, &vt1);
2912 if (pr1->get_codec)
2913 codec1 = pr1->get_codec(c1);
2914 ast_rtp_get_peer(p0, &t0);
2915 if (vp0)
2916 ast_rtp_get_peer(vp0, &vt0);
2917 if (pr0->get_codec)
2918 codec0 = pr0->get_codec(c0);
2919 if ((inaddrcmp(&t1, &ac1)) ||
2920 (vp1 && inaddrcmp(&vt1, &vac1)) ||
2921 (codec1 != oldcodec1)) {
2922 if (option_debug > 1) {
2923 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2924 c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
2925 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2926 c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2927 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2928 c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2929 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2930 c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2931 }
2932 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)))
2933 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2934 memcpy(&ac1, &t1, sizeof(ac1));
2935 memcpy(&vac1, &vt1, sizeof(vac1));
2936 oldcodec1 = codec1;
2937 }
2938 if ((inaddrcmp(&t0, &ac0)) ||
2939 (vp0 && inaddrcmp(&vt0, &vac0))) {
2940 if (option_debug > 1) {
2941 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2942 c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
2943 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2944 c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2945 }
2946 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)))
2947 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2948 memcpy(&ac0, &t0, sizeof(ac0));
2949 memcpy(&vac0, &vt0, sizeof(vac0));
2950 oldcodec0 = codec0;
2951 }
2952
2953 /* Wait for frame to come in on the channels */
2954 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2955 if (!timeoutms) {
2956 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2957 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2958 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2959 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2960 return AST_BRIDGE_RETRY;
2961 }
2962 if (option_debug)
2963 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2964 if (ast_check_hangup(c0) || ast_check_hangup(c1))
2965 break;
2966 continue;
2967 }
2968 fr = ast_read(who);
2969 other = (who == c0) ? c1 : c0;
2970 if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
2971 (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
2972 ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2973 /* Break out of bridge */
2974 *fo = fr;
2975 *rc = who;
2976 if (option_debug)
2977 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2978 if (c0->tech_pvt == pvt0)
2979 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2980 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2981 if (c1->tech_pvt == pvt1)
2982 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2983 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2984 return AST_BRIDGE_COMPLETE;
2985 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2986 if ((fr->subclass == AST_CONTROL_HOLD) ||
2987 (fr->subclass == AST_CONTROL_UNHOLD) ||
2988 (fr->subclass == AST_CONTROL_VIDUPDATE) ||
2989 (fr->subclass == AST_CONTROL_SRCUPDATE)) {
2990 if (fr->subclass == AST_CONTROL_HOLD) {
2991 /* If we someone went on hold we want the other side to reinvite back to us */
2992 if (who == c0)
2993 pr1->set_rtp_peer(c1, NULL, NULL, 0, 0);
2994 else
2995 pr0->set_rtp_peer(c0, NULL, NULL, 0, 0);
2996 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
2997 /* If they went off hold they should go back to being direct */
2998 if (who == c0)
2999 pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE));
3000 else
3001 pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE));
3002 }
3003 /* Update local address information */
3004 ast_rtp_get_peer(p0, &t0);
3005 memcpy(&ac0, &t0, sizeof(ac0));
3006 ast_rtp_get_peer(p1, &t1);
3007 memcpy(&ac1, &t1, sizeof(ac1));
3008 /* Update codec information */
3009 if (pr0->get_codec && c0->tech_pvt)
3010 oldcodec0 = codec0 = pr0->get_codec(c0);
3011 if (pr1->get_codec && c1->tech_pvt)
3012 oldcodec1 = codec1 = pr1->get_codec(c1);
3013 ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
3014 ast_frfree(fr);
3015 } else {
3016 *fo = fr;
3017 *rc = who;
3018 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3019 return AST_BRIDGE_COMPLETE;
3020 }
3021 } else {
3022 if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
3023 (fr->frametype == AST_FRAME_DTMF_END) ||
3024 (fr->frametype == AST_FRAME_VOICE) ||
3025 (fr->frametype == AST_FRAME_VIDEO) ||
3026 (fr->frametype == AST_FRAME_IMAGE) ||
3027 (fr->frametype == AST_FRAME_HTML) ||
3028 (fr->frametype == AST_FRAME_MODEM) ||
3029 (fr->frametype == AST_FRAME_TEXT)) {
3030 ast_write(other, fr);
3031 }
3032 ast_frfree(fr);
3033 }
3034 /* Swap priority */
3035 cs[2] = cs[0];
3036 cs[0] = cs[1];
3037 cs[1] = cs[2];
3038 }
3039
3040 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
3041 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3042 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
3043 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3044
3045 return AST_BRIDGE_FAILED;
3046 }
3047
3048 /*! \brief P2P RTP Callback */
3049 #ifdef P2P_INTENSE
3050 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
3051 {
3052 int res = 0, hdrlen = 12;
3053 struct sockaddr_in sin;
3054 socklen_t len;
3055 unsigned int *header;
3056 struct ast_rtp *rtp = cbdata, *bridged = NULL;
3057
3058 if (!rtp)
3059 return 1;
3060
3061 len = sizeof(sin);
3062 if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
3063 return 1;
3064
3065 header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
3066
3067 /* If NAT support is turned on, then see if we need to change their address */
3068 if ((rtp->nat) &&
3069 ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
3070 (rtp->them.sin_port != sin.sin_port))) {
3071 rtp->them = sin;
3072 rtp->rxseqno = 0;
3073 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
3074 if (option_debug || rtpdebug)
3075 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));
3076 }
3077
3078 /* Write directly out to other RTP stream if bridged */
3079 if ((bridged = ast_rtp_get_bridged(rtp)))
3080 bridge_p2p_rtp_write(rtp, bridged, header, res, hdrlen);
3081
3082 return 1;
3083 }
3084
3085 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
3086 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
3087 {
3088 /* If we need DTMF, are looking for STUN, or we have no IO structure then we can't do direct callback */
3089 if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || ast_test_flag(rtp, FLAG_HAS_STUN) || !rtp->io)
3090 return 0;
3091
3092 /* If the RTP structure is already in callback mode, remove it temporarily */
3093 if (rtp->ioid) {
3094 ast_io_remove(rtp->io, rtp->ioid);
3095 rtp->ioid = NULL;
3096 }
3097
3098 /* Steal the file descriptors from the channel and stash them away */
3099 fds[0] = chan->fds[0];
3100 chan->fds[0] = -1;
3101
3102 /* Now, fire up callback mode */
3103 iod[0] = ast_io_add(rtp->io, fds[0], p2p_rtp_callback, AST_IO_IN, rtp);
3104
3105 return 1;
3106 }
3107 #else
3108 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
3109 {
3110 return 0;
3111 }
3112 #endif
3113
3114 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
3115 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
3116 {
3117 ast_channel_lock(chan);
3118
3119 /* Remove the callback from the IO context */
3120 ast_io_remove(rtp->io, iod[0]);
3121
3122 /* Restore file descriptors */
3123 chan->fds[0] = fds[0];
3124 ast_channel_unlock(chan);
3125
3126 /* Restore callback mode if previously used */
3127 if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
3128 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
3129
3130 return 0;
3131 }
3132
3133 /*! \brief Helper function that sets what an RTP structure is bridged to */
3134 static void p2p_set_bridge(struct ast_rtp *rtp0, struct ast_rtp *rtp1)
3135 {
3136 ast_mutex_lock(&rtp0->bridge_lock);
3137 rtp0->bridged = rtp1;
3138 ast_mutex_unlock(&rtp0->bridge_lock);
3139
3140 return;
3141 }
3142
3143 /*! \brief Bridge loop for partial native bridge (packet2packet) */
3144 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)
3145 {
3146 struct ast_frame *fr = NULL;
3147 struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
3148 int p0_fds[2] = {-1, -1}, p1_fds[2] = {-1, -1};
3149 int *p0_iod[2] = {NULL, NULL}, *p1_iod[2] = {NULL, NULL};
3150 int p0_callback = 0, p1_callback = 0;
3151 enum ast_bridge_result res = AST_BRIDGE_FAILED;
3152
3153 /* Okay, setup each RTP structure to do P2P forwarding */
3154 ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3155 p2p_set_bridge(p0, p1);
3156 ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3157 p2p_set_bridge(p1, p0);
3158
3159 /* Activate callback modes if possible */
3160 p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
3161 p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
3162
3163 /* Now let go of the channel locks and be on our way */
3164 ast_channel_unlock(c0);
3165 ast_channel_unlock(c1);
3166
3167 /* Go into a loop forwarding frames until we don't need to anymore */
3168 cs[0] = c0;
3169 cs[1] = c1;
3170 cs[2] = NULL;
3171 for (;;) {
3172 /* If the underlying formats have changed force this bridge to break */
3173 if ((c0->rawreadformat != c1->rawwriteformat) || (c1->rawreadformat != c0->rawwriteformat)) {
3174 ast_log(LOG_DEBUG, "Oooh, formats changed, backing out\n");
3175 res = AST_BRIDGE_FAILED_NOWARN;
3176 break;
3177 }
3178 /* Check if anything changed */
3179 if ((c0->tech_pvt != pvt0) ||
3180 (c1->tech_pvt != pvt1) ||
3181 (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
3182 (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
3183 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
3184 if ((c0->masq || c0->masqr) && (fr = ast_read(c0)))
3185 ast_frfree(fr);
3186 if ((c1->masq || c1->masqr) && (fr = ast_read(c1)))
3187 ast_frfree(fr);
3188 res = AST_BRIDGE_RETRY;
3189 break;
3190 }
3191 /* Wait on a channel to feed us a frame */
3192 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
3193 if (!timeoutms) {
3194 res = AST_BRIDGE_RETRY;
3195 break;
3196 }
3197 if (option_debug)
3198 ast_log(LOG_NOTICE, "Ooh, empty read...\n");
3199 if (ast_check_hangup(c0) || ast_check_hangup(c1))
3200 break;
3201 continue;
3202 }
3203 /* Read in frame from channel */
3204 fr = ast_read(who);
3205 other = (who == c0) ? c1 : c0;
3206 /* Dependong on the frame we may need to break out of our bridge */
3207 if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
3208 ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
3209 ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
3210 /* Record received frame and who */
3211 *fo = fr;
3212 *rc = who;
3213 if (option_debug)
3214 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
3215 res = AST_BRIDGE_COMPLETE;
3216 break;
3217 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3218 if ((fr->subclass == AST_CONTROL_HOLD) ||
3219 (fr->subclass == AST_CONTROL_UNHOLD) ||
3220 (fr->subclass == AST_CONTROL_VIDUPDATE) ||
3221 (fr->subclass == AST_CONTROL_SRCUPDATE)) {
3222 /* If we are going on hold, then break callback mode and P2P bridging */
3223 if (fr->subclass == AST_CONTROL_HOLD) {
3224 if (p0_callback)
3225 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3226 if (p1_callback)
3227 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3228 p2p_set_bridge(p0, NULL);
3229 p2p_set_bridge(p1, NULL);
3230 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3231 /* If we are off hold, then go back to callback mode and P2P bridging */
3232 ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3233 p2p_set_bridge(p0, p1);
3234 ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3235 p2p_set_bridge(p1, p0);
3236 p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
3237 p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
3238 }
3239 ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
3240 ast_frfree(fr);
3241 } else {
3242 *fo = fr;
3243 *rc = who;
3244 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3245 res = AST_BRIDGE_COMPLETE;
3246 break;
3247 }
3248 } else {
3249 if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
3250 (fr->frametype == AST_FRAME_DTMF_END) ||
3251 (fr->frametype == AST_FRAME_VOICE) ||
3252 (fr->frametype == AST_FRAME_VIDEO) ||
3253 (fr->frametype == AST_FRAME_IMAGE) ||
3254 (fr->frametype == AST_FRAME_HTML) ||
3255 (fr->frametype == AST_FRAME_MODEM) ||
3256 (fr->frametype == AST_FRAME_TEXT)) {
3257 ast_write(other, fr);
3258 }
3259
3260 ast_frfree(fr);
3261 }
3262 /* Swap priority */
3263 cs[2] = cs[0];
3264 cs[0] = cs[1];
3265 cs[1] = cs[2];
3266 }
3267
3268 /* If we are totally avoiding the core, then restore our link to it */
3269 if (p0_callback)
3270 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3271 if (p1_callback)
3272 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3273
3274 /* Break out of the direct bridge */
3275 p2p_set_bridge(p0, NULL);
3276 p2p_set_bridge(p1, NULL);
3277
3278 return res;
3279 }
3280
3281 /*! \brief Bridge calls. If possible and allowed, initiate
3282 re-invite so the peers exchange media directly outside
3283 of Asterisk. */
3284 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)
3285 {
3286 struct ast_rtp *p0 = NULL, *p1 = NULL; /* Audio RTP Channels */
3287 struct ast_rtp *vp0 = NULL, *vp1 = NULL; /* Video RTP channels */
3288 struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL;
3289 enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED;
3290 enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED;
3291 enum ast_bridge_result res = AST_BRIDGE_FAILED;
3292 int codec0 = 0, codec1 = 0;
3293 void *pvt0 = NULL, *pvt1 = NULL;
3294
3295 /* Lock channels */
3296 ast_channel_lock(c0);
3297 while(ast_channel_trylock(c1)) {
3298 ast_channel_unlock(c0);
3299 usleep(1);
3300 ast_channel_lock(c0);
3301 }
3302
3303 /* Ensure neither channel got hungup during lock avoidance */
3304 if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
3305 ast_log(LOG_WARNING, "Got hangup while attempting to bridge '%s' and '%s'\n", c0->name, c1->name);
3306 ast_channel_unlock(c0);
3307 ast_channel_unlock(c1);
3308 return AST_BRIDGE_FAILED;
3309 }
3310
3311 /* Find channel driver interfaces */
3312 if (!(pr0 = get_proto(c0))) {
3313 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
3314 ast_channel_unlock(c0);
3315 ast_channel_unlock(c1);
3316 return AST_BRIDGE_FAILED;
3317 }
3318 if (!(pr1 = get_proto(c1))) {
3319 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
3320 ast_channel_unlock(c0);
3321 ast_channel_unlock(c1);
3322 return AST_BRIDGE_FAILED;
3323 }
3324
3325 /* Get channel specific interface structures */
3326 pvt0 = c0->tech_pvt;
3327 pvt1 = c1->tech_pvt;
3328
3329 /* Get audio and video interface (if native bridge is possible) */
3330 audio_p0_res = pr0->get_rtp_info(c0, &p0);
3331 video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED;
3332 audio_p1_res = pr1->get_rtp_info(c1, &p1);
3333 video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED;
3334
3335 /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */
3336 if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE))
3337 audio_p0_res = AST_RTP_GET_FAILED;
3338 if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE))
3339 audio_p1_res = AST_RTP_GET_FAILED;
3340
3341 /* Check if a bridge is possible (partial/native) */
3342 if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) {
3343 /* Somebody doesn't want to play... */
3344 ast_channel_unlock(c0);
3345 ast_channel_unlock(c1);
3346 return AST_BRIDGE_FAILED_NOWARN;
3347 }
3348
3349 /* If we need to feed DTMF frames into the core then only do a partial native bridge */
3350 if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
3351 ast_set_flag(p0, FLAG_P2P_NEED_DTMF);
3352 audio_p0_res = AST_RTP_TRY_PARTIAL;
3353 }
3354
3355 if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
3356 ast_set_flag(p1, FLAG_P2P_NEED_DTMF);
3357 audio_p1_res = AST_RTP_TRY_PARTIAL;
3358 }
3359
3360 /* If both sides are not using the same method of DTMF transmission
3361 * (ie: one is RFC2833, other is INFO... then we can not do direct media.
3362 * --------------------------------------------------
3363 * | DTMF Mode | HAS_DTMF | Accepts Begin Frames |
3364 * |-----------|------------|-----------------------|
3365 * | Inband | False | True |
3366 * | RFC2833 | True | True |
3367 * | SIP INFO | False | False |
3368 * --------------------------------------------------
3369 * However, if DTMF from both channels is being monitored by the core, then
3370 * we can still do packet-to-packet bridging, because passing through the
3371 * core will handle DTMF mode translation.
3372 */
3373 if ( (ast_test_flag(p0, FLAG_HAS_DTMF) != ast_test_flag(p1, FLAG_HAS_DTMF)) ||
3374 (!c0->tech->send_digit_begin != !c1->tech->send_digit_begin)) {
3375 if (!ast_test_flag(p0, FLAG_P2P_NEED_DTMF) || !ast_test_flag(p1, FLAG_P2P_NEED_DTMF)) {
3376 ast_channel_unlock(c0);
3377 ast_channel_unlock(c1);
3378 return AST_BRIDGE_FAILED_NOWARN;
3379 }
3380 audio_p0_res = AST_RTP_TRY_PARTIAL;
3381 audio_p1_res = AST_RTP_TRY_PARTIAL;
3382 }
3383
3384 /* If we need to feed frames into the core don't do a P2P bridge */
3385 if ((audio_p0_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p0, FLAG_P2P_NEED_DTMF)) ||
3386 (audio_p1_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p1, FLAG_P2P_NEED_DTMF))) {
3387 ast_channel_unlock(c0);
3388 ast_channel_unlock(c1);
3389 return AST_BRIDGE_FAILED_NOWARN;
3390 }
3391
3392 /* Get codecs from both sides */
3393 codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
3394 codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
3395 if (codec0 && codec1 && !(codec0 & codec1)) {
3396 /* Hey, we can't do native bridging if both parties speak different codecs */
3397 if (option_debug)
3398 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
3399 ast_channel_unlock(c0);
3400 ast_channel_unlock(c1);
3401 return AST_BRIDGE_FAILED_NOWARN;
3402 }
3403
3404 /* If either side can only do a partial bridge, then don't try for a true native bridge */
3405 if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) {
3406 struct ast_format_list fmt0, fmt1;
3407
3408 /* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */
3409 if (c0->rawreadformat != c1->rawwriteformat || c1->rawreadformat != c0->rawwriteformat) {
3410 if (option_debug)
3411 ast_log(LOG_DEBUG, "Cannot packet2packet bridge - raw formats are incompatible\n");
3412 ast_channel_unlock(c0);
3413 ast_channel_unlock(c1);
3414 return AST_BRIDGE_FAILED_NOWARN;
3415 }
3416 /* They must also be using the same packetization */
3417 fmt0 = ast_codec_pref_getsize(&p0->pref, c0->rawreadformat);
3418 fmt1 = ast_codec_pref_getsize(&p1->pref, c1->rawreadformat);
3419 if (fmt0.cur_ms != fmt1.cur_ms) {
3420 if (option_debug)
3421 ast_log(LOG_DEBUG, "Cannot packet2packet bridge - packetization settings prevent it\n");
3422 ast_channel_unlock(c0);
3423 ast_channel_unlock(c1);
3424 return AST_BRIDGE_FAILED_NOWARN;
3425 }
3426
3427 if (option_verbose > 2)
3428 ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name);
3429 res = bridge_p2p_loop(c0, c1, p0, p1, timeoutms, flags, fo, rc, pvt0, pvt1);
3430 } else {
3431 if (option_verbose > 2)
3432 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
3433 res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1);
3434 }
3435
3436 return res;
3437 }
3438
3439 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
3440 {
3441 struct hostent *hp;
3442 struct ast_hostent ahp;
3443 int port = 0;
3444 char *p, *arg;
3445
3446 if (argc != 4)
3447 return RESULT_SHOWUSAGE;
3448 arg = argv[3];
3449 p = strstr(arg, ":");
3450 if (p) {
3451 *p = '\0';
3452 p++;
3453 port = atoi(p);
3454 }
3455 hp = ast_gethostbyname(arg, &ahp);
3456 if (hp == NULL)
3457 return RESULT_SHOWUSAGE;
3458 rtpdebugaddr.sin_family = AF_INET;
3459 memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
3460 rtpdebugaddr.sin_port = htons(port);
3461 if (port == 0)
3462 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
3463 else
3464 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
3465 rtpdebug = 1;
3466 return RESULT_SUCCESS;
3467 }
3468
3469 static int rtcp_do_debug_ip_deprecated(int fd, int argc, char *argv[])
3470 {
3471 struct hostent *hp;
3472 struct ast_hostent ahp;
3473 int port = 0;
3474 char *p, *arg;
3475 if (argc != 5)
3476 return RESULT_SHOWUSAGE;
3477
3478 arg = argv[4];
3479 p = strstr(arg, ":");
3480 if (p) {
3481 *p = '\0';
3482 p++;
3483 port = atoi(p);
3484 }
3485 hp = ast_gethostbyname(arg, &ahp);
3486 if (hp == NULL)
3487 return RESULT_SHOWUSAGE;
3488 rtcpdebugaddr.sin_family = AF_INET;
3489 memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
3490 rtcpdebugaddr.sin_port = htons(port);
3491 if (port == 0)
3492 ast_cli(fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
3493 else
3494 ast_cli(fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
3495 rtcpdebug = 1;
3496 return RESULT_SUCCESS;
3497 }
3498
3499 static int rtcp_do_debug_ip(int fd, int argc, char *argv[])
3500 {
3501 struct hostent *hp;
3502 struct ast_hostent ahp;
3503 int port = 0;
3504 char *p, *arg;
3505 if (argc != 4)
3506 return RESULT_SHOWUSAGE;
3507
3508 arg = argv[3];
3509 p = strstr(arg, ":");
3510 if (p) {
3511 *p = '\0';
3512 p++;
3513 port = atoi(p);
3514 }
3515 hp = ast_gethostbyname(arg, &ahp);
3516 if (hp == NULL)
3517 return RESULT_SHOWUSAGE;
3518 rtcpdebugaddr.sin_family = AF_INET;
3519 memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
3520 rtcpdebugaddr.sin_port = htons(port);
3521 if (port == 0)
3522 ast_cli(fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
3523 else
3524 ast_cli(fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
3525 rtcpdebug = 1;
3526 return RESULT_SUCCESS;
3527 }
3528
3529 static int rtp_do_debug(int fd, int argc, char *argv[])
3530 {
3531 if (argc != 2) {
3532 if (argc != 4)
3533 return RESULT_SHOWUSAGE;
3534 return rtp_do_debug_ip(fd, argc, argv);
3535 }
3536 rtpdebug = 1;
3537 memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
3538 ast_cli(fd, "RTP Debugging Enabled\n");
3539 return RESULT_SUCCESS;
3540 }
3541
3542 static int rtcp_do_debug_deprecated(int fd, int argc, char *argv[]) {
3543 if (argc != 3) {
3544 if (argc != 5)
3545 return RESULT_SHOWUSAGE;
3546 return rtcp_do_debug_ip_deprecated(fd, argc, argv);
3547 }
3548 rtcpdebug = 1;
3549 memset(&rtcpdebugaddr,0,sizeof(rtcpdebugaddr));
3550 ast_cli(fd, "RTCP Debugging Enabled\n");
3551 return RESULT_SUCCESS;
3552 }
3553
3554 static int rtcp_do_debug(int fd, int argc, char *argv[]) {
3555 if (argc != 2) {
3556 if (argc != 4)
3557 return RESULT_SHOWUSAGE;
3558 return rtcp_do_debug_ip(fd, argc, argv);
3559 }
3560 rtcpdebug = 1;
3561 memset(&rtcpdebugaddr,0,sizeof(rtcpdebugaddr));
3562 ast_cli(fd, "RTCP Debugging Enabled\n");
3563 return RESULT_SUCCESS;
3564 }
3565
3566 static int rtcp_do_stats_deprecated(int fd, int argc, char *argv[]) {
3567 if (argc != 3) {
3568 return RESULT_SHOWUSAGE;
3569 }
3570 rtcpstats = 1;
3571 ast_cli(fd, "RTCP Stats Enabled\n");
3572 return RESULT_SUCCESS;
3573 }
3574
3575 static int rtcp_do_stats(int fd, int argc, char *argv[]) {
3576 if (argc != 2) {
3577 return RESULT_SHOWUSAGE;
3578 }
3579 rtcpstats = 1;
3580 ast_cli(fd, "RTCP Stats Enabled\n");
3581 return RESULT_SUCCESS;
3582 }
3583
3584 static int rtp_no_debug(int fd, int argc, char *argv[])
3585 {
3586 if (argc != 3)
3587 return RESULT_SHOWUSAGE;
3588 rtpdebug = 0;
3589 ast_cli(fd,"RTP Debugging Disabled\n");
3590 return RESULT_SUCCESS;
3591 }
3592
3593 static int rtcp_no_debug_deprecated(int fd, int argc, char *argv[])
3594 {
3595 if (argc != 4)
3596 return RESULT_SHOWUSAGE;
3597 rtcpdebug = 0;
3598 ast_cli(fd,"RTCP Debugging Disabled\n");
3599 return RESULT_SUCCESS;
3600 }
3601
3602 static int rtcp_no_debug(int fd, int argc, char *argv[])
3603 {
3604 if (argc != 3)
3605 return RESULT_SHOWUSAGE;
3606 rtcpdebug = 0;
3607 ast_cli(fd,"RTCP Debugging Disabled\n");
3608 return RESULT_SUCCESS;
3609 }
3610
3611 static int rtcp_no_stats_deprecated(int fd, int argc, char *argv[])
3612 {
3613 if (argc != 4)
3614 return RESULT_SHOWUSAGE;
3615 rtcpstats = 0;
3616 ast_cli(fd,"RTCP Stats Disabled\n");
3617 return RESULT_SUCCESS;
3618 }
3619
3620 static int rtcp_no_stats(int fd, int argc, char *argv[])
3621 {
3622 if (argc != 3)
3623 return RESULT_SHOWUSAGE;
3624 rtcpstats = 0;
3625 ast_cli(fd,"RTCP Stats Disabled\n");
3626 return RESULT_SUCCESS;
3627 }
3628
3629 static int stun_do_debug(int fd, int argc, char *argv[])
3630 {
3631 if (argc != 2) {
3632 return RESULT_SHOWUSAGE;
3633 }
3634 stundebug = 1;
3635 ast_cli(fd, "STUN Debugging Enabled\n");
3636 return RESULT_SUCCESS;
3637 }
3638
3639 static int stun_no_debug(int fd, int argc, char *argv[])
3640 {
3641 if (argc != 3)
3642 return RESULT_SHOWUSAGE;
3643 stundebug = 0;
3644 ast_cli(fd, "STUN Debugging Disabled\n");
3645 return RESULT_SUCCESS;
3646 }
3647
3648 static char debug_usage[] =
3649 "Usage: rtp debug [ip host[:port]]\n"
3650 " Enable dumping of all RTP packets to and from host.\n";
3651
3652 static char no_debug_usage[] =
3653 "Usage: rtp debug off\n"
3654 " Disable all RTP debugging\n";
3655
3656 static char stun_debug_usage[] =
3657 "Usage: stun debug\n"
3658 " Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
3659
3660 static char stun_no_debug_usage[] =
3661 "Usage: stun debug off\n"
3662 " Disable STUN debugging\n";
3663
3664 static char rtcp_debug_usage[] =
3665 "Usage: rtcp debug [ip host[:port]]\n"
3666 " Enable dumping of all RTCP packets to and from host.\n";
3667
3668 static char rtcp_no_debug_usage[] =
3669 "Usage: rtcp debug off\n"
3670 " Disable all RTCP debugging\n";
3671
3672 static char rtcp_stats_usage[] =
3673 "Usage: rtcp stats\n"
3674 " Enable dumping of RTCP stats.\n";
3675
3676 static char rtcp_no_stats_usage[] =
3677 "Usage: rtcp stats off\n"
3678 " Disable all RTCP stats\n";
3679
3680 static struct ast_cli_entry cli_rtp_no_debug_deprecated = {
3681 { "rtp", "no", "debug", NULL },
3682 rtp_no_debug, NULL,
3683 NULL };
3684
3685 static struct ast_cli_entry cli_rtp_rtcp_debug_ip_deprecated = {
3686 { "rtp", "rtcp", "debug", "ip", NULL },
3687 rtcp_do_debug_deprecated, NULL,
3688 NULL };
3689
3690 static struct ast_cli_entry cli_rtp_rtcp_debug_deprecated = {
3691 { "rtp", "rtcp", "debug", NULL },
3692 rtcp_do_debug_deprecated, NULL,
3693 NULL };
3694
3695 static struct ast_cli_entry cli_rtp_rtcp_no_debug_deprecated = {
3696 { "rtp", "rtcp", "no", "debug", NULL },
3697 rtcp_no_debug_deprecated, NULL,
3698 NULL };
3699
3700 static struct ast_cli_entry cli_rtp_rtcp_stats_deprecated = {
3701 { "rtp", "rtcp", "stats", NULL },
3702 rtcp_do_stats_deprecated, NULL,
3703 NULL };
3704
3705 static struct ast_cli_entry cli_rtp_rtcp_no_stats_deprecated = {
3706 { "rtp", "rtcp", "no", "stats", NULL },
3707 rtcp_no_stats_deprecated, NULL,
3708 NULL };
3709
3710 static struct ast_cli_entry cli_stun_no_debug_deprecated = {
3711 { "stun", "no", "debug", NULL },
3712 stun_no_debug, NULL,
3713 NULL };
3714
3715 static struct ast_cli_entry cli_rtp[] = {
3716 { { "rtp", "debug", "ip", NULL },
3717 rtp_do_debug, "Enable RTP debugging on IP",
3718 debug_usage },
3719
3720 { { "rtp", "debug", NULL },
3721 rtp_do_debug, "Enable RTP debugging",
3722 debug_usage },
3723
3724 { { "rtp", "debug", "off", NULL },
3725 rtp_no_debug, "Disable RTP debugging",
3726 no_debug_usage, NULL, &cli_rtp_no_debug_deprecated },
3727
3728 { { "rtcp", "debug", "ip", NULL },
3729 rtcp_do_debug, "Enable RTCP debugging on IP",
3730 rtcp_debug_usage, NULL, &cli_rtp_rtcp_debug_ip_deprecated },
3731
3732 { { "rtcp", "debug", NULL },
3733 rtcp_do_debug, "Enable RTCP debugging",
3734 rtcp_debug_usage, NULL, &cli_rtp_rtcp_debug_deprecated },
3735
3736 { { "rtcp", "debug", "off", NULL },
3737 rtcp_no_debug, "Disable RTCP debugging",
3738 rtcp_no_debug_usage, NULL, &cli_rtp_rtcp_no_debug_deprecated },
3739
3740 { { "rtcp", "stats", NULL },
3741 rtcp_do_stats, "Enable RTCP stats",
3742 rtcp_stats_usage, NULL, &cli_rtp_rtcp_stats_deprecated },
3743
3744 { { "rtcp", "stats", "off", NULL },
3745 rtcp_no_stats, "Disable RTCP stats",
3746 rtcp_no_stats_usage, NULL, &cli_rtp_rtcp_no_stats_deprecated },
3747
3748 { { "stun", "debug", NULL },
3749 stun_do_debug, "Enable STUN debugging",
3750 stun_debug_usage },
3751
3752 { { "stun", "debug", "off", NULL },
3753 stun_no_debug, "Disable STUN debugging",
3754 stun_no_debug_usage, NULL, &cli_stun_no_debug_deprecated },
3755 };
3756
3757 int ast_rtp_reload(void)
3758 {
3759 struct ast_config *cfg;
3760 const char *s;
3761
3762 rtpstart = 5000;
3763 rtpend = 31000;
3764 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3765 cfg = ast_config_load("rtp.conf");
3766 if (cfg) {
3767 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
3768 rtpstart = atoi(s);
3769 if (rtpstart < 1024)
3770 rtpstart = 1024;
3771 if (rtpstart > 65535)
3772 rtpstart = 65535;
3773 }
3774 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
3775 rtpend = atoi(s);
3776 if (rtpend < 1024)
3777 rtpend = 1024;
3778 if (rtpend > 65535)
3779 rtpend = 65535;
3780 }
3781 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
3782 rtcpinterval = atoi(s);
3783 if (rtcpinterval == 0)
3784 rtcpinterval = 0; /* Just so we're clear... it's zero */
3785 if (rtcpinterval < RTCP_MIN_INTERVALMS)
3786 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
3787 if (rtcpinterval > RTCP_MAX_INTERVALMS)
3788 rtcpinterval = RTCP_MAX_INTERVALMS;
3789 }
3790 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
3791 #ifdef SO_NO_CHECK
3792 if (ast_false(s))
3793 nochecksums = 1;
3794 else
3795 nochecksums = 0;
3796 #else
3797 if (ast_false(s))
3798 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
3799 #endif
3800 }
3801 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
3802 dtmftimeout = atoi(s);
3803 if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
3804 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
3805 dtmftimeout, DEFAULT_DTMF_TIMEOUT);
3806 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3807 };
3808 }
3809 ast_config_destroy(cfg);
3810 }
3811 if (rtpstart >= rtpend) {
3812 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
3813 rtpstart = 5000;
3814 rtpend = 31000;
3815 }
3816 if (option_verbose > 1)
3817 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
3818 return 0;
3819 }
3820
3821 /*! \brief Initialize the RTP system in Asterisk */
3822 void ast_rtp_init(void)
3823 {
3824 ast_cli_register_multiple(cli_rtp, sizeof(cli_rtp) / sizeof(struct ast_cli_entry));
3825 ast_rtp_reload();
3826 }
3827
Open Source Private Branch Exchange (PBX)