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