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