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