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