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