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