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