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