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