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