00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #include "asterisk.h"
00036
00037 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 384048 $")
00038
00039 #include <sys/time.h>
00040 #include <signal.h>
00041 #include <fcntl.h>
00042
00043 #include "asterisk/stun.h"
00044 #include "asterisk/pbx.h"
00045 #include "asterisk/frame.h"
00046 #include "asterisk/channel.h"
00047 #include "asterisk/acl.h"
00048 #include "asterisk/config.h"
00049 #include "asterisk/lock.h"
00050 #include "asterisk/utils.h"
00051 #include "asterisk/cli.h"
00052 #include "asterisk/manager.h"
00053 #include "asterisk/unaligned.h"
00054 #include "asterisk/module.h"
00055 #include "asterisk/rtp_engine.h"
00056
00057 #define MAX_TIMESTAMP_SKEW 640
00058
00059 #define RTP_SEQ_MOD (1<<16)
00060 #define RTCP_DEFAULT_INTERVALMS 5000
00061 #define RTCP_MIN_INTERVALMS 500
00062 #define RTCP_MAX_INTERVALMS 60000
00063
00064 #define DEFAULT_RTP_START 5000
00065 #define DEFAULT_RTP_END 31000
00066
00067 #define MINIMUM_RTP_PORT 1024
00068 #define MAXIMUM_RTP_PORT 65535
00069
00070 #define RTCP_PT_FUR 192
00071 #define RTCP_PT_SR 200
00072 #define RTCP_PT_RR 201
00073 #define RTCP_PT_SDES 202
00074 #define RTCP_PT_BYE 203
00075 #define RTCP_PT_APP 204
00076
00077 #define RTP_MTU 1200
00078
00079 #define DEFAULT_DTMF_TIMEOUT (150 * (8000 / 1000))
00080
00081 #define ZFONE_PROFILE_ID 0x505a
00082
00083 #define DEFAULT_LEARNING_MIN_SEQUENTIAL 4
00084
00085 extern struct ast_srtp_res *res_srtp;
00086 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
00087
00088 static int rtpstart = DEFAULT_RTP_START;
00089 static int rtpend = DEFAULT_RTP_END;
00090 static int rtpdebug;
00091 static int rtcpdebug;
00092 static int rtcpstats;
00093 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS;
00094 static struct ast_sockaddr rtpdebugaddr;
00095 static struct ast_sockaddr rtcpdebugaddr;
00096 static int rtpdebugport;
00097 static int rtcpdebugport;
00098 #ifdef SO_NO_CHECK
00099 static int nochecksums;
00100 #endif
00101 static int strictrtp;
00102 static int learning_min_sequential;
00103
00104 enum strict_rtp_state {
00105 STRICT_RTP_OPEN = 0,
00106 STRICT_RTP_LEARN,
00107 STRICT_RTP_CLOSED,
00108 };
00109
00110 #define FLAG_3389_WARNING (1 << 0)
00111 #define FLAG_NAT_ACTIVE (3 << 1)
00112 #define FLAG_NAT_INACTIVE (0 << 1)
00113 #define FLAG_NAT_INACTIVE_NOWARN (1 << 1)
00114 #define FLAG_NEED_MARKER_BIT (1 << 3)
00115 #define FLAG_DTMF_COMPENSATE (1 << 4)
00116
00117
00118 struct ast_rtp {
00119 int s;
00120 struct ast_frame f;
00121 unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
00122 unsigned int ssrc;
00123 unsigned int themssrc;
00124 unsigned int rxssrc;
00125 unsigned int lastts;
00126 unsigned int lastrxts;
00127 unsigned int lastividtimestamp;
00128 unsigned int lastovidtimestamp;
00129 unsigned int lastitexttimestamp;
00130 unsigned int lastotexttimestamp;
00131 unsigned int lasteventseqn;
00132 int lastrxseqno;
00133 unsigned short seedrxseqno;
00134 unsigned int seedrxts;
00135 unsigned int rxcount;
00136 unsigned int rxoctetcount;
00137 unsigned int txcount;
00138 unsigned int txoctetcount;
00139 unsigned int cycles;
00140 double rxjitter;
00141 double rxtransit;
00142 format_t lasttxformat;
00143 format_t lastrxformat;
00144
00145 int rtptimeout;
00146 int rtpholdtimeout;
00147 int rtpkeepalive;
00148
00149
00150 char resp;
00151 unsigned int last_seqno;
00152 unsigned int last_end_timestamp;
00153 unsigned int dtmf_duration;
00154 unsigned int dtmf_timeout;
00155 unsigned int dtmfsamples;
00156 enum ast_rtp_dtmf_mode dtmfmode;
00157
00158 unsigned int lastdigitts;
00159 char sending_digit;
00160 char send_digit;
00161 int send_payload;
00162 int send_duration;
00163 unsigned int flags;
00164 struct timeval rxcore;
00165 struct timeval txcore;
00166 double drxcore;
00167 struct timeval lastrx;
00168 struct timeval dtmfmute;
00169 struct ast_smoother *smoother;
00170 int *ioid;
00171 unsigned short seqno;
00172 unsigned short rxseqno;
00173 struct sched_context *sched;
00174 struct io_context *io;
00175 void *data;
00176 struct ast_rtcp *rtcp;
00177 struct ast_rtp *bridged;
00178
00179 enum strict_rtp_state strict_rtp_state;
00180 struct ast_sockaddr strict_rtp_address;
00181 struct ast_sockaddr alt_rtp_address;
00182
00183
00184
00185
00186
00187 uint16_t learning_max_seq;
00188 int learning_probation;
00189
00190 struct rtp_red *red;
00191 };
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203 struct ast_rtcp {
00204 int rtcp_info;
00205 int s;
00206 struct ast_sockaddr us;
00207 struct ast_sockaddr them;
00208 unsigned int soc;
00209 unsigned int spc;
00210 unsigned int themrxlsr;
00211 struct timeval rxlsr;
00212 struct timeval txlsr;
00213 unsigned int expected_prior;
00214 unsigned int received_prior;
00215 int schedid;
00216 unsigned int rr_count;
00217 unsigned int sr_count;
00218 unsigned int lastsrtxcount;
00219 double accumulated_transit;
00220 double rtt;
00221 unsigned int reported_jitter;
00222 unsigned int reported_lost;
00223
00224 double reported_maxjitter;
00225 double reported_minjitter;
00226 double reported_normdev_jitter;
00227 double reported_stdev_jitter;
00228 unsigned int reported_jitter_count;
00229
00230 double reported_maxlost;
00231 double reported_minlost;
00232 double reported_normdev_lost;
00233 double reported_stdev_lost;
00234
00235 double rxlost;
00236 double maxrxlost;
00237 double minrxlost;
00238 double normdev_rxlost;
00239 double stdev_rxlost;
00240 unsigned int rxlost_count;
00241
00242 double maxrxjitter;
00243 double minrxjitter;
00244 double normdev_rxjitter;
00245 double stdev_rxjitter;
00246 unsigned int rxjitter_count;
00247 double maxrtt;
00248 double minrtt;
00249 double normdevrtt;
00250 double stdevrtt;
00251 unsigned int rtt_count;
00252 };
00253
00254 struct rtp_red {
00255 struct ast_frame t140;
00256 struct ast_frame t140red;
00257 unsigned char pt[AST_RED_MAX_GENERATION];
00258 unsigned char ts[AST_RED_MAX_GENERATION];
00259 unsigned char len[AST_RED_MAX_GENERATION];
00260 int num_gen;
00261 int schedid;
00262 int ti;
00263 unsigned char t140red_data[64000];
00264 unsigned char buf_data[64000];
00265 int hdrlen;
00266 long int prev_ts;
00267 };
00268
00269 AST_LIST_HEAD_NOLOCK(frame_list, ast_frame);
00270
00271
00272 static int ast_rtp_new(struct ast_rtp_instance *instance, struct sched_context *sched, struct ast_sockaddr *addr, void *data);
00273 static int ast_rtp_destroy(struct ast_rtp_instance *instance);
00274 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit);
00275 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit);
00276 static int ast_rtp_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration);
00277 static int ast_rtp_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode);
00278 static enum ast_rtp_dtmf_mode ast_rtp_dtmf_mode_get(struct ast_rtp_instance *instance);
00279 static void ast_rtp_update_source(struct ast_rtp_instance *instance);
00280 static void ast_rtp_change_source(struct ast_rtp_instance *instance);
00281 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame);
00282 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp);
00283 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value);
00284 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp);
00285 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr);
00286 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr);
00287 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations);
00288 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame);
00289 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1);
00290 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat);
00291 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1);
00292 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username);
00293 static void ast_rtp_stop(struct ast_rtp_instance *instance);
00294 static int ast_rtp_qos_set(struct ast_rtp_instance *instance, int tos, int cos, const char* desc);
00295 static int ast_rtp_sendcng(struct ast_rtp_instance *instance, int level);
00296
00297
00298 static struct ast_rtp_engine asterisk_rtp_engine = {
00299 .name = "asterisk",
00300 .new = ast_rtp_new,
00301 .destroy = ast_rtp_destroy,
00302 .dtmf_begin = ast_rtp_dtmf_begin,
00303 .dtmf_end = ast_rtp_dtmf_end,
00304 .dtmf_end_with_duration = ast_rtp_dtmf_end_with_duration,
00305 .dtmf_mode_set = ast_rtp_dtmf_mode_set,
00306 .dtmf_mode_get = ast_rtp_dtmf_mode_get,
00307 .update_source = ast_rtp_update_source,
00308 .change_source = ast_rtp_change_source,
00309 .write = ast_rtp_write,
00310 .read = ast_rtp_read,
00311 .prop_set = ast_rtp_prop_set,
00312 .fd = ast_rtp_fd,
00313 .remote_address_set = ast_rtp_remote_address_set,
00314 .alt_remote_address_set = ast_rtp_alt_remote_address_set,
00315 .red_init = rtp_red_init,
00316 .red_buffer = rtp_red_buffer,
00317 .local_bridge = ast_rtp_local_bridge,
00318 .get_stat = ast_rtp_get_stat,
00319 .dtmf_compatible = ast_rtp_dtmf_compatible,
00320 .stun_request = ast_rtp_stun_request,
00321 .stop = ast_rtp_stop,
00322 .qos = ast_rtp_qos_set,
00323 .sendcng = ast_rtp_sendcng,
00324 };
00325
00326 static inline int rtp_debug_test_addr(struct ast_sockaddr *addr)
00327 {
00328 if (!rtpdebug) {
00329 return 0;
00330 }
00331 if (!ast_sockaddr_isnull(&rtpdebugaddr)) {
00332 if (rtpdebugport) {
00333 return (ast_sockaddr_cmp(&rtpdebugaddr, addr) == 0);
00334 } else {
00335 return (ast_sockaddr_cmp_addr(&rtpdebugaddr, addr) == 0);
00336 }
00337 }
00338
00339 return 1;
00340 }
00341
00342 static inline int rtcp_debug_test_addr(struct ast_sockaddr *addr)
00343 {
00344 if (!rtcpdebug) {
00345 return 0;
00346 }
00347 if (!ast_sockaddr_isnull(&rtcpdebugaddr)) {
00348 if (rtcpdebugport) {
00349 return (ast_sockaddr_cmp(&rtcpdebugaddr, addr) == 0);
00350 } else {
00351 return (ast_sockaddr_cmp_addr(&rtcpdebugaddr, addr) == 0);
00352 }
00353 }
00354
00355 return 1;
00356 }
00357
00358 static int __rtp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp)
00359 {
00360 int len;
00361 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00362 struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
00363 char *in = buf;
00364
00365 if ((len = ast_recvfrom(rtcp ? rtp->rtcp->s : rtp->s, buf, size, flags, sa)) < 0) {
00366 return len;
00367 }
00368
00369 if ((*in & 0xC0) && res_srtp && srtp && res_srtp->unprotect(srtp, buf, &len, rtcp) < 0) {
00370 return -1;
00371 }
00372
00373 return len;
00374 }
00375
00376 static int rtcp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
00377 {
00378 return __rtp_recvfrom(instance, buf, size, flags, sa, 1);
00379 }
00380
00381 static int rtp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
00382 {
00383 return __rtp_recvfrom(instance, buf, size, flags, sa, 0);
00384 }
00385
00386 static int __rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp)
00387 {
00388 int len = size;
00389 void *temp = buf;
00390 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00391 struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
00392
00393 if (res_srtp && srtp && res_srtp->protect(srtp, &temp, &len, rtcp) < 0) {
00394 return -1;
00395 }
00396
00397 return ast_sendto(rtcp ? rtp->rtcp->s : rtp->s, temp, len, flags, sa);
00398 }
00399
00400 static int rtcp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
00401 {
00402 return __rtp_sendto(instance, buf, size, flags, sa, 1);
00403 }
00404
00405 static int rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
00406 {
00407 return __rtp_sendto(instance, buf, size, flags, sa, 0);
00408 }
00409
00410 static int rtp_get_rate(format_t subclass)
00411 {
00412 return (subclass == AST_FORMAT_G722) ? 8000 : ast_format_rate(subclass);
00413 }
00414
00415 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
00416 {
00417 unsigned int interval;
00418
00419
00420 interval = rtcpinterval;
00421 return interval;
00422 }
00423
00424
00425 static double normdev_compute(double normdev, double sample, unsigned int sample_count)
00426 {
00427 normdev = normdev * sample_count + sample;
00428 sample_count++;
00429
00430 return normdev / sample_count;
00431 }
00432
00433 static double stddev_compute(double stddev, double sample, double normdev, double normdev_curent, unsigned int sample_count)
00434 {
00435
00436
00437
00438
00439
00440
00441 #define SQUARE(x) ((x) * (x))
00442
00443 stddev = sample_count * stddev;
00444 sample_count++;
00445
00446 return stddev +
00447 ( sample_count * SQUARE( (sample - normdev) / sample_count ) ) +
00448 ( SQUARE(sample - normdev_curent) / sample_count );
00449
00450 #undef SQUARE
00451 }
00452
00453 static int create_new_socket(const char *type, int af)
00454 {
00455 int sock = socket(af, SOCK_DGRAM, 0);
00456
00457 if (sock < 0) {
00458 if (!type) {
00459 type = "RTP/RTCP";
00460 }
00461 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
00462 } else {
00463 long flags = fcntl(sock, F_GETFL);
00464 fcntl(sock, F_SETFL, flags | O_NONBLOCK);
00465 #ifdef SO_NO_CHECK
00466 if (nochecksums) {
00467 setsockopt(sock, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
00468 }
00469 #endif
00470 }
00471
00472 return sock;
00473 }
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483 static void rtp_learning_seq_init(struct ast_rtp *rtp, uint16_t seq)
00484 {
00485 rtp->learning_max_seq = seq - 1;
00486 rtp->learning_probation = learning_min_sequential;
00487 }
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498 static int rtp_learning_rtp_seq_update(struct ast_rtp *rtp, uint16_t seq)
00499 {
00500 int probation = 1;
00501
00502 ast_debug(1, "%p -- probation = %d, seq = %d\n", rtp, rtp->learning_probation, seq);
00503
00504 if (seq == rtp->learning_max_seq + 1) {
00505
00506 rtp->learning_probation--;
00507 rtp->learning_max_seq = seq;
00508 if (rtp->learning_probation == 0) {
00509 probation = 0;
00510 }
00511 } else {
00512 rtp->learning_probation = learning_min_sequential - 1;
00513 rtp->learning_max_seq = seq;
00514 }
00515
00516 return probation;
00517 }
00518
00519 static int ast_rtp_new(struct ast_rtp_instance *instance,
00520 struct sched_context *sched, struct ast_sockaddr *addr,
00521 void *data)
00522 {
00523 struct ast_rtp *rtp = NULL;
00524 int x, startplace;
00525
00526
00527 if (!(rtp = ast_calloc(1, sizeof(*rtp)))) {
00528 return -1;
00529 }
00530
00531
00532 rtp->ssrc = ast_random();
00533 rtp->seqno = ast_random() & 0xffff;
00534 rtp->strict_rtp_state = (strictrtp ? STRICT_RTP_LEARN : STRICT_RTP_OPEN);
00535 if (strictrtp) {
00536 rtp_learning_seq_init(rtp, (uint16_t)rtp->seqno);
00537 }
00538
00539
00540 if ((rtp->s =
00541 create_new_socket("RTP",
00542 ast_sockaddr_is_ipv4(addr) ? AF_INET :
00543 ast_sockaddr_is_ipv6(addr) ? AF_INET6 : -1)) < 0) {
00544 ast_debug(1, "Failed to create a new socket for RTP instance '%p'\n", instance);
00545 ast_free(rtp);
00546 return -1;
00547 }
00548
00549
00550 x = (rtpend == rtpstart) ? rtpstart : (ast_random() % (rtpend - rtpstart)) + rtpstart;
00551 x = x & ~1;
00552 startplace = x;
00553
00554 for (;;) {
00555 ast_sockaddr_set_port(addr, x);
00556
00557 if (!ast_bind(rtp->s, addr)) {
00558 ast_debug(1, "Allocated port %d for RTP instance '%p'\n", x, instance);
00559 ast_rtp_instance_set_local_address(instance, addr);
00560 break;
00561 }
00562
00563 x += 2;
00564 if (x > rtpend) {
00565 x = (rtpstart + 1) & ~1;
00566 }
00567
00568
00569 if (x == startplace || errno != EADDRINUSE) {
00570 ast_log(LOG_ERROR, "Oh dear... we couldn't allocate a port for RTP instance '%p'\n", instance);
00571 close(rtp->s);
00572 ast_free(rtp);
00573 return -1;
00574 }
00575 }
00576
00577
00578 rtp->sched = sched;
00579
00580
00581 ast_rtp_instance_set_data(instance, rtp);
00582
00583 return 0;
00584 }
00585
00586 static int ast_rtp_destroy(struct ast_rtp_instance *instance)
00587 {
00588 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00589
00590
00591 if (rtp->smoother) {
00592 ast_smoother_free(rtp->smoother);
00593 }
00594
00595
00596 if (rtp->s > -1) {
00597 close(rtp->s);
00598 }
00599
00600
00601 if (rtp->rtcp) {
00602
00603
00604
00605
00606
00607 close(rtp->rtcp->s);
00608 ast_free(rtp->rtcp);
00609 }
00610
00611
00612 if (rtp->red) {
00613 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
00614 ast_free(rtp->red);
00615 }
00616
00617
00618 ast_free(rtp);
00619
00620 return 0;
00621 }
00622
00623 static int ast_rtp_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
00624 {
00625 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00626 rtp->dtmfmode = dtmf_mode;
00627 return 0;
00628 }
00629
00630 static enum ast_rtp_dtmf_mode ast_rtp_dtmf_mode_get(struct ast_rtp_instance *instance)
00631 {
00632 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00633 return rtp->dtmfmode;
00634 }
00635
00636 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit)
00637 {
00638 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00639 struct ast_sockaddr remote_address = { {0,} };
00640 int hdrlen = 12, res = 0, i = 0, payload = 101;
00641 char data[256];
00642 unsigned int *rtpheader = (unsigned int*)data;
00643
00644 ast_rtp_instance_get_remote_address(instance, &remote_address);
00645
00646
00647 if (ast_sockaddr_isnull(&remote_address)) {
00648 return -1;
00649 }
00650
00651
00652 if ((digit <= '9') && (digit >= '0')) {
00653 digit -= '0';
00654 } else if (digit == '*') {
00655 digit = 10;
00656 } else if (digit == '#') {
00657 digit = 11;
00658 } else if ((digit >= 'A') && (digit <= 'D')) {
00659 digit = digit - 'A' + 12;
00660 } else if ((digit >= 'a') && (digit <= 'd')) {
00661 digit = digit - 'a' + 12;
00662 } else {
00663 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
00664 return -1;
00665 }
00666
00667
00668 payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 0, AST_RTP_DTMF);
00669
00670 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
00671 rtp->send_duration = 160;
00672 rtp->lastdigitts = rtp->lastts + rtp->send_duration;
00673
00674
00675 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
00676 rtpheader[1] = htonl(rtp->lastdigitts);
00677 rtpheader[2] = htonl(rtp->ssrc);
00678
00679
00680 for (i = 0; i < 2; i++) {
00681 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
00682 res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address);
00683 if (res < 0) {
00684 ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
00685 ast_sockaddr_stringify(&remote_address),
00686 strerror(errno));
00687 }
00688 if (rtp_debug_test_addr(&remote_address)) {
00689 ast_verbose("Sent RTP DTMF packet to %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
00690 ast_sockaddr_stringify(&remote_address),
00691 payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
00692 }
00693 rtp->seqno++;
00694 rtp->send_duration += 160;
00695 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
00696 }
00697
00698
00699 rtp->sending_digit = 1;
00700 rtp->send_digit = digit;
00701 rtp->send_payload = payload;
00702
00703 return 0;
00704 }
00705
00706 static int ast_rtp_dtmf_continuation(struct ast_rtp_instance *instance)
00707 {
00708 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00709 struct ast_sockaddr remote_address = { {0,} };
00710 int hdrlen = 12, res = 0;
00711 char data[256];
00712 unsigned int *rtpheader = (unsigned int*)data;
00713
00714 ast_rtp_instance_get_remote_address(instance, &remote_address);
00715
00716
00717 if (ast_sockaddr_isnull(&remote_address)) {
00718 return -1;
00719 }
00720
00721
00722 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
00723 rtpheader[1] = htonl(rtp->lastdigitts);
00724 rtpheader[2] = htonl(rtp->ssrc);
00725 rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
00726
00727
00728 res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address);
00729 if (res < 0) {
00730 ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
00731 ast_sockaddr_stringify(&remote_address),
00732 strerror(errno));
00733 }
00734
00735 if (rtp_debug_test_addr(&remote_address)) {
00736 ast_verbose("Sent RTP DTMF packet to %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
00737 ast_sockaddr_stringify(&remote_address),
00738 rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
00739 }
00740
00741
00742 rtp->seqno++;
00743 rtp->send_duration += 160;
00744
00745 return 0;
00746 }
00747
00748 static int ast_rtp_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration)
00749 {
00750 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00751 struct ast_sockaddr remote_address = { {0,} };
00752 int hdrlen = 12, res = 0, i = 0;
00753 char data[256];
00754 unsigned int *rtpheader = (unsigned int*)data;
00755 unsigned int measured_samples;
00756
00757 ast_rtp_instance_get_remote_address(instance, &remote_address);
00758
00759
00760 if (ast_sockaddr_isnull(&remote_address)) {
00761 return -1;
00762 }
00763
00764
00765 if ((digit <= '9') && (digit >= '0')) {
00766 digit -= '0';
00767 } else if (digit == '*') {
00768 digit = 10;
00769 } else if (digit == '#') {
00770 digit = 11;
00771 } else if ((digit >= 'A') && (digit <= 'D')) {
00772 digit = digit - 'A' + 12;
00773 } else if ((digit >= 'a') && (digit <= 'd')) {
00774 digit = digit - 'a' + 12;
00775 } else {
00776 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
00777 return -1;
00778 }
00779
00780 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
00781
00782 if (duration > 0 && (measured_samples = duration * rtp_get_rate(rtp->f.subclass.codec) / 1000) > rtp->send_duration) {
00783 ast_debug(2, "Adjusting final end duration from %u to %u\n", rtp->send_duration, measured_samples);
00784 rtp->send_duration = measured_samples;
00785 }
00786
00787
00788 rtpheader[1] = htonl(rtp->lastdigitts);
00789 rtpheader[2] = htonl(rtp->ssrc);
00790 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
00791 rtpheader[3] |= htonl((1 << 23));
00792
00793
00794 for (i = 0; i < 3; i++) {
00795
00796 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
00797
00798 res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address);
00799 if (res < 0) {
00800 ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
00801 ast_sockaddr_stringify(&remote_address),
00802 strerror(errno));
00803 }
00804 if (rtp_debug_test_addr(&remote_address)) {
00805 ast_verbose("Sent RTP DTMF packet to %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
00806 ast_sockaddr_stringify(&remote_address),
00807 rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
00808 }
00809
00810 rtp->seqno++;
00811 }
00812
00813
00814 rtp->lastts += rtp->send_duration;
00815 rtp->sending_digit = 0;
00816 rtp->send_digit = 0;
00817
00818 return 0;
00819 }
00820
00821 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit)
00822 {
00823 return ast_rtp_dtmf_end_with_duration(instance, digit, 0);
00824 }
00825
00826 static void ast_rtp_update_source(struct ast_rtp_instance *instance)
00827 {
00828 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00829
00830
00831 ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
00832 ast_debug(3, "Setting the marker bit due to a source update\n");
00833
00834 return;
00835 }
00836
00837 static void ast_rtp_change_source(struct ast_rtp_instance *instance)
00838 {
00839 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00840 struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
00841 unsigned int ssrc = ast_random();
00842
00843 if (!rtp->lastts) {
00844 ast_debug(3, "Not changing SSRC since we haven't sent any RTP yet\n");
00845 return;
00846 }
00847
00848
00849 ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
00850
00851 ast_debug(3, "Changing ssrc from %u to %u due to a source change\n", rtp->ssrc, ssrc);
00852
00853 if (srtp) {
00854 ast_debug(3, "Changing ssrc for SRTP from %u to %u\n", rtp->ssrc, ssrc);
00855 res_srtp->change_source(srtp, rtp->ssrc, ssrc);
00856 }
00857
00858 rtp->ssrc = ssrc;
00859
00860 return;
00861 }
00862
00863 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
00864 {
00865 struct timeval t;
00866 long ms;
00867
00868 if (ast_tvzero(rtp->txcore)) {
00869 rtp->txcore = ast_tvnow();
00870 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
00871 }
00872
00873 t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
00874 if ((ms = ast_tvdiff_ms(t, rtp->txcore)) < 0) {
00875 ms = 0;
00876 }
00877 rtp->txcore = t;
00878
00879 return (unsigned int) ms;
00880 }
00881
00882 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
00883 {
00884 unsigned int sec, usec, frac;
00885 sec = tv.tv_sec + 2208988800u;
00886 usec = tv.tv_usec;
00887 frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
00888 *msw = sec;
00889 *lsw = frac;
00890 }
00891
00892
00893 static int ast_rtcp_write_rr(struct ast_rtp_instance *instance)
00894 {
00895 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00896 int res;
00897 int len = 32;
00898 unsigned int lost;
00899 unsigned int extended;
00900 unsigned int expected;
00901 unsigned int expected_interval;
00902 unsigned int received_interval;
00903 int lost_interval;
00904 struct timeval now;
00905 unsigned int *rtcpheader;
00906 char bdata[1024];
00907 struct timeval dlsr;
00908 int fraction;
00909 int rate = rtp_get_rate(rtp->f.subclass.codec);
00910
00911 double rxlost_current;
00912
00913 if (!rtp || !rtp->rtcp)
00914 return 0;
00915
00916 if (ast_sockaddr_isnull(&rtp->rtcp->them)) {
00917
00918
00919
00920 return 0;
00921 }
00922
00923 extended = rtp->cycles + rtp->lastrxseqno;
00924 expected = extended - rtp->seedrxseqno + 1;
00925 lost = expected - rtp->rxcount;
00926 expected_interval = expected - rtp->rtcp->expected_prior;
00927 rtp->rtcp->expected_prior = expected;
00928 received_interval = rtp->rxcount - rtp->rtcp->received_prior;
00929 rtp->rtcp->received_prior = rtp->rxcount;
00930 lost_interval = expected_interval - received_interval;
00931
00932 if (lost_interval <= 0)
00933 rtp->rtcp->rxlost = 0;
00934 else rtp->rtcp->rxlost = rtp->rtcp->rxlost;
00935 if (rtp->rtcp->rxlost_count == 0)
00936 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
00937 if (lost_interval < rtp->rtcp->minrxlost)
00938 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
00939 if (lost_interval > rtp->rtcp->maxrxlost)
00940 rtp->rtcp->maxrxlost = rtp->rtcp->rxlost;
00941
00942 rxlost_current = normdev_compute(rtp->rtcp->normdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->rxlost_count);
00943 rtp->rtcp->stdev_rxlost = stddev_compute(rtp->rtcp->stdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->normdev_rxlost, rxlost_current, rtp->rtcp->rxlost_count);
00944 rtp->rtcp->normdev_rxlost = rxlost_current;
00945 rtp->rtcp->rxlost_count++;
00946
00947 if (expected_interval == 0 || lost_interval <= 0)
00948 fraction = 0;
00949 else
00950 fraction = (lost_interval << 8) / expected_interval;
00951 gettimeofday(&now, NULL);
00952 timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
00953 rtcpheader = (unsigned int *)bdata;
00954 rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
00955 rtcpheader[1] = htonl(rtp->ssrc);
00956 rtcpheader[2] = htonl(rtp->themssrc);
00957 rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
00958 rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
00959 rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * rate));
00960 rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
00961 rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
00962
00963
00964
00965 rtcpheader[len/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
00966 rtcpheader[(len/4)+1] = htonl(rtp->ssrc);
00967 rtcpheader[(len/4)+2] = htonl(0x01 << 24);
00968 len += 12;
00969
00970 res = rtcp_sendto(instance, (unsigned int *)rtcpheader, len, 0, &rtp->rtcp->them);
00971
00972 if (res < 0) {
00973 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
00974 return 0;
00975 }
00976
00977 rtp->rtcp->rr_count++;
00978 if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
00979 ast_verbose("\n* Sending RTCP RR to %s\n"
00980 " Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n"
00981 " IA jitter: %.4f\n"
00982 " Their last SR: %u\n"
00983 " DLSR: %4.4f (sec)\n\n",
00984 ast_sockaddr_stringify(&rtp->rtcp->them),
00985 rtp->ssrc, rtp->themssrc, fraction, lost,
00986 rtp->rxjitter,
00987 rtp->rtcp->themrxlsr,
00988 (double)(ntohl(rtcpheader[7])/65536.0));
00989 }
00990
00991 return res;
00992 }
00993
00994
00995 static int ast_rtcp_write_sr(struct ast_rtp_instance *instance)
00996 {
00997 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
00998 int res;
00999 int len = 0;
01000 struct timeval now;
01001 unsigned int now_lsw;
01002 unsigned int now_msw;
01003 unsigned int *rtcpheader;
01004 unsigned int lost;
01005 unsigned int extended;
01006 unsigned int expected;
01007 unsigned int expected_interval;
01008 unsigned int received_interval;
01009 int lost_interval;
01010 int fraction;
01011 struct timeval dlsr;
01012 char bdata[512];
01013 int rate = rtp_get_rate(rtp->f.subclass.codec);
01014
01015 if (!rtp || !rtp->rtcp)
01016 return 0;
01017
01018 if (ast_sockaddr_isnull(&rtp->rtcp->them)) {
01019
01020
01021
01022 return 0;
01023 }
01024
01025 gettimeofday(&now, NULL);
01026 timeval2ntp(now, &now_msw, &now_lsw);
01027 rtcpheader = (unsigned int *)bdata;
01028 rtcpheader[1] = htonl(rtp->ssrc);
01029 rtcpheader[2] = htonl(now_msw);
01030 rtcpheader[3] = htonl(now_lsw);
01031 rtcpheader[4] = htonl(rtp->lastts);
01032 rtcpheader[5] = htonl(rtp->txcount);
01033 rtcpheader[6] = htonl(rtp->txoctetcount);
01034 len += 28;
01035
01036 extended = rtp->cycles + rtp->lastrxseqno;
01037 expected = extended - rtp->seedrxseqno + 1;
01038 if (rtp->rxcount > expected)
01039 expected += rtp->rxcount - expected;
01040 lost = expected - rtp->rxcount;
01041 expected_interval = expected - rtp->rtcp->expected_prior;
01042 rtp->rtcp->expected_prior = expected;
01043 received_interval = rtp->rxcount - rtp->rtcp->received_prior;
01044 rtp->rtcp->received_prior = rtp->rxcount;
01045 lost_interval = expected_interval - received_interval;
01046 if (expected_interval == 0 || lost_interval <= 0)
01047 fraction = 0;
01048 else
01049 fraction = (lost_interval << 8) / expected_interval;
01050 timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
01051 rtcpheader[7] = htonl(rtp->themssrc);
01052 rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
01053 rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
01054 rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * rate));
01055 rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
01056 rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
01057 len += 24;
01058
01059 rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
01060
01061
01062
01063 rtcpheader[len/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
01064 rtcpheader[(len/4)+1] = htonl(rtp->ssrc);
01065 rtcpheader[(len/4)+2] = htonl(0x01 << 24);
01066 len += 12;
01067
01068 res = rtcp_sendto(instance, (unsigned int *)rtcpheader, len, 0, &rtp->rtcp->them);
01069 if (res < 0) {
01070 ast_log(LOG_ERROR, "RTCP SR transmission error to %s, rtcp halted %s\n",
01071 ast_sockaddr_stringify(&rtp->rtcp->them),
01072 strerror(errno));
01073 return 0;
01074 }
01075
01076
01077 gettimeofday(&rtp->rtcp->txlsr, NULL);
01078 rtp->rtcp->sr_count++;
01079
01080 rtp->rtcp->lastsrtxcount = rtp->txcount;
01081
01082 if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
01083 ast_verbose("* Sent RTCP SR to %s\n", ast_sockaddr_stringify(&rtp->rtcp->them));
01084 ast_verbose(" Our SSRC: %u\n", rtp->ssrc);
01085 ast_verbose(" Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
01086 ast_verbose(" Sent(RTP): %u\n", rtp->lastts);
01087 ast_verbose(" Sent packets: %u\n", rtp->txcount);
01088 ast_verbose(" Sent octets: %u\n", rtp->txoctetcount);
01089 ast_verbose(" Report block:\n");
01090 ast_verbose(" Fraction lost: %u\n", fraction);
01091 ast_verbose(" Cumulative loss: %u\n", lost);
01092 ast_verbose(" IA jitter: %.4f\n", rtp->rxjitter);
01093 ast_verbose(" Their last SR: %u\n", rtp->rtcp->themrxlsr);
01094 ast_verbose(" DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
01095 }
01096 manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To: %s\r\n"
01097 "OurSSRC: %u\r\n"
01098 "SentNTP: %u.%010u\r\n"
01099 "SentRTP: %u\r\n"
01100 "SentPackets: %u\r\n"
01101 "SentOctets: %u\r\n"
01102 "ReportBlock:\r\n"
01103 "FractionLost: %u\r\n"
01104 "CumulativeLoss: %u\r\n"
01105 "IAJitter: %.4f\r\n"
01106 "TheirLastSR: %u\r\n"
01107 "DLSR: %4.4f (sec)\r\n",
01108 ast_sockaddr_stringify(&rtp->rtcp->them),
01109 rtp->ssrc,
01110 (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
01111 rtp->lastts,
01112 rtp->txcount,
01113 rtp->txoctetcount,
01114 fraction,
01115 lost,
01116 rtp->rxjitter,
01117 rtp->rtcp->themrxlsr,
01118 (double)(ntohl(rtcpheader[12])/65536.0));
01119 return res;
01120 }
01121
01122
01123
01124
01125 static int ast_rtcp_write(const void *data)
01126 {
01127 struct ast_rtp_instance *instance = (struct ast_rtp_instance *) data;
01128 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
01129 int res;
01130
01131 if (!rtp || !rtp->rtcp || rtp->rtcp->schedid == -1) {
01132 ao2_ref(instance, -1);
01133 return 0;
01134 }
01135
01136 if (rtp->txcount > rtp->rtcp->lastsrtxcount) {
01137 res = ast_rtcp_write_sr(instance);
01138 } else {
01139 res = ast_rtcp_write_rr(instance);
01140 }
01141
01142 if (!res) {
01143
01144
01145
01146 ao2_ref(instance, -1);
01147 rtp->rtcp->schedid = -1;
01148 }
01149
01150 return res;
01151 }
01152
01153 static int ast_rtp_raw_write(struct ast_rtp_instance *instance, struct ast_frame *frame, int codec)
01154 {
01155 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
01156 int pred, mark = 0;
01157 unsigned int ms = calc_txstamp(rtp, &frame->delivery);
01158 struct ast_sockaddr remote_address = { {0,} };
01159 int rate = rtp_get_rate(frame->subclass.codec) / 1000;
01160
01161 if (frame->subclass.codec == AST_FORMAT_G722) {
01162 frame->samples /= 2;
01163 }
01164
01165 if (rtp->sending_digit) {
01166 return 0;
01167 }
01168
01169 if (frame->frametype == AST_FRAME_VOICE) {
01170 pred = rtp->lastts + frame->samples;
01171
01172
01173 rtp->lastts = rtp->lastts + ms * rate;
01174 if (ast_tvzero(frame->delivery)) {
01175
01176
01177 if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW) {
01178 rtp->lastts = pred;
01179 } else {
01180 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
01181 mark = 1;
01182 }
01183 }
01184 } else if (frame->frametype == AST_FRAME_VIDEO) {
01185 mark = frame->subclass.codec & 0x1;
01186 pred = rtp->lastovidtimestamp + frame->samples;
01187
01188 rtp->lastts = rtp->lastts + ms * 90;
01189
01190 if (ast_tvzero(frame->delivery)) {
01191 if (abs(rtp->lastts - pred) < 7200) {
01192 rtp->lastts = pred;
01193 rtp->lastovidtimestamp += frame->samples;
01194 } else {
01195 ast_debug(3, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, frame->samples);
01196 rtp->lastovidtimestamp = rtp->lastts;
01197 }
01198 }
01199 } else {
01200 pred = rtp->lastotexttimestamp + frame->samples;
01201
01202 rtp->lastts = rtp->lastts + ms;
01203
01204 if (ast_tvzero(frame->delivery)) {
01205 if (abs(rtp->lastts - pred) < 7200) {
01206 rtp->lastts = pred;
01207 rtp->lastotexttimestamp += frame->samples;
01208 } else {
01209 ast_debug(3, "Difference is %d, ms is %d, pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, rtp->lastts, pred, frame->samples);
01210 rtp->lastotexttimestamp = rtp->lastts;
01211 }
01212 }
01213 }
01214
01215
01216 if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
01217 mark = 1;
01218 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
01219 }
01220
01221
01222 if (rtp->lastts > rtp->lastdigitts) {
01223 rtp->lastdigitts = rtp->lastts;
01224 }
01225
01226 if (ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO)) {
01227 rtp->lastts = frame->ts * rate;
01228 }
01229
01230 ast_rtp_instance_get_remote_address(instance, &remote_address);
01231
01232
01233 if (!ast_sockaddr_isnull(&remote_address)) {
01234 int hdrlen = 12, res;
01235 unsigned char *rtpheader = (unsigned char *)(frame->data.ptr - hdrlen);
01236
01237 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
01238 put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
01239 put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
01240
01241 if ((res = rtp_sendto(instance, (void *)rtpheader, frame->datalen + hdrlen, 0, &remote_address)) < 0) {
01242 if (!ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT) || (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT) && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
01243 ast_debug(1, "RTP Transmission error of packet %d to %s: %s\n",
01244 rtp->seqno,
01245 ast_sockaddr_stringify(&remote_address),
01246 strerror(errno));
01247 } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
01248
01249 if (option_debug || rtpdebug)
01250 ast_debug(0, "RTP NAT: Can't write RTP to private address %s, waiting for other end to send audio...\n",
01251 ast_sockaddr_stringify(&remote_address));
01252 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
01253 }
01254 } else {
01255 rtp->txcount++;
01256 rtp->txoctetcount += (res - hdrlen);
01257
01258 if (rtp->rtcp && rtp->rtcp->schedid < 1) {
01259 ast_debug(1, "Starting RTCP transmission on RTP instance '%p'\n", instance);
01260 ao2_ref(instance, +1);
01261 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, instance);
01262 if (rtp->rtcp->schedid < 0) {
01263 ao2_ref(instance, -1);
01264 ast_log(LOG_WARNING, "scheduling RTCP transmission failed.\n");
01265 }
01266 }
01267 }
01268
01269 if (rtp_debug_test_addr(&remote_address)) {
01270 ast_verbose("Sent RTP packet to %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
01271 ast_sockaddr_stringify(&remote_address),
01272 codec, rtp->seqno, rtp->lastts, res - hdrlen);
01273 }
01274 }
01275
01276 rtp->seqno++;
01277
01278 return 0;
01279 }
01280
01281 static struct ast_frame *red_t140_to_red(struct rtp_red *red) {
01282 unsigned char *data = red->t140red.data.ptr;
01283 int len = 0;
01284 int i;
01285
01286
01287 if (red->len[0]) {
01288 for (i = 1; i < red->num_gen+1; i++)
01289 len += red->len[i];
01290
01291 memmove(&data[red->hdrlen], &data[red->hdrlen+red->len[0]], len);
01292 }
01293
01294
01295 for (i = 0; i < red->num_gen; i++)
01296 red->len[i] = red->len[i+1];
01297 red->len[i] = red->t140.datalen;
01298
01299
01300 len = red->hdrlen;
01301 for (i = 0; i < red->num_gen; i++)
01302 len += data[i*4+3] = red->len[i];
01303
01304
01305 memcpy(&data[len], red->t140.data.ptr, red->t140.datalen);
01306 red->t140red.datalen = len + red->t140.datalen;
01307
01308
01309 if (len == red->hdrlen && !red->t140.datalen)
01310 return NULL;
01311
01312
01313 red->t140.datalen = 0;
01314
01315 return &red->t140red;
01316 }
01317
01318 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
01319 {
01320 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
01321 struct ast_sockaddr remote_address = { {0,} };
01322 format_t codec, subclass;
01323
01324 ast_rtp_instance_get_remote_address(instance, &remote_address);
01325
01326
01327 if (ast_sockaddr_isnull(&remote_address)) {
01328 ast_debug(1, "No remote address on RTP instance '%p' so dropping frame\n", instance);
01329 return 0;
01330 }
01331
01332
01333 if (!frame->datalen) {
01334 ast_debug(1, "Received frame with no data for RTP instance '%p' so dropping frame\n", instance);
01335 return 0;
01336 }
01337
01338
01339 if (frame->frametype != AST_FRAME_VOICE && frame->frametype != AST_FRAME_VIDEO && frame->frametype != AST_FRAME_TEXT) {
01340 ast_log(LOG_WARNING, "RTP can only send voice, video, and text\n");
01341 return -1;
01342 }
01343
01344 if (rtp->red) {
01345
01346
01347 if ((frame = red_t140_to_red(rtp->red)) == NULL)
01348 return 0;
01349 }
01350
01351
01352 subclass = frame->subclass.codec;
01353 if (frame->frametype == AST_FRAME_VIDEO) {
01354 subclass &= ~0x1LL;
01355 }
01356 if ((codec = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 1, subclass)) < 0) {
01357 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(frame->subclass.codec));
01358 return -1;
01359 }
01360
01361
01362 if (rtp->lasttxformat != subclass) {
01363 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
01364 rtp->lasttxformat = subclass;
01365 if (rtp->smoother) {
01366 ast_smoother_free(rtp->smoother);
01367 rtp->smoother = NULL;
01368 }
01369 }
01370
01371
01372 if (!rtp->smoother) {
01373 struct ast_format_list fmt = ast_codec_pref_getsize(&ast_rtp_instance_get_codecs(instance)->pref, subclass);
01374
01375 switch (subclass) {
01376 case AST_FORMAT_SPEEX:
01377 case AST_FORMAT_SPEEX16:
01378 case AST_FORMAT_G723_1:
01379 case AST_FORMAT_SIREN7:
01380 case AST_FORMAT_SIREN14:
01381 case AST_FORMAT_G719:
01382
01383
01384 break;
01385 default:
01386 if (fmt.inc_ms) {
01387 if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
01388 ast_log(LOG_WARNING, "Unable to create smoother: format %s ms: %d len: %d\n", ast_getformatname(subclass), fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
01389 return -1;
01390 }
01391 if (fmt.flags) {
01392 ast_smoother_set_flags(rtp->smoother, fmt.flags);
01393 }
01394 ast_debug(1, "Created smoother: format: %s ms: %d len: %d\n", ast_getformatname(subclass), fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
01395 }
01396 }
01397 }
01398
01399
01400 if (rtp->smoother) {
01401 struct ast_frame *f;
01402
01403 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
01404 ast_smoother_feed_be(rtp->smoother, frame);
01405 } else {
01406 ast_smoother_feed(rtp->smoother, frame);
01407 }
01408
01409 while ((f = ast_smoother_read(rtp->smoother)) && (f->data.ptr)) {
01410 ast_rtp_raw_write(instance, f, codec);
01411 }
01412 } else {
01413 int hdrlen = 12;
01414 struct ast_frame *f = NULL;
01415
01416 if (frame->offset < hdrlen) {
01417 f = ast_frdup(frame);
01418 } else {
01419 f = frame;
01420 }
01421 if (f->data.ptr) {
01422 ast_rtp_raw_write(instance, f, codec);
01423 }
01424 if (f != frame) {
01425 ast_frfree(f);
01426 }
01427
01428 }
01429
01430 return 0;
01431 }
01432
01433 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
01434 {
01435 struct timeval now;
01436 struct timeval tmp;
01437 double transit;
01438 double current_time;
01439 double d;
01440 double dtv;
01441 double prog;
01442 int rate = rtp_get_rate(rtp->f.subclass.codec);
01443
01444 double normdev_rxjitter_current;
01445 if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
01446 gettimeofday(&rtp->rxcore, NULL);
01447 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
01448
01449 rtp->seedrxts = timestamp;
01450 tmp = ast_samp2tv(timestamp, rate);
01451 rtp->rxcore = ast_tvsub(rtp->rxcore, tmp);
01452
01453 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
01454 }
01455
01456 gettimeofday(&now,NULL);
01457
01458 tmp = ast_samp2tv(timestamp, rate);
01459 *tv = ast_tvadd(rtp->rxcore, tmp);
01460
01461 prog = (double)((timestamp-rtp->seedrxts)/(float)(rate));
01462 dtv = (double)rtp->drxcore + (double)(prog);
01463 current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
01464 transit = current_time - dtv;
01465 d = transit - rtp->rxtransit;
01466 rtp->rxtransit = transit;
01467 if (d<0)
01468 d=-d;
01469 rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
01470
01471 if (rtp->rtcp) {
01472 if (rtp->rxjitter > rtp->rtcp->maxrxjitter)
01473 rtp->rtcp->maxrxjitter = rtp->rxjitter;
01474 if (rtp->rtcp->rxjitter_count == 1)
01475 rtp->rtcp->minrxjitter = rtp->rxjitter;
01476 if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
01477 rtp->rtcp->minrxjitter = rtp->rxjitter;
01478
01479 normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
01480 rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
01481
01482 rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
01483 rtp->rtcp->rxjitter_count++;
01484 }
01485 }
01486
01487 static struct ast_frame *create_dtmf_frame(struct ast_rtp_instance *instance, enum ast_frame_type type, int compensate)
01488 {
01489 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
01490 struct ast_sockaddr remote_address = { {0,} };
01491
01492 ast_rtp_instance_get_remote_address(instance, &remote_address);
01493
01494 if (((compensate && type == AST_FRAME_DTMF_END) || (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
01495 ast_debug(1, "Ignore potential DTMF echo from '%s'\n",
01496 ast_sockaddr_stringify(&remote_address));
01497 rtp->resp = 0;
01498 rtp->dtmfsamples = 0;
01499 return &ast_null_frame;
01500 }
01501 ast_debug(1, "Creating %s DTMF Frame: %d (%c), at %s\n",
01502 type == AST_FRAME_DTMF_END ? "END" : "BEGIN",
01503 rtp->resp, rtp->resp,
01504 ast_sockaddr_stringify(&remote_address));
01505 if (rtp->resp == 'X') {
01506 rtp->f.frametype = AST_FRAME_CONTROL;
01507 rtp->f.subclass.integer = AST_CONTROL_FLASH;
01508 } else {
01509 rtp->f.frametype = type;
01510 rtp->f.subclass.integer = rtp->resp;
01511 }
01512 rtp->f.datalen = 0;
01513 rtp->f.samples = 0;
01514 rtp->f.mallocd = 0;
01515 rtp->f.src = "RTP";
01516 AST_LIST_NEXT(&rtp->f, frame_list) = NULL;
01517
01518 return &rtp->f;
01519 }
01520
01521 static void process_dtmf_rfc2833(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct ast_sockaddr *addr, int payloadtype, int mark, struct frame_list *frames)
01522 {
01523 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
01524 struct ast_sockaddr remote_address = { {0,} };
01525 unsigned int event, event_end, samples;
01526 char resp = 0;
01527 struct ast_frame *f = NULL;
01528
01529 ast_rtp_instance_get_remote_address(instance, &remote_address);
01530
01531
01532 event = ntohl(*((unsigned int *)(data)));
01533 event >>= 24;
01534 event_end = ntohl(*((unsigned int *)(data)));
01535 event_end <<= 8;
01536 event_end >>= 24;
01537 samples = ntohl(*((unsigned int *)(data)));
01538 samples &= 0xFFFF;
01539
01540 if (rtp_debug_test_addr(&remote_address)) {
01541 ast_verbose("Got RTP RFC2833 from %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n",
01542 ast_sockaddr_stringify(&remote_address),
01543 payloadtype, seqno, timestamp, len, (mark?1:0), event, ((event_end & 0x80)?1:0), samples);
01544 }
01545
01546
01547 if (rtpdebug || option_debug > 2)
01548 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
01549
01550
01551 if (event < 10) {
01552 resp = '0' + event;
01553 } else if (event < 11) {
01554 resp = '*';
01555 } else if (event < 12) {
01556 resp = '#';
01557 } else if (event < 16) {
01558 resp = 'A' + (event - 12);
01559 } else if (event < 17) {
01560 resp = 'X';
01561 } else {
01562
01563 ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
01564 return;
01565 }
01566
01567 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
01568 if ((rtp->last_end_timestamp != timestamp) || (rtp->resp && rtp->resp != resp)) {
01569 rtp->resp = resp;
01570 rtp->dtmf_timeout = 0;
01571 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)));
01572 f->len = 0;
01573 rtp->last_end_timestamp = timestamp;
01574 AST_LIST_INSERT_TAIL(frames, f, frame_list);
01575 }
01576 } else {
01577
01578
01579
01580
01581
01582 unsigned int new_duration = rtp->dtmf_duration;
01583 unsigned int last_duration = new_duration & 0xFFFF;
01584
01585 if (last_duration > 64000 && samples < last_duration) {
01586 new_duration += 0xFFFF + 1;
01587 }
01588 new_duration = (new_duration & ~0xFFFF) | samples;
01589
01590 if (event_end & 0x80) {
01591 if ((seqno != rtp->last_seqno) && (timestamp > rtp->last_end_timestamp)) {
01592 rtp->last_end_timestamp = timestamp;
01593 rtp->dtmf_duration = new_duration;
01594 rtp->resp = resp;
01595 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0));
01596 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
01597 rtp->resp = 0;
01598 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
01599 AST_LIST_INSERT_TAIL(frames, f, frame_list);
01600 } else if (rtpdebug) {
01601 ast_debug(1, "Dropping re-transmitted, duplicate, or out of order DTMF END frame (seqno: %d, ts %d, digit %c)\n",
01602 seqno, timestamp, resp);
01603 }
01604 } else {
01605
01606
01607
01608
01609
01610
01611 if ((rtp->last_seqno > seqno && rtp->last_seqno - seqno < 50)
01612 || timestamp <= rtp->last_end_timestamp) {
01613
01614
01615
01616
01617 if (rtpdebug) {
01618 ast_debug(1, "Dropping out of order DTMF frame (seqno %d, ts %d, digit %c)\n",
01619 seqno, timestamp, resp);
01620 }
01621 return;
01622 }
01623
01624 if (rtp->resp && rtp->resp != resp) {
01625
01626 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0));
01627 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
01628 rtp->resp = 0;
01629 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
01630 AST_LIST_INSERT_TAIL(frames, f, frame_list);
01631 }
01632
01633 if (rtp->resp) {
01634
01635 rtp->dtmf_duration = new_duration;
01636 } else {
01637
01638 rtp->resp = resp;
01639 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_BEGIN, 0));
01640 rtp->dtmf_duration = samples;
01641 AST_LIST_INSERT_TAIL(frames, f, frame_list);
01642 }
01643
01644 rtp->dtmf_timeout = timestamp + rtp->dtmf_duration + dtmftimeout;
01645 }
01646
01647 rtp->last_seqno = seqno;
01648 }
01649
01650 rtp->dtmfsamples = samples;
01651
01652 return;
01653 }
01654
01655 static struct ast_frame *process_dtmf_cisco(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct ast_sockaddr *addr, int payloadtype, int mark)
01656 {
01657 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
01658 unsigned int event, flags, power;
01659 char resp = 0;
01660 unsigned char seq;
01661 struct ast_frame *f = NULL;
01662
01663 if (len < 4) {
01664 return NULL;
01665 }
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
01681
01682
01683
01684
01685
01686
01687
01688
01689
01690
01691
01692
01693
01694
01695
01696
01697 seq = data[0];
01698 flags = data[1];
01699 power = data[2];
01700 event = data[3] & 0x1f;
01701
01702 if (option_debug > 2 || rtpdebug)
01703 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);
01704 if (event < 10) {
01705 resp = '0' + event;
01706 } else if (event < 11) {
01707 resp = '*';
01708 } else if (event < 12) {
01709 resp = '#';
01710 } else if (event < 16) {
01711 resp = 'A' + (event - 12);
01712 } else if (event < 17) {
01713 resp = 'X';
01714 }
01715 if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
01716 rtp->resp = resp;
01717
01718 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
01719 f = create_dtmf_frame(instance, AST_FRAME_DTMF_BEGIN, 0);
01720 rtp->dtmfsamples = 0;
01721 }
01722 } else if ((rtp->resp == resp) && !power) {
01723 f = create_dtmf_frame(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
01724 f->samples = rtp->dtmfsamples * (rtp->lastrxformat ? (rtp_get_rate(rtp->lastrxformat) / 1000) : 8);
01725 rtp->resp = 0;
01726 } else if (rtp->resp == resp)
01727 rtp->dtmfsamples += 20 * (rtp->lastrxformat ? (rtp_get_rate(rtp->lastrxformat) / 1000) : 8);
01728
01729 rtp->dtmf_timeout = 0;
01730
01731 return f;
01732 }
01733
01734 static struct ast_frame *process_cn_rfc3389(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct ast_sockaddr *addr, int payloadtype, int mark)
01735 {
01736 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
01737
01738
01739
01740
01741 if (rtpdebug)
01742 ast_debug(0, "- RTP 3389 Comfort noise event: Level %" PRId64 " (len = %d)\n", rtp->lastrxformat, len);
01743
01744 if (ast_test_flag(rtp, FLAG_3389_WARNING)) {
01745 struct ast_sockaddr remote_address = { {0,} };
01746
01747 ast_rtp_instance_get_remote_address(instance, &remote_address);
01748
01749 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client address: %s\n",
01750 ast_sockaddr_stringify(&remote_address));
01751 ast_set_flag(rtp, FLAG_3389_WARNING);
01752 }
01753
01754
01755 if (!len)
01756 return NULL;
01757 if (len < 24) {
01758 rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
01759 rtp->f.datalen = len - 1;
01760 rtp->f.offset = AST_FRIENDLY_OFFSET;
01761 memcpy(rtp->f.data.ptr, data + 1, len - 1);
01762 } else {
01763 rtp->f.data.ptr = NULL;
01764 rtp->f.offset = 0;
01765 rtp->f.datalen = 0;
01766 }
01767 rtp->f.frametype = AST_FRAME_CNG;
01768 rtp->f.subclass.integer = data[0] & 0x7f;
01769 rtp->f.samples = 0;
01770 rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
01771
01772 return &rtp->f;
01773 }
01774
01775 static struct ast_frame *ast_rtcp_read(struct ast_rtp_instance *instance)
01776 {
01777 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
01778 struct ast_sockaddr addr;
01779 unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
01780 unsigned int *rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
01781 int res, packetwords, position = 0;
01782 struct ast_frame *f = &ast_null_frame;
01783
01784
01785 if ((res = rtcp_recvfrom(instance, rtcpdata + AST_FRIENDLY_OFFSET,
01786 sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
01787 0, &addr)) < 0) {
01788 ast_assert(errno != EBADF);
01789 if (errno != EAGAIN) {
01790 ast_log(LOG_WARNING, "RTCP Read error: %s. Hanging up.\n", strerror(errno));
01791 return NULL;
01792 }
01793 return &ast_null_frame;
01794 }
01795
01796 packetwords = res / 4;
01797
01798 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
01799
01800 if (ast_sockaddr_cmp(&rtp->rtcp->them, &addr)) {
01801 ast_sockaddr_copy(&rtp->rtcp->them, &addr);
01802 if (option_debug || rtpdebug)
01803 ast_debug(0, "RTCP NAT: Got RTCP from other end. Now sending to address %s\n",
01804 ast_sockaddr_stringify(&rtp->rtcp->them));
01805 }
01806 }
01807
01808 ast_debug(1, "Got RTCP report of %d bytes\n", res);
01809
01810 while (position < packetwords) {
01811 int i, pt, rc;
01812 unsigned int length, dlsr, lsr, msw, lsw, comp;
01813 struct timeval now;
01814 double rttsec, reported_jitter, reported_normdev_jitter_current, normdevrtt_current, reported_lost, reported_normdev_lost_current;
01815 uint64_t rtt = 0;
01816
01817 i = position;
01818 length = ntohl(rtcpheader[i]);
01819 pt = (length & 0xff0000) >> 16;
01820 rc = (length & 0x1f000000) >> 24;
01821 length &= 0xffff;
01822
01823 if ((i + length) > packetwords) {
01824 if (option_debug || rtpdebug)
01825 ast_log(LOG_DEBUG, "RTCP Read too short\n");
01826 return &ast_null_frame;
01827 }
01828
01829 if (rtcp_debug_test_addr(&addr)) {
01830 ast_verbose("\n\nGot RTCP from %s\n",
01831 ast_sockaddr_stringify(&addr));
01832 ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
01833 ast_verbose("Reception reports: %d\n", rc);
01834 ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
01835 }
01836
01837 i += 2;
01838 if (rc == 0 && pt == RTCP_PT_RR) {
01839 position += (length + 1);
01840 continue;
01841 }
01842
01843 switch (pt) {
01844 case RTCP_PT_SR:
01845 gettimeofday(&rtp->rtcp->rxlsr,NULL);
01846 rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
01847 rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
01848 rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16);
01849
01850 if (rtcp_debug_test_addr(&addr)) {
01851 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
01852 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
01853 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
01854 }
01855 i += 5;
01856 if (rc < 1)
01857 break;
01858
01859 case RTCP_PT_RR:
01860
01861
01862 gettimeofday(&now, NULL);
01863 timeval2ntp(now, &msw, &lsw);
01864 if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) {
01865 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
01866 lsr = ntohl(rtcpheader[i + 4]);
01867 dlsr = ntohl(rtcpheader[i + 5]);
01868 rtt = comp - lsr - dlsr;
01869
01870
01871
01872 if (rtt < 4294) {
01873 rtt = (rtt * 1000000) >> 16;
01874 } else {
01875 rtt = (rtt * 1000) >> 16;
01876 rtt *= 1000;
01877 }
01878 rtt = rtt / 1000.;
01879 rttsec = rtt / 1000.;
01880 rtp->rtcp->rtt = rttsec;
01881
01882 if (comp - dlsr >= lsr) {
01883 rtp->rtcp->accumulated_transit += rttsec;
01884
01885 if (rtp->rtcp->rtt_count == 0)
01886 rtp->rtcp->minrtt = rttsec;
01887
01888 if (rtp->rtcp->maxrtt<rttsec)
01889 rtp->rtcp->maxrtt = rttsec;
01890 if (rtp->rtcp->minrtt>rttsec)
01891 rtp->rtcp->minrtt = rttsec;
01892
01893 normdevrtt_current = normdev_compute(rtp->rtcp->normdevrtt, rttsec, rtp->rtcp->rtt_count);
01894
01895 rtp->rtcp->stdevrtt = stddev_compute(rtp->rtcp->stdevrtt, rttsec, rtp->rtcp->normdevrtt, normdevrtt_current, rtp->rtcp->rtt_count);
01896
01897 rtp->rtcp->normdevrtt = normdevrtt_current;
01898
01899 rtp->rtcp->rtt_count++;
01900 } else if (rtcp_debug_test_addr(&addr)) {
01901 ast_verbose("Internal RTCP NTP clock skew detected: "
01902 "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
01903 "diff=%d\n",
01904 lsr, comp, dlsr, dlsr / 65536,
01905 (dlsr % 65536) * 1000 / 65536,
01906 dlsr - (comp - lsr));
01907 }
01908 }
01909
01910 rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
01911 reported_jitter = (double) rtp->rtcp->reported_jitter;
01912
01913 if (rtp->rtcp->reported_jitter_count == 0)
01914 rtp->rtcp->reported_minjitter = reported_jitter;
01915
01916 if (reported_jitter < rtp->rtcp->reported_minjitter)
01917 rtp->rtcp->reported_minjitter = reported_jitter;
01918
01919 if (reported_jitter > rtp->rtcp->reported_maxjitter)
01920 rtp->rtcp->reported_maxjitter = reported_jitter;
01921
01922 reported_normdev_jitter_current = normdev_compute(rtp->rtcp->reported_normdev_jitter, reported_jitter, rtp->rtcp->reported_jitter_count);
01923
01924 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);
01925
01926 rtp->rtcp->reported_normdev_jitter = reported_normdev_jitter_current;
01927
01928 rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
01929
01930 reported_lost = (double) rtp->rtcp->reported_lost;
01931
01932
01933 if (rtp->rtcp->reported_jitter_count == 0)
01934 rtp->rtcp->reported_minlost = reported_lost;
01935
01936 if (reported_lost < rtp->rtcp->reported_minlost)
01937 rtp->rtcp->reported_minlost = reported_lost;
01938
01939 if (reported_lost > rtp->rtcp->reported_maxlost)
01940 rtp->rtcp->reported_maxlost = reported_lost;
01941 reported_normdev_lost_current = normdev_compute(rtp->rtcp->reported_normdev_lost, reported_lost, rtp->rtcp->reported_jitter_count);
01942
01943 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);
01944
01945 rtp->rtcp->reported_normdev_lost = reported_normdev_lost_current;
01946
01947 rtp->rtcp->reported_jitter_count++;
01948
01949 if (rtcp_debug_test_addr(&addr)) {
01950 ast_verbose(" Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
01951 ast_verbose(" Packets lost so far: %d\n", rtp->rtcp->reported_lost);
01952 ast_verbose(" Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
01953 ast_verbose(" Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2])) >> 16);
01954 ast_verbose(" Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
01955 ast_verbose(" Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
01956 ast_verbose(" DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
01957 if (rtt)
01958 ast_verbose(" RTT: %lu(sec)\n", (unsigned long) rtt);
01959 }
01960 if (rtt) {
01961 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From: %s\r\n"
01962 "PT: %d(%s)\r\n"
01963 "ReceptionReports: %d\r\n"
01964 "SenderSSRC: %u\r\n"
01965 "FractionLost: %ld\r\n"
01966 "PacketsLost: %d\r\n"
01967 "HighestSequence: %ld\r\n"
01968 "SequenceNumberCycles: %ld\r\n"
01969 "IAJitter: %u\r\n"
01970 "LastSR: %lu.%010lu\r\n"
01971 "DLSR: %4.4f(sec)\r\n"
01972 "RTT: %llu(sec)\r\n",
01973 ast_sockaddr_stringify(&addr),
01974 pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
01975 rc,
01976 rtcpheader[i + 1],
01977 (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
01978 rtp->rtcp->reported_lost,
01979 (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
01980 (long) (ntohl(rtcpheader[i + 2])) >> 16,
01981 rtp->rtcp->reported_jitter,
01982 (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
01983 ntohl(rtcpheader[i + 5])/65536.0,
01984 (unsigned long long)rtt);
01985 } else {
01986 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From: %s\r\n"
01987 "PT: %d(%s)\r\n"
01988 "ReceptionReports: %d\r\n"
01989 "SenderSSRC: %u\r\n"
01990 "FractionLost: %ld\r\n"
01991 "PacketsLost: %d\r\n"
01992 "HighestSequence: %ld\r\n"
01993 "SequenceNumberCycles: %ld\r\n"
01994 "IAJitter: %u\r\n"
01995 "LastSR: %lu.%010lu\r\n"
01996 "DLSR: %4.4f(sec)\r\n",
01997 ast_sockaddr_stringify(&addr),
01998 pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
01999 rc,
02000 rtcpheader[i + 1],
02001 (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
02002 rtp->rtcp->reported_lost,
02003 (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
02004 (long) (ntohl(rtcpheader[i + 2])) >> 16,
02005 rtp->rtcp->reported_jitter,
02006 (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
02007 ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
02008 ntohl(rtcpheader[i + 5])/65536.0);
02009 }
02010 break;
02011 case RTCP_PT_FUR:
02012 if (rtcp_debug_test_addr(&addr))
02013 ast_verbose("Received an RTCP Fast Update Request\n");
02014 rtp->f.frametype = AST_FRAME_CONTROL;
02015 rtp->f.subclass.integer = AST_CONTROL_VIDUPDATE;
02016 rtp->f.datalen = 0;
02017 rtp->f.samples = 0;
02018 rtp->f.mallocd = 0;
02019 rtp->f.src = "RTP";
02020 f = &rtp->f;
02021 break;
02022 case RTCP_PT_SDES:
02023 if (rtcp_debug_test_addr(&addr))
02024 ast_verbose("Received an SDES from %s\n",
02025 ast_sockaddr_stringify(&rtp->rtcp->them));
02026 break;
02027 case RTCP_PT_BYE:
02028 if (rtcp_debug_test_addr(&addr))
02029 ast_verbose("Received a BYE from %s\n",
02030 ast_sockaddr_stringify(&rtp->rtcp->them));
02031 break;
02032 default:
02033 ast_debug(1, "Unknown RTCP packet (pt=%d) received from %s\n",
02034 pt, ast_sockaddr_stringify(&rtp->rtcp->them));
02035 break;
02036 }
02037 position += (length + 1);
02038 }
02039
02040 rtp->rtcp->rtcp_info = 1;
02041
02042 return f;
02043 }
02044
02045 static int bridge_p2p_rtp_write(struct ast_rtp_instance *instance, unsigned int *rtpheader, int len, int hdrlen)
02046 {
02047 struct ast_rtp_instance *instance1 = ast_rtp_instance_get_bridged(instance);
02048 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance), *bridged = ast_rtp_instance_get_data(instance1);
02049 int res = 0, payload = 0, bridged_payload = 0, mark;
02050 struct ast_rtp_payload_type payload_type;
02051 int reconstruct = ntohl(rtpheader[0]);
02052 struct ast_sockaddr remote_address = { {0,} };
02053
02054
02055 payload = (reconstruct & 0x7f0000) >> 16;
02056 mark = (((reconstruct & 0x800000) >> 23) != 0);
02057
02058
02059 payload_type = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payload);
02060
02061
02062 bridged_payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance1), payload_type.asterisk_format, payload_type.code);
02063
02064
02065 if (bridged_payload < 0) {
02066 return -1;
02067 }
02068
02069
02070 if (!(ast_rtp_instance_get_codecs(instance1)->payloads[bridged_payload].code)) {
02071 return -1;
02072 }
02073
02074
02075 if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
02076 mark = 1;
02077 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
02078 }
02079
02080
02081 reconstruct &= 0xFF80FFFF;
02082 reconstruct |= (bridged_payload << 16);
02083 reconstruct |= (mark << 23);
02084 rtpheader[0] = htonl(reconstruct);
02085
02086 ast_rtp_instance_get_remote_address(instance1, &remote_address);
02087
02088 if (ast_sockaddr_isnull(&remote_address)) {
02089 ast_debug(1, "Remote address is null, most likely RTP has been stopped\n");
02090 return 0;
02091 }
02092
02093
02094 res = rtp_sendto(instance1, (void *)rtpheader, len, 0, &remote_address);
02095 if (res < 0) {
02096 if (!ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_NAT) || (ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_NAT) && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
02097 ast_log(LOG_WARNING,
02098 "RTP Transmission error of packet to %s: %s\n",
02099 ast_sockaddr_stringify(&remote_address),
02100 strerror(errno));
02101 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
02102 if (option_debug || rtpdebug)
02103 ast_log(LOG_WARNING,
02104 "RTP NAT: Can't write RTP to private "
02105 "address %s, waiting for other end to "
02106 "send audio...\n",
02107 ast_sockaddr_stringify(&remote_address));
02108 ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
02109 }
02110 return 0;
02111 } else if (rtp_debug_test_addr(&remote_address)) {
02112 ast_verbose("Sent RTP P2P packet to %s (type %-2.2d, len %-6.6u)\n",
02113 ast_sockaddr_stringify(&remote_address),
02114 bridged_payload, len - hdrlen);
02115 }
02116
02117 return 0;
02118 }
02119
02120 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp)
02121 {
02122 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02123 struct ast_sockaddr addr;
02124 int res, hdrlen = 12, version, payloadtype, padding, mark, ext, cc, prev_seqno;
02125 unsigned int *rtpheader = (unsigned int*)(rtp->rawdata + AST_FRIENDLY_OFFSET), seqno, ssrc, timestamp;
02126 struct ast_rtp_payload_type payload;
02127 struct ast_sockaddr remote_address = { {0,} };
02128 struct frame_list frames;
02129
02130
02131 if (rtcp) {
02132 if (rtp->rtcp) {
02133 return ast_rtcp_read(instance);
02134 }
02135 return &ast_null_frame;
02136 }
02137
02138
02139 if (rtp->sending_digit) {
02140 ast_rtp_dtmf_continuation(instance);
02141 }
02142
02143
02144 if ((res = rtp_recvfrom(instance, rtp->rawdata + AST_FRIENDLY_OFFSET,
02145 sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0,
02146 &addr)) < 0) {
02147 ast_assert(errno != EBADF);
02148 if (errno != EAGAIN) {
02149 ast_log(LOG_WARNING, "RTP Read error: %s. Hanging up.\n", strerror(errno));
02150 return NULL;
02151 }
02152 return &ast_null_frame;
02153 }
02154
02155
02156 if (res < hdrlen) {
02157 ast_log(LOG_WARNING, "RTP Read too short\n");
02158 return &ast_null_frame;
02159 }
02160
02161
02162 seqno = ntohl(rtpheader[0]);
02163
02164 ast_rtp_instance_get_remote_address(instance, &remote_address);
02165
02166 if (!(version = (seqno & 0xC0000000) >> 30)) {
02167 struct sockaddr_in addr_tmp;
02168 struct ast_sockaddr addr_v4;
02169 if (ast_sockaddr_is_ipv4(&addr)) {
02170 ast_sockaddr_to_sin(&addr, &addr_tmp);
02171 } else if (ast_sockaddr_ipv4_mapped(&addr, &addr_v4)) {
02172 ast_debug(1, "Using IPv6 mapped address %s for STUN\n",
02173 ast_sockaddr_stringify(&addr));
02174 ast_sockaddr_to_sin(&addr_v4, &addr_tmp);
02175 } else {
02176 ast_debug(1, "Cannot do STUN for non IPv4 address %s\n",
02177 ast_sockaddr_stringify(&addr));
02178 return &ast_null_frame;
02179 }
02180 if ((ast_stun_handle_packet(rtp->s, &addr_tmp, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == AST_STUN_ACCEPT) &&
02181 ast_sockaddr_isnull(&remote_address)) {
02182 ast_sockaddr_from_sin(&addr, &addr_tmp);
02183 ast_rtp_instance_set_remote_address(instance, &addr);
02184 }
02185 return &ast_null_frame;
02186 }
02187
02188
02189 if (rtp->strict_rtp_state == STRICT_RTP_LEARN) {
02190 ast_debug(1, "%p -- start learning mode pass with addr = %s\n", rtp, ast_sockaddr_stringify(&addr));
02191
02192 ast_sockaddr_copy(&rtp->strict_rtp_address, &addr);
02193
02194
02195 if (rtp_learning_rtp_seq_update(rtp, ntohl(rtpheader[0]))) {
02196 ast_debug(1, "%p -- Condition for learning hasn't exited, so reject the frame.\n", rtp);
02197 return &ast_null_frame;
02198 }
02199
02200 ast_debug(1, "%p -- Probation Ended. Set strict_rtp_state to STRICT_RTP_CLOSED with address %s\n", rtp, ast_sockaddr_stringify(&addr));
02201 rtp->strict_rtp_state = STRICT_RTP_CLOSED;
02202 } else if (rtp->strict_rtp_state == STRICT_RTP_CLOSED) {
02203 if (ast_sockaddr_cmp(&rtp->strict_rtp_address, &addr)) {
02204
02205 if (!ast_sockaddr_cmp(&rtp->alt_rtp_address, &addr)) {
02206
02207 ast_sockaddr_copy(&rtp->strict_rtp_address,
02208 &addr);
02209 } else {
02210 const char *real_addr = ast_strdupa(ast_sockaddr_stringify(&addr));
02211 const char *expected_addr = ast_strdupa(ast_sockaddr_stringify(&rtp->strict_rtp_address));
02212
02213 ast_debug(1, "Received RTP packet from %s, dropping due to strict RTP protection. Expected it to be from %s\n",
02214 real_addr, expected_addr);
02215
02216 return &ast_null_frame;
02217 }
02218 }
02219 }
02220
02221
02222 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
02223 if (ast_sockaddr_cmp(&remote_address, &addr)) {
02224 ast_rtp_instance_set_remote_address(instance, &addr);
02225 ast_sockaddr_copy(&remote_address, &addr);
02226 if (rtp->rtcp) {
02227 ast_sockaddr_copy(&rtp->rtcp->them, &addr);
02228 ast_sockaddr_set_port(&rtp->rtcp->them, ast_sockaddr_port(&addr) + 1);
02229 }
02230 rtp->rxseqno = 0;
02231 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
02232 if (option_debug || rtpdebug)
02233 ast_debug(0, "RTP NAT: Got audio from other end. Now sending to address %s\n",
02234 ast_sockaddr_stringify(&remote_address));
02235 }
02236 }
02237
02238
02239 if (ast_rtp_instance_get_bridged(instance) && !bridge_p2p_rtp_write(instance, rtpheader, res, hdrlen)) {
02240 return &ast_null_frame;
02241 }
02242
02243
02244 if (version != 2) {
02245 return &ast_null_frame;
02246 }
02247
02248
02249 payloadtype = (seqno & 0x7f0000) >> 16;
02250 padding = seqno & (1 << 29);
02251 mark = seqno & (1 << 23);
02252 ext = seqno & (1 << 28);
02253 cc = (seqno & 0xF000000) >> 24;
02254 seqno &= 0xffff;
02255 timestamp = ntohl(rtpheader[1]);
02256 ssrc = ntohl(rtpheader[2]);
02257
02258 AST_LIST_HEAD_INIT_NOLOCK(&frames);
02259
02260 if (rtp->rxssrc && rtp->rxssrc != ssrc) {
02261 struct ast_frame *f, srcupdate = {
02262 AST_FRAME_CONTROL,
02263 .subclass.integer = AST_CONTROL_SRCCHANGE,
02264 };
02265
02266 if (!mark) {
02267 if (option_debug || rtpdebug) {
02268 ast_debug(1, "Forcing Marker bit, because SSRC has changed\n");
02269 }
02270 mark = 1;
02271 }
02272
02273 f = ast_frisolate(&srcupdate);
02274 AST_LIST_INSERT_TAIL(&frames, f, frame_list);
02275
02276 rtp->last_seqno = 0;
02277 rtp->last_end_timestamp = 0;
02278 }
02279
02280 rtp->rxssrc = ssrc;
02281
02282
02283 if (padding) {
02284 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
02285 }
02286
02287
02288 if (cc) {
02289 hdrlen += cc * 4;
02290 }
02291
02292
02293 if (ext) {
02294 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
02295 hdrlen += 4;
02296 if (option_debug) {
02297 int profile;
02298 profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
02299 if (profile == 0x505a)
02300 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
02301 else
02302 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
02303 }
02304 }
02305
02306
02307 if (res < hdrlen) {
02308 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d\n", res, hdrlen);
02309 return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
02310 }
02311
02312 rtp->rxcount++;
02313 if (rtp->rxcount == 1) {
02314 rtp->seedrxseqno = seqno;
02315 }
02316
02317
02318 if (rtp->rtcp && !ast_sockaddr_isnull(&rtp->rtcp->them) && rtp->rtcp->schedid < 1) {
02319
02320 ao2_ref(instance, +1);
02321 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, instance);
02322 if (rtp->rtcp->schedid < 0) {
02323 ao2_ref(instance, -1);
02324 ast_log(LOG_WARNING, "scheduling RTCP transmission failed.\n");
02325 }
02326 }
02327 if ((int)rtp->lastrxseqno - (int)seqno > 100)
02328 rtp->cycles += RTP_SEQ_MOD;
02329
02330 prev_seqno = rtp->lastrxseqno;
02331 rtp->lastrxseqno = seqno;
02332
02333 if (!rtp->themssrc) {
02334 rtp->themssrc = ntohl(rtpheader[2]);
02335 }
02336
02337 if (rtp_debug_test_addr(&addr)) {
02338 ast_verbose("Got RTP packet from %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
02339 ast_sockaddr_stringify(&addr),
02340 payloadtype, seqno, timestamp,res - hdrlen);
02341 }
02342
02343 payload = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payloadtype);
02344
02345
02346 if (!payload.asterisk_format) {
02347 struct ast_frame *f = NULL;
02348 if (payload.code == AST_RTP_DTMF) {
02349
02350
02351
02352
02353 process_dtmf_rfc2833(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark, &frames);
02354 } else if (payload.code == AST_RTP_CISCO_DTMF) {
02355 f = process_dtmf_cisco(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark);
02356 } else if (payload.code == AST_RTP_CN) {
02357 f = process_cn_rfc3389(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark);
02358 } else {
02359 ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n",
02360 payloadtype,
02361 ast_sockaddr_stringify(&remote_address));
02362 }
02363
02364 if (f) {
02365 AST_LIST_INSERT_TAIL(&frames, f, frame_list);
02366 }
02367
02368
02369
02370 if (!AST_LIST_EMPTY(&frames)) {
02371 return AST_LIST_FIRST(&frames);
02372 }
02373 return &ast_null_frame;
02374 }
02375
02376 rtp->lastrxformat = rtp->f.subclass.codec = payload.code;
02377 rtp->f.frametype = (rtp->f.subclass.codec & AST_FORMAT_AUDIO_MASK) ? AST_FRAME_VOICE : (rtp->f.subclass.codec & AST_FORMAT_VIDEO_MASK) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
02378
02379 rtp->rxseqno = seqno;
02380
02381 if (rtp->dtmf_timeout && rtp->dtmf_timeout < timestamp) {
02382 rtp->dtmf_timeout = 0;
02383
02384 if (rtp->resp) {
02385 struct ast_frame *f;
02386 f = create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0);
02387 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
02388 rtp->resp = 0;
02389 rtp->dtmf_timeout = rtp->dtmf_duration = 0;
02390 AST_LIST_INSERT_TAIL(&frames, f, frame_list);
02391 return AST_LIST_FIRST(&frames);
02392 }
02393 }
02394
02395 rtp->lastrxts = timestamp;
02396
02397 rtp->f.src = "RTP";
02398 rtp->f.mallocd = 0;
02399 rtp->f.datalen = res - hdrlen;
02400 rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
02401 rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
02402 rtp->f.seqno = seqno;
02403
02404 if (rtp->f.subclass.codec == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
02405 unsigned char *data = rtp->f.data.ptr;
02406
02407 memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
02408 rtp->f.datalen +=3;
02409 *data++ = 0xEF;
02410 *data++ = 0xBF;
02411 *data = 0xBD;
02412 }
02413
02414 if (rtp->f.subclass.codec == AST_FORMAT_T140RED) {
02415 unsigned char *data = rtp->f.data.ptr;
02416 unsigned char *header_end;
02417 int num_generations;
02418 int header_length;
02419 int len;
02420 int diff =(int)seqno - (prev_seqno+1);
02421 int x;
02422
02423 rtp->f.subclass.codec = AST_FORMAT_T140;
02424 header_end = memchr(data, ((*data) & 0x7f), rtp->f.datalen);
02425 if (header_end == NULL) {
02426 return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
02427 }
02428 header_end++;
02429
02430 header_length = header_end - data;
02431 num_generations = header_length / 4;
02432 len = header_length;
02433
02434 if (!diff) {
02435 for (x = 0; x < num_generations; x++)
02436 len += data[x * 4 + 3];
02437
02438 if (!(rtp->f.datalen - len))
02439 return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
02440
02441 rtp->f.data.ptr += len;
02442 rtp->f.datalen -= len;
02443 } else if (diff > num_generations && diff < 10) {
02444 len -= 3;
02445 rtp->f.data.ptr += len;
02446 rtp->f.datalen -= len;
02447
02448 data = rtp->f.data.ptr;
02449 *data++ = 0xEF;
02450 *data++ = 0xBF;
02451 *data = 0xBD;
02452 } else {
02453 for ( x = 0; x < num_generations - diff; x++)
02454 len += data[x * 4 + 3];
02455
02456 rtp->f.data.ptr += len;
02457 rtp->f.datalen -= len;
02458 }
02459 }
02460
02461 if (rtp->f.subclass.codec & AST_FORMAT_AUDIO_MASK) {
02462 rtp->f.samples = ast_codec_get_samples(&rtp->f);
02463 if ((rtp->f.subclass.codec == AST_FORMAT_SLINEAR) || (rtp->f.subclass.codec == AST_FORMAT_SLINEAR16)) {
02464 ast_frame_byteswap_be(&rtp->f);
02465 }
02466 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
02467
02468 ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
02469 rtp->f.ts = timestamp / (rtp_get_rate(rtp->f.subclass.codec) / 1000);
02470 rtp->f.len = rtp->f.samples / ((ast_format_rate(rtp->f.subclass.codec) / 1000));
02471 } else if (rtp->f.subclass.codec & AST_FORMAT_VIDEO_MASK) {
02472
02473 if (!rtp->lastividtimestamp)
02474 rtp->lastividtimestamp = timestamp;
02475 rtp->f.samples = timestamp - rtp->lastividtimestamp;
02476 rtp->lastividtimestamp = timestamp;
02477 rtp->f.delivery.tv_sec = 0;
02478 rtp->f.delivery.tv_usec = 0;
02479
02480
02481
02482
02483
02484 if (mark)
02485 rtp->f.subclass.codec |= 0x1;
02486 } else {
02487
02488 if (!rtp->lastitexttimestamp)
02489 rtp->lastitexttimestamp = timestamp;
02490 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
02491 rtp->lastitexttimestamp = timestamp;
02492 rtp->f.delivery.tv_sec = 0;
02493 rtp->f.delivery.tv_usec = 0;
02494 }
02495
02496 AST_LIST_INSERT_TAIL(&frames, &rtp->f, frame_list);
02497 return AST_LIST_FIRST(&frames);
02498 }
02499
02500 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
02501 {
02502 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02503
02504 if (property == AST_RTP_PROPERTY_RTCP) {
02505 if (value) {
02506 if (rtp->rtcp) {
02507 ast_debug(1, "Ignoring duplicate RTCP property on RTP instance '%p'\n", instance);
02508 return;
02509 }
02510
02511 if (!(rtp->rtcp = ast_calloc(1, sizeof(*rtp->rtcp)))) {
02512 return;
02513 }
02514
02515
02516 ast_rtp_instance_get_local_address(instance, &rtp->rtcp->us);
02517 ast_sockaddr_set_port(&rtp->rtcp->us,
02518 ast_sockaddr_port(&rtp->rtcp->us) + 1);
02519
02520 if ((rtp->rtcp->s =
02521 create_new_socket("RTCP",
02522 ast_sockaddr_is_ipv4(&rtp->rtcp->us) ?
02523 AF_INET :
02524 ast_sockaddr_is_ipv6(&rtp->rtcp->us) ?
02525 AF_INET6 : -1)) < 0) {
02526 ast_debug(1, "Failed to create a new socket for RTCP on instance '%p'\n", instance);
02527 ast_free(rtp->rtcp);
02528 rtp->rtcp = NULL;
02529 return;
02530 }
02531
02532
02533 if (ast_bind(rtp->rtcp->s, &rtp->rtcp->us)) {
02534 ast_debug(1, "Failed to setup RTCP on RTP instance '%p'\n", instance);
02535 close(rtp->rtcp->s);
02536 ast_free(rtp->rtcp);
02537 rtp->rtcp = NULL;
02538 return;
02539 }
02540
02541 ast_debug(1, "Setup RTCP on RTP instance '%p'\n", instance);
02542 rtp->rtcp->schedid = -1;
02543
02544 return;
02545 } else {
02546 if (rtp->rtcp) {
02547 if (rtp->rtcp->schedid > 0) {
02548 if (!ast_sched_del(rtp->sched, rtp->rtcp->schedid)) {
02549
02550 ao2_ref(instance, -1);
02551 } else {
02552
02553 ast_debug(1, "Failed to tear down RTCP on RTP instance '%p'\n", instance);
02554 return;
02555 }
02556 rtp->rtcp->schedid = -1;
02557 }
02558 close(rtp->rtcp->s);
02559 ast_free(rtp->rtcp);
02560 rtp->rtcp = NULL;
02561 }
02562 return;
02563 }
02564 }
02565
02566 return;
02567 }
02568
02569 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp)
02570 {
02571 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02572
02573 return rtcp ? (rtp->rtcp ? rtp->rtcp->s : -1) : rtp->s;
02574 }
02575
02576 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr)
02577 {
02578 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02579
02580 if (rtp->rtcp) {
02581 ast_debug(1, "Setting RTCP address on RTP instance '%p'\n", instance);
02582 ast_sockaddr_copy(&rtp->rtcp->them, addr);
02583 if (!ast_sockaddr_isnull(addr)) {
02584 ast_sockaddr_set_port(&rtp->rtcp->them,
02585 ast_sockaddr_port(addr) + 1);
02586 }
02587 }
02588
02589 rtp->rxseqno = 0;
02590
02591 if (strictrtp) {
02592 rtp->strict_rtp_state = STRICT_RTP_LEARN;
02593 rtp_learning_seq_init(rtp, rtp->seqno);
02594 }
02595
02596 return;
02597 }
02598
02599 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr)
02600 {
02601 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02602
02603
02604
02605
02606 ast_sockaddr_copy(&rtp->alt_rtp_address, addr);
02607
02608 return;
02609 }
02610
02611
02612
02613
02614 static int red_write(const void *data)
02615 {
02616 struct ast_rtp_instance *instance = (struct ast_rtp_instance*) data;
02617 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02618
02619 ast_rtp_write(instance, &rtp->red->t140);
02620
02621 return 1;
02622 }
02623
02624 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
02625 {
02626 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02627 int x;
02628
02629 if (!(rtp->red = ast_calloc(1, sizeof(*rtp->red)))) {
02630 return -1;
02631 }
02632
02633 rtp->red->t140.frametype = AST_FRAME_TEXT;
02634 rtp->red->t140.subclass.codec = AST_FORMAT_T140RED;
02635 rtp->red->t140.data.ptr = &rtp->red->buf_data;
02636
02637 rtp->red->t140.ts = 0;
02638 rtp->red->t140red = rtp->red->t140;
02639 rtp->red->t140red.data.ptr = &rtp->red->t140red_data;
02640 rtp->red->t140red.datalen = 0;
02641 rtp->red->ti = buffer_time;
02642 rtp->red->num_gen = generations;
02643 rtp->red->hdrlen = generations * 4 + 1;
02644 rtp->red->prev_ts = 0;
02645
02646 for (x = 0; x < generations; x++) {
02647 rtp->red->pt[x] = payloads[x];
02648 rtp->red->pt[x] |= 1 << 7;
02649 rtp->red->t140red_data[x*4] = rtp->red->pt[x];
02650 }
02651 rtp->red->t140red_data[x*4] = rtp->red->pt[x] = payloads[x];
02652 rtp->red->schedid = ast_sched_add(rtp->sched, generations, red_write, instance);
02653
02654 rtp->red->t140.datalen = 0;
02655
02656 return 0;
02657 }
02658
02659 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
02660 {
02661 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02662
02663 if (frame->datalen > -1) {
02664 struct rtp_red *red = rtp->red;
02665 memcpy(&red->buf_data[red->t140.datalen], frame->data.ptr, frame->datalen);
02666 red->t140.datalen += frame->datalen;
02667 red->t140.ts = frame->ts;
02668 }
02669
02670 return 0;
02671 }
02672
02673 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1)
02674 {
02675 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance0);
02676
02677 ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
02678
02679 return 0;
02680 }
02681
02682 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
02683 {
02684 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02685
02686 if (!rtp->rtcp) {
02687 return -1;
02688 }
02689
02690 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXCOUNT, -1, stats->txcount, rtp->txcount);
02691 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXCOUNT, -1, stats->rxcount, rtp->rxcount);
02692
02693 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->txploss, rtp->rtcp->reported_lost);
02694 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->rxploss, rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
02695 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_maxrxploss, rtp->rtcp->reported_maxlost);
02696 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_minrxploss, rtp->rtcp->reported_minlost);
02697 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_normdevrxploss, rtp->rtcp->reported_normdev_lost);
02698 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_stdevrxploss, rtp->rtcp->reported_stdev_lost);
02699 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_maxrxploss, rtp->rtcp->maxrxlost);
02700 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_minrxploss, rtp->rtcp->minrxlost);
02701 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_normdevrxploss, rtp->rtcp->normdev_rxlost);
02702 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_stdevrxploss, rtp->rtcp->stdev_rxlost);
02703 AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_LOSS);
02704
02705 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->txjitter, rtp->rxjitter);
02706 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->rxjitter, rtp->rtcp->reported_jitter / (unsigned int) 65536.0);
02707 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_maxjitter, rtp->rtcp->reported_maxjitter);
02708 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_minjitter, rtp->rtcp->reported_minjitter);
02709 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_normdevjitter, rtp->rtcp->reported_normdev_jitter);
02710 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_stdevjitter, rtp->rtcp->reported_stdev_jitter);
02711 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_maxjitter, rtp->rtcp->maxrxjitter);
02712 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_minjitter, rtp->rtcp->minrxjitter);
02713 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_normdevjitter, rtp->rtcp->normdev_rxjitter);
02714 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_stdevjitter, rtp->rtcp->stdev_rxjitter);
02715 AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_JITTER);
02716
02717 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->rtt, rtp->rtcp->rtt);
02718 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MAX_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->maxrtt, rtp->rtcp->maxrtt);
02719 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MIN_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->minrtt, rtp->rtcp->minrtt);
02720 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_NORMDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->normdevrtt, rtp->rtcp->normdevrtt);
02721 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_STDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->stdevrtt, rtp->rtcp->stdevrtt);
02722 AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_RTT);
02723
02724 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_SSRC, -1, stats->local_ssrc, rtp->ssrc);
02725 AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_SSRC, -1, stats->remote_ssrc, rtp->themssrc);
02726
02727 return 0;
02728 }
02729
02730 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1)
02731 {
02732
02733
02734
02735
02736
02737
02738
02739
02740
02741
02742 return (((ast_rtp_instance_get_prop(instance0, AST_RTP_PROPERTY_DTMF) != ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_DTMF)) ||
02743 (!chan0->tech->send_digit_begin != !chan1->tech->send_digit_begin)) ? 0 : 1);
02744 }
02745
02746 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username)
02747 {
02748 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02749 struct sockaddr_in suggestion_tmp;
02750
02751 ast_sockaddr_to_sin(suggestion, &suggestion_tmp);
02752 ast_stun_request(rtp->s, &suggestion_tmp, username, NULL);
02753 ast_sockaddr_from_sin(suggestion, &suggestion_tmp);
02754 }
02755
02756 static void ast_rtp_stop(struct ast_rtp_instance *instance)
02757 {
02758 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02759 struct ast_sockaddr addr = { {0,} };
02760
02761 if (rtp->rtcp && rtp->rtcp->schedid > 0) {
02762 if (!ast_sched_del(rtp->sched, rtp->rtcp->schedid)) {
02763
02764 ao2_ref(instance, -1);
02765 }
02766 rtp->rtcp->schedid = -1;
02767 }
02768
02769 if (rtp->red) {
02770 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
02771 free(rtp->red);
02772 rtp->red = NULL;
02773 }
02774
02775 ast_rtp_instance_set_remote_address(instance, &addr);
02776 if (rtp->rtcp) {
02777 ast_sockaddr_setnull(&rtp->rtcp->them);
02778 }
02779
02780 ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
02781 }
02782
02783 static int ast_rtp_qos_set(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
02784 {
02785 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02786
02787 return ast_set_qos(rtp->s, tos, cos, desc);
02788 }
02789
02790
02791 static int ast_rtp_sendcng(struct ast_rtp_instance *instance, int level)
02792 {
02793 unsigned int *rtpheader;
02794 int hdrlen = 12;
02795 int res;
02796 struct ast_rtp_payload_type payload;
02797 char data[256];
02798 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
02799 struct ast_sockaddr remote_address = { {0,} };
02800
02801 ast_rtp_instance_get_remote_address(instance, &remote_address);
02802
02803 if (ast_sockaddr_isnull(&remote_address)) {
02804 return -1;
02805 }
02806
02807 payload = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), AST_RTP_CN);
02808
02809 level = 127 - (level & 0x7f);
02810
02811 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
02812
02813
02814 rtpheader = (unsigned int *)data;
02815 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload.code << 16) | (rtp->seqno++));
02816 rtpheader[1] = htonl(rtp->lastts);
02817 rtpheader[2] = htonl(rtp->ssrc);
02818 data[12] = level;
02819
02820 res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 1, 0, &remote_address);
02821
02822 if (res < 0) {
02823 ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s: %s\n", ast_sockaddr_stringify(&remote_address), strerror(errno));
02824 } else if (rtp_debug_test_addr(&remote_address)) {
02825 ast_verbose("Sent Comfort Noise RTP packet to %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
02826 ast_sockaddr_stringify(&remote_address),
02827 AST_RTP_CN, rtp->seqno, rtp->lastdigitts, res - hdrlen);
02828 }
02829
02830 return res;
02831 }
02832
02833 static char *rtp_do_debug_ip(struct ast_cli_args *a)
02834 {
02835 char *arg = ast_strdupa(a->argv[4]);
02836 char *debughost = NULL;
02837 char *debugport = NULL;
02838
02839 if (!ast_sockaddr_parse(&rtpdebugaddr, arg, 0) || !ast_sockaddr_split_hostport(arg, &debughost, &debugport, 0)) {
02840 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
02841 return CLI_FAILURE;
02842 }
02843 rtpdebugport = (!ast_strlen_zero(debugport) && debugport[0] != '0');
02844 ast_cli(a->fd, "RTP Debugging Enabled for address: %s\n",
02845 ast_sockaddr_stringify(&rtpdebugaddr));
02846 rtpdebug = 1;
02847 return CLI_SUCCESS;
02848 }
02849
02850 static char *rtcp_do_debug_ip(struct ast_cli_args *a)
02851 {
02852 char *arg = ast_strdupa(a->argv[4]);
02853 char *debughost = NULL;
02854 char *debugport = NULL;
02855
02856 if (!ast_sockaddr_parse(&rtcpdebugaddr, arg, 0) || !ast_sockaddr_split_hostport(arg, &debughost, &debugport, 0)) {
02857 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
02858 return CLI_FAILURE;
02859 }
02860 rtcpdebugport = (!ast_strlen_zero(debugport) && debugport[0] != '0');
02861 ast_cli(a->fd, "RTCP Debugging Enabled for address: %s\n",
02862 ast_sockaddr_stringify(&rtcpdebugaddr));
02863 rtcpdebug = 1;
02864 return CLI_SUCCESS;
02865 }
02866
02867 static char *handle_cli_rtp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
02868 {
02869 switch (cmd) {
02870 case CLI_INIT:
02871 e->command = "rtp set debug {on|off|ip}";
02872 e->usage =
02873 "Usage: rtp set debug {on|off|ip host[:port]}\n"
02874 " Enable/Disable dumping of all RTP packets. If 'ip' is\n"
02875 " specified, limit the dumped packets to those to and from\n"
02876 " the specified 'host' with optional port.\n";
02877 return NULL;
02878 case CLI_GENERATE:
02879 return NULL;
02880 }
02881
02882 if (a->argc == e->args) {
02883 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
02884 rtpdebug = 1;
02885 memset(&rtpdebugaddr, 0, sizeof(rtpdebugaddr));
02886 ast_cli(a->fd, "RTP Debugging Enabled\n");
02887 return CLI_SUCCESS;
02888 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
02889 rtpdebug = 0;
02890 ast_cli(a->fd, "RTP Debugging Disabled\n");
02891 return CLI_SUCCESS;
02892 }
02893 } else if (a->argc == e->args +1) {
02894 return rtp_do_debug_ip(a);
02895 }
02896
02897 return CLI_SHOWUSAGE;
02898 }
02899
02900 static char *handle_cli_rtcp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
02901 {
02902 switch (cmd) {
02903 case CLI_INIT:
02904 e->command = "rtcp set debug {on|off|ip}";
02905 e->usage =
02906 "Usage: rtcp set debug {on|off|ip host[:port]}\n"
02907 " Enable/Disable dumping of all RTCP packets. If 'ip' is\n"
02908 " specified, limit the dumped packets to those to and from\n"
02909 " the specified 'host' with optional port.\n";
02910 return NULL;
02911 case CLI_GENERATE:
02912 return NULL;
02913 }
02914
02915 if (a->argc == e->args) {
02916 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
02917 rtcpdebug = 1;
02918 memset(&rtcpdebugaddr, 0, sizeof(rtcpdebugaddr));
02919 ast_cli(a->fd, "RTCP Debugging Enabled\n");
02920 return CLI_SUCCESS;
02921 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
02922 rtcpdebug = 0;
02923 ast_cli(a->fd, "RTCP Debugging Disabled\n");
02924 return CLI_SUCCESS;
02925 }
02926 } else if (a->argc == e->args +1) {
02927 return rtcp_do_debug_ip(a);
02928 }
02929
02930 return CLI_SHOWUSAGE;
02931 }
02932
02933 static char *handle_cli_rtcp_set_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
02934 {
02935 switch (cmd) {
02936 case CLI_INIT:
02937 e->command = "rtcp set stats {on|off}";
02938 e->usage =
02939 "Usage: rtcp set stats {on|off}\n"
02940 " Enable/Disable dumping of RTCP stats.\n";
02941 return NULL;
02942 case CLI_GENERATE:
02943 return NULL;
02944 }
02945
02946 if (a->argc != e->args)
02947 return CLI_SHOWUSAGE;
02948
02949 if (!strncasecmp(a->argv[e->args-1], "on", 2))
02950 rtcpstats = 1;
02951 else if (!strncasecmp(a->argv[e->args-1], "off", 3))
02952 rtcpstats = 0;
02953 else
02954 return CLI_SHOWUSAGE;
02955
02956 ast_cli(a->fd, "RTCP Stats %s\n", rtcpstats ? "Enabled" : "Disabled");
02957 return CLI_SUCCESS;
02958 }
02959
02960 static struct ast_cli_entry cli_rtp[] = {
02961 AST_CLI_DEFINE(handle_cli_rtp_set_debug, "Enable/Disable RTP debugging"),
02962 AST_CLI_DEFINE(handle_cli_rtcp_set_debug, "Enable/Disable RTCP debugging"),
02963 AST_CLI_DEFINE(handle_cli_rtcp_set_stats, "Enable/Disable RTCP stats"),
02964 };
02965
02966 static int rtp_reload(int reload)
02967 {
02968 struct ast_config *cfg;
02969 const char *s;
02970 struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
02971
02972 cfg = ast_config_load2("rtp.conf", "rtp", config_flags);
02973 if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
02974 return 0;
02975 }
02976
02977 rtpstart = DEFAULT_RTP_START;
02978 rtpend = DEFAULT_RTP_END;
02979 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
02980 strictrtp = STRICT_RTP_OPEN;
02981 learning_min_sequential = DEFAULT_LEARNING_MIN_SEQUENTIAL;
02982 if (cfg) {
02983 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
02984 rtpstart = atoi(s);
02985 if (rtpstart < MINIMUM_RTP_PORT)
02986 rtpstart = MINIMUM_RTP_PORT;
02987 if (rtpstart > MAXIMUM_RTP_PORT)
02988 rtpstart = MAXIMUM_RTP_PORT;
02989 }
02990 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
02991 rtpend = atoi(s);
02992 if (rtpend < MINIMUM_RTP_PORT)
02993 rtpend = MINIMUM_RTP_PORT;
02994 if (rtpend > MAXIMUM_RTP_PORT)
02995 rtpend = MAXIMUM_RTP_PORT;
02996 }
02997 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
02998 rtcpinterval = atoi(s);
02999 if (rtcpinterval == 0)
03000 rtcpinterval = 0;
03001 if (rtcpinterval < RTCP_MIN_INTERVALMS)
03002 rtcpinterval = RTCP_MIN_INTERVALMS;
03003 if (rtcpinterval > RTCP_MAX_INTERVALMS)
03004 rtcpinterval = RTCP_MAX_INTERVALMS;
03005 }
03006 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
03007 #ifdef SO_NO_CHECK
03008 nochecksums = ast_false(s) ? 1 : 0;
03009 #else
03010 if (ast_false(s))
03011 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
03012 #endif
03013 }
03014 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
03015 dtmftimeout = atoi(s);
03016 if ((dtmftimeout < 0) || (dtmftimeout > 64000)) {
03017 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
03018 dtmftimeout, DEFAULT_DTMF_TIMEOUT);
03019 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
03020 };
03021 }
03022 if ((s = ast_variable_retrieve(cfg, "general", "strictrtp"))) {
03023 strictrtp = ast_true(s);
03024 }
03025 if ((s = ast_variable_retrieve(cfg, "general", "probation"))) {
03026 if ((sscanf(s, "%d", &learning_min_sequential) <= 0) || learning_min_sequential <= 0) {
03027 ast_log(LOG_WARNING, "Value for 'probation' could not be read, using default of '%d' instead\n",
03028 DEFAULT_LEARNING_MIN_SEQUENTIAL);
03029 }
03030 }
03031 ast_config_destroy(cfg);
03032 }
03033 if (rtpstart >= rtpend) {
03034 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
03035 rtpstart = DEFAULT_RTP_START;
03036 rtpend = DEFAULT_RTP_END;
03037 }
03038 ast_verb(2, "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
03039 return 0;
03040 }
03041
03042 static int reload_module(void)
03043 {
03044 rtp_reload(1);
03045 return 0;
03046 }
03047
03048 static int load_module(void)
03049 {
03050 if (ast_rtp_engine_register(&asterisk_rtp_engine)) {
03051 return AST_MODULE_LOAD_DECLINE;
03052 }
03053
03054 if (ast_cli_register_multiple(cli_rtp, ARRAY_LEN(cli_rtp))) {
03055 ast_rtp_engine_unregister(&asterisk_rtp_engine);
03056 return AST_MODULE_LOAD_DECLINE;
03057 }
03058
03059 rtp_reload(0);
03060
03061 return AST_MODULE_LOAD_SUCCESS;
03062 }
03063
03064 static int unload_module(void)
03065 {
03066 ast_rtp_engine_unregister(&asterisk_rtp_engine);
03067 ast_cli_unregister_multiple(cli_rtp, ARRAY_LEN(cli_rtp));
03068
03069 return 0;
03070 }
03071
03072 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Asterisk RTP Stack",
03073 .load = load_module,
03074 .unload = unload_module,
03075 .reload = reload_module,
03076 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
03077 );