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