Merged revisions 100465 via svnmerge from
[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==0)
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         // dest = c0, src = c1
1802         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1803         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1804         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1805         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1806         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;
1807         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;
1808         int srccodec, destcodec, nat_active = 0;
1809
1810         /* Lock channels */
1811         ast_channel_lock(c0);
1812         if (c1) {
1813                 while (ast_channel_trylock(c1)) {
1814                         ast_channel_unlock(c0);
1815                         usleep(1);
1816                         ast_channel_lock(c0);
1817                 }
1818         }
1819
1820         /* Find channel driver interfaces */
1821         destpr = get_proto(c0);
1822         if (c1)
1823                 srcpr = get_proto(c1);
1824         if (!destpr) {
1825                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c0->name);
1826                 ast_channel_unlock(c0);
1827                 if (c1)
1828                         ast_channel_unlock(c1);
1829                 return -1;
1830         }
1831         if (!srcpr) {
1832                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>");
1833                 ast_channel_unlock(c0);
1834                 if (c1)
1835                         ast_channel_unlock(c1);
1836                 return -1;
1837         }
1838
1839         /* Get audio, video  and text interface (if native bridge is possible) */
1840         audio_dest_res = destpr->get_rtp_info(c0, &destp);
1841         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED;
1842         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(c0, &tdestp) : AST_RTP_GET_FAILED;
1843         if (srcpr) {
1844                 audio_src_res = srcpr->get_rtp_info(c1, &srcp);
1845                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED;
1846                 text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(c1, &tsrcp) : AST_RTP_GET_FAILED;
1847         }
1848
1849         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1850         if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1851                 /* Somebody doesn't want to play... */
1852                 ast_channel_unlock(c0);
1853                 if (c1)
1854                         ast_channel_unlock(c1);
1855                 return -1;
1856         }
1857         if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1858                 srccodec = srcpr->get_codec(c1);
1859         else
1860                 srccodec = 0;
1861         if (audio_dest_res == AST_RTP_TRY_NATIVE && destpr->get_codec)
1862                 destcodec = destpr->get_codec(c0);
1863         else
1864                 destcodec = 0;
1865         /* Ensure we have at least one matching codec */
1866         if (!(srccodec & destcodec)) {
1867                 ast_channel_unlock(c0);
1868                 if (c1)
1869                         ast_channel_unlock(c1);
1870                 return 0;
1871         }
1872         /* Consider empty media as non-existant */
1873         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1874                 srcp = NULL;
1875         if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1876                 nat_active = 1;
1877         /* Bridge media early */
1878         if (destpr->set_rtp_peer(c0, srcp, vsrcp, tsrcp, srccodec, nat_active))
1879                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1880         ast_channel_unlock(c0);
1881         if (c1)
1882                 ast_channel_unlock(c1);
1883         ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1884         return 0;
1885 }
1886
1887 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1888 {
1889         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1890         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1891         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1892         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1893         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;
1894         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; 
1895         int srccodec, destcodec;
1896
1897         /* Lock channels */
1898         ast_channel_lock(dest);
1899         while (ast_channel_trylock(src)) {
1900                 ast_channel_unlock(dest);
1901                 usleep(1);
1902                 ast_channel_lock(dest);
1903         }
1904
1905         /* Find channel driver interfaces */
1906         if (!(destpr = get_proto(dest))) {
1907                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1908                 ast_channel_unlock(dest);
1909                 ast_channel_unlock(src);
1910                 return 0;
1911         }
1912         if (!(srcpr = get_proto(src))) {
1913                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", src->name);
1914                 ast_channel_unlock(dest);
1915                 ast_channel_unlock(src);
1916                 return 0;
1917         }
1918
1919         /* Get audio and video interface (if native bridge is possible) */
1920         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1921         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1922         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(dest, &tdestp) : AST_RTP_GET_FAILED;
1923         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1924         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1925         text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(src, &tsrcp) : AST_RTP_GET_FAILED;
1926
1927         /* Ensure we have at least one matching codec */
1928         if (srcpr->get_codec)
1929                 srccodec = srcpr->get_codec(src);
1930         else
1931                 srccodec = 0;
1932         if (destpr->get_codec)
1933                 destcodec = destpr->get_codec(dest);
1934         else
1935                 destcodec = 0;
1936
1937         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1938         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE || !(srccodec & destcodec)) {
1939                 /* Somebody doesn't want to play... */
1940                 ast_channel_unlock(dest);
1941                 ast_channel_unlock(src);
1942                 return 0;
1943         }
1944         ast_rtp_pt_copy(destp, srcp);
1945         if (vdestp && vsrcp)
1946                 ast_rtp_pt_copy(vdestp, vsrcp);
1947         if (tdestp && tsrcp)
1948                 ast_rtp_pt_copy(tdestp, tsrcp);
1949         if (media) {
1950                 /* Bridge early */
1951                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, tsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1952                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1953         }
1954         ast_channel_unlock(dest);
1955         ast_channel_unlock(src);
1956         ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1957         return 1;
1958 }
1959
1960 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1961  * By default, use the well-known value for this type (although it may 
1962  * still be set to a different value by a subsequent "a=rtpmap:" line)
1963  */
1964 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1965 {
1966         if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) 
1967                 return; /* bogus payload type */
1968
1969         rtp_bridge_lock(rtp);
1970         rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1971         rtp_bridge_unlock(rtp);
1972
1973
1974 /*! \brief remove setting from payload type list if the rtpmap header indicates
1975     an unknown media type */
1976 void ast_rtp_unset_m_type(struct ast_rtp* rtp, int pt) 
1977 {
1978         rtp_bridge_lock(rtp);
1979         rtp->current_RTP_PT[pt].isAstFormat = 0;
1980         rtp->current_RTP_PT[pt].code = 0;
1981         rtp_bridge_unlock(rtp);
1982 }
1983
1984 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1985  * an SDP "a=rtpmap:" line.
1986  * \return 0 if the MIME type was found and set, -1 if it wasn't found
1987  */
1988 int ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1989                              char *mimeType, char *mimeSubtype,
1990                              enum ast_rtp_options options)
1991 {
1992         unsigned int i;
1993         int found = 0;
1994
1995         if (pt < 0 || pt > MAX_RTP_PT) 
1996                 return -1; /* bogus payload type */
1997         
1998         rtp_bridge_lock(rtp);
1999
2000         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
2001                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
2002                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
2003                         found = 1;
2004                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
2005                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
2006                             mimeTypes[i].payloadType.isAstFormat &&
2007                             (options & AST_RTP_OPT_G726_NONSTANDARD))
2008                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
2009                         break;
2010                 }
2011         }
2012
2013         rtp_bridge_unlock(rtp);
2014
2015         return (found ? 0 : -1);
2016
2017
2018 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
2019  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
2020 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
2021                                  int* astFormats, int* nonAstFormats)
2022 {
2023         int pt;
2024         
2025         rtp_bridge_lock(rtp);
2026         
2027         *astFormats = *nonAstFormats = 0;
2028         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2029                 if (rtp->current_RTP_PT[pt].isAstFormat) {
2030                         *astFormats |= rtp->current_RTP_PT[pt].code;
2031                 } else {
2032                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
2033                 }
2034         }
2035
2036         rtp_bridge_unlock(rtp);
2037         
2038         return;
2039 }
2040
2041 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
2042 {
2043         struct rtpPayloadType result;
2044
2045         result.isAstFormat = result.code = 0;
2046
2047         if (pt < 0 || pt > MAX_RTP_PT) 
2048                 return result; /* bogus payload type */
2049
2050         /* Start with negotiated codecs */
2051         rtp_bridge_lock(rtp);
2052         result = rtp->current_RTP_PT[pt];
2053         rtp_bridge_unlock(rtp);
2054
2055         /* If it doesn't exist, check our static RTP type list, just in case */
2056         if (!result.code) 
2057                 result = static_RTP_PT[pt];
2058
2059         return result;
2060 }
2061
2062 /*! \brief Looks up an RTP code out of our *static* outbound list */
2063 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
2064 {
2065         int pt = 0;
2066
2067         rtp_bridge_lock(rtp);
2068
2069         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
2070                 code == rtp->rtp_lookup_code_cache_code) {
2071                 /* Use our cached mapping, to avoid the overhead of the loop below */
2072                 pt = rtp->rtp_lookup_code_cache_result;
2073                 rtp_bridge_unlock(rtp);
2074                 return pt;
2075         }
2076
2077         /* Check the dynamic list first */
2078         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2079                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
2080                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
2081                         rtp->rtp_lookup_code_cache_code = code;
2082                         rtp->rtp_lookup_code_cache_result = pt;
2083                         rtp_bridge_unlock(rtp);
2084                         return pt;
2085                 }
2086         }
2087
2088         /* Then the static list */
2089         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2090                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
2091                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
2092                         rtp->rtp_lookup_code_cache_code = code;
2093                         rtp->rtp_lookup_code_cache_result = pt;
2094                         rtp_bridge_unlock(rtp);
2095                         return pt;
2096                 }
2097         }
2098
2099         rtp_bridge_unlock(rtp);
2100
2101         return -1;
2102 }
2103
2104 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
2105                                   enum ast_rtp_options options)
2106 {
2107         unsigned int i;
2108
2109         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
2110                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
2111                         if (isAstFormat &&
2112                             (code == AST_FORMAT_G726_AAL2) &&
2113                             (options & AST_RTP_OPT_G726_NONSTANDARD))
2114                                 return "G726-32";
2115                         else
2116                                 return mimeTypes[i].subtype;
2117                 }
2118         }
2119
2120         return "";
2121 }
2122
2123 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
2124                                    const int isAstFormat, enum ast_rtp_options options)
2125 {
2126         int format;
2127         unsigned len;
2128         char *end = buf;
2129         char *start = buf;
2130
2131         if (!buf || !size)
2132                 return NULL;
2133
2134         snprintf(end, size, "0x%x (", capability);
2135
2136         len = strlen(end);
2137         end += len;
2138         size -= len;
2139         start = end;
2140
2141         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
2142                 if (capability & format) {
2143                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
2144
2145                         snprintf(end, size, "%s|", name);
2146                         len = strlen(end);
2147                         end += len;
2148                         size -= len;
2149                 }
2150         }
2151
2152         if (start == end)
2153                 ast_copy_string(start, "nothing)", size); 
2154         else if (size > 1)
2155                 *(end -1) = ')';
2156         
2157         return buf;
2158 }
2159
2160 /*! \brief Open RTP or RTCP socket for a session.
2161  * Print a message on failure. 
2162  */
2163 static int rtp_socket(const char *type)
2164 {
2165         int s = socket(AF_INET, SOCK_DGRAM, 0);
2166         if (s < 0) {
2167                 if (type == NULL)
2168                         type = "RTP/RTCP";
2169                 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
2170         } else {
2171                 long flags = fcntl(s, F_GETFL);
2172                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
2173 #ifdef SO_NO_CHECK
2174                 if (nochecksums)
2175                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
2176 #endif
2177         }
2178         return s;
2179 }
2180
2181 /*!
2182  * \brief Initialize a new RTCP session.
2183  * 
2184  * \returns The newly initialized RTCP session.
2185  */
2186 static struct ast_rtcp *ast_rtcp_new(void)
2187 {
2188         struct ast_rtcp *rtcp;
2189
2190         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
2191                 return NULL;
2192         rtcp->s = rtp_socket("RTCP");
2193         rtcp->us.sin_family = AF_INET;
2194         rtcp->them.sin_family = AF_INET;
2195
2196         if (rtcp->s < 0) {
2197                 ast_free(rtcp);
2198                 return NULL;
2199         }
2200
2201         return rtcp;
2202 }
2203
2204 /*!
2205  * \brief Initialize a new RTP structure.
2206  *
2207  */
2208 void ast_rtp_new_init(struct ast_rtp *rtp)
2209 {
2210 #ifdef P2P_INTENSE
2211         ast_mutex_init(&rtp->bridge_lock);
2212 #endif
2213
2214         rtp->them.sin_family = AF_INET;
2215         rtp->us.sin_family = AF_INET;
2216         rtp->ssrc = ast_random();
2217         rtp->seqno = ast_random() & 0xffff;
2218         ast_set_flag(rtp, FLAG_HAS_DTMF);
2219         rtp->strict_rtp_state = (strictrtp ? STRICT_RTP_LEARN : STRICT_RTP_OPEN);
2220
2221         return;
2222 }
2223
2224 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
2225 {
2226         struct ast_rtp *rtp;
2227         int x;
2228         int startplace;
2229         
2230         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
2231                 return NULL;
2232
2233         ast_rtp_new_init(rtp);
2234
2235         rtp->s = rtp_socket("RTP");
2236         if (rtp->s < 0)
2237                 goto fail;
2238         if (sched && rtcpenable) {
2239                 rtp->sched = sched;
2240                 rtp->rtcp = ast_rtcp_new();
2241         }
2242         
2243         /*
2244          * Try to bind the RTP port, x, and possibly the RTCP port, x+1 as well.
2245          * Start from a random (even, by RTP spec) port number, and
2246          * iterate until success or no ports are available.
2247          * Note that the requirement of RTP port being even, or RTCP being the
2248          * next one, cannot be enforced in presence of a NAT box because the
2249          * mapping is not under our control.
2250          */
2251         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
2252         x = x & ~1;             /* make it an even number */
2253         startplace = x;         /* remember the starting point */
2254         /* this is constant across the loop */
2255         rtp->us.sin_addr = addr;
2256         if (rtp->rtcp)
2257                 rtp->rtcp->us.sin_addr = addr;
2258         for (;;) {
2259                 rtp->us.sin_port = htons(x);
2260                 if (!bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) {
2261                         /* bind succeeded, if no rtcp then we are done */
2262                         if (!rtp->rtcp)
2263                                 break;
2264                         /* have rtcp, try to bind it */
2265                         rtp->rtcp->us.sin_port = htons(x + 1);
2266                         if (!bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us)))
2267                                 break;  /* success again, we are really done */
2268                         /*
2269                          * RTCP bind failed, so close and recreate the
2270                          * already bound RTP socket for the next round.
2271                          */
2272                         close(rtp->s);
2273                         rtp->s = rtp_socket("RTP");
2274                         if (rtp->s < 0)
2275                                 goto fail;
2276                 }
2277                 /*
2278                  * If we get here, there was an error in one of the bind()
2279                  * calls, so make sure it is nothing unexpected.
2280                  */
2281                 if (errno != EADDRINUSE) {
2282                         /* We got an error that wasn't expected, abort! */
2283                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
2284                         goto fail;
2285                 }
2286                 /*
2287                  * One of the ports is in use. For the next iteration,
2288                  * increment by two and handle wraparound.
2289                  * If we reach the starting point, then declare failure.
2290                  */
2291                 x += 2;
2292                 if (x > rtpend)
2293                         x = (rtpstart + 1) & ~1;
2294                 if (x == startplace) {
2295                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
2296                         goto fail;
2297                 }
2298         }
2299         rtp->sched = sched;
2300         rtp->io = io;
2301         if (callbackmode) {
2302                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2303                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
2304         }
2305         ast_rtp_pt_default(rtp);
2306         return rtp;
2307
2308 fail:
2309         if (rtp->s >= 0)
2310                 close(rtp->s);
2311         if (rtp->rtcp) {
2312                 close(rtp->rtcp->s);
2313                 ast_free(rtp->rtcp);
2314         }
2315         ast_free(rtp);
2316         return NULL;
2317 }
2318
2319 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
2320 {
2321         struct in_addr ia;
2322
2323         memset(&ia, 0, sizeof(ia));
2324         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
2325 }
2326
2327 int ast_rtp_setqos(struct ast_rtp *rtp, int tos, int cos, char *desc)
2328 {
2329         return ast_netsock_set_qos(rtp->s, tos, cos, desc);
2330 }
2331
2332 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2333 {
2334         rtp->them.sin_port = them->sin_port;
2335         rtp->them.sin_addr = them->sin_addr;
2336         if (rtp->rtcp) {
2337                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
2338                 rtp->rtcp->them.sin_addr = them->sin_addr;
2339         }
2340         rtp->rxseqno = 0;
2341         /* If strict RTP protection is enabled switch back to the learn state so we don't drop packets from above */
2342         if (strictrtp)
2343                 rtp->strict_rtp_state = STRICT_RTP_LEARN;
2344 }
2345
2346 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2347 {
2348         if ((them->sin_family != AF_INET) ||
2349                 (them->sin_port != rtp->them.sin_port) ||
2350                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2351                 them->sin_family = AF_INET;
2352                 them->sin_port = rtp->them.sin_port;
2353                 them->sin_addr = rtp->them.sin_addr;
2354                 return 1;
2355         }
2356         return 0;
2357 }
2358
2359 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2360 {
2361         *us = rtp->us;
2362 }
2363
2364 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2365 {
2366         struct ast_rtp *bridged = NULL;
2367
2368         rtp_bridge_lock(rtp);
2369         bridged = rtp->bridged;
2370         rtp_bridge_unlock(rtp);
2371
2372         return bridged;
2373 }
2374
2375 void ast_rtp_stop(struct ast_rtp *rtp)
2376 {
2377         AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2378
2379         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2380         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2381         if (rtp->rtcp) {
2382                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2383                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2384         }
2385         
2386         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2387 }
2388
2389 void ast_rtp_reset(struct ast_rtp *rtp)
2390 {
2391         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2392         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2393         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2394         rtp->lastts = 0;
2395         rtp->lastdigitts = 0;
2396         rtp->lastrxts = 0;
2397         rtp->lastividtimestamp = 0;
2398         rtp->lastovidtimestamp = 0;
2399         rtp->lastitexttimestamp = 0;
2400         rtp->lastotexttimestamp = 0;
2401         rtp->lasteventseqn = 0;
2402         rtp->lastevent = 0;
2403         rtp->lasttxformat = 0;
2404         rtp->lastrxformat = 0;
2405         rtp->dtmfcount = 0;
2406         rtp->dtmfsamples = 0;
2407         rtp->seqno = 0;
2408         rtp->rxseqno = 0;
2409 }
2410
2411 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2412 {
2413         /*
2414         *ssrc          our ssrc
2415         *themssrc      their ssrc
2416         *lp            lost packets
2417         *rxjitter      our calculated jitter(rx)
2418         *rxcount       no. received packets
2419         *txjitter      reported jitter of the other end
2420         *txcount       transmitted packets
2421         *rlp           remote lost packets
2422         *rtt           round trip time
2423         */
2424
2425         if (qual && rtp) {
2426                 qual->local_ssrc = rtp->ssrc;
2427                 qual->local_jitter = rtp->rxjitter;
2428                 qual->local_count = rtp->rxcount;
2429                 qual->remote_ssrc = rtp->themssrc;
2430                 qual->remote_count = rtp->txcount;
2431                 if (rtp->rtcp) {
2432                         qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2433                         qual->remote_lostpackets = rtp->rtcp->reported_lost;
2434                         qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2435                         qual->rtt = rtp->rtcp->rtt;
2436                 }
2437         }
2438         if (rtp->rtcp) {
2439                 snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality),
2440                         "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f",
2441                         rtp->ssrc,
2442                         rtp->themssrc,
2443                         rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2444                         rtp->rxjitter,
2445                         rtp->rxcount,
2446                         (double)rtp->rtcp->reported_jitter / 65536.0,
2447                         rtp->txcount,
2448                         rtp->rtcp->reported_lost,
2449                         rtp->rtcp->rtt);
2450                 return rtp->rtcp->quality;
2451         } else
2452                 return "<Unknown> - RTP/RTCP has already been destroyed";
2453 }
2454
2455 void ast_rtp_destroy(struct ast_rtp *rtp)
2456 {
2457         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2458                 /*Print some info on the call here */
2459                 ast_verbose("  RTP-stats\n");
2460                 ast_verbose("* Our Receiver:\n");
2461                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
2462                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
2463                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2464                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
2465                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2466                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2467                 ast_verbose("* Our Sender:\n");
2468                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2469                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2470                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2471                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter / (unsigned int)65536.0);
2472                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2473                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2474         }
2475
2476         manager_event(EVENT_FLAG_REPORTING, "RTPReceiverStat", "SSRC: %u\r\n"
2477                                             "ReceivedPackets: %u\r\n"
2478                                             "LostPackets: %u\r\n"
2479                                             "Jitter: %.4f\r\n"
2480                                             "Transit: %.4f\r\n"
2481                                             "RRCount: %u\r\n",
2482                                             rtp->themssrc,
2483                                             rtp->rxcount,
2484                                             rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2485                                             rtp->rxjitter,
2486                                             rtp->rxtransit,
2487                                             rtp->rtcp->rr_count);
2488         manager_event(EVENT_FLAG_REPORTING, "RTPSenderStat", "SSRC: %u\r\n"
2489                                             "SentPackets: %u\r\n"
2490                                             "LostPackets: %u\r\n"
2491                                             "Jitter: %u\r\n"
2492                                             "SRCount: %u\r\n"
2493                                             "RTT: %f\r\n",
2494                                             rtp->ssrc,
2495                                             rtp->txcount,
2496                                             rtp->rtcp->reported_lost,
2497                                             rtp->rtcp->reported_jitter,
2498                                             rtp->rtcp->sr_count,
2499                                             rtp->rtcp->rtt);
2500         if (rtp->smoother)
2501                 ast_smoother_free(rtp->smoother);
2502         if (rtp->ioid)
2503                 ast_io_remove(rtp->io, rtp->ioid);
2504         if (rtp->s > -1)
2505                 close(rtp->s);
2506         if (rtp->rtcp) {
2507                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2508                 close(rtp->rtcp->s);
2509                 ast_free(rtp->rtcp);
2510                 rtp->rtcp=NULL;
2511         }
2512 #ifdef P2P_INTENSE
2513         ast_mutex_destroy(&rtp->bridge_lock);
2514 #endif
2515         ast_free(rtp);
2516 }
2517
2518 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2519 {
2520         struct timeval t;
2521         long ms;
2522         if (ast_tvzero(rtp->txcore)) {
2523                 rtp->txcore = ast_tvnow();
2524                 /* Round to 20ms for nice, pretty timestamps */
2525                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2526         }
2527         /* Use previous txcore if available */
2528         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2529         ms = ast_tvdiff_ms(t, rtp->txcore);
2530         if (ms < 0)
2531                 ms = 0;
2532         /* Use what we just got for next time */
2533         rtp->txcore = t;
2534         return (unsigned int) ms;
2535 }
2536
2537 /*! \brief Send begin frames for DTMF */
2538 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2539 {
2540         unsigned int *rtpheader;
2541         int hdrlen = 12, res = 0, i = 0, payload = 0;
2542         char data[256];
2543
2544         if ((digit <= '9') && (digit >= '0'))
2545                 digit -= '0';
2546         else if (digit == '*')
2547                 digit = 10;
2548         else if (digit == '#')
2549                 digit = 11;
2550         else if ((digit >= 'A') && (digit <= 'D'))
2551                 digit = digit - 'A' + 12;
2552         else if ((digit >= 'a') && (digit <= 'd'))
2553                 digit = digit - 'a' + 12;
2554         else {
2555                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2556                 return 0;
2557         }
2558
2559         /* If we have no peer, return immediately */    
2560         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2561                 return 0;
2562
2563         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2564
2565         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2566         rtp->send_duration = 160;
2567         
2568         /* Get a pointer to the header */
2569         rtpheader = (unsigned int *)data;
2570         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2571         rtpheader[1] = htonl(rtp->lastdigitts);
2572         rtpheader[2] = htonl(rtp->ssrc); 
2573
2574         for (i = 0; i < 2; i++) {
2575                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2576                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2577                 if (res < 0) 
2578                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2579                                 ast_inet_ntoa(rtp->them.sin_addr),
2580                                 ntohs(rtp->them.sin_port), strerror(errno));
2581                 if (rtp_debug_test_addr(&rtp->them))
2582                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2583                                     ast_inet_ntoa(rtp->them.sin_addr),
2584                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2585                 /* Increment sequence number */
2586                 rtp->seqno++;
2587                 /* Increment duration */
2588                 rtp->send_duration += 160;
2589                 /* Clear marker bit and set seqno */
2590                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2591         }
2592
2593         /* Since we received a begin, we can safely store the digit and disable any compensation */
2594         rtp->sending_digit = 1;
2595         rtp->send_digit = digit;
2596         rtp->send_payload = payload;
2597
2598         return 0;
2599 }
2600
2601 /*! \brief Send continuation frame for DTMF */
2602 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2603 {
2604         unsigned int *rtpheader;
2605         int hdrlen = 12, res = 0;
2606         char data[256];
2607
2608         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2609                 return 0;
2610
2611         /* Setup packet to send */
2612         rtpheader = (unsigned int *)data;
2613         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2614         rtpheader[1] = htonl(rtp->lastdigitts);
2615         rtpheader[2] = htonl(rtp->ssrc);
2616         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2617         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2618         
2619         /* Transmit */
2620         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2621         if (res < 0)
2622                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2623                         ast_inet_ntoa(rtp->them.sin_addr),
2624                         ntohs(rtp->them.sin_port), strerror(errno));
2625         if (rtp_debug_test_addr(&rtp->them))
2626                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2627                             ast_inet_ntoa(rtp->them.sin_addr),
2628                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2629
2630         /* Increment sequence number */
2631         rtp->seqno++;
2632         /* Increment duration */
2633         rtp->send_duration += 160;
2634
2635         return 0;
2636 }
2637
2638 /*! \brief Send end packets for DTMF */
2639 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2640 {
2641         unsigned int *rtpheader;
2642         int hdrlen = 12, res = 0, i = 0;
2643         char data[256];
2644         
2645         /* If no address, then bail out */
2646         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2647                 return 0;
2648         
2649         if ((digit <= '9') && (digit >= '0'))
2650                 digit -= '0';
2651         else if (digit == '*')
2652                 digit = 10;
2653         else if (digit == '#')
2654                 digit = 11;
2655         else if ((digit >= 'A') && (digit <= 'D'))
2656                 digit = digit - 'A' + 12;
2657         else if ((digit >= 'a') && (digit <= 'd'))
2658                 digit = digit - 'a' + 12;
2659         else {
2660                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2661                 return 0;
2662         }
2663
2664         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2665
2666         rtpheader = (unsigned int *)data;
2667         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2668         rtpheader[1] = htonl(rtp->lastdigitts);
2669         rtpheader[2] = htonl(rtp->ssrc);
2670         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2671         /* Set end bit */
2672         rtpheader[3] |= htonl((1 << 23));
2673         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2674         /* Send 3 termination packets */
2675         for (i = 0; i < 3; i++) {
2676                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2677                 if (res < 0)
2678                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2679                                 ast_inet_ntoa(rtp->them.sin_addr),
2680                                 ntohs(rtp->them.sin_port), strerror(errno));
2681                 if (rtp_debug_test_addr(&rtp->them))
2682                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2683                                     ast_inet_ntoa(rtp->them.sin_addr),
2684                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2685         }
2686         rtp->sending_digit = 0;
2687         rtp->send_digit = 0;
2688         /* Increment lastdigitts */
2689         rtp->lastdigitts += 960;
2690         rtp->seqno++;
2691
2692         return res;
2693 }
2694
2695 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2696 int ast_rtcp_send_h261fur(void *data)
2697 {
2698         struct ast_rtp *rtp = data;
2699         int res;
2700
2701         rtp->rtcp->sendfur = 1;
2702         res = ast_rtcp_write(data);
2703         
2704         return res;
2705 }
2706
2707 /*! \brief Send RTCP sender's report */
2708 static int ast_rtcp_write_sr(const void *data)
2709 {
2710         struct ast_rtp *rtp = (struct ast_rtp *)data;
2711         int res;
2712         int len = 0;
2713         struct timeval now;
2714         unsigned int now_lsw;
2715         unsigned int now_msw;
2716         unsigned int *rtcpheader;
2717         unsigned int lost;
2718         unsigned int extended;
2719         unsigned int expected;
2720         unsigned int expected_interval;
2721         unsigned int received_interval;
2722         int lost_interval;
2723         int fraction;
2724         struct timeval dlsr;
2725         char bdata[512];
2726
2727         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2728         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2729                 return 0;
2730         
2731         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2732                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2733                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2734                 return 0;
2735         }
2736
2737         gettimeofday(&now, NULL);
2738         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2739         rtcpheader = (unsigned int *)bdata;
2740         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2741         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2742         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2743         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2744         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2745         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2746         len += 28;
2747         
2748         extended = rtp->cycles + rtp->lastrxseqno;
2749         expected = extended - rtp->seedrxseqno + 1;
2750         if (rtp->rxcount > expected) 
2751                 expected += rtp->rxcount - expected;
2752         lost = expected - rtp->rxcount;
2753         expected_interval = expected - rtp->rtcp->expected_prior;
2754         rtp->rtcp->expected_prior = expected;
2755         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2756         rtp->rtcp->received_prior = rtp->rxcount;
2757         lost_interval = expected_interval - received_interval;
2758         if (expected_interval == 0 || lost_interval <= 0)
2759                 fraction = 0;
2760         else
2761                 fraction = (lost_interval << 8) / expected_interval;
2762         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2763         rtcpheader[7] = htonl(rtp->themssrc);
2764         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2765         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2766         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2767         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2768         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2769         len += 24;
2770         
2771         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2772
2773         if (rtp->rtcp->sendfur) {
2774                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2775                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2776                 len += 8;
2777                 rtp->rtcp->sendfur = 0;
2778         }
2779         
2780         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2781         /* it can change mid call, and SDES can't) */
2782         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2783         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2784         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2785         len += 12;
2786         
2787         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2788         if (res < 0) {
2789                 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));
2790                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2791                 return 0;
2792         }
2793         
2794         /* FIXME Don't need to get a new one */
2795         gettimeofday(&rtp->rtcp->txlsr, NULL);
2796         rtp->rtcp->sr_count++;
2797
2798         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2799         
2800         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2801                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2802                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2803                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2804                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2805                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2806                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2807                 ast_verbose("  Report block:\n");
2808                 ast_verbose("  Fraction lost: %u\n", fraction);
2809                 ast_verbose("  Cumulative loss: %u\n", lost);
2810                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2811                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2812                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2813         }
2814         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To %s:%d\r\n"
2815                                             "OurSSRC: %u\r\n"
2816                                             "SentNTP: %u.%010u\r\n"
2817                                             "SentRTP: %u\r\n"
2818                                             "SentPackets: %u\r\n"
2819                                             "SentOctets: %u\r\n"
2820                                             "ReportBlock:\r\n"
2821                                             "FractionLost: %u\r\n"
2822                                             "CumulativeLoss: %u\r\n"
2823                                             "IAJitter: %.4f\r\n"
2824                                             "TheirLastSR: %u\r\n"
2825                                             "DLSR: %4.4f (sec)\r\n",
2826                                             ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
2827                                             rtp->ssrc,
2828                                             (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
2829                                             rtp->lastts,
2830                                             rtp->txcount,
2831                                             rtp->txoctetcount,
2832                                             fraction,
2833                                             lost,
2834                                             rtp->rxjitter,
2835                                             rtp->rtcp->themrxlsr,
2836                                             (double)(ntohl(rtcpheader[12])/65536.0));
2837         return res;
2838 }
2839
2840 /*! \brief Send RTCP recipient's report */
2841 static int ast_rtcp_write_rr(const void *data)
2842 {
2843         struct ast_rtp *rtp = (struct ast_rtp *)data;
2844         int res;
2845         int len = 32;
2846         unsigned int lost;
2847         unsigned int extended;
2848         unsigned int expected;
2849         unsigned int expected_interval;
2850         unsigned int received_interval;
2851         int lost_interval;
2852         struct timeval now;
2853         unsigned int *rtcpheader;
2854         char bdata[1024];
2855         struct timeval dlsr;
2856         int fraction;
2857
2858         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2859                 return 0;
2860           
2861         if (!rtp->rtcp->them.sin_addr.s_addr) {
2862                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2863                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2864                 return 0;
2865         }
2866
2867         extended = rtp->cycles + rtp->lastrxseqno;
2868         expected = extended - rtp->seedrxseqno + 1;
2869         lost = expected - rtp->rxcount;
2870         expected_interval = expected - rtp->rtcp->expected_prior;
2871         rtp->rtcp->expected_prior = expected;
2872         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2873         rtp->rtcp->received_prior = rtp->rxcount;
2874         lost_interval = expected_interval - received_interval;
2875         if (expected_interval == 0 || lost_interval <= 0)
2876                 fraction = 0;
2877         else
2878                 fraction = (lost_interval << 8) / expected_interval;
2879         gettimeofday(&now, NULL);
2880         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2881         rtcpheader = (unsigned int *)bdata;
2882         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2883         rtcpheader[1] = htonl(rtp->ssrc);
2884         rtcpheader[2] = htonl(rtp->themssrc);
2885         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2886         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2887         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2888         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2889         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2890
2891         if (rtp->rtcp->sendfur) {
2892                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2893                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2894                 len += 8;
2895                 rtp->rtcp->sendfur = 0;
2896         }
2897
2898         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2899         it can change mid call, and SDES can't) */
2900         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2901         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2902         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2903         len += 12;
2904         
2905         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2906
2907         if (res < 0) {
2908                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2909                 /* Remove the scheduler */
2910                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2911                 return 0;
2912         }
2913
2914         rtp->rtcp->rr_count++;
2915
2916         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2917                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2918                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2919                         "  IA jitter: %.4f\n" 
2920                         "  Their last SR: %u\n" 
2921                         "  DLSR: %4.4f (sec)\n\n",
2922                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2923                         ntohs(rtp->rtcp->them.sin_port),
2924                         rtp->ssrc, rtp->themssrc, fraction, lost,
2925                         rtp->rxjitter,
2926                         rtp->rtcp->themrxlsr,
2927                         (double)(ntohl(rtcpheader[7])/65536.0));
2928         }
2929
2930         return res;
2931 }
2932
2933 /*! \brief Write and RTCP packet to the far end
2934  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2935  * RR is sent if we have not sent any rtp packets in the previous interval */
2936 static int ast_rtcp_write(const void *data)
2937 {
2938         struct ast_rtp *rtp = (struct ast_rtp *)data;
2939         int res;
2940         
2941         if (!rtp || !rtp->rtcp)
2942                 return 0;
2943
2944         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2945                 res = ast_rtcp_write_sr(data);
2946         else
2947                 res = ast_rtcp_write_rr(data);
2948         
2949         return res;
2950 }
2951
2952 /*! \brief generate comfort noice (CNG) */
2953 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2954 {
2955         unsigned int *rtpheader;
2956         int hdrlen = 12;
2957         int res;
2958         int payload;
2959         char data[256];
2960         level = 127 - (level & 0x7f);
2961         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2962
2963         /* If we have no peer, return immediately */    
2964         if (!rtp->them.sin_addr.s_addr)
2965                 return 0;
2966
2967         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2968
2969         /* Get a pointer to the header */
2970         rtpheader = (unsigned int *)data;
2971         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2972         rtpheader[1] = htonl(rtp->lastts);
2973         rtpheader[2] = htonl(rtp->ssrc); 
2974         data[12] = level;
2975         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2976                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2977                 if (res <0) 
2978                         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));
2979                 if (rtp_debug_test_addr(&rtp->them))
2980                         ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2981                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2982                    
2983         }
2984         return 0;
2985 }
2986
2987 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
2988 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2989 {
2990         unsigned char *rtpheader;
2991         int hdrlen = 12;
2992         int res;
2993         unsigned int ms;
2994         int pred;
2995         int mark = 0;
2996
2997         ms = calc_txstamp(rtp, &f->delivery);
2998         /* Default prediction */
2999         if (f->subclass & AST_FORMAT_AUDIO_MASK) {
3000                 pred = rtp->lastts + f->samples;
3001
3002                 /* Re-calculate last TS */
3003                 rtp->lastts = rtp->lastts + ms * 8;
3004                 if (ast_tvzero(f->delivery)) {
3005                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
3006                            and if so, go with our prediction */
3007                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
3008                                 rtp->lastts = pred;
3009                         else {
3010                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
3011                                 mark = 1;
3012                         }
3013                 }
3014         } else if(f->subclass & AST_FORMAT_VIDEO_MASK) {
3015                 mark = f->subclass & 0x1;
3016                 pred = rtp->lastovidtimestamp + f->samples;
3017                 /* Re-calculate last TS */
3018                 rtp->lastts = rtp->lastts + ms * 90;
3019                 /* If it's close to our prediction, go for it */
3020                 if (ast_tvzero(f->delivery)) {
3021                         if (abs(rtp->lastts - pred) < 7200) {
3022                                 rtp->lastts = pred;
3023                                 rtp->lastovidtimestamp += f->samples;
3024                         } else {
3025                                 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);
3026                                 rtp->lastovidtimestamp = rtp->lastts;
3027                         }
3028                 }
3029         } else {
3030                 pred = rtp->lastotexttimestamp + f->samples;
3031                 /* Re-calculate last TS */
3032                 rtp->lastts = rtp->lastts + ms * 90;
3033                 /* If it's close to our prediction, go for it */
3034                 if (ast_tvzero(f->delivery)) {
3035                         if (abs(rtp->lastts - pred) < 7200) {
3036                                 rtp->lastts = pred;
3037                                 rtp->lastotexttimestamp += f->samples;
3038                         } else {
3039                                 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);
3040                                 rtp->lastotexttimestamp = rtp->lastts;
3041                         }
3042                 }
3043         }
3044         /* If the timestamp for non-digit packets has moved beyond the timestamp
3045            for digits, update the digit timestamp.
3046         */
3047         if (rtp->lastts > rtp->lastdigitts)
3048                 rtp->lastdigitts = rtp->lastts;
3049
3050         if (ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO))
3051                 rtp->lastts = f->ts * 8;
3052
3053         /* Get a pointer to the header */
3054         rtpheader = (unsigned char *)(f->data - hdrlen);
3055
3056         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
3057         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
3058         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
3059
3060         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
3061                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
3062                 if (res <0) {
3063                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
3064                                 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));
3065                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
3066                                 /* Only give this error message once if we are not RTP debugging */
3067                                 if (option_debug || rtpdebug)
3068                                         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));
3069                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
3070                         }
3071                 } else {
3072                         rtp->txcount++;
3073                         rtp->txoctetcount +=(res - hdrlen);
3074                         
3075                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
3076                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
3077                 }
3078                                 
3079                 if (rtp_debug_test_addr(&rtp->them))
3080                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
3081                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
3082         }
3083
3084         rtp->seqno++;
3085
3086         return 0;
3087 }
3088
3089 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
3090 {
3091         int x;
3092         for (x = 0; x < 32; x++) {  /* Ugly way */
3093                 rtp->pref.order[x] = prefs->order[x];
3094                 rtp->pref.framing[x] = prefs->framing[x];
3095         }
3096         if (rtp->smoother)
3097                 ast_smoother_free(rtp->smoother);
3098         rtp->smoother = NULL;
3099         return 0;
3100 }
3101
3102 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
3103 {
3104         return &rtp->pref;
3105 }
3106
3107 int ast_rtp_codec_getformat(int pt)
3108 {
3109         if (pt < 0 || pt > MAX_RTP_PT)
3110                 return 0; /* bogus payload type */
3111
3112         if (static_RTP_PT[pt].isAstFormat)
3113                 return static_RTP_PT[pt].code;
3114         else
3115                 return 0;
3116 }
3117
3118 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
3119 {
3120         struct ast_frame *f;
3121         int codec;
3122         int hdrlen = 12;
3123         int subclass;
3124         
3125
3126         /* If we have no peer, return immediately */    
3127         if (!rtp->them.sin_addr.s_addr)
3128                 return 0;
3129
3130         /* If there is no data length, return immediately */
3131         if (!_f->datalen) 
3132                 return 0;
3133         
3134         /* Make sure we have enough space for RTP header */
3135         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO) && (_f->frametype != AST_FRAME_TEXT)) {
3136                 ast_log(LOG_WARNING, "RTP can only send voice, video and text\n");
3137                 return -1;<