d59d29bb74c0bd2812d5a80832fb72212c4a8bc6
[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         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
2378                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2379                 rtp->rtcp->schedid = -1;
2380         }
2381
2382         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2383         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2384         if (rtp->rtcp) {
2385                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2386                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2387         }
2388         
2389         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2390 }
2391
2392 void ast_rtp_reset(struct ast_rtp *rtp)
2393 {
2394         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2395         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2396         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2397         rtp->lastts = 0;
2398         rtp->lastdigitts = 0;
2399         rtp->lastrxts = 0;
2400         rtp->lastividtimestamp = 0;
2401         rtp->lastovidtimestamp = 0;
2402         rtp->lastitexttimestamp = 0;
2403         rtp->lastotexttimestamp = 0;
2404         rtp->lasteventseqn = 0;
2405         rtp->lastevent = 0;
2406         rtp->lasttxformat = 0;
2407         rtp->lastrxformat = 0;
2408         rtp->dtmfcount = 0;
2409         rtp->dtmfsamples = 0;
2410         rtp->seqno = 0;
2411         rtp->rxseqno = 0;
2412 }
2413
2414 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2415 {
2416         /*
2417         *ssrc          our ssrc
2418         *themssrc      their ssrc
2419         *lp            lost packets
2420         *rxjitter      our calculated jitter(rx)
2421         *rxcount       no. received packets
2422         *txjitter      reported jitter of the other end
2423         *txcount       transmitted packets
2424         *rlp           remote lost packets
2425         *rtt           round trip time
2426         */
2427
2428         if (qual && rtp) {
2429                 qual->local_ssrc = rtp->ssrc;
2430                 qual->local_jitter = rtp->rxjitter;
2431                 qual->local_count = rtp->rxcount;
2432                 qual->remote_ssrc = rtp->themssrc;
2433                 qual->remote_count = rtp->txcount;
2434                 if (rtp->rtcp) {
2435                         qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2436                         qual->remote_lostpackets = rtp->rtcp->reported_lost;
2437                         qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2438                         qual->rtt = rtp->rtcp->rtt;
2439                 }
2440         }
2441         if (rtp->rtcp) {
2442                 snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality),
2443                         "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f",
2444                         rtp->ssrc,
2445                         rtp->themssrc,
2446                         rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2447                         rtp->rxjitter,
2448                         rtp->rxcount,
2449                         (double)rtp->rtcp->reported_jitter / 65536.0,
2450                         rtp->txcount,
2451                         rtp->rtcp->reported_lost,
2452                         rtp->rtcp->rtt);
2453                 return rtp->rtcp->quality;
2454         } else
2455                 return "<Unknown> - RTP/RTCP has already been destroyed";
2456 }
2457
2458 void ast_rtp_destroy(struct ast_rtp *rtp)
2459 {
2460         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2461                 /*Print some info on the call here */
2462                 ast_verbose("  RTP-stats\n");
2463                 ast_verbose("* Our Receiver:\n");
2464                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
2465                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
2466                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2467                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
2468                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2469                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2470                 ast_verbose("* Our Sender:\n");
2471                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2472                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2473                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2474                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter / (unsigned int)65536.0);
2475                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2476                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2477         }
2478
2479         manager_event(EVENT_FLAG_REPORTING, "RTPReceiverStat", "SSRC: %u\r\n"
2480                                             "ReceivedPackets: %u\r\n"
2481                                             "LostPackets: %u\r\n"
2482                                             "Jitter: %.4f\r\n"
2483                                             "Transit: %.4f\r\n"
2484                                             "RRCount: %u\r\n",
2485                                             rtp->themssrc,
2486                                             rtp->rxcount,
2487                                             rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2488                                             rtp->rxjitter,
2489                                             rtp->rxtransit,
2490                                             rtp->rtcp->rr_count);
2491         manager_event(EVENT_FLAG_REPORTING, "RTPSenderStat", "SSRC: %u\r\n"
2492                                             "SentPackets: %u\r\n"
2493                                             "LostPackets: %u\r\n"
2494                                             "Jitter: %u\r\n"
2495                                             "SRCount: %u\r\n"
2496                                             "RTT: %f\r\n",
2497                                             rtp->ssrc,
2498                                             rtp->txcount,
2499                                             rtp->rtcp->reported_lost,
2500                                             rtp->rtcp->reported_jitter,
2501                                             rtp->rtcp->sr_count,
2502                                             rtp->rtcp->rtt);
2503         if (rtp->smoother)
2504                 ast_smoother_free(rtp->smoother);
2505         if (rtp->ioid)
2506                 ast_io_remove(rtp->io, rtp->ioid);
2507         if (rtp->s > -1)
2508                 close(rtp->s);
2509         if (rtp->rtcp) {
2510                 if (rtp->rtcp->schedid > 0)
2511                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2512                 close(rtp->rtcp->s);
2513                 ast_free(rtp->rtcp);
2514                 rtp->rtcp=NULL;
2515         }
2516 #ifdef P2P_INTENSE
2517         ast_mutex_destroy(&rtp->bridge_lock);
2518 #endif
2519         ast_free(rtp);
2520 }
2521
2522 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2523 {
2524         struct timeval t;
2525         long ms;
2526         if (ast_tvzero(rtp->txcore)) {
2527                 rtp->txcore = ast_tvnow();
2528                 /* Round to 20ms for nice, pretty timestamps */
2529                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2530         }
2531         /* Use previous txcore if available */
2532         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2533         ms = ast_tvdiff_ms(t, rtp->txcore);
2534         if (ms < 0)
2535                 ms = 0;
2536         /* Use what we just got for next time */
2537         rtp->txcore = t;
2538         return (unsigned int) ms;
2539 }
2540
2541 /*! \brief Send begin frames for DTMF */
2542 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2543 {
2544         unsigned int *rtpheader;
2545         int hdrlen = 12, res = 0, i = 0, payload = 0;
2546         char data[256];
2547
2548         if ((digit <= '9') && (digit >= '0'))
2549                 digit -= '0';
2550         else if (digit == '*')
2551                 digit = 10;
2552         else if (digit == '#')
2553                 digit = 11;
2554         else if ((digit >= 'A') && (digit <= 'D'))
2555                 digit = digit - 'A' + 12;
2556         else if ((digit >= 'a') && (digit <= 'd'))
2557                 digit = digit - 'a' + 12;
2558         else {
2559                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2560                 return 0;
2561         }
2562
2563         /* If we have no peer, return immediately */    
2564         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2565                 return 0;
2566
2567         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2568
2569         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2570         rtp->send_duration = 160;
2571         
2572         /* Get a pointer to the header */
2573         rtpheader = (unsigned int *)data;
2574         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2575         rtpheader[1] = htonl(rtp->lastdigitts);
2576         rtpheader[2] = htonl(rtp->ssrc); 
2577
2578         for (i = 0; i < 2; i++) {
2579                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2580                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2581                 if (res < 0) 
2582                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2583                                 ast_inet_ntoa(rtp->them.sin_addr),
2584                                 ntohs(rtp->them.sin_port), strerror(errno));
2585                 if (rtp_debug_test_addr(&rtp->them))
2586                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2587                                     ast_inet_ntoa(rtp->them.sin_addr),
2588                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2589                 /* Increment sequence number */
2590                 rtp->seqno++;
2591                 /* Increment duration */
2592                 rtp->send_duration += 160;
2593                 /* Clear marker bit and set seqno */
2594                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2595         }
2596
2597         /* Since we received a begin, we can safely store the digit and disable any compensation */
2598         rtp->sending_digit = 1;
2599         rtp->send_digit = digit;
2600         rtp->send_payload = payload;
2601
2602         return 0;
2603 }
2604
2605 /*! \brief Send continuation frame for DTMF */
2606 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2607 {
2608         unsigned int *rtpheader;
2609         int hdrlen = 12, res = 0;
2610         char data[256];
2611
2612         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2613                 return 0;
2614
2615         /* Setup packet to send */
2616         rtpheader = (unsigned int *)data;
2617         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2618         rtpheader[1] = htonl(rtp->lastdigitts);
2619         rtpheader[2] = htonl(rtp->ssrc);
2620         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2621         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2622         
2623         /* Transmit */
2624         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2625         if (res < 0)
2626                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2627                         ast_inet_ntoa(rtp->them.sin_addr),
2628                         ntohs(rtp->them.sin_port), strerror(errno));
2629         if (rtp_debug_test_addr(&rtp->them))
2630                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2631                             ast_inet_ntoa(rtp->them.sin_addr),
2632                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2633
2634         /* Increment sequence number */
2635         rtp->seqno++;
2636         /* Increment duration */
2637         rtp->send_duration += 160;
2638
2639         return 0;
2640 }
2641
2642 /*! \brief Send end packets for DTMF */
2643 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2644 {
2645         unsigned int *rtpheader;
2646         int hdrlen = 12, res = 0, i = 0;
2647         char data[256];
2648         
2649         /* If no address, then bail out */
2650         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2651                 return 0;
2652         
2653         if ((digit <= '9') && (digit >= '0'))
2654                 digit -= '0';
2655         else if (digit == '*')
2656                 digit = 10;
2657         else if (digit == '#')
2658                 digit = 11;
2659         else if ((digit >= 'A') && (digit <= 'D'))
2660                 digit = digit - 'A' + 12;
2661         else if ((digit >= 'a') && (digit <= 'd'))
2662                 digit = digit - 'a' + 12;
2663         else {
2664                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2665                 return 0;
2666         }
2667
2668         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2669
2670         rtpheader = (unsigned int *)data;
2671         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2672         rtpheader[1] = htonl(rtp->lastdigitts);
2673         rtpheader[2] = htonl(rtp->ssrc);
2674         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2675         /* Set end bit */
2676         rtpheader[3] |= htonl((1 << 23));
2677         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2678         /* Send 3 termination packets */
2679         for (i = 0; i < 3; i++) {
2680                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2681                 if (res < 0)
2682                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2683                                 ast_inet_ntoa(rtp->them.sin_addr),
2684                                 ntohs(rtp->them.sin_port), strerror(errno));
2685                 if (rtp_debug_test_addr(&rtp->them))
2686                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2687                                     ast_inet_ntoa(rtp->them.sin_addr),
2688                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2689         }
2690         rtp->sending_digit = 0;
2691         rtp->send_digit = 0;
2692         /* Increment lastdigitts */
2693         rtp->lastdigitts += 960;
2694         rtp->seqno++;
2695
2696         return res;
2697 }
2698
2699 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2700 int ast_rtcp_send_h261fur(void *data)
2701 {
2702         struct ast_rtp *rtp = data;
2703         int res;
2704
2705         rtp->rtcp->sendfur = 1;
2706         res = ast_rtcp_write(data);
2707         
2708         return res;
2709 }
2710
2711 /*! \brief Send RTCP sender's report */
2712 static int ast_rtcp_write_sr(const void *data)
2713 {
2714         struct ast_rtp *rtp = (struct ast_rtp *)data;
2715         int res;
2716         int len = 0;
2717         struct timeval now;
2718         unsigned int now_lsw;
2719         unsigned int now_msw;
2720         unsigned int *rtcpheader;
2721         unsigned int lost;
2722         unsigned int extended;
2723         unsigned int expected;
2724         unsigned int expected_interval;
2725         unsigned int received_interval;
2726         int lost_interval;
2727         int fraction;
2728         struct timeval dlsr;
2729         char bdata[512];
2730
2731         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2732         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2733                 return 0;
2734         
2735         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2736                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2737                 if (rtp->rtcp->schedid > 0)
2738                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2739                 rtp->rtcp->schedid = -1;
2740                 return 0;
2741         }
2742
2743         gettimeofday(&now, NULL);
2744         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2745         rtcpheader = (unsigned int *)bdata;
2746         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2747         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2748         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2749         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2750         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2751         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2752         len += 28;
2753         
2754         extended = rtp->cycles + rtp->lastrxseqno;
2755         expected = extended - rtp->seedrxseqno + 1;
2756         if (rtp->rxcount > expected) 
2757                 expected += rtp->rxcount - expected;
2758         lost = expected - rtp->rxcount;
2759         expected_interval = expected - rtp->rtcp->expected_prior;
2760         rtp->rtcp->expected_prior = expected;
2761         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2762         rtp->rtcp->received_prior = rtp->rxcount;
2763         lost_interval = expected_interval - received_interval;
2764         if (expected_interval == 0 || lost_interval <= 0)
2765                 fraction = 0;
2766         else
2767                 fraction = (lost_interval << 8) / expected_interval;
2768         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2769         rtcpheader[7] = htonl(rtp->themssrc);
2770         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2771         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2772         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2773         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2774         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2775         len += 24;
2776         
2777         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2778
2779         if (rtp->rtcp->sendfur) {
2780                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2781                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2782                 len += 8;
2783                 rtp->rtcp->sendfur = 0;
2784         }
2785         
2786         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2787         /* it can change mid call, and SDES can't) */
2788         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2789         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2790         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2791         len += 12;
2792         
2793         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2794         if (res < 0) {
2795                 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));
2796                 if (rtp->rtcp->schedid > 0)
2797                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2798                 rtp->rtcp->schedid = -1;
2799                 return 0;
2800         }
2801         
2802         /* FIXME Don't need to get a new one */
2803         gettimeofday(&rtp->rtcp->txlsr, NULL);
2804         rtp->rtcp->sr_count++;
2805
2806         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2807         
2808         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2809                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2810                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2811                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2812                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2813                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2814                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2815                 ast_verbose("  Report block:\n");
2816                 ast_verbose("  Fraction lost: %u\n", fraction);
2817                 ast_verbose("  Cumulative loss: %u\n", lost);
2818                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2819                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2820                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2821         }
2822         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To %s:%d\r\n"
2823                                             "OurSSRC: %u\r\n"
2824                                             "SentNTP: %u.%010u\r\n"
2825                                             "SentRTP: %u\r\n"
2826                                             "SentPackets: %u\r\n"
2827                                             "SentOctets: %u\r\n"
2828                                             "ReportBlock:\r\n"
2829                                             "FractionLost: %u\r\n"
2830                                             "CumulativeLoss: %u\r\n"
2831                                             "IAJitter: %.4f\r\n"
2832                                             "TheirLastSR: %u\r\n"
2833                                             "DLSR: %4.4f (sec)\r\n",
2834                                             ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
2835                                             rtp->ssrc,
2836                                             (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
2837                                             rtp->lastts,
2838                                             rtp->txcount,
2839                                             rtp->txoctetcount,
2840                                             fraction,
2841                                             lost,
2842                                             rtp->rxjitter,
2843                                             rtp->rtcp->themrxlsr,
2844                                             (double)(ntohl(rtcpheader[12])/65536.0));
2845         return res;
2846 }
2847
2848 /*! \brief Send RTCP recipient's report */
2849 static int ast_rtcp_write_rr(const void *data)
2850 {
2851         struct ast_rtp *rtp = (struct ast_rtp *)data;
2852         int res;
2853         int len = 32;
2854         unsigned int lost;
2855         unsigned int extended;
2856         unsigned int expected;
2857         unsigned int expected_interval;
2858         unsigned int received_interval;
2859         int lost_interval;
2860         struct timeval now;
2861         unsigned int *rtcpheader;
2862         char bdata[1024];
2863         struct timeval dlsr;
2864         int fraction;
2865
2866         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2867                 return 0;
2868           
2869         if (!rtp->rtcp->them.sin_addr.s_addr) {
2870                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2871                 if (rtp->rtcp->schedid > 0)
2872                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2873                 rtp->rtcp->schedid = -1;
2874                 return 0;
2875         }
2876
2877         extended = rtp->cycles + rtp->lastrxseqno;
2878         expected = extended - rtp->seedrxseqno + 1;
2879         lost = expected - rtp->rxcount;
2880         expected_interval = expected - rtp->rtcp->expected_prior;
2881         rtp->rtcp->expected_prior = expected;
2882         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2883         rtp->rtcp->received_prior = rtp->rxcount;
2884         lost_interval = expected_interval - received_interval;
2885         if (expected_interval == 0 || lost_interval <= 0)
2886                 fraction = 0;
2887         else
2888                 fraction = (lost_interval << 8) / expected_interval;
2889         gettimeofday(&now, NULL);
2890         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2891         rtcpheader = (unsigned int *)bdata;
2892         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2893         rtcpheader[1] = htonl(rtp->ssrc);
2894         rtcpheader[2] = htonl(rtp->themssrc);
2895         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2896         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2897         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2898         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2899         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2900
2901         if (rtp->rtcp->sendfur) {
2902                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2903                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2904                 len += 8;
2905                 rtp->rtcp->sendfur = 0;
2906         }
2907
2908         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2909         it can change mid call, and SDES can't) */
2910         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2911         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2912         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2913         len += 12;
2914         
2915         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2916
2917         if (res < 0) {
2918                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2919                 /* Remove the scheduler */
2920                 if (rtp->rtcp->schedid > 0)
2921                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2922                 rtp->rtcp->schedid = -1;
2923                 return 0;
2924         }
2925
2926         rtp->rtcp->rr_count++;
2927
2928         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2929                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2930                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2931                         "  IA jitter: %.4f\n" 
2932                         "  Their last SR: %u\n" 
2933                         "  DLSR: %4.4f (sec)\n\n",
2934                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2935                         ntohs(rtp->rtcp->them.sin_port),
2936                         rtp->ssrc, rtp->themssrc, fraction, lost,
2937                         rtp->rxjitter,
2938                         rtp->rtcp->themrxlsr,
2939                         (double)(ntohl(rtcpheader[7])/65536.0));
2940         }
2941
2942         return res;
2943 }
2944
2945 /*! \brief Write and RTCP packet to the far end
2946  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2947  * RR is sent if we have not sent any rtp packets in the previous interval */
2948 static int ast_rtcp_write(const void *data)
2949 {
2950         struct ast_rtp *rtp = (struct ast_rtp *)data;
2951         int res;
2952         
2953         if (!rtp || !rtp->rtcp)
2954                 return 0;
2955
2956         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2957                 res = ast_rtcp_write_sr(data);
2958         else
2959                 res = ast_rtcp_write_rr(data);
2960         
2961         return res;
2962 }
2963
2964 /*! \brief generate comfort noice (CNG) */
2965 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2966 {
2967         unsigned int *rtpheader;
2968         int hdrlen = 12;
2969         int res;
2970         int payload;
2971         char data[256];
2972         level = 127 - (level & 0x7f);
2973         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2974
2975         /* If we have no peer, return immediately */    
2976         if (!rtp->them.sin_addr.s_addr)
2977                 return 0;
2978
2979         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2980
2981         /* Get a pointer to the header */
2982         rtpheader = (unsigned int *)data;
2983         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2984         rtpheader[1] = htonl(rtp->lastts);
2985         rtpheader[2] = htonl(rtp->ssrc); 
2986         data[12] = level;
2987         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2988                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2989                 if (res <0) 
2990                         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));
2991                 if (rtp_debug_test_addr(&rtp->them))
2992                         ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2993                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2994                    
2995         }
2996         return 0;
2997 }
2998
2999 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
3000 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
3001 {
3002         unsigned char *rtpheader;
3003         int hdrlen = 12;
3004         int res;
3005         unsigned int ms;
3006         int pred;
3007         int mark = 0;
3008
3009         ms = calc_txstamp(rtp, &f->delivery);
3010         /* Default prediction */
3011         if (f->subclass & AST_FORMAT_AUDIO_MASK) {
3012                 pred = rtp->lastts + f->samples;
3013
3014                 /* Re-calculate last TS */
3015                 rtp->lastts = rtp->lastts + ms * 8;
3016                 if (ast_tvzero(f->delivery)) {
3017                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
3018                            and if so, go with our prediction */
3019                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
3020                                 rtp->lastts = pred;
3021                         else {
3022                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
3023                                 mark = 1;
3024                         }
3025                 }
3026         } else if(f->subclass & AST_FORMAT_VIDEO_MASK) {
3027                 mark = f->subclass & 0x1;
3028                 pred = rtp->lastovidtimestamp + f->samples;
3029                 /* Re-calculate last TS */
3030                 rtp->lastts = rtp->lastts + ms * 90;
3031                 /* If it's close to our prediction, go for it */
3032                 if (ast_tvzero(f->delivery)) {
3033                         if (abs(rtp->lastts - pred) < 7200) {
3034                                 rtp->lastts = pred;
3035                                 rtp->lastovidtimestamp += f->samples;
3036                         } else {
3037                                 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);
3038                                 rtp->lastovidtimestamp = rtp->lastts;
3039                         }
3040                 }
3041         } else {
3042                 pred = rtp->lastotexttimestamp + f->samples;
3043                 /* Re-calculate last TS */
3044                 rtp->lastts = rtp->lastts + ms * 90;
3045                 /* If it's close to our prediction, go for it */
3046                 if (ast_tvzero(f->delivery)) {
3047                         if (abs(rtp->lastts - pred) < 7200) {
3048                                 rtp->lastts = pred;
3049                                 rtp->lastotexttimestamp += f->samples;
3050                         } else {
3051                                 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);
3052                                 rtp->lastotexttimestamp = rtp->lastts;
3053                         }
3054                 }
3055         }
3056         /* If the timestamp for non-digit packets has moved beyond the timestamp
3057            for digits, update the digit timestamp.
3058         */
3059         if (rtp->lastts > rtp->lastdigitts)
3060                 rtp->lastdigitts = rtp->lastts;
3061
3062         if (ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO))
3063                 rtp->lastts = f->ts * 8;
3064
3065         /* Get a pointer to the header */
3066         rtpheader = (unsigned char *)(f->data - hdrlen);
3067
3068         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
3069         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
3070         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
3071
3072         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
3073                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
3074                 if (res <0) {
3075                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
3076                                 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));
3077                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
3078                                 /* Only give this error message once if we are not RTP debugging */
3079                                 if (option_debug || rtpdebug)
3080                                         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));
3081                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
3082                         }
3083                 } else {
3084                         rtp->txcount++;
3085                         rtp->txoctetcount +=(res - hdrlen);
3086                         
3087                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
3088                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
3089                 }
3090                                 
3091                 if (rtp_debug_test_addr(&rtp->them))
3092                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
3093                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
3094         }
3095
3096         rtp->seqno++;
3097
3098         return 0;
3099 }
3100
3101 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
3102 {
3103         int x;
3104         for (x = 0; x < 32; x++) {  /* Ugly way */
3105                 rtp->pref.order[x] = prefs->order[x];
3106                 rtp->pref.framing[x] = prefs->framing[x];
3107         }
3108         if (rtp->smoother)
3109                 ast_smoother_free(rtp->smoother);
3110         rtp->smoother = NULL;
3111         return 0;
3112 }
3113
3114 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
3115 {
3116         return &rtp->pref;
3117 }
3118
3119 int ast_rtp_codec_getformat(int pt)
3120 {
3121         if (pt < 0 || pt > MAX_RTP_PT)
3122                 return 0; /* bogus payload type */
3123
3124         if (static_RTP_PT[pt].isAstFormat)
3125                 return static_RTP_PT[pt].code;
3126         else
3127                 return 0;
3128 }
3129
3130 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
3131 {
3132         struct ast_frame *f;
3133         int codec;
3134         int hdrlen = 12;
3135         int subclass;
3136         
3137
3138         /* If we have no peer, return immediately */    
3139         if (!rtp->them.sin_addr.s_addr)
3140                 return 0;
3141
3142         /* If there is no data length, return immediately */
3143         if (!_f->datalen) 
3144                 return 0;
3145         
3146         /* Make sure we have enough space for RTP header */
3147         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO) && (_f->frametype != AST_FRAME_TEXT)) {
3148                 ast_log(LOG_WARNING, "RTP can only send voice, video and text\n");
3149                 return -1;
3150         }
3151
3152         /* The bottom bit of a video subclass contains the marker bit */
3153         subclass = _f->subclass;
3154         if (_f->frametype == AST_FRAME_VIDEO)
3155                 subclass &= ~0x1;
3156
3157         codec = ast_rtp_lookup_code(rtp, 1, subclass);
3158         if (codec < 0) {
3159                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
3160                 return -1;
3161         }
3162
3163         if (rtp->lasttxformat != subclass) {
3164                 /* New format, reset the smoother */
3165                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
3166                 rtp->lasttxformat = subclass;
3167                 if (rtp->smoother)
3168                         ast_smoother_free(rtp->smoother);
3169                 rtp->smoother = NULL;
3170         }
3171
3172         if (!rtp->smoother && subclass != AST_FORMAT_SPEEX && subclass != AST_FORMAT_G723_1) {
3173                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
3174                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
3175                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
3176                                 ast_log(LOG_WARNING, "Unable to create smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
3177                                 return -1;
3178                         }
3179                         if (fmt.flags)
3180                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
3181                         ast_debug(1, "Created smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
3182                 }
3183         }
3184         if (rtp->smoother) {
3185                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
3186                         ast_smoother_feed_be(rtp->smoother, _f);
3187                 } else {
3188                         ast_smoother_feed(rtp->smoother, _f);
3189                 }
3190
3191                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data))
3192                         ast_rtp_raw_write(rtp, f, codec);
3193         } else {
3194                 /* Don't buffer outgoing frames; send them one-per-packet: */
3195                 if (_f->offset < hdrlen) 
3196                         f = ast_frdup(_f);      /*! \bug XXX this might never be free'd. Why do we do this? */
3197                 else
3198                         f = _f;
3199                 if (f->data)
3200                         ast_rtp_raw_write(rtp, f, codec);
3201                 if (f != _f)
3202                         ast_frfree(f);
3203         }
3204                 
3205         return 0;
3206 }
3207
3208 /*! \brief Unregister interface to channel driver */
3209 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
3210 {
3211         AST_RWLIST_WRLOCK(&protos);
3212         AST_RWLIST_REMOVE(&protos, proto, list);
3213         AST_RWLIST_UNLOCK(&protos);
3214 }
3215
3216 /*! \brief Register interface to channel driver */
3217 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
3218 {
3219         struct ast_rtp_protocol *cur;
3220
3221         AST_RWLIST_WRLOCK(&protos);
3222         AST_RWLIST_TRAVERSE(&protos, cur, list) {       
3223                 if (!strcmp(cur->type, proto->type)) {
3224                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
3225                         AST_RWLIST_UNLOCK(&protos);
3226                         return -1;
3227                 }
3228         }
3229         AST_RWLIST_INSERT_HEAD(&protos, proto, list);
3230         AST_RWLIST_UNLOCK(&protos);
3231         
3232         return 0;
3233 }
3234
3235 /*! \brief Bridge loop for true native bridge (reinvite) */
3236 static enum ast_bridge_result bridge_native_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, struct ast_rtp *vp0, struct ast_rtp *vp1, struct ast_rtp *tp0, struct ast_rtp *tp1, struct ast_rtp_protocol *pr0, struct ast_rtp_protocol *pr1, int codec0, int codec1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
3237 {
3238         struct ast_frame *fr = NULL;
3239         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
3240         int oldcodec0 = codec0, oldcodec1 = codec1;
3241         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, tac1 = {0,}, ac0 = {0,}, vac0 = {0,}, tac0 = {0,};
3242         struct sockaddr_in t1 = {0,}, vt1 = {0,}, tt1 = {0,}, t0 = {0,}, vt0 = {0,}, tt0 = {0,};
3243         
3244         /* Set it up so audio goes directly between the two endpoints */
3245
3246         /* Test the first channel */
3247         if (!(pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
3248                 ast_rtp_get_peer(p1, &ac1);
3249                 if (vp1)
3250                         ast_rtp_get_peer(vp1, &vac1);
3251                 if (tp1)
3252                         ast_rtp_get_peer(tp1, &tac1);
3253         } else
3254                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
3255         
3256         /* Test the second channel */
3257         if (!(pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
3258                 ast_rtp_get_peer(p0, &ac0);
3259                 if (vp0)
3260                         ast_rtp_get_peer(vp0, &vac0);
3261                 if (tp0)
3262                         ast_rtp_get_peer(tp0, &tac0);
3263         } else
3264                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
3265
3266         /* Now we can unlock and move into our loop */
3267         ast_channel_unlock(c0);
3268         ast_channel_unlock(c1);
3269
3270         ast_poll_channel_add(c0, c1);
3271
3272         /* Throw our channels into the structure and enter the loop */
3273         cs[0] = c0;
3274         cs[1] = c1;
3275         cs[2] = NULL;
3276         for (;;) {
3277                 /* Check if anything changed */
3278                 if ((c0->tech_pvt != pvt0) ||
3279                     (c1->tech_pvt != pvt1) ||
3280                     (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
3281                     (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
3282                         ast_debug(1, "Oooh, something is weird, backing out\n");
3283                         if (c0->tech_pvt == pvt0)
3284                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3285                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3286                         if (c1->tech_pvt == pvt1)
3287                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3288                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3289                         ast_poll_channel_del(c0, c1);
3290                         return AST_BRIDGE_RETRY;
3291                 }
3292
3293                 /* Check if they have changed their address */
3294                 ast_rtp_get_peer(p1, &t1);
3295                 if (vp1)
3296                         ast_rtp_get_peer(vp1, &vt1);
3297                 if (tp1)
3298                         ast_rtp_get_peer(tp1, &tt1);
3299                 if (pr1->get_codec)
3300                         codec1 = pr1->get_codec(c1);
3301                 ast_rtp_get_peer(p0, &t0);
3302                 if (vp0)
3303                         ast_rtp_get_peer(vp0, &vt0);
3304                 if (tp0)
3305                         ast_rtp_get_peer(tp0, &tt0);
3306                 if (pr0->get_codec)
3307                         codec0 = pr0->get_codec(c0);
3308                 if ((inaddrcmp(&t1, &ac1)) ||
3309                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
3310                     (tp1 && inaddrcmp(&tt1, &tac1)) ||
3311                     (codec1 != oldcodec1)) {
3312                         ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
3313                                 c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
3314                         ast_debug(2, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
3315                                 c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
3316                         ast_debug(2, "Oooh, '%s' changed end taddress to %s:%d (format %d)\n",
3317                                 c1->name, ast_inet_ntoa(tt1.sin_addr), ntohs(tt1.sin_port), codec1);
3318                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
3319                                 c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
3320                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
3321                                 c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
3322                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
3323                                 c1->name, ast_inet_ntoa(tac1.sin_addr), ntohs(tac1.sin_port), oldcodec1);
3324                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, tt1.sin_addr.s_addr ? tp1 : NULL, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))
3325                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
3326                         memcpy(&ac1, &t1, sizeof(ac1));
3327                         memcpy(&vac1, &vt1, sizeof(vac1));
3328                         memcpy(&tac1, &tt1, sizeof(tac1));
3329                         oldcodec1 = codec1;
3330                 }
3331                 if ((inaddrcmp(&t0, &ac0)) ||
3332                     (vp0 && inaddrcmp(&vt0, &vac0)) ||
3333                     (tp0 && inaddrcmp(&tt0, &tac0))) {
3334                         ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
3335                                 c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
3336                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
3337                                 c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
3338                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, tt0.sin_addr.s_addr ? tp0 : NULL, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
3339                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
3340                         memcpy(&ac0, &t0, sizeof(ac0));
3341                         memcpy(&vac0, &vt0, sizeof(vac0));
3342                         memcpy(&tac0, &tt0, sizeof(tac0));
3343                         oldcodec0 = codec0;
3344                 }
3345
3346                 /* Wait for frame to come in on the channels */
3347                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
3348                         if (!timeoutms) {
3349                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3350                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3351                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3352                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3353                                 return AST_BRIDGE_RETRY;
3354                         }
3355                         ast_debug(1, "Ooh, empty read...\n");
3356                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
3357                                 break;
3358                         continue;
3359                 }
3360                 fr = ast_read(who);
3361                 other = (who == c0) ? c1 : c0;
3362                 if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
3363                             (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
3364                              ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
3365                         /* Break out of bridge */
3366                         *fo = fr;
3367                         *rc = who;
3368                         ast_debug(1, "Oooh, got a %s\n", fr ? "digit" : "hangup");
3369                         if (c0->tech_pvt == pvt0)
3370                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3371                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3372                         if (c1->tech_pvt == pvt1)
3373                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3374                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3375                         ast_poll_channel_del(c0, c1);
3376                         return AST_BRIDGE_COMPLETE;
3377                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3378                         if ((fr->subclass == AST_CONTROL_HOLD) ||
3379                             (fr->subclass == AST_CONTROL_UNHOLD) ||
3380                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
3381                                 if (fr->subclass == AST_CONTROL_HOLD) {
3382                                         /* If we someone went on hold we want the other side to reinvite back to us */
3383                                         if (who == c0)
3384                                                 pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0);
3385                                         else
3386                                                 pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0);
3387                                 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3388                                         /* If they went off hold they should go back to being direct */
3389                                         if (who == c0)
3390                                                 pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE));
3391                                         else
3392                                                 pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE));
3393                                 }
3394                                 /* Update local address information */
3395                                 ast_rtp_get_peer(p0, &t0);
3396                                 memcpy(&ac0, &t0, sizeof(ac0));
3397                                 ast_rtp_get_peer(p1, &t1);
3398                                 memcpy(&ac1, &t1, sizeof(ac1));
3399                                 /* Update codec information */
3400                                 if (pr0->get_codec && c0->tech_pvt)
3401                                         oldcodec0 = codec0 = pr0->get_codec(c0);
3402                                 if (pr1->get_codec && c1->tech_pvt)
3403                                         oldcodec1 = codec1 = pr1->get_codec(c1);
3404                                 ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
3405                                 ast_frfree(fr);
3406                         } else {
3407                                 *fo = fr;
3408                                 *rc = who;
3409                                 ast_debug(1, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3410                                 return AST_BRIDGE_COMPLETE;
3411                         }
3412                 } else {
3413                         if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
3414                             (fr->frametype == AST_FRAME_DTMF_END) ||
3415                             (fr->frametype == AST_FRAME_VOICE) ||
3416                             (fr->frametype == AST_FRAME_VIDEO) ||
3417                             (fr->frametype == AST_FRAME_IMAGE) ||
3418                             (fr->frametype == AST_FRAME_HTML) ||
3419                             (fr->frametype == AST_FRAME_MODEM) ||
3420                             (fr->frametype == AST_FRAME_TEXT)) {
3421                                 ast_write(other, fr);
3422                         }
3423                         ast_frfree(fr);
3424                 }
3425                 /* Swap priority */
3426 #ifndef HAVE_EPOLL
3427                 cs[2] = cs[0];
3428                 cs[0] = cs[1];
3429                 cs[1] = cs[2];
3430 #endif
3431         }
3432
3433         ast_poll_channel_del(c0, c1);
3434
3435         if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3436                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3437         if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3438                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3439
3440         return AST_BRIDGE_FAILED;
3441 }
3442
3443 /*! \brief P2P RTP Callback */
3444 #ifdef P2P_INTENSE
3445 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
3446 {
3447         int res = 0, hdrlen = 12;
3448         struct sockaddr_in sin;
3449         socklen_t len;
3450         unsigned int *header;
3451         struct ast_rtp *rtp = cbdata, *bridged = NULL;
3452
3453         if (!rtp)
3454                 return 1;
3455
3456         len = sizeof(sin);
3457         if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
3458                 return 1;
3459
3460         header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
3461         
3462         /* If NAT support is turned on, then see if we need to change their address */
3463         if ((rtp->nat) && 
3464             ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
3465              (rtp->them.sin_port != sin.sin_port))) {
3466                 rtp->them = sin;
3467                 rtp->rxseqno = 0;
3468                 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
3469                 if (option_debug || rtpdebug)
3470                         ast_debug(0, "P2P 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));
3471         }
3472
3473         /* Write directly out to other RTP stream if bridged */
3474         if ((bridged = ast_rtp_get_bridged(rtp)))
3475                 bridge_p2p_rtp_write(rtp, bridged, header, res, hdrlen);
3476         
3477         return 1;
3478 }
3479
3480 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
3481 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3482 {
3483         /* If we need DTMF, are looking for STUN, or we have no IO structure then we can't do direct callback */
3484         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || ast_test_flag(rtp, FLAG_HAS_STUN) || !rtp->io)
3485                 return 0;
3486
3487         /* If the RTP structure is already in callback mode, remove it temporarily */
3488         if (rtp->ioid) {
3489                 ast_io_remove(rtp->io, rtp->ioid);
3490                 rtp->ioid = NULL;
3491         }
3492
3493         /* Steal the file descriptors from the channel */
3494         chan->fds[0] = -1;
3495
3496         /* Now, fire up callback mode */
3497         iod[0] = ast_io_add(rtp->io, ast_rtp_fd(rtp), p2p_rtp_callback, AST_IO_IN, rtp);
3498
3499         return 1;
3500 }
3501 #else
3502 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3503 {
3504         return 0;
3505 }
3506 #endif
3507
3508 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
3509 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3510 {
3511         ast_channel_lock(chan);
3512
3513         /* Remove the callback from the IO context */
3514         ast_io_remove(rtp->io, iod[0]);
3515
3516         /* Restore file descriptors */
3517         chan->fds[0] = ast_rtp_fd(rtp);
3518         ast_channel_unlock(chan);
3519
3520         /* Restore callback mode if previously used */
3521         if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
3522                 rtp->ioid = ast_io_add(rtp->io, ast_rtp_fd(rtp), rtpread, AST_IO_IN, rtp);
3523
3524         return 0;
3525 }
3526
3527 /*! \brief Helper function that sets what an RTP structure is bridged to */
3528 static void p2p_set_bridge(struct ast_rtp *rtp0, struct ast_rtp *rtp1)
3529 {
3530         rtp_bridge_lock(rtp0);
3531         rtp0->bridged = rtp1;
3532         rtp_bridge_unlock(rtp0);
3533
3534         return;
3535 }
3536
3537 /*! \brief Bridge loop for partial native bridge (packet2packet) 
3538
3539         In p2p mode, Asterisk is a very basic RTP proxy, just forwarding whatever
3540         rtp/rtcp we get in to the channel. 
3541         \note this currently only works for Audio
3542 */
3543 static enum ast_bridge_result bridge_p2p_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
3544 {
3545         struct ast_frame *fr = NULL;
3546         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
3547         int *p0_iod[2] = {NULL, NULL}, *p1_iod[2] = {NULL, NULL};
3548         int p0_callback = 0, p1_callback = 0;
3549         enum ast_bridge_result res = AST_BRIDGE_FAILED;
3550
3551         /* Okay, setup each RTP structure to do P2P forwarding */
3552         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3553         p2p_set_bridge(p0, p1);
3554         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3555         p2p_set_bridge(p1, p0);
3556
3557         /* Activate callback modes if possible */
3558         p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
3559         p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
3560
3561         /* Now let go of the channel locks and be on our way */
3562         ast_channel_unlock(c0);
3563         ast_channel_unlock(c1);
3564
3565         ast_poll_channel_add(c0, c1);
3566
3567         /* Go into a loop forwarding frames until we don't need to anymore */
3568         cs[0] = c0;
3569         cs[1] = c1;
3570         cs[2] = NULL;
3571         for (;;) {
3572                 /* If the underlying formats have changed force this bridge to break */
3573                 if ((c0->rawreadformat != c1->rawwriteformat) || (c1->rawreadformat != c0->rawwriteformat)) {
3574                         ast_debug(3, "p2p-rtp-bridge: Oooh, formats changed, backing out\n");
3575                         res = AST_BRIDGE_FAILED_NOWARN;
3576                         break;
3577                 }
3578                 /* Check if anything changed */