39#include <arpa/nameser.h>
50#include <openssl/opensslconf.h>
51#include <openssl/opensslv.h>
52#if !defined(OPENSSL_NO_SRTP) && (OPENSSL_VERSION_NUMBER >= 0x10001000L)
53#include <openssl/ssl.h>
54#include <openssl/err.h>
55#include <openssl/bio.h>
56#if !defined(OPENSSL_NO_ECDH) && (OPENSSL_VERSION_NUMBER >= 0x10000000L)
57#include <openssl/bn.h>
60#include <openssl/dh.h>
67#include <pjlib-util.h>
98#define MAX_TIMESTAMP_SKEW 640
100#define RTP_SEQ_MOD (1<<16)
101#define RTCP_DEFAULT_INTERVALMS 5000
102#define RTCP_MIN_INTERVALMS 500
103#define RTCP_MAX_INTERVALMS 60000
105#define DEFAULT_RTP_START 5000
106#define DEFAULT_RTP_END 31000
108#define MINIMUM_RTP_PORT 1024
109#define MAXIMUM_RTP_PORT 65535
111#define DEFAULT_TURN_PORT 3478
113#define TURN_STATE_WAIT_TIME 2000
115#define DEFAULT_RTP_SEND_BUFFER_SIZE 250
116#define MAXIMUM_RTP_SEND_BUFFER_SIZE (DEFAULT_RTP_SEND_BUFFER_SIZE + 200)
117#define DEFAULT_RTP_RECV_BUFFER_SIZE 20
118#define MAXIMUM_RTP_RECV_BUFFER_SIZE (DEFAULT_RTP_RECV_BUFFER_SIZE + 20)
119#define OLD_PACKET_COUNT 1000
120#define MISSING_SEQNOS_ADDED_TRIGGER 2
122#define SEQNO_CYCLE_OVER 65536
125#define RTCP_PT_FUR 192
127#define RTCP_PT_SR AST_RTP_RTCP_SR
129#define RTCP_PT_RR AST_RTP_RTCP_RR
131#define RTCP_PT_SDES 202
133#define RTCP_PT_BYE 203
135#define RTCP_PT_APP 204
138#define RTCP_PT_PSFB AST_RTP_RTCP_PSFB
141#define DTMF_SAMPLE_RATE_MS 8
143#define DEFAULT_DTMF_TIMEOUT (150 * (8000 / 1000))
145#define ZFONE_PROFILE_ID 0x505a
147#define DEFAULT_LEARNING_MIN_SEQUENTIAL 4
160#define CALC_LEARNING_MIN_DURATION(count) (((count) - 1) * 9 - 5)
161#define DEFAULT_LEARNING_MIN_DURATION CALC_LEARNING_MIN_DURATION(DEFAULT_LEARNING_MIN_SEQUENTIAL)
163#define SRTP_MASTER_KEY_LEN 16
164#define SRTP_MASTER_SALT_LEN 14
165#define SRTP_MASTER_LEN (SRTP_MASTER_KEY_LEN + SRTP_MASTER_SALT_LEN)
167#define RTP_DTLS_ESTABLISHED -37
188#define STRICT_RTP_LEARN_TIMEOUT 5000
190#define DEFAULT_STRICT_RTP STRICT_RTP_YES
191#define DEFAULT_SRTP_REPLAY_PROTECTION 1
192#define DEFAULT_ICESUPPORT 1
193#define DEFAULT_STUN_SOFTWARE_ATTRIBUTE 1
194#define DEFAULT_DTLS_MTU 1200
204#define RTP_IGNORE_FIRST_PACKETS_COUNT 15
220static int nochecksums;
226#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
232static struct sockaddr_in stunaddr;
233static pj_str_t turnaddr;
235static pj_str_t turnusername;
236static pj_str_t turnpassword;
256static pj_pool_t *pool;
259static pj_timer_heap_t *timer_heap;
262static pj_thread_t *timer_thread;
265static int timer_terminate;
268struct ast_rtp_ioqueue_thread {
274 pj_ioqueue_t *ioqueue;
276 pj_timer_heap_t *timerheap;
289struct ast_ice_host_candidate {
292 unsigned int include_local;
303#define FLAG_3389_WARNING (1 << 0)
304#define FLAG_NAT_ACTIVE (3 << 1)
305#define FLAG_NAT_INACTIVE (0 << 1)
306#define FLAG_NAT_INACTIVE_NOWARN (1 << 1)
307#define FLAG_NEED_MARKER_BIT (1 << 3)
308#define FLAG_DTMF_COMPENSATE (1 << 4)
309#define FLAG_REQ_LOCAL_BRIDGE_BIT (1 << 5)
311#define TRANSPORT_SOCKET_RTP 0
312#define TRANSPORT_SOCKET_RTCP 1
313#define TRANSPORT_TURN_RTP 2
314#define TRANSPORT_TURN_RTCP 3
327#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
341 pj_ice_sess *real_ice;
484 struct ice_wrap *ice;
486 pj_turn_sock *turn_rtp;
487 pj_turn_sock *turn_rtcp;
488 pj_turn_state_t turn_state;
489 unsigned int passthrough:1;
490 unsigned int rtp_passthrough:1;
491 unsigned int rtcp_passthrough:1;
492 unsigned int ice_port;
496 struct ast_rtp_ioqueue_thread *ioqueue;
498 char remote_ufrag[256];
499 char remote_passwd[256];
501 char local_ufrag[256];
502 char local_passwd[256];
508 unsigned int ice_num_components;
509 unsigned int ice_media_started:1;
512#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
517 char local_fingerprint[160];
519 unsigned char remote_fingerprint[EVP_MAX_MD_SIZE];
522 struct dtls_details dtls;
604#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
605 struct dtls_details dtls;
674#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
678static int dtls_bio_write(BIO *bio,
const char *
buf,
int len);
679static long dtls_bio_ctrl(BIO *bio,
int cmd,
long arg1,
void *arg2);
680static int dtls_bio_new(BIO *bio);
681static int dtls_bio_free(BIO *bio);
683#ifndef HAVE_OPENSSL_BIO_METHOD
684static BIO_METHOD dtls_bio_methods = {
685 .type = BIO_TYPE_BIO,
687 .bwrite = dtls_bio_write,
688 .ctrl = dtls_bio_ctrl,
689 .create = dtls_bio_new,
690 .destroy = dtls_bio_free,
693static BIO_METHOD *dtls_bio_methods;
700static void stunaddr_resolve_callback(
const struct ast_dns_query *query);
701static int store_stunaddr_resolved(
const struct ast_dns_query *query);
704#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
705static int dtls_bio_new(BIO *bio)
707#ifdef HAVE_OPENSSL_BIO_METHOD
708 BIO_set_init(bio, 1);
709 BIO_set_data(bio,
NULL);
710 BIO_set_shutdown(bio, 0);
719static int dtls_bio_free(BIO *bio)
725#ifdef HAVE_OPENSSL_BIO_METHOD
726 BIO_set_data(bio,
NULL);
733static int dtls_bio_write(BIO *bio,
const char *
buf,
int len)
735#ifdef HAVE_OPENSSL_BIO_METHOD
750 if (rtp->
rtcp && rtp->
rtcp->dtls.write_bio == bio) {
761 bytes_sent =
__rtp_sendto(instance, (
char *)
buf,
len, 0, &remote_address, rtcp, &ice, 0);
764 ast_debug(0,
"(%p) DTLS - sent %s packet to %s%s (len %-6.6d)\n",
766 ice ?
" (via ICE)" :
"", bytes_sent);
772static long dtls_bio_ctrl(BIO *bio,
int cmd,
long arg1,
void *arg2)
777 case BIO_CTRL_DGRAM_QUERY_MTU:
779 case BIO_CTRL_WPENDING:
780 case BIO_CTRL_PENDING:
791static void host_candidate_overrides_clear(
void)
793 struct ast_ice_host_candidate *candidate;
808 char address[PJ_INET6_ADDRSTRLEN];
810 if (component < 1 || !ice->comp[component - 1].valid_check) {
815 pj_sockaddr_print(&ice->comp[component - 1].valid_check->rcand->addr,
address,
818 pj_sockaddr_get_port(&ice->comp[component - 1].valid_check->rcand->addr));
822static void ast_rtp_ice_candidate_destroy(
void *obj)
836static void ast_rtp_ice_set_authentication(
struct ast_rtp_instance *instance,
const char *ufrag,
const char *password)
839 int ice_attrb_reset = 0;
842 if (!
ast_strlen_zero(rtp->remote_ufrag) && strcmp(ufrag, rtp->remote_ufrag)) {
849 if (!
ast_strlen_zero(rtp->remote_passwd) && strcmp(password, rtp->remote_passwd)) {
852 ast_copy_string(rtp->remote_passwd, password,
sizeof(rtp->remote_passwd));
856 if (ice_attrb_reset) {
862static int ice_candidate_cmp(
void *obj,
void *arg,
int flags)
866 if (strcmp(candidate1->
foundation, candidate2->foundation) ||
867 candidate1->
id != candidate2->id ||
868 candidate1->
type != candidate2->type ||
883 if (strcasecmp(candidate->
transport,
"udp")) {
887 if (!rtp->ice_proposed_remote_candidates) {
890 if (!rtp->ice_proposed_remote_candidates) {
900 if (!(remote_candidate =
ao2_alloc(
sizeof(*remote_candidate), ast_rtp_ice_candidate_destroy))) {
905 remote_candidate->
id = candidate->
id;
910 remote_candidate->
type = candidate->
type;
912 ast_debug_ice(2,
"(%p) ICE add remote candidate\n", instance);
914 ao2_link(rtp->ice_proposed_remote_candidates, remote_candidate);
921static void pj_thread_register_check(
void)
923 pj_thread_desc *
desc;
926 if (pj_thread_is_registered() == PJ_TRUE) {
932 ast_log(
LOG_ERROR,
"Could not get thread desc from thread-local storage. Expect awful things to occur\n");
937 if (pj_thread_register(
"Asterisk Thread", *
desc, &
thread) != PJ_SUCCESS) {
950 struct ice_wrap *ice;
972static void ice_wrap_dtor(
void *vdoomed)
974 struct ice_wrap *ice = vdoomed;
977 pj_thread_register_check();
979 pj_ice_sess_destroy(ice->real_ice);
983static void ast2pj_rtp_ice_role(
enum ast_rtp_ice_role ast_role,
enum pj_ice_sess_role *pj_role)
987 *pj_role = PJ_ICE_SESS_ROLE_CONTROLLED;
990 *pj_role = PJ_ICE_SESS_ROLE_CONTROLLING;
995static void pj2ast_rtp_ice_role(
enum pj_ice_sess_role pj_role,
enum ast_rtp_ice_role *ast_role)
998 case PJ_ICE_SESS_ROLE_CONTROLLED:
1001 case PJ_ICE_SESS_ROLE_CONTROLLING:
1004 case PJ_ICE_SESS_ROLE_UNKNOWN:
1021 if (!rtp->ice->real_ice->is_nominating && !rtp->ice->real_ice->is_complete) {
1022 ast_debug_ice(3,
" (%p) ICE nevermind, not ready for a reset\n", instance);
1026 ast_debug_ice(3,
"(%p) ICE recreating ICE session %s (%d)\n",
1028 res = ice_create(instance, &rtp->ice_original_rtp_addr, rtp->ice_port, 1);
1031 enum pj_ice_sess_role role = PJ_ICE_SESS_ROLE_UNKNOWN;
1032 ast2pj_rtp_ice_role(rtp->role, &role);
1033 pj_ice_sess_change_role(rtp->ice->real_ice, role);
1039 if (rtp->ice_num_components == 1 && rtp->turn_rtcp) {
1041 struct timespec ts = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000, };
1043 rtp->turn_state = PJ_TURN_STATE_NULL;
1047 pj_turn_sock_destroy(rtp->turn_rtcp);
1049 while (rtp->turn_state != PJ_TURN_STATE_DESTROYING) {
1054 rtp->ice_media_started = 0;
1072 if (!left_candidate) {
1090 pj_str_t ufrag = pj_str(rtp->remote_ufrag), passwd = pj_str(rtp->remote_passwd);
1091 pj_ice_sess_cand candidates[PJ_ICE_MAX_CAND];
1094 int cand_cnt = 0, has_rtp = 0, has_rtcp = 0;
1096 if (!rtp->ice || !rtp->ice_proposed_remote_candidates) {
1101 if (rtp->ice_active_remote_candidates &&
1102 !ice_candidates_compare(rtp->ice_proposed_remote_candidates, rtp->ice_active_remote_candidates)) {
1103 ast_debug_ice(2,
"(%p) ICE proposed equals active candidates\n", instance);
1105 rtp->ice_proposed_remote_candidates =
NULL;
1107 pj2ast_rtp_ice_role(rtp->ice->real_ice->role, &rtp->role);
1113 rtp->ice_active_remote_candidates = rtp->ice_proposed_remote_candidates;
1114 rtp->ice_proposed_remote_candidates =
NULL;
1119 if (ice_reset_session(instance)) {
1120 ast_log(
LOG_NOTICE,
"(%p) ICE failed to create replacement session\n", instance);
1124 pj_thread_register_check();
1135 pj_strdup2(rtp->ice->real_ice->pool, &candidates[cand_cnt].foundation,
1137 candidates[cand_cnt].comp_id = candidate->
id;
1138 candidates[cand_cnt].prio = candidate->
priority;
1147 candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_HOST;
1149 candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_SRFLX;
1151 candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_RELAYED;
1158 pj_turn_sock_set_perm(rtp->turn_rtp, 1, &candidates[cand_cnt].addr, 1);
1164 pj_turn_sock_set_perm(rtp->turn_rtcp, 1, &candidates[cand_cnt].addr, 1);
1175 ast_log(
LOG_WARNING,
"(%p) ICE lost %d candidates. Consider increasing PJ_ICE_MAX_CAND in PJSIP\n",
1184 if (!has_rtcp && rtp->ice_num_components > 1) {
1188 if (rtp->ice && has_rtp && (has_rtcp || rtp->ice_num_components == 1)) {
1191 struct ice_wrap *ice;
1197 res = pj_ice_sess_create_check_list(ice->real_ice, &ufrag, &passwd, cand_cnt, &candidates[0]);
1198 if (res == PJ_SUCCESS) {
1199 ast_debug_ice(2,
"(%p) ICE successfully created checklist\n", instance);
1201 pj_ice_sess_start_check(ice->real_ice);
1202 pj_timer_heap_poll(timer_heap,
NULL);
1211 pj_strerror(res, reason,
sizeof(reason));
1212 ast_log(
LOG_WARNING,
"(%p) ICE failed to create session check list: %s\n", instance, reason);
1221 ao2_ref(rtp->ice_active_remote_candidates, -1);
1222 rtp->ice_active_remote_candidates =
NULL;
1224 rtp->ice->real_ice->rcand_cnt = rtp->ice->real_ice->clist.count = 0;
1233 return rtp->local_ufrag;
1237static const char *ast_rtp_ice_get_password(
struct ast_rtp_instance *instance)
1241 return rtp->local_passwd;
1249 if (rtp->ice_local_candidates) {
1250 ao2_ref(rtp->ice_local_candidates, +1);
1253 return rtp->ice_local_candidates;
1265 pj_thread_register_check();
1267 pj_ice_sess_change_role(rtp->ice->real_ice, PJ_ICE_SESS_ROLE_CONTROLLING);
1276 ast_debug_ice(3,
"(%p) ICE set role failed; no ice instance\n", instance);
1282 if (!rtp->ice->real_ice->is_nominating && !rtp->ice->real_ice->is_complete) {
1283 pj_thread_register_check();
1287 PJ_ICE_SESS_ROLE_CONTROLLED : PJ_ICE_SESS_ROLE_CONTROLLING);
1289 ast_debug_ice(2,
"(%p) ICE not setting role because state is %s\n",
1290 instance, rtp->ice->real_ice->is_nominating ?
"nominating" :
"complete");
1296 unsigned comp_id,
unsigned transport_id, pj_ice_cand_type
type, pj_uint16_t local_pref,
1297 const pj_sockaddr_t *addr,
const pj_sockaddr_t *base_addr,
const pj_sockaddr_t *rel_addr,
1300 pj_str_t foundation;
1302 struct ice_wrap *ice;
1303 char address[PJ_INET6_ADDRSTRLEN];
1310 pj_thread_register_check();
1312 pj_ice_calc_foundation(rtp->ice->real_ice->pool, &foundation,
type, addr);
1314 if (!rtp->ice_local_candidates) {
1316 NULL, ice_candidate_cmp);
1317 if (!rtp->ice_local_candidates) {
1322 if (!(candidate =
ao2_alloc(
sizeof(*candidate), ast_rtp_ice_candidate_destroy))) {
1327 candidate->
id = comp_id;
1338 if (
type == PJ_ICE_CAND_TYPE_HOST) {
1340 }
else if (
type == PJ_ICE_CAND_TYPE_SRFLX) {
1342 }
else if (
type == PJ_ICE_CAND_TYPE_RELAYED) {
1356 status = pj_ice_sess_add_cand(ice->real_ice, comp_id, transport_id,
type, local_pref,
1357 &foundation, addr, base_addr, rel_addr, addr_len,
NULL);
1360 if (!rtp->ice ||
status != PJ_SUCCESS) {
1368 candidate->
priority = rtp->ice->real_ice->lcand[rtp->ice->real_ice->lcand_cnt - 1].prio;
1373 ao2_link(rtp->ice_local_candidates, candidate);
1378static void ast_rtp_on_turn_rx_rtp_data(pj_turn_sock *turn_sock,
void *pkt,
unsigned pkt_len,
const pj_sockaddr_t *peer_addr,
unsigned addr_len)
1382 struct ice_wrap *ice;
1393 if (
status != PJ_SUCCESS) {
1401 if (!rtp->rtp_passthrough) {
1404 rtp->rtp_passthrough = 0;
1407 ast_sendto(rtp->
s, pkt, pkt_len, 0, &rtp->rtp_loop);
1411static void ast_rtp_on_turn_rtp_state(pj_turn_sock *turn_sock, pj_turn_state_t old_state, pj_turn_state_t new_state)
1426 rtp->turn_state = new_state;
1429 if (new_state == PJ_TURN_STATE_DESTROYING) {
1430 pj_turn_sock_set_user_data(rtp->turn_rtp,
NULL);
1431 rtp->turn_rtp =
NULL;
1438static pj_turn_sock_cb ast_rtp_turn_rtp_sock_cb = {
1439 .on_rx_data = ast_rtp_on_turn_rx_rtp_data,
1440 .on_state = ast_rtp_on_turn_rtp_state,
1444static void ast_rtp_on_turn_rx_rtcp_data(pj_turn_sock *turn_sock,
void *pkt,
unsigned pkt_len,
const pj_sockaddr_t *peer_addr,
unsigned addr_len)
1448 struct ice_wrap *ice;
1459 if (
status != PJ_SUCCESS) {
1467 if (!rtp->rtcp_passthrough) {
1470 rtp->rtcp_passthrough = 0;
1477static void ast_rtp_on_turn_rtcp_state(pj_turn_sock *turn_sock, pj_turn_state_t old_state, pj_turn_state_t new_state)
1492 rtp->turn_state = new_state;
1495 if (new_state == PJ_TURN_STATE_DESTROYING) {
1496 pj_turn_sock_set_user_data(rtp->turn_rtcp,
NULL);
1497 rtp->turn_rtcp =
NULL;
1504static pj_turn_sock_cb ast_rtp_turn_rtcp_sock_cb = {
1505 .on_rx_data = ast_rtp_on_turn_rx_rtcp_data,
1506 .on_state = ast_rtp_on_turn_rtcp_state,
1510static int ioqueue_worker_thread(
void *data)
1512 struct ast_rtp_ioqueue_thread *ioqueue = data;
1514 while (!ioqueue->terminate) {
1515 const pj_time_val delay = {0, 10};
1517 pj_ioqueue_poll(ioqueue->ioqueue, &delay);
1519 pj_timer_heap_poll(ioqueue->timerheap,
NULL);
1526static void rtp_ioqueue_thread_destroy(
struct ast_rtp_ioqueue_thread *ioqueue)
1528 if (ioqueue->thread) {
1529 ioqueue->terminate = 1;
1530 pj_thread_join(ioqueue->thread);
1531 pj_thread_destroy(ioqueue->thread);
1534 if (ioqueue->pool) {
1538 pj_pool_t *temp_pool = ioqueue->pool;
1540 ioqueue->pool =
NULL;
1541 pj_pool_release(temp_pool);
1548static void rtp_ioqueue_thread_remove(
struct ast_rtp_ioqueue_thread *ioqueue)
1554 if ((ioqueue->count -= 2) == 0) {
1564 rtp_ioqueue_thread_destroy(ioqueue);
1568static struct ast_rtp_ioqueue_thread *rtp_ioqueue_thread_get_or_create(
void)
1570 struct ast_rtp_ioqueue_thread *ioqueue;
1577 if ((ioqueue->count + 2) < PJ_IOQUEUE_MAX_HANDLES) {
1584 ioqueue->count += 2;
1593 ioqueue->pool = pj_pool_create(&
cachingpool.factory,
"rtp", 512, 512,
NULL);
1598 if (pj_timer_heap_create(ioqueue->pool, 4, &ioqueue->timerheap) != PJ_SUCCESS) {
1602 if (pj_lock_create_recursive_mutex(ioqueue->pool,
"rtp%p", &
lock) != PJ_SUCCESS) {
1606 pj_timer_heap_set_lock(ioqueue->timerheap,
lock, PJ_TRUE);
1608 if (pj_ioqueue_create(ioqueue->pool, PJ_IOQUEUE_MAX_HANDLES, &ioqueue->ioqueue) != PJ_SUCCESS) {
1612 if (pj_thread_create(ioqueue->pool,
"ice", &ioqueue_worker_thread, ioqueue, 0, 0, &ioqueue->thread) != PJ_SUCCESS) {
1624 rtp_ioqueue_thread_destroy(ioqueue);
1634 enum ast_transport transport,
const char *server,
unsigned int port,
const char *username,
const char *password)
1637 pj_turn_sock **turn_sock;
1638 const pj_turn_sock_cb *turn_cb;
1639 pj_turn_tp_type conn_type;
1641 pj_stun_auth_cred cred = { 0, };
1644 pj_stun_config stun_config;
1646 struct timespec ts = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000, };
1647 pj_turn_session_info
info;
1650 pj_turn_sock_cfg turn_sock_cfg;
1651 struct ice_wrap *ice;
1662 turn_sock = &rtp->turn_rtp;
1663 turn_cb = &ast_rtp_turn_rtp_sock_cb;
1667 turn_sock = &rtp->turn_rtcp;
1668 turn_cb = &ast_rtp_turn_rtcp_sock_cb;
1676 conn_type = PJ_TURN_TP_UDP;
1678 conn_type = PJ_TURN_TP_TCP;
1687 rtp->turn_state = PJ_TURN_STATE_NULL;
1691 pj_turn_sock_destroy(*turn_sock);
1693 while (rtp->turn_state != PJ_TURN_STATE_DESTROYING) {
1705 rtp->ioqueue = rtp_ioqueue_thread_get_or_create();
1707 if (!rtp->ioqueue) {
1712 pj_stun_config_init(&stun_config, &
cachingpool.factory, 0, rtp->ioqueue->ioqueue, rtp->ioqueue->timerheap);
1713 if (!stun_software_attribute) {
1714 stun_config.software_name = pj_str(
NULL);
1718 pj_turn_sock_cfg_default(&turn_sock_cfg);
1721 turn_sock_cfg.grp_lock = ice->real_ice->grp_lock;
1727 status = pj_turn_sock_create(&stun_config,
1729 turn_cb, &turn_sock_cfg, instance, turn_sock);
1731 if (
status != PJ_SUCCESS) {
1737 cred.type = PJ_STUN_AUTH_CRED_STATIC;
1738 pj_strset2(&cred.data.static_cred.username, (
char*)username);
1739 cred.data.static_cred.data_type = PJ_STUN_PASSWD_PLAIN;
1740 pj_strset2(&cred.data.static_cred.data, (
char*)password);
1742 pj_turn_sock_alloc(*turn_sock, pj_cstr(&turn_addr, server), port,
NULL, &cred,
NULL);
1744 ast_debug_ice(2,
"(%p) ICE request TURN %s %s candidate\n", instance,
1754 while (rtp->turn_state < PJ_TURN_STATE_READY) {
1759 if (rtp->turn_state != PJ_TURN_STATE_READY) {
1763 pj_turn_sock_get_info(*turn_sock, &
info);
1765 ast_rtp_ice_add_cand(instance, rtp, component, conn_transport,
1766 PJ_ICE_CAND_TYPE_RELAYED, 65535, &
info.relay_addr, &
info.relay_addr,
1767 &
info.mapped_addr, pj_sockaddr_get_len(&
info.relay_addr));
1781 for (x=0; x<4; x++) {
1784 snprintf(
buf, size,
"%08lx%08lx%08lx%08lx", (
long unsigned)
val[0], (
long unsigned)
val[1], (
long unsigned)
val[2], (
long unsigned)
val[3]);
1790static void ast_rtp_ice_change_components(
struct ast_rtp_instance *instance,
int num_components)
1797 if (!icesupport || !rtp->ice || rtp->ice_num_components == num_components) {
1801 ast_debug_ice(2,
"(%p) ICE change number of components %u -> %u\n", instance,
1802 rtp->ice_num_components, num_components);
1804 rtp->ice_num_components = num_components;
1805 ice_reset_session(instance);
1811 .add_remote_candidate = ast_rtp_ice_add_remote_candidate,
1812 .start = ast_rtp_ice_start,
1813 .stop = ast_rtp_ice_stop,
1814 .get_ufrag = ast_rtp_ice_get_ufrag,
1815 .get_password = ast_rtp_ice_get_password,
1816 .get_local_candidates = ast_rtp_ice_get_local_candidates,
1817 .ice_lite = ast_rtp_ice_lite,
1818 .set_role = ast_rtp_ice_set_role,
1819 .turn_request = ast_rtp_ice_turn_request,
1820 .change_components = ast_rtp_ice_change_components,
1824#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
1825static int dtls_verify_callback(
int preverify_ok, X509_STORE_CTX *ctx)
1831static int dtls_details_initialize(
struct dtls_details *dtls,
SSL_CTX *ssl_ctx,
1834 dtls->dtls_setup = setup;
1836 if (!(dtls->ssl = SSL_new(ssl_ctx))) {
1841 if (!(dtls->read_bio = BIO_new(BIO_s_mem()))) {
1845 BIO_set_mem_eof_return(dtls->read_bio, -1);
1847#ifdef HAVE_OPENSSL_BIO_METHOD
1848 if (!(dtls->write_bio = BIO_new(dtls_bio_methods))) {
1849 ast_log(
LOG_ERROR,
"Failed to allocate memory for outbound SSL traffic\n");
1853 BIO_set_data(dtls->write_bio, instance);
1855 if (!(dtls->write_bio = BIO_new(&dtls_bio_methods))) {
1856 ast_log(
LOG_ERROR,
"Failed to allocate memory for outbound SSL traffic\n");
1859 dtls->write_bio->ptr = instance;
1861 SSL_set_bio(dtls->ssl, dtls->read_bio, dtls->write_bio);
1864 SSL_set_accept_state(dtls->ssl);
1866 SSL_set_connect_state(dtls->ssl);
1873 if (dtls->read_bio) {
1874 BIO_free(dtls->read_bio);
1875 dtls->read_bio =
NULL;
1878 if (dtls->write_bio) {
1879 BIO_free(dtls->write_bio);
1880 dtls->write_bio =
NULL;
1884 SSL_free(dtls->ssl);
1894 if (!rtp->ssl_ctx || !rtp->
rtcp) {
1899 return dtls_details_initialize(&rtp->
rtcp->dtls, rtp->ssl_ctx, rtp->dtls.dtls_setup, instance);
1902static const SSL_METHOD *get_dtls_method(
void)
1904#if OPENSSL_VERSION_NUMBER < 0x10002000L
1905 return DTLSv1_method();
1907 return DTLS_method();
1911struct dtls_cert_info {
1912 EVP_PKEY *private_key;
1916static int apply_dh_params(
SSL_CTX *ctx, BIO *bio)
1920#if OPENSSL_VERSION_NUMBER >= 0x30000000L
1921 EVP_PKEY *dhpkey = PEM_read_bio_Parameters(bio,
NULL);
1922 if (dhpkey && EVP_PKEY_is_a(dhpkey,
"DH")) {
1923 res = SSL_CTX_set0_tmp_dh_pkey(ctx, dhpkey);
1929 EVP_PKEY_free(dhpkey);
1934 res = SSL_CTX_set_tmp_dh(ctx, dh);
1944#if !defined(OPENSSL_NO_ECDH) && (OPENSSL_VERSION_NUMBER >= 0x10000000L) && (OPENSSL_VERSION_NUMBER < 0x10100000L)
1948#ifndef OPENSSL_NO_DH
1950 BIO *bio = BIO_new_file(dtls_cfg->
pvtfile,
"r");
1952 if (apply_dh_params(rtp->ssl_ctx, bio)) {
1953 long options = SSL_OP_CIPHER_SERVER_PREFERENCE |
1954 SSL_OP_SINGLE_DH_USE | SSL_OP_SINGLE_ECDH_USE;
1956 ast_verb(2,
"DTLS DH initialized, PFS enabled\n");
1963#if !defined(OPENSSL_NO_ECDH) && (OPENSSL_VERSION_NUMBER >= 0x10000000L) && (OPENSSL_VERSION_NUMBER < 0x10100000L)
1965 ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
1967 if (SSL_CTX_set_tmp_ecdh(rtp->ssl_ctx, ecdh)) {
1968 #ifndef SSL_CTRL_SET_ECDH_AUTO
1969 #define SSL_CTRL_SET_ECDH_AUTO 94
1972 if (SSL_CTX_ctrl(rtp->ssl_ctx, SSL_CTRL_SET_ECDH_AUTO, 1,
NULL)) {
1973 ast_verb(2,
"DTLS ECDH initialized (automatic), faster PFS enabled\n");
1975 ast_verb(2,
"DTLS ECDH initialized (secp256r1), faster PFS enabled\n");
1983#if !defined(OPENSSL_NO_ECDH) && (OPENSSL_VERSION_NUMBER >= 0x10000000L)
1985static int create_ephemeral_ec_keypair(EVP_PKEY **keypair)
1987#if OPENSSL_VERSION_NUMBER >= 0x30000000L
1988 *keypair = EVP_EC_gen(SN_X9_62_prime256v1);
1989 return *keypair ? 0 : -1;
1991 EC_KEY *eckey =
NULL;
1994 group = EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1);
1999 EC_GROUP_set_asn1_flag(
group, OPENSSL_EC_NAMED_CURVE);
2000 EC_GROUP_set_point_conversion_form(
group, POINT_CONVERSION_UNCOMPRESSED);
2002 eckey = EC_KEY_new();
2007 if (!EC_KEY_set_group(eckey,
group)) {
2011 if (!EC_KEY_generate_key(eckey)) {
2015 *keypair = EVP_PKEY_new();
2020 EVP_PKEY_assign_EC_KEY(*keypair, eckey);
2021 EC_GROUP_free(
group);
2027 EC_GROUP_free(
group);
2034#define SERIAL_RAND_BITS 159
2036static int create_ephemeral_certificate(EVP_PKEY *keypair, X509 **certificate)
2039 BIGNUM *serial =
NULL;
2047 if (!X509_set_version(cert, 2)) {
2052 X509_set_pubkey(cert, keypair);
2055 if (!(serial = BN_new())
2056 || !BN_rand(serial, SERIAL_RAND_BITS, -1, 0)
2057 || !BN_to_ASN1_INTEGER(serial, X509_get_serialNumber(cert))) {
2068#if OPENSSL_VERSION_NUMBER < 0x10100000L
2069 if (!X509_time_adj_ex(X509_get_notBefore(cert), -1, 0,
NULL)
2070 || !X509_time_adj_ex(X509_get_notAfter(cert), 30, 0,
NULL)) {
2074 if (!X509_time_adj_ex(X509_getm_notBefore(cert), -1, 0,
NULL)
2075 || !X509_time_adj_ex(X509_getm_notAfter(cert), 30, 0,
NULL)) {
2081 if (!(
name = X509_get_subject_name(cert))
2082 || !X509_NAME_add_entry_by_NID(
name, NID_commonName, MBSTRING_ASC,
2083 (
unsigned char *)
"asterisk", -1, -1, 0)
2084 || !X509_set_issuer_name(cert,
name)) {
2089 if (!X509_sign(cert, keypair, EVP_sha256())) {
2093 *certificate = cert;
2105 struct dtls_cert_info *cert_info)
2108 cert_info->private_key =
NULL;
2109 cert_info->certificate =
NULL;
2111 if (create_ephemeral_ec_keypair(&cert_info->private_key)) {
2116 if (create_ephemeral_certificate(cert_info->private_key, &cert_info->certificate)) {
2124 X509_free(cert_info->certificate);
2125 EVP_PKEY_free(cert_info->private_key);
2134 struct dtls_cert_info *cert_info)
2136 ast_log(
LOG_ERROR,
"Your version of OpenSSL does not support ECDSA keys\n");
2144 struct dtls_cert_info *cert_info)
2147 BIO *certbio =
NULL;
2148 EVP_PKEY *private_key =
NULL;
2152 fp = fopen(private_key_file,
"r");
2154 ast_log(
LOG_ERROR,
"Failed to read private key from file '%s': %s\n", private_key_file, strerror(
errno));
2158 if (!PEM_read_PrivateKey(fp, &private_key,
NULL,
NULL)) {
2159 ast_log(
LOG_ERROR,
"Failed to read private key from PEM file '%s'\n", private_key_file);
2165 ast_log(
LOG_ERROR,
"Failed to close private key file '%s': %s\n", private_key_file, strerror(
errno));
2169 certbio = BIO_new(BIO_s_file());
2171 ast_log(
LOG_ERROR,
"Failed to allocate memory for certificate fingerprinting on RTP instance '%p'\n",
2176 if (!BIO_read_filename(certbio, dtls_cfg->
certfile)
2177 || !(cert = PEM_read_bio_X509(certbio,
NULL, 0,
NULL))) {
2182 cert_info->private_key = private_key;
2183 cert_info->certificate = cert;
2185 BIO_free_all(certbio);
2191 BIO_free_all(certbio);
2192 EVP_PKEY_free(private_key);
2199 struct dtls_cert_info *cert_info)
2202 return create_certificate_ephemeral(instance, dtls_cfg, cert_info);
2204 return create_certificate_from_file(instance, dtls_cfg, cert_info);
2214 struct dtls_cert_info cert_info = { 0 };
2224 ast_log(
LOG_ERROR,
"SRTP support module is not loaded or available. Try loading res_srtp.so.\n");
2232 rtp->ssl_ctx = SSL_CTX_new(get_dtls_method());
2233 if (!rtp->ssl_ctx) {
2237 SSL_CTX_set_read_ahead(rtp->ssl_ctx, 1);
2239 configure_dhparams(rtp, dtls_cfg);
2241 rtp->dtls_verify = dtls_cfg->
verify;
2245 dtls_verify_callback :
NULL);
2248 SSL_CTX_set_tlsext_use_srtp(rtp->ssl_ctx,
"SRTP_AES128_CM_SHA1_80");
2250 SSL_CTX_set_tlsext_use_srtp(rtp->ssl_ctx,
"SRTP_AES128_CM_SHA1_32");
2252 ast_log(
LOG_ERROR,
"Unsupported suite specified for DTLS-SRTP on RTP instance '%p'\n", instance);
2256 rtp->local_hash = dtls_cfg->
hash;
2258 if (!load_dtls_certificate(instance, dtls_cfg, &cert_info)) {
2260 unsigned int size, i;
2261 unsigned char fingerprint[EVP_MAX_MD_SIZE];
2262 char *local_fingerprint = rtp->local_fingerprint;
2264 if (!SSL_CTX_use_certificate(rtp->ssl_ctx, cert_info.certificate)) {
2265 ast_log(
LOG_ERROR,
"Specified certificate for RTP instance '%p' could not be used\n",
2270 if (!SSL_CTX_use_PrivateKey(rtp->ssl_ctx, cert_info.private_key)
2271 || !SSL_CTX_check_private_key(rtp->ssl_ctx)) {
2272 ast_log(
LOG_ERROR,
"Specified private key for RTP instance '%p' could not be used\n",
2280 type = EVP_sha256();
2282 ast_log(
LOG_ERROR,
"Unsupported fingerprint hash type on RTP instance '%p'\n",
2287 if (!X509_digest(cert_info.certificate,
type, fingerprint, &size) || !size) {
2288 ast_log(
LOG_ERROR,
"Could not produce fingerprint from certificate for RTP instance '%p'\n",
2293 for (i = 0; i < size; i++) {
2294 sprintf(local_fingerprint,
"%02hhX:", fingerprint[i]);
2295 local_fingerprint += 3;
2298 *(local_fingerprint - 1) = 0;
2300 EVP_PKEY_free(cert_info.private_key);
2301 X509_free(cert_info.certificate);
2305 if (!SSL_CTX_set_cipher_list(rtp->ssl_ctx, dtls_cfg->
cipher)) {
2306 ast_log(
LOG_ERROR,
"Invalid cipher specified in cipher list '%s' for RTP instance '%p'\n",
2307 dtls_cfg->
cipher, instance);
2314 ast_log(
LOG_ERROR,
"Invalid certificate authority file '%s' or path '%s' specified for RTP instance '%p'\n",
2320 rtp->rekey = dtls_cfg->
rekey;
2321 rtp->suite = dtls_cfg->
suite;
2323 res = dtls_details_initialize(&rtp->dtls, rtp->ssl_ctx, dtls_cfg->
default_setup, instance);
2325 dtls_setup_rtcp(instance);
2336 return !rtp->ssl_ctx ? 0 : 1;
2343 SSL *ssl = rtp->dtls.ssl;
2347 dtls_srtp_stop_timeout_timer(instance, rtp, 0);
2351 SSL_CTX_free(rtp->ssl_ctx);
2352 rtp->ssl_ctx =
NULL;
2355 if (rtp->dtls.ssl) {
2356 SSL_free(rtp->dtls.ssl);
2357 rtp->dtls.ssl =
NULL;
2362 dtls_srtp_stop_timeout_timer(instance, rtp, 1);
2365 if (rtp->
rtcp->dtls.ssl) {
2366 if (rtp->
rtcp->dtls.ssl != ssl) {
2367 SSL_free(rtp->
rtcp->dtls.ssl);
2379 if (SSL_is_init_finished(rtp->dtls.ssl)) {
2380 SSL_shutdown(rtp->dtls.ssl);
2384 if (rtp->
rtcp && SSL_is_init_finished(rtp->
rtcp->dtls.ssl)) {
2385 SSL_shutdown(rtp->
rtcp->dtls.ssl);
2395 return rtp->dtls.connection;
2403 return rtp->dtls.dtls_setup;
2432 if (old == *dtls_setup) {
2442 SSL_set_connect_state(ssl);
2444 SSL_set_accept_state(ssl);
2455 if (rtp->dtls.ssl) {
2456 dtls_set_setup(&rtp->dtls.dtls_setup, setup, rtp->dtls.ssl);
2459 if (rtp->
rtcp && rtp->
rtcp->dtls.ssl) {
2460 dtls_set_setup(&rtp->
rtcp->dtls.dtls_setup, setup, rtp->
rtcp->dtls.ssl);
2475 rtp->remote_hash = hash;
2477 while ((
value =
strsep(&
tmp,
":")) && (pos != (EVP_MAX_MD_SIZE - 1))) {
2478 sscanf(
value,
"%02hhx", &rtp->remote_fingerprint[pos++]);
2487 return rtp->local_hash;
2491static const char *ast_rtp_dtls_get_fingerprint(
struct ast_rtp_instance *instance)
2495 return rtp->local_fingerprint;
2501 .active = ast_rtp_dtls_active,
2502 .stop = ast_rtp_dtls_stop,
2503 .reset = ast_rtp_dtls_reset,
2504 .get_connection = ast_rtp_dtls_get_connection,
2505 .get_setup = ast_rtp_dtls_get_setup,
2506 .set_setup = ast_rtp_dtls_set_setup,
2507 .set_fingerprint = ast_rtp_dtls_set_fingerprint,
2508 .get_fingerprint_hash = ast_rtp_dtls_get_fingerprint_hash,
2509 .get_fingerprint = ast_rtp_dtls_get_fingerprint,
2514#ifdef TEST_FRAMEWORK
2552 if (rtp && rtp->
rtcp) {
2557static struct ast_rtp_engine_test ast_rtp_test = {
2558 .packets_to_drop = 0,
2561 .recv_buffer_count = get_recv_buffer_count,
2562 .recv_buffer_max = get_recv_buffer_max,
2563 .send_buffer_count = get_send_buffer_count,
2564 .set_schedid = set_rtp_rtcp_schedid,
2594#ifdef HAVE_PJPROJECT
2595 .ice = &ast_rtp_ice,
2597#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
2598 .dtls = &ast_rtp_dtls,
2599 .activate = ast_rtp_activate,
2607#ifdef TEST_FRAMEWORK
2608 .test = &ast_rtp_test,
2612#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
2614static void dtls_perform_handshake(
struct ast_rtp_instance *instance,
struct dtls_details *
dtls,
int rtcp)
2618 ast_debug_dtls(3,
"(%p) DTLS perform handshake - ssl = %p, setup = %d\n",
2619 rtp, dtls->ssl, dtls->dtls_setup);
2629 SSL_do_handshake(dtls->ssl);
2639 dtls_srtp_start_timeout_timer(instance, rtp,
rtcp);
2643#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
2644static void dtls_perform_setup(
struct dtls_details *dtls)
2646 if (!dtls->ssl || !SSL_is_init_finished(dtls->ssl)) {
2650 SSL_clear(dtls->ssl);
2652 SSL_set_accept_state(dtls->ssl);
2654 SSL_set_connect_state(dtls->ssl);
2662#ifdef HAVE_PJPROJECT
2666static void ast_rtp_ice_start_media(pj_ice_sess *ice, pj_status_t
status)
2673 if (
status == PJ_SUCCESS) {
2690#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
2692 if (rtp->ice_media_started) {
2698 "(%p) ICE starting media - perform DTLS - (%p)\n", instance, rtp);
2712 dtls_perform_handshake(instance, &rtp->dtls, 0);
2715 dtls_perform_handshake(instance, &rtp->
rtcp->dtls, 1);
2719 rtp->ice_media_started = 1;
2726 ast_verb(4,
"%p -- Strict RTP learning after ICE completion\n", rtp);
2731#ifdef HAVE_PJPROJECT_ON_VALID_ICE_PAIR_CALLBACK
2733static void ast_rtp_on_valid_pair(pj_ice_sess *ice)
2735 ast_debug_ice(2,
"(%p) ICE valid pair, start media\n", ice->user_data);
2736 ast_rtp_ice_start_media(ice, PJ_SUCCESS);
2741static void ast_rtp_on_ice_complete(pj_ice_sess *ice, pj_status_t
status)
2743 ast_debug_ice(2,
"(%p) ICE complete, start media\n", ice->user_data);
2744 ast_rtp_ice_start_media(ice,
status);
2748static void ast_rtp_on_ice_rx_data(pj_ice_sess *ice,
unsigned comp_id,
unsigned transport_id,
void *pkt, pj_size_t size,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len)
2756 rtp->passthrough = 1;
2758 rtp->rtp_passthrough = 1;
2760 rtp->rtcp_passthrough = 1;
2765static pj_status_t ast_rtp_on_ice_tx_pkt(pj_ice_sess *ice,
unsigned comp_id,
unsigned transport_id,
const void *pkt, pj_size_t size,
const pj_sockaddr_t *dst_addr,
unsigned dst_addr_len)
2769 pj_status_t
status = PJ_EINVALIDOP;
2770 pj_ssize_t _size = (pj_ssize_t)size;
2774 status = pj_sock_sendto(rtp->
s, pkt, &_size, 0, dst_addr, dst_addr_len);
2780 status = pj_sock_sendto(rtp->
rtcp->
s, pkt, &_size, 0, dst_addr, dst_addr_len);
2788 if (rtp->turn_rtp) {
2789 status = pj_turn_sock_sendto(rtp->turn_rtp, pkt, size, dst_addr, dst_addr_len);
2793 if (rtp->turn_rtcp) {
2794 status = pj_turn_sock_sendto(rtp->turn_rtcp, pkt, size, dst_addr, dst_addr_len);
2802static pj_ice_sess_cb ast_rtp_ice_sess_cb = {
2803#ifdef HAVE_PJPROJECT_ON_VALID_ICE_PAIR_CALLBACK
2804 .on_valid_pair = ast_rtp_on_valid_pair,
2806 .on_ice_complete = ast_rtp_on_ice_complete,
2807 .on_rx_data = ast_rtp_on_ice_rx_data,
2808 .on_tx_pkt = ast_rtp_on_ice_tx_pkt,
2812static int timer_worker_thread(
void *data)
2814 pj_ioqueue_t *ioqueue;
2816 if (pj_ioqueue_create(pool, 1, &ioqueue) != PJ_SUCCESS) {
2820 while (!timer_terminate) {
2821 const pj_time_val delay = {0, 10};
2823 pj_timer_heap_poll(timer_heap,
NULL);
2824 pj_ioqueue_poll(ioqueue, &delay);
2863#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
2868 struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->
rtcp->dtls;
2869 struct timeval dtls_timeout;
2871 ast_debug_dtls(3,
"(%p) DTLS srtp - handle timeout - rtcp=%d\n", instance, rtcp);
2872 DTLSv1_handle_timeout(dtls->ssl);
2875 if (!DTLSv1_get_timeout(dtls->ssl, &dtls_timeout)) {
2876 dtls->timeout_timer = -1;
2880 return dtls_timeout.tv_sec * 1000 + dtls_timeout.tv_usec / 1000;
2884static int dtls_srtp_handle_rtp_timeout(
const void *data)
2890 reschedule = dtls_srtp_handle_timeout(instance, 0);
2900static int dtls_srtp_handle_rtcp_timeout(
const void *
data)
2906 reschedule = dtls_srtp_handle_timeout(instance, 1);
2917 struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->
rtcp->dtls;
2918 struct timeval dtls_timeout;
2920 if (DTLSv1_get_timeout(dtls->ssl, &dtls_timeout)) {
2921 int timeout = dtls_timeout.tv_sec * 1000 + dtls_timeout.tv_usec / 1000;
2927 !rtcp ? dtls_srtp_handle_rtp_timeout : dtls_srtp_handle_rtcp_timeout, instance)) < 0) {
2929 ast_log(
LOG_WARNING,
"Scheduling '%s' DTLS retransmission for RTP instance [%p] failed.\n",
2930 !rtcp ?
"RTP" :
"RTCP", instance);
2932 ast_debug_dtls(3,
"(%p) DTLS srtp - scheduled timeout timer for '%d'\n", instance, timeout);
2940 struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->
rtcp->dtls;
2943 ast_debug_dtls(3,
"(%p) DTLS srtp - stopped timeout timer'\n", instance);
2947static int dtls_srtp_renegotiate(
const void *data)
2955 SSL_renegotiate(rtp->dtls.ssl);
2956 SSL_do_handshake(rtp->dtls.ssl);
2958 if (rtp->
rtcp && rtp->
rtcp->dtls.ssl && rtp->
rtcp->dtls.ssl != rtp->dtls.ssl) {
2959 SSL_renegotiate(rtp->
rtcp->dtls.ssl);
2960 SSL_do_handshake(rtp->
rtcp->dtls.ssl);
2974 unsigned char *local_key, *local_salt, *remote_key, *remote_salt;
2977 struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->
rtcp->dtls;
2979 ast_debug_dtls(3,
"(%p) DTLS srtp - add local ssrc - rtcp=%d, set_remote_policy=%d'\n",
2980 instance, rtcp, set_remote_policy);
2983 if (!SSL_export_keying_material(dtls->ssl, material,
SRTP_MASTER_LEN * 2,
"EXTRACTOR-dtls_srtp", 19,
NULL, 0, 0)) {
2984 ast_log(
LOG_WARNING,
"Unable to extract SRTP keying material from DTLS-SRTP negotiation on RTP instance '%p'\n",
2991 local_key = material;
2996 remote_key = material;
3007 ast_log(
LOG_WARNING,
"Could not set key/salt information on local policy of '%p' when setting up DTLS-SRTP\n", rtp);
3012 ast_log(
LOG_WARNING,
"Could not set suite to '%u' on local policy of '%p' when setting up DTLS-SRTP\n", rtp->suite, rtp);
3018 if (set_remote_policy) {
3024 ast_log(
LOG_WARNING,
"Could not set key/salt information on remote policy of '%p' when setting up DTLS-SRTP\n", rtp);
3029 ast_log(
LOG_WARNING,
"Could not set suite to '%u' on remote policy of '%p' when setting up DTLS-SRTP\n", rtp->suite, rtp);
3037 ast_log(
LOG_WARNING,
"Could not set policies when setting up DTLS-SRTP on '%p'\n", rtp);
3047 if (remote_policy) {
3056 struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->
rtcp->dtls;
3059 ast_debug_dtls(3,
"(%p) DTLS setup SRTP rtp=%p'\n", instance, rtp);
3065 if (!(certificate = SSL_get_peer_certificate(dtls->ssl))) {
3066 ast_log(
LOG_WARNING,
"No certificate was provided by the peer on RTP instance '%p'\n", instance);
3071 if (rtp->remote_fingerprint[0]) {
3073 unsigned char fingerprint[EVP_MAX_MD_SIZE];
3079 type = EVP_sha256();
3081 ast_log(
LOG_WARNING,
"Unsupported fingerprint hash type on RTP instance '%p'\n", instance);
3085 if (!X509_digest(certificate,
type, fingerprint, &size) ||
3087 memcmp(fingerprint, rtp->remote_fingerprint, size)) {
3088 X509_free(certificate);
3089 ast_log(
LOG_WARNING,
"Fingerprint provided by remote party does not match that of peer certificate on RTP instance '%p'\n",
3095 X509_free(certificate);
3126 return elem -
value;
3132 return elem ==
value;
3145 version = (packet[0] & 0XC0) >> 6;
3160 m = packet[1] & 0x80;
3161 pt = packet[1] & 0x7F;
3162 if (m && pt >= 64 && pt <= 95) {
3173#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
3176#ifdef HAVE_PJPROJECT
3177 struct ast_sockaddr *loop = rtcp ? &rtp->rtcp_loop : &rtp->rtp_loop;
3179#ifdef TEST_FRAMEWORK
3180 struct ast_rtp_engine_test *
test = ast_rtp_instance_get_test(instance);
3187#ifdef TEST_FRAMEWORK
3188 if (
test &&
test->packets_to_drop > 0) {
3189 test->packets_to_drop--;
3194#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
3197 if ((*
in >= 20) && (*
in <= 63)) {
3198 struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->
rtcp->dtls;
3203 ast_log(
LOG_ERROR,
"Received SSL traffic on RTP instance '%p' without an SSL session\n",
3208 ast_debug_dtls(3,
"(%p) DTLS - __rtp_recvfrom rtp=%p - Got SSL packet '%d'\n", instance, rtp, *
in);
3217#ifdef HAVE_PJPROJECT
3219 int pass_src_check = 0;
3233 if (!rtp->ice_media_started) {
3246 for (ix = 0; ix < rtp->ice->real_ice->rcand_cnt; ix++) {
3247 pj_ice_sess_cand *rcand = &rtp->ice->real_ice->rcand[ix];
3254 if (!pass_src_check) {
3255 ast_log(
LOG_WARNING,
"%s: DTLS packet from %s dropped. Source not in ICE active candidate list.\n",
3273 dtls_srtp_stop_timeout_timer(instance, rtp, rtcp);
3279 SSL_set_accept_state(dtls->ssl);
3282 BIO_write(dtls->read_bio,
buf,
len);
3286 if ((
len < 0) && (SSL_get_error(dtls->ssl,
len) == SSL_ERROR_SSL)) {
3287 unsigned long error = ERR_get_error();
3288 ast_log(
LOG_ERROR,
"DTLS failure occurred on RTP instance '%p' due to reason '%s', terminating\n",
3289 instance, ERR_reason_error_string(
error));
3293 if (SSL_is_init_finished(dtls->ssl)) {
3297 if ((res = dtls_srtp_setup(rtp, instance, rtcp))) {
3303 ast_debug_dtls(3,
"(%p) DTLS - __rtp_recvfrom rtp=%p - established'\n", instance, rtp);
3306 dtls_srtp_start_timeout_timer(instance, rtp, rtcp);
3313#ifdef HAVE_PJPROJECT
3323 }
else if (rtp->ice) {
3327 struct ice_wrap *ice;
3329 pj_thread_register_check();
3331 pj_sockaddr_parse(pj_AF_UNSPEC(), 0, &combined, &
address);
3337 status = pj_ice_sess_on_rx_pkt(ice->real_ice,
3340 pj_sockaddr_get_len(&
address));
3343 if (
status != PJ_SUCCESS) {
3346 pj_strerror(
status, err_buf,
sizeof(err_buf));
3351 if (!rtp->passthrough) {
3356 if (!rtp->ice_active_remote_candidates && !rtp->ice_proposed_remote_candidates) {
3365 rtp->passthrough = 0;
3401#ifdef HAVE_PJPROJECT
3402 if (transport_rtp->ice) {
3405 struct ice_wrap *ice;
3408 if (rtcp && rtp->
rtcp->
s == rtp->
s) {
3412 pj_thread_register_check();
3415 ice = transport_rtp->ice;
3417 if (instance == transport) {
3420 status = pj_ice_sess_send_data(ice->real_ice, component, temp,
len);
3422 if (instance == transport) {
3425 if (
status == PJ_SUCCESS) {
3463 unsigned int interval;
3476 double last_sum_of_squares = (*std_dev) * (*std_dev) * (*count ?: 1);
3478 if (++(*count) == 0) {
3490 delta1 = new_sample - *mean;
3491 *mean += (delta1 / *count);
3492 delta2 = new_sample - *mean;
3495 *std_dev = sqrt((last_sum_of_squares + (delta1 * delta2)) / *count);
3509 setsockopt(sock, SOL_SOCKET, SO_NO_CHECK, &nochecksums,
sizeof(nochecksums));
3528 memset(&
info->received, 0,
sizeof(
info->received));
3543 if (
seq == (uint16_t) (
info->max_seq + 1)) {
3554 switch (
info->stream_type) {
3564 }
else if (!
info->packets
3581 return info->packets;
3598#ifdef HAVE_PJPROJECT
3644static int stun_address_is_blacklisted(
const struct ast_sockaddr *addr)
3659 unsigned int count = 0;
3660 struct ifaddrs *ifa, *ia;
3663 struct ast_ice_host_candidate *candidate;
3664 int af_inet_ok = 0, af_inet6_ok = 0;
3665 struct sockaddr_in stunaddr_copy;
3670 af_inet_ok = af_inet6_ok = 1;
3675 if (getifaddrs(&ifa) < 0) {
3677 ast_log(
LOG_ERROR,
"(%p) ICE Error obtaining list of local addresses: %s\n",
3678 instance, strerror(
errno));
3680 ast_debug_ice(2,
"(%p) ICE add system candidates\n", instance);
3684 for (ia = ifa; ia && count < PJ_ICE_MAX_CAND; ia = ia->ifa_next) {
3687 if (!ia->ifa_addr || (ia->ifa_flags & IFF_UP) == 0) {
3692 if (ia->ifa_addr->sa_family != AF_INET && ia->ifa_addr->sa_family != AF_INET6) {
3698 if (ia->ifa_addr->sa_family == AF_INET) {
3699 const struct sockaddr_in *sa_in = (
struct sockaddr_in*)ia->ifa_addr;
3707 if ((sa_in->sin_addr.s_addr & htonl(0xFF000000)) == htonl(0x7F000000)) {
3712 if ((sa_in->sin_addr.s_addr & htonl(0xFF000000)) == 0) {
3735 if (!rtp_address_is_ice_blacklisted(&candidate->advertised)) {
3737 pj_sockaddr_set_port(&pjtmp, port);
3738 ast_rtp_ice_add_cand(instance, rtp, component, transport,
3739 PJ_ICE_CAND_TYPE_HOST, 65535, &pjtmp, &pjtmp,
NULL,
3740 pj_sockaddr_get_len(&pjtmp));
3744 if (!candidate->include_local) {
3761 if (rtp_address_is_ice_blacklisted(&
tmp)) {
3766 pj_sockaddr_set_port(&pjtmp, port);
3767 ast_rtp_ice_add_cand(instance, rtp, component, transport,
3768 PJ_ICE_CAND_TYPE_HOST, 65535, &pjtmp, &pjtmp,
NULL,
3769 pj_sockaddr_get_len(&pjtmp));
3776 memcpy(&stunaddr_copy, &stunaddr,
sizeof(stunaddr));
3780 if (stunaddr_copy.sin_addr.s_addr && !stun_address_is_blacklisted(addr) &&
3782 count < PJ_ICE_MAX_CAND) {
3783 struct sockaddr_in
answer;
3787 "(%p) ICE request STUN %s %s candidate\n", instance,
3801 pj_sockaddr
ext, base;
3803 int srflx = 1, baseset = 0;
3806 pj_sockaddr_init(pj_AF_INET(), &
ext, &mapped, ntohs(
answer.sin_port));
3820 if (!pj_sockaddr_cmp(&candidate->
address, &
ext)) {
3828 if (srflx && baseset) {
3829 pj_sockaddr_set_port(&base, port);
3830 ast_rtp_ice_add_cand(instance, rtp, component, transport,
3831 PJ_ICE_CAND_TYPE_SRFLX, 65535, &
ext, &base, &base,
3832 pj_sockaddr_get_len(&
ext));
3838 if (pj_strlen(&turnaddr)) {
3839 ast_rtp_ice_turn_request(instance, component,
AST_TRANSPORT_TCP, pj_strbuf(&turnaddr), turnport,
3840 pj_strbuf(&turnusername), pj_strbuf(&turnpassword));
3871 return (
unsigned int) ms;
3874#ifdef HAVE_PJPROJECT
3892 pj_stun_config stun_config;
3893 pj_str_t ufrag, passwd;
3895 struct ice_wrap *ice_old;
3896 struct ice_wrap *ice;
3897 pj_ice_sess *real_ice =
NULL;
3901 rtp->ice_local_candidates =
NULL;
3907 ast_rtp_ice_stop(instance);
3911 pj_thread_register_check();
3913 pj_stun_config_init(&stun_config, &
cachingpool.factory, 0,
NULL, timer_heap);
3914 if (!stun_software_attribute) {
3915 stun_config.software_name = pj_str(
NULL);
3918 ufrag = pj_str(rtp->local_ufrag);
3919 passwd = pj_str(rtp->local_passwd);
3924 status = pj_ice_sess_create(&stun_config,
NULL, PJ_ICE_SESS_ROLE_UNKNOWN,
3925 rtp->ice_num_components, &ast_rtp_ice_sess_cb, &ufrag, &passwd,
NULL, &real_ice);
3927 if (
status == PJ_SUCCESS) {
3929 real_ice->user_data = instance;
3930 ice->real_ice = real_ice;
3946 if (
replace && rtp->
rtcp && rtp->ice_num_components > 1) {
3947 rtp_add_candidates_to_ice(instance, rtp, &rtp->
rtcp->
us,
3961 ast_rtp_ice_stop(instance);
3969 int x, startplace, i, maxloops;
3978 ast_log(
LOG_WARNING,
"Failed to create a new socket for RTP instance '%p'\n", instance);
3990 for (i = 0; i <= maxloops; i++) {
3994 ast_debug_rtp(1,
"(%p) RTP allocated port %d\n", instance, x);
4006 if (x == startplace || (
errno != EADDRINUSE &&
errno != EACCES)) {
4007 ast_log(
LOG_ERROR,
"Oh dear... we couldn't allocate a port for RTP instance '%p'\n", instance);
4014#ifdef HAVE_PJPROJECT
4023 rtp->ice_num_components = 2;
4024 ast_debug_ice(2,
"(%p) ICE creating session %s (%d)\n", instance,
4035#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
4037 rtp->dtls.timeout_timer = -1;
4045 int saved_rtp_s = rtp->
s;
4046#ifdef HAVE_PJPROJECT
4048 struct timespec ts = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000, };
4051#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
4052 ast_rtp_dtls_stop(instance);
4063 if (saved_rtp_s != rtp->
rtcp->
s) {
4064 close(rtp->
rtcp->
s);
4069#ifdef HAVE_PJPROJECT
4070 pj_thread_register_check();
4077 if (rtp->turn_rtp) {
4078 rtp->turn_state = PJ_TURN_STATE_NULL;
4082 pj_turn_sock_destroy(rtp->turn_rtp);
4084 while (rtp->turn_state != PJ_TURN_STATE_DESTROYING) {
4087 rtp->turn_rtp =
NULL;
4091 if (rtp->turn_rtcp) {
4092 rtp->turn_state = PJ_TURN_STATE_NULL;
4096 pj_turn_sock_destroy(rtp->turn_rtcp);
4098 while (rtp->turn_state != PJ_TURN_STATE_DESTROYING) {
4101 rtp->turn_rtcp =
NULL;
4104 ast_debug_ice(2,
"(%p) ICE RTP transport deallocating\n", instance);
4106 ast_rtp_ice_stop(instance);
4109 if (rtp->ice_local_candidates) {
4110 ao2_ref(rtp->ice_local_candidates, -1);
4111 rtp->ice_local_candidates =
NULL;
4114 if (rtp->ice_active_remote_candidates) {
4115 ao2_ref(rtp->ice_active_remote_candidates, -1);
4116 rtp->ice_active_remote_candidates =
NULL;
4119 if (rtp->ice_proposed_remote_candidates) {
4120 ao2_ref(rtp->ice_proposed_remote_candidates, -1);
4121 rtp->ice_proposed_remote_candidates =
NULL;
4131 rtp_ioqueue_thread_remove(rtp->ioqueue);
4133 rtp->ioqueue =
NULL;
4149 rtp->
owner = instance;
4192#define SSRC_MAPPING_ELEM_CMP(elem, value) ((elem).instance == (value))
4286 int hdrlen = 12, res = 0, i = 0, payload = 101;
4288 unsigned int *rtpheader = (
unsigned int*)data;
4300 }
else if (
digit ==
'*') {
4302 }
else if (
digit ==
'#') {
4304 }
else if ((
digit >=
'A') && (
digit <=
'D')) {
4306 }
else if ((
digit >=
'a') && (
digit <=
'd')) {
4322 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->
seqno));
4324 rtpheader[2] = htonl(rtp->
ssrc);
4327 for (i = 0; i < 2; i++) {
4331 res =
rtp_sendto(instance, (
void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
4338 ast_verbose(
"Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
4340 ice ?
" (via ICE)" :
"",
4345 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->
seqno));
4361 int hdrlen = 12, res = 0;
4363 unsigned int *rtpheader = (
unsigned int*)data;
4376 rtpheader[2] = htonl(rtp->
ssrc);
4380 res =
rtp_sendto(instance, (
void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
4388 ast_verbose(
"Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
4390 ice ?
" (via ICE)" :
"",
4407 int hdrlen = 12, res = -1, i = 0;
4409 unsigned int *rtpheader = (
unsigned int*)data;
4410 unsigned int measured_samples;
4422 }
else if (
digit ==
'*') {
4424 }
else if (
digit ==
'#') {
4426 }
else if ((
digit >=
'A') && (
digit <=
'D')) {
4428 }
else if ((
digit >=
'a') && (
digit <=
'd')) {
4438 ast_debug_rtp(2,
"(%p) RTP adjusting final end duration from %d to %u\n",
4445 rtpheader[2] = htonl(rtp->
ssrc);
4447 rtpheader[3] |= htonl((1 << 23));
4450 for (i = 0; i < 3; i++) {
4455 res =
rtp_sendto(instance, (
void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
4464 ast_verbose(
"Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
4466 ice ?
" (via ICE)" :
"",
4505 ast_debug_rtp(3,
"(%p) RTP setting the marker bit due to a source update\n", instance);
4523 ast_debug_rtp(3,
"(%p) RTP changing ssrc from %u to %u due to a source change\n",
4524 instance,
rtp->ssrc, ssrc);
4527 ast_debug_rtp(3,
"(%p) RTP changing ssrc for SRTP from %u to %u\n",
4528 instance,
rtp->ssrc, ssrc);
4530 if (rtcp_srtp != srtp) {
4538 rtp->expectedrxseqno = -1;
4543static void timeval2ntp(
struct timeval tv,
unsigned int *msw,
unsigned int *lsw)
4545 unsigned int sec, usec, frac;
4546 sec = tv.tv_sec + 2208988800u;
4567 frac = ((((usec << 12) / 125) << 7) / 125) << 7;
4572static void ntp2timeval(
unsigned int msw,
unsigned int lsw,
struct timeval *tv)
4574 tv->tv_sec = msw - 2208988800u;
4576 tv->tv_usec = ((((lsw >> 7) * 125) >> 7) * 125) >> 12;
4580 unsigned int *lost_packets,
4583 unsigned int extended_seq_no;
4584 unsigned int expected_packets;
4585 unsigned int expected_interval;
4586 unsigned int received_interval;
4590 extended_seq_no =
rtp->cycles +
rtp->lastrxseqno;
4591 expected_packets = extended_seq_no -
rtp->seedrxseqno + 1;
4592 if (
rtp->rxcount > expected_packets) {
4593 expected_packets +=
rtp->rxcount - expected_packets;
4595 *lost_packets = expected_packets -
rtp->rxcount;
4596 expected_interval = expected_packets -
rtp->rtcp->expected_prior;
4597 received_interval =
rtp->rxcount -
rtp->rtcp->received_prior;
4598 if (received_interval > expected_interval) {
4604 expected_interval = received_interval;
4606 lost_interval = expected_interval - received_interval;
4607 if (expected_interval == 0 || lost_interval <= 0) {
4610 *fraction_lost = (lost_interval << 8) / expected_interval;
4614 rtp->rtcp->received_prior =
rtp->rxcount;
4615 rtp->rtcp->expected_prior = expected_packets;
4623 if (lost_interval <= 0) {
4624 rtp->rtcp->rxlost = 0;
4626 rtp->rtcp->rxlost = lost_interval;
4628 if (
rtp->rtcp->rxlost_count == 0) {
4629 rtp->rtcp->minrxlost =
rtp->rtcp->rxlost;
4631 if (lost_interval && lost_interval < rtp->rtcp->minrxlost) {
4632 rtp->rtcp->minrxlost =
rtp->rtcp->rxlost;
4634 if (lost_interval >
rtp->rtcp->maxrxlost) {
4635 rtp->rtcp->maxrxlost =
rtp->rtcp->rxlost;
4639 &
rtp->rtcp->stdev_rxlost, &
rtp->rtcp->rxlost_count);
4648 unsigned int now_lsw;
4649 unsigned int now_msw;
4650 unsigned int lost_packets;
4652 struct timeval dlsr = { 0, };
4655 if (!rtp || !rtp->
rtcp) {
4678 gettimeofday(&now,
NULL);
4690 report_block =
ast_calloc(1,
sizeof(*report_block));
4691 if (!report_block) {
4705 report_block->
dlsr = (((
dlsr.tv_sec * 1000) + (
dlsr.tv_usec / 1000)) * 65536) / 1000;
4742 if (!rtp || !rtp->
rtcp) {
4765 ast_verbose(
"* Sent RTCP %s to %s%s\n", sr ?
"SR" :
"RR",
4786 ast_verbose(
" DLSR: %4.4f (sec)\n\n", (
double)(report_block->
dlsr / 65536.0));
4796 rtcp_report, message_blob);
4806 uint16_t sdes_packet_len_bytes;
4807 uint16_t sdes_packet_len_rounded;
4809 if (!rtp || !rtp->
rtcp) {
4821 sdes_packet_len_bytes =
4830 sdes_packet_len_rounded = (sdes_packet_len_bytes + 3) & ~0x3;
4834 rtcpheader[8] = 0x01;
4849 len += (sdes_packet_len_rounded - sdes_packet_len_bytes);
4872 if (res == 0 || res == 1) {
4873 ast_debug_rtcp(1,
"(%p) RTCP failed to generate %s report!\n", instance, sr ?
"SR" :
"RR");
4881 if (res == 0 || res == 1) {
4882 ast_debug_rtcp(1,
"(%p) RTCP failed to generate SDES!\n", instance);
4886 return packet_len + res;
4895 unsigned int fci = 0;
4896 size_t remaining_missing_seqno;
4898 if (!rtp || !rtp->
rtcp) {
4911 if (!remaining_missing_seqno) {
4918 while (remaining_missing_seqno) {
4930 if (blp_index >= 17) {
4937 if (blp_index == 0) {
4938 fci |= (current_seqno << 16);
4940 fci |= (1 << (blp_index - 1));
4944 remaining_missing_seqno--;
4983 unsigned char *rtcpheader;
4997 if (res == 0 || res == 1) {
5009 res =
rtcp_sendto(instance, (
unsigned int *)rtcpheader, packet_len, 0, &remote_address, &ice);
5036 unsigned char *cp = p;
5040 datum = (time_msw << 18) & 0x00fc0000;
5041 datum |= (time_lsw >> 14) & 0x0003ffff;
5043 cp[0] =
datum >> 16;
5057#ifdef TEST_FRAMEWORK
5058 struct ast_rtp_engine_test *
test = ast_rtp_instance_get_test(instance);
5069#ifdef TEST_FRAMEWORK
5071 test->send_report = 0;
5088 ast_debug_rtp(3,
"(%p) RTP audio difference is %d, ms is %u\n",
5089 instance,
abs((
int)rtp->
lastts - pred), ms);
5100 if (
abs((
int)rtp->
lastts - pred) < 7200) {
5104 ast_debug_rtp(3,
"(%p) RTP video difference is %d, ms is %u (%u), pred/ts/samples %u/%d/%d\n",
5115 if (
abs((
int)rtp->
lastts - pred) < 7200) {
5119 ast_debug_rtp(3,
"(%p) RTP other difference is %d, ms is %u, pred/ts/samples %u/%d/%d\n",
5151 if (
abs(difference) > 100) {
5156 seqno += difference;
5158 if (difference >= 0) {
5161 rtp->
seqno += difference;
5183 int abs_send_time_id;
5185 unsigned char *rtpheader;
5189 if (abs_send_time_id != -1) {
5195 packet_len = frame->
datalen + hdrlen;
5196 rtpheader = (
unsigned char *)(frame->
data.
ptr - hdrlen);
5205 if (abs_send_time_id != -1) {
5206 unsigned int now_msw;
5207 unsigned int now_lsw;
5213 rtpheader[16] = (abs_send_time_id << 4) | 2;
5223 payload =
ast_malloc(
sizeof(*payload) + packet_len);
5225 payload->
size = packet_len;
5226 memcpy(payload->
buf, rtpheader, packet_len);
5233 res =
rtp_sendto(instance, (
void *)rtpheader, packet_len, 0, &remote_address, &ice);
5236 ast_debug_rtp(1,
"(%p) RTP transmission error of packet %d to %s: %s\n",
5237 instance, rtp->
seqno,
5243 ast_debug(0,
"(%p) RTP NAT: Can't write RTP to private address %s, waiting for other end to send audio...\n",
5261 ast_verbose(
"Sent RTP packet to %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
5263 ice ?
" (via ICE)" :
"",
5272 if (seqno == rtp->
seqno) {
5287 for (i = 1; i < red->
num_gen+1; i++)
5294 for (i = 0; i < red->
num_gen; i++)
5295 red->
len[i] = red->
len[i+1];
5300 for (i = 0; i < red->
num_gen; i++) {
5321 unsigned char *rtcpheader;
5322 unsigned char bdata[1024];
5330 if (!rtp || !rtp->
rtcp) {
5358 if (res == 0 || res == 1) {
5370 res =
rtcp_sendto(instance, (
unsigned int *)rtcpheader, packet_len + fir_len, 0, rtp->
bundled ? remote_address : &rtp->
rtcp->
them, &ice);
5383 unsigned char *rtcpheader;
5384 unsigned char bdata[1024];
5393 ast_debug_rtcp(1,
"(%p) RTCP provided feedback frame of format %d to write, but only REMB is supported\n",
5394 instance, feedback->
fmt);
5398 if (!rtp || !rtp->
rtcp) {
5404 ast_debug_rtcp(1,
"(%p) RTCP provided feedback REMB report to write, but REMB support not enabled\n",
5422 if (res == 0 || res == 1) {
5432 put_unaligned_uint32(rtcpheader + packet_len + 12, htonl((
'R' << 24) | (
'E' << 16) | (
'M' << 8) | (
'B')));
5435 res =
rtcp_sendto(instance, (
unsigned int *)rtcpheader, packet_len + remb_len, 0, rtp->
bundled ? remote_address : &rtp->
rtcp->
them, &ice);
5457 ast_debug_rtp(1,
"(%p) RTP no remote address on instance, so dropping frame\n", instance);
5474 ast_debug_rtp(1,
"(%p) RTP received frame with no data for instance, so dropping frame\n", instance);
5506 ast_debug_rtp(1,
"(%s) RTP ooh, format changed from %s to %s\n",
5554 if (frame->
offset < hdrlen) {
5572 struct ast_rtp *rtp,
unsigned int rx_rtp_ts,
5577 double jitter = 0.0;
5578 double prev_jitter = 0.0;
5583 unsigned int arrival;
5587 gettimeofday(&now,
NULL);
5589 if (rtp->
rxcount == 1 || mark) {
5611 "Seed ts: %u current time: %f\n",
5653 "pkt: %5u Stable Seed ts: %u current time: %f\n",
5669 ast_debug_rtcp(3,
"%s: Current packet seq %d != last packet seq %d + 1. Ignoring\n",
5709 transit = arrival - rx_rtp_ts;
5717 jitter = (1.0/16.0) * (((
double)
d) - prev_jitter);
5726 "Arrival sec: %7.3f Arrival ts: %10u RX ts: %10u "
5727 "Transit samp: %6d Last transit samp: %6d d: %4d "
5728 "Curr jitter: %7.0f(%7.3f) Prev Jitter: %7.0f(%7.3f) New Jitter: %7.0f(%7.3f)\n",
5774 ast_debug_rtp(1,
"(%p) RTP ignore potential DTMF echo from '%s'\n",
5787 if (rtp->
resp ==
'X') {
5793 ast_debug_rtp(1,
"(%p) RTP creating %s DTMF Frame: %d (%c), at %s\n",
5813 unsigned int event, event_end, samples;
5820 event = ntohl(*((
unsigned int *)(
data)));
5822 event_end = ntohl(*((
unsigned int *)(
data)));
5829 ast_verbose(
"Got RTP RFC2833 from %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6d, mark %d, event %08x, end %d, duration %-5.5u) \n",
5841 }
else if (
event < 11) {
5843 }
else if (
event < 12) {
5845 }
else if (
event < 16) {
5846 resp =
'A' + (
event - 12);
5847 }
else if (
event < 17) {
5851 ast_debug_rtp(1,
"(%p) RTP ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", instance,
event);
5872 unsigned int last_duration = new_duration & 0xFFFF;
5874 if (last_duration > 64000 &&
samples < last_duration) {
5875 new_duration += 0xFFFF + 1;
5877 new_duration = (new_duration & ~0xFFFF) |
samples;
5879 if (event_end & 0x80) {
5892 ast_debug_rtp(1,
"(%p) RTP dropping duplicate or out of order DTMF END frame (seqno: %u, ts %u, digit %c)\n",
5893 instance,
seqno, timestamp, resp);
5904 && timestamp <= rtp->last_end_timestamp.ts)) {
5910 ast_debug(0,
"Dropping out of order DTMF frame (seqno %u, ts %u, digit %c)\n",
5911 seqno, timestamp, resp);
5916 if (rtp->
resp && rtp->
resp != resp) {
5992 event =
data[3] & 0x1f;
5995 ast_debug(0,
"Cisco DTMF Digit: %02x (len=%d, seq=%d, flags=%02x, power=%u, history count=%d)\n",
event,
len,
seq,
flags, power, (
len - 4) / 2);
5998 }
else if (
event < 11) {
6000 }
else if (
event < 12) {
6002 }
else if (
event < 16) {
6003 resp =
'A' + (
event - 12);
6004 }
else if (
event < 17) {
6007 if ((!rtp->
resp && power) || (rtp->
resp && (rtp->
resp != resp))) {
6014 }
else if ((rtp->
resp == resp) && !power) {
6018 }
else if (rtp->
resp == resp) {
6035 ast_debug(0,
"- RTP 3389 Comfort noise event: Format %s (len = %d)\n",
6044 ast_log(
LOG_NOTICE,
"Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client address: %s\n",
6074 struct timeval rtt_tv;
6077 unsigned int rtt_msw;
6078 unsigned int rtt_lsw;
6082 gettimeofday(&now,
NULL);
6085 lsr_a = ((msw & 0x0000ffff) << 16) | ((lsw & 0xffff0000) >> 16);
6086 rtt = lsr_a - lsr - dlsr;
6087 rtt_msw = (rtt & 0xffff0000) >> 16;
6088 rtt_lsw = (rtt & 0x0000ffff);
6089 rtt_tv.tv_sec = rtt_msw;
6103 rtt_tv.tv_usec = (rtt_lsw * 15625) >> 10;
6104 rtp->
rtcp->
rtt = (double)rtt_tv.tv_sec + ((
double)rtt_tv.tv_usec / 1000000);
6105 if (lsr_a - dlsr < lsr) {
6154 double reported_lost;
6161 if (reported_lost < rtp->rtcp->reported_minlost) {
6172#define RESCALE(in, inmin, inmax, outmin, outmax) ((((in - inmin)/(inmax-inmin))*(outmax-outmin))+outmin)
6197 double normdevrtt,
double normdev_rxjitter,
double stdev_rxjitter,
6198 double normdev_rxlost)
6213 double effective_latency = (normdevrtt * 1000)
6214 + ((normdev_rxjitter * 2) * (stdev_rxjitter / 3))
6225 if (effective_latency < 160) {
6226 r_value = 93.2 - (effective_latency / 40);
6228 r_value = 93.2 - (effective_latency - 120) / 10;
6232 r_value = r_value - (normdev_rxlost * 2.0);
6240 }
else if (r_value > 100) {
6243 pseudo_mos = 1 + (0.035 * r_value) + (r_value * (r_value - 60) * (100 - r_value) * 0.000007);
6251 mes =
RESCALE(pseudo_mos, 0.0, 5.0, 0.0, 100.0);
6273 if (mes < rtp->rtcp->reported_minmes) {
6283 ast_debug_rtcp(2,
"%s: rtt: %.9f j: %.9f sjh: %.9f lost: %.9f mes: %4.1f\n",
6317 ast_debug_rtcp(2,
" %s: rtt: %.9f j: %.9f sjh: %.9f lost: %.9f mes: %4.1f\n",
6327 struct ast_rtp *rtp,
unsigned int ssrc,
int source)
6355 struct ast_rtp *rtp,
unsigned int ssrc)
6362 struct ast_rtp *rtp,
unsigned int ssrc)
6373 str =
"Sender Report";
6376 str =
"Receiver Report";
6387 str =
"Source Description";
6421 unsigned int length)
6429 unsigned int current_word;
6433 int abs_send_time_id;
6434 unsigned int now_msw = 0;
6435 unsigned int now_lsw = 0;
6436 unsigned int packets_not_found = 0;
6440 "but we don't have a RTP packet storage!\n", instance);
6445 if (abs_send_time_id != -1) {
6455 for (packet_index = 3; packet_index < length; packet_index++) {
6456 current_word = ntohl(nackdata[position + packet_index]);
6457 pid = current_word >> 16;
6461 if (abs_send_time_id != -1) {
6467 res +=
rtp_sendto(instance, payload->
buf, payload->
size, 0, &remote_address, &ice);
6469 ast_debug_rtcp(1,
"(%p) RTCP received NACK request for RTP packet with seqno %d, "
6470 "but we don't have it\n", instance, pid);
6471 packets_not_found++;
6479 blp = current_word & 0xffff;
6484 unsigned int seqno = (pid + blp_index) % 65536;
6487 if (abs_send_time_id != -1) {
6490 res +=
rtp_sendto(instance, payload->
buf, payload->
size, 0, &remote_address, &ice);
6492 ast_debug_rtcp(1,
"(%p) RTCP remote end also requested RTP packet with seqno %d, "
6493 "but we don't have it\n", instance, seqno);
6494 packets_not_found++;
6502 if (packets_not_found) {
6508 ast_debug_rtcp(2,
"(%p) RTCP send buffer on RTP instance is now at maximum of %zu\n",
6518#define RTCP_LENGTH_MASK 0xFFFF
6519#define RTCP_PAYLOAD_TYPE_MASK 0xFF
6520#define RTCP_REPORT_COUNT_MASK 0x1F
6521#define RTCP_PADDING_MASK 0x01
6522#define RTCP_VERSION_MASK 0x03
6527#define RTCP_LENGTH_SHIFT 0
6528#define RTCP_PAYLOAD_TYPE_SHIFT 16
6529#define RTCP_REPORT_COUNT_SHIFT 24
6530#define RTCP_PADDING_SHIFT 29
6531#define RTCP_VERSION_SHIFT 30
6533#define RTCP_VERSION 2U
6534#define RTCP_VERSION_SHIFTED (RTCP_VERSION << RTCP_VERSION_SHIFT)
6535#define RTCP_VERSION_MASK_SHIFTED (RTCP_VERSION_MASK << RTCP_VERSION_SHIFT)
6548#define RTCP_VALID_MASK (RTCP_VERSION_MASK_SHIFTED | (((RTCP_PAYLOAD_TYPE_MASK & ~0x1)) << RTCP_PAYLOAD_TYPE_SHIFT))
6549#define RTCP_VALID_VALUE (RTCP_VERSION_SHIFTED | (RTCP_PT_SR << RTCP_PAYLOAD_TYPE_SHIFT))
6551#define RTCP_SR_BLOCK_WORD_LENGTH 5
6552#define RTCP_RR_BLOCK_WORD_LENGTH 6
6553#define RTCP_HEADER_SSRC_LENGTH 2
6554#define RTCP_FB_REMB_BLOCK_WORD_LENGTH 4
6555#define RTCP_FB_NACK_BLOCK_WORD_LENGTH 2
6558 const unsigned char *rtcpdata,
size_t size,
struct ast_sockaddr *addr)
6563 unsigned int *rtcpheader = (
unsigned int *)(rtcpdata);
6564 unsigned int packetwords;
6565 unsigned int position;
6566 unsigned int first_word;
6568 unsigned int ssrc_seen;
6571#ifdef TEST_FRAMEWORK
6572 struct ast_rtp_engine_test *test_engine;
6581 packetwords =
len / 4;
6592 ast_debug_rtcp(2,
"(%s) RTCP %p -- from %s: Frame size (%u words) is too short\n",
6598 first_word = ntohl(rtcpheader[position]);
6600 ast_debug_rtcp(2,
"(%s) RTCP %p -- from %s: Failed first packet validity check\n",
6607 if (packetwords <= position) {
6610 first_word = ntohl(rtcpheader[position]);
6612 if (position != packetwords) {
6613 ast_debug_rtcp(2,
"(%s) RTCP %p -- from %s: Failed packet version or length check\n",
6638 while (position < packetwords) {
6644 unsigned int ssrc_valid;
6645 unsigned int length;
6646 unsigned int min_length;
6648 unsigned int use_packet_source = 1;
6657 first_word = ntohl(rtcpheader[i]);
6671 use_packet_source = 0;
6683 use_packet_source = 0;
6702 min_length = length;
6705 ast_debug_rtcp(1,
"(%p) RTCP %p -- from %s: %u(%s) skipping record\n",
6709 ast_verbose(
"RTCP from %s: %u(%s) skipping record\n",
6715 if (length < min_length) {
6716 ast_debug_rtcp(1,
"(%p) RTCP %p -- from %s: %u(%s) length field less than expected minimum. Min:%u Got:%u\n",
6718 min_length - 1, length - 1);
6731 rtcp_report->reception_report_count = rc;
6733 ssrc = ntohl(rtcpheader[i + 2]);
6734 rtcp_report->ssrc = ssrc;
6738 ssrc = ntohl(rtcpheader[i + 1]);
6741 ssrc = ntohl(rtcpheader[i + 2]);
6758 ast_verbose(
"Packet Subtype: %u (%s)\n", rc, subtype);
6771 if (use_packet_source) {
6776 if (child && child != transport) {
6788 rtp = transport_rtp;
6792 rtp = transport_rtp;
6805 if ((ssrc != rtp->
themssrc && use_packet_source && ssrc != 1)
6813 ast_debug_rtcp(1,
"(%p) RTCP %p -- from %s: Skipping record, received SSRC '%u' != expected '%u'\n",
6828 ast_debug(0,
"(%p) RTCP NAT: Got RTCP from other end. Now sending to address %s\n",
6838 rtp->
rtcp->
themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16);
6839 rtp->
rtcp->
spc = ntohl(rtcpheader[i + 3]);
6840 rtp->
rtcp->
soc = ntohl(rtcpheader[i + 4]);
6843 rtcp_report->sender_information.packet_count = rtp->
rtcp->
spc;
6844 rtcp_report->sender_information.octet_count = rtp->
rtcp->
soc;
6846 (
unsigned int)ntohl(rtcpheader[i + 1]),
6847 &rtcp_report->sender_information.ntp_timestamp);
6848 rtcp_report->sender_information.rtp_timestamp = ntohl(rtcpheader[i + 2]);
6851 (
unsigned int)rtcp_report->sender_information.ntp_timestamp.tv_sec,
6852 (
unsigned int)rtcp_report->sender_information.ntp_timestamp.tv_usec);
6853 ast_verbose(
"RTP timestamp: %u\n", rtcp_report->sender_information.rtp_timestamp);
6855 rtcp_report->sender_information.packet_count,
6856 rtcp_report->sender_information.octet_count);
6867 report_block =
ast_calloc(1,
sizeof(*report_block));
6868 if (!report_block) {
6874 rtcp_report->report_block[0] = report_block;
6879 report_block->
ia_jitter = ntohl(rtcpheader[i + 3]);
6880 report_block->
lsr = ntohl(rtcpheader[i + 4]);
6881 report_block->
dlsr = ntohl(rtcpheader[i + 5]);
6882 if (report_block->
lsr) {
6886 unsigned int lsr_now, lsw, msw;
6887 gettimeofday(&now,
NULL);
6889 lsr_now = (((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16));
6890 ast_verbose(
"Internal RTCP NTP clock skew detected: "
6891 "lsr=%u, now=%u, dlsr=%u (%u:%03ums), "
6893 report_block->
lsr, lsr_now, report_block->
dlsr, report_block->
dlsr / 65536,
6894 (report_block->
dlsr % 65536) * 1000 / 65536,
6895 report_block->
dlsr - (lsr_now - report_block->
lsr));
6916 ast_verbose(
" Last SR(our NTP): %lu.%010lu\n",(
unsigned long)(report_block->
lsr) >> 16,((
unsigned long)(report_block->
lsr) << 16) * 4096);
6917 ast_verbose(
" DLSR: %4.4f (sec)\n",(
double)report_block->
dlsr / 65536.0);
6957 transport_rtp->
f.
src =
"RTP";
6959 f = &transport_rtp->
f;
6970 ast_verbose(
"Received generic RTCP NACK message\n");
6987 ast_verbose(
"Received an RTCP Fast Update Request\n");
6994 transport_rtp->
f.
src =
"RTP";
6995 f = &transport_rtp->
f;
7010 feedback = transport_rtp->
f.
data.
ptr;
7014 first_word = ntohl(rtcpheader[i + 2]);
7015 feedback->
remb.
br_exp = (first_word >> 18) & ((1 << 6) - 1);
7024 transport_rtp->
f.
src =
"RTP";
7025 f = &transport_rtp->
f;
7036#ifdef TEST_FRAMEWORK
7037 if ((test_engine = ast_rtp_instance_get_test(instance))) {
7038 test_engine->sdes_received = 1;
7074 if ((res =
rtcp_recvfrom(instance, read_area, read_area_size,
7083 if (
errno != EAGAIN) {
7097 struct sockaddr_in addr_tmp;
7107 ast_debug_stun(2,
"(%p) STUN cannot do for non IPv4 address %s\n",
7127 int res = 0, payload = 0, bridged_payload = 0, mark;
7132 unsigned int timestamp = ntohl(rtpheader[1]);
7140 if (!payload_type) {
7146 payload_type->asterisk_format, payload_type->format, payload_type->rtp_code);
7149 if (bridged_payload < 0) {
7155 ast_debug_rtp(1,
"(%p, %p) RTP unsupported payload type received\n", instance, instance1);
7165 ast_debug_rtp(1,
"(%p, %p) RTP feeding packet with duplicate timestamp to core\n", instance, instance1);
7169 if (payload_type->asterisk_format) {
7197 ast_debug_rtp(1,
"(%p, %p) RTP Feeding packet to core until DTMF finishes\n", instance, instance1);
7203 if (payload_type->asterisk_format) {
7211 ast_debug_rtp(1,
"(%p, %p) RTP asymmetric RTP codecs detected (TX: %s, RX: %s) sending frame to core\n",
7225 ast_debug_rtp(5,
"(%p, %p) RTP remote address is null, most likely RTP has been stopped\n",
7226 instance, instance1);
7252 bridged->
ssrc = ntohl(rtpheader[2]);
7256 res =
rtp_sendto(instance1, (
void *)rtpheader,
len, 0, &remote_address, &ice);
7260 "RTP Transmission error of packet to %s: %s\n",
7266 "RTP NAT: Can't write RTP to private "
7267 "address %s, waiting for other end to "
7279 ast_verbose(
"Sent RTP P2P packet to %s%s (type %-2.2d, len %-6.6d)\n",
7281 ice ?
" (via ICE)" :
"",
7282 bridged_payload,
len - hdrlen);
7300 return a.seqno -
b.seqno;
7304 uint16_t *status_vector_chunk,
int status)
7307 *status_vector_chunk_bits -= 2;
7313 *status_vector_chunk |= (
status << (16 - 2 - (14 - *status_vector_chunk_bits)));
7316 if (*status_vector_chunk_bits) {
7322 *status_vector_chunk_bits = 14;
7328 *status_vector_chunk = (1 << 15) | (1 << 14);
7333 uint16_t *status_vector_chunk,
int *run_length_chunk_count,
int *run_length_chunk_status,
int status)
7335 if (*run_length_chunk_status !=
status) {
7336 while (*run_length_chunk_count > 0 && *run_length_chunk_count < 8) {
7344 status_vector_chunk, *run_length_chunk_status);
7345 *run_length_chunk_count -= 1;
7348 if (*run_length_chunk_count) {
7350 put_unaligned_uint16(rtcpheader + *packet_len, htons((0 << 15) | (*run_length_chunk_status << 13) | *run_length_chunk_count));
7355 *run_length_chunk_count = 0;
7356 *run_length_chunk_status = -1;
7358 if (*status_vector_chunk_bits == 14) {
7360 *run_length_chunk_status =
status;
7361 *run_length_chunk_count = 1;
7365 status_vector_chunk,
status);
7369 *run_length_chunk_count += 1;
7377 unsigned char *rtcpheader;
7382 int status_vector_chunk_bits = 14;
7383 uint16_t status_vector_chunk = (1 << 15) | (1 << 14);
7384 int run_length_chunk_count = 0;
7385 int run_length_chunk_status = -1;
7386 int packet_len = 20;
7388 int packet_count = 0;
7389 unsigned int received_msw;
7390 unsigned int received_lsw;
7394 unsigned int large_delta_count = 0;
7395 unsigned int small_delta_count = 0;
7396 unsigned int lost_count = 0;
7411 rtcpheader = (
unsigned char *)bdata;
7415 previous_packet = first_packet;
7442 &status_vector_chunk, &run_length_chunk_count, &run_length_chunk_status, 0);
7448 if (packet_len + delta_len + 20 >
sizeof(bdata)) {
7468 &status_vector_chunk, &run_length_chunk_count, &run_length_chunk_status, 2);
7470 large_delta_count++;
7474 &status_vector_chunk, &run_length_chunk_count, &run_length_chunk_status, 1);
7476 small_delta_count++;
7482 if (packet_len + delta_len + 20 >
sizeof(bdata)) {
7487 if (status_vector_chunk_bits != 14) {
7491 }
else if (run_length_chunk_count) {
7493 put_unaligned_uint16(rtcpheader + packet_len, htons((0 << 15) | (run_length_chunk_status << 13) | run_length_chunk_count));
7522 while (packet_len % 4) {
7523 rtcpheader[packet_len++] = 0;
7542 ast_debug_rtcp(2,
"(%p) RTCP sending transport-cc feedback packet of size '%d' on '%s' with packet count of %d (small = %d, large = %d, lost = %d)\n",
7545 res =
rtcp_sendto(instance, (
unsigned int *)rtcpheader, packet_len, 0, &remote_address, &ice);
7561 unsigned char *data,
int len)
7563 uint16_t *
seqno = (uint16_t *)data;
7603 ast_debug_rtcp(1,
"(%p) RTCP starting transport-cc feedback transmission on RTP instance '%p'\n", instance, transport);
7609 ast_log(
LOG_WARNING,
"Scheduling RTCP transport-cc feedback transmission failed on RTP instance '%p'\n",
7622 if (transport_wide_cc_id == -1) {
7629 int extension_len = (
extension[pos] & 0xF) + 1;
7646 }
else if (
id == 15) {
7656 }
else if ((pos + extension_len) >
len) {
7664 if (
id == transport_wide_cc_id) {
7669 pos += extension_len;
7674 const struct ast_sockaddr *remote_address,
unsigned char *read_area,
int length,
int prev_seqno,
7675 unsigned int bundled)
7677 unsigned int *rtpheader = (
unsigned int*)(read_area);
7680 int res = length, hdrlen = 12, ssrc, seqno, payloadtype, padding, mark,
ext, cc;
7681 unsigned int timestamp;
7697 ssrc = ntohl(rtpheader[2]);
7698 seqno = ntohl(rtpheader[0]);
7699 payloadtype = (seqno & 0x7f0000) >> 16;
7700 padding = seqno & (1 << 29);
7701 mark = seqno & (1 << 23);
7702 ext = seqno & (1 << 28);
7703 cc = (seqno & 0xF000000) >> 24;
7705 timestamp = ntohl(rtpheader[1]);
7711 res -= read_area[res - 1];
7721 int extensions_size = (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
7722 unsigned int profile;
7723 profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
7725 if (profile == 0xbede) {
7729 if (profile == 0x505a) {
7730 ast_log(
LOG_DEBUG,
"Found Zfone extension in RTP stream - zrtp - not supported.\n");
7737 hdrlen += extensions_size;
7758 ast_debug(0,
"(%p) RTP forcing Marker bit, because SSRC has changed\n", instance);
7800 if ((
int)prev_seqno - (
int)
seqno > 100)
7810 struct timeval rxtime;
7832 if (!payload->asterisk_format) {
7842 }
else if (payload->rtp_code ==
AST_RTP_CN) {
7896 rtp->
f.
data.
ptr = read_area + hdrlen;
7903 && ((
int)
seqno - (prev_seqno + 1) > 0)
7904 && ((
int)
seqno - (prev_seqno + 1) < 10)) {
7916 unsigned char *header_end;
7917 int num_generations;
7920 int diff =(int)
seqno - (prev_seqno+1);
7925 if (header_end ==
NULL) {
7930 header_length = header_end -
data;
7931 num_generations = header_length / 4;
7932 len = header_length;
7935 for (x = 0; x < num_generations; x++)
7943 }
else if (diff > num_generations && diff < 10) {
7953 for ( x = 0; x < num_generations - diff; x++)
8004struct rtp_drop_packets_data {
8006 unsigned int use_random_num;
8008 unsigned int use_random_interval;
8011 unsigned int num_to_drop;
8013 unsigned int num_dropped;
8016 struct timeval interval;
8018 struct timeval next;
8025static struct rtp_drop_packets_data drop_packets_data;
8027static void drop_packets_data_update(
struct timeval tv)
8036 drop_packets_data.num_dropped = drop_packets_data.use_random_num ?
8037 ast_random() % drop_packets_data.num_to_drop : 0;
8045 if (drop_packets_data.use_random_interval) {
8048 &drop_packets_data.interval) * ((
double)(
ast_random() % 100 + 1) / 100),
8051 drop_packets_data.next =
ast_tvadd(tv, interval);
8053 drop_packets_data.next =
ast_tvadd(tv, drop_packets_data.interval);
8057static int should_drop_packets(
struct ast_sockaddr *addr)
8061 if (!drop_packets_data.num_to_drop) {
8070 (drop_packets_data.port ?
8078 if (drop_packets_data.num_dropped < drop_packets_data.num_to_drop) {
8079 ++drop_packets_data.num_dropped;
8088 if (
ast_tvzero(drop_packets_data.interval)) {
8090 drop_packets_data.num_to_drop = 0;
8095 if (
ast_tvcmp(tv, drop_packets_data.next) == -1) {
8105 drop_packets_data_update(tv);
8118 int res, hdrlen = 12,
version, payloadtype;
8121 unsigned int *rtpheader = (
unsigned int*)(read_area), seqno, ssrc, timestamp, prev_seqno;
8125 unsigned int bundled;
8136 if ((res =
rtp_recvfrom(instance, read_area, read_area_size, 0,
8145 if (
errno != EAGAIN) {
8167 for (i = 0; i < res; ++i) {
8168 if (read_area[i] !=
'\0') {
8177 seqno = ntohl(rtpheader[0]);
8182 struct sockaddr_in addr_tmp;
8191 ast_debug_stun(1,
"(%p) STUN cannot do for non IPv4 address %s\n",
8209 ssrc = ntohl(rtpheader[2]);
8220 if (child != instance) {
8278 ast_verb(4,
"%p -- Strict RTP learning complete - Locking on source address %s\n",
8307 ast_verb(4,
"%p -- Strict RTP switching to RTP target address %s as source\n",
8326 ast_verb(4,
"%p -- Strict RTP qualifying stream type: %s\n",
8331 ast_verb(4,
"%p -- Strict RTP switching source address to %s\n",
8338 ast_debug_rtp(1,
"(%p) RTP %p -- Received packet from %s, dropping due to strict RTP protection. Will switch to it in %d packets.\n",
8347 ast_debug_rtp(1,
"(%p) RTP %p -- Received packet from %s, dropping due to strict RTP protection. Qualifying new stream.\n",
8366 ast_debug_rtp(1,
"(%p) RTP %p -- Received packet from %s, dropping due to strict RTP protection.\n",
8368#ifdef TEST_FRAMEWORK
8370 static int strict_rtp_test_event = 1;
8371 if (strict_rtp_test_event) {
8374 strict_rtp_test_event = 0;
8395 ast_debug(0,
"(%p) RTP NAT: Got audio from other end. Now sending to address %s\n",
8401 payloadtype = (seqno & 0x7f0000) >> 16;
8403 timestamp = ntohl(rtpheader[1]);
8406 if (should_drop_packets(&addr)) {
8407 ast_debug(0,
"(%p) RTP: drop received packet from %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6d)\n",
8414 ast_verbose(
"Got RTP packet from %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6d)\n",
8416 payloadtype, seqno, timestamp, res - hdrlen);
8430 frame =
ast_rtp_interpret(instance, srtp, &addr, read_area, res, prev_seqno, bundled);
8445 frame =
ast_rtp_interpret(instance, srtp, &addr, read_area, res, prev_seqno, bundled);
8452 ast_debug_rtp(2,
"(%p) RTP Packet with sequence number '%d' on instance is no longer missing\n",
8460 frame =
ast_rtp_interpret(instance, srtp, &addr, read_area, res, prev_seqno, bundled);
8495 ast_debug_rtp(2,
"(%p) RTP pulled buffered packet with sequence number '%d' to additionally return\n",
8496 instance, frame->
seqno);
8517 ast_debug_rtp(2,
"(%p) RTP source has wild gap or packet loss, sending FIR\n",
8535 ast_debug_rtp(2,
"(%p) RTP inserted just received packet with sequence number '%d' in correct order\n",
8560 ast_debug_rtp(2,
"(%p) RTP emptying queue and returning packet with sequence number '%d'\n",
8561 instance, frame->
seqno);
8578 frame =
ast_rtp_interpret(instance, srtp, &addr, read_area, res, prev_seqno, bundled);
8585 ast_debug_rtp(2,
"(%p) RTP adding just received packet with sequence number '%d' to end of dumped queue\n",
8620 ast_debug_rtp(2,
"(%p) RTP received an old packet with sequence number '%d', dropping it\n",
8625 ast_debug_rtp(2,
"(%p) RTP received a duplicate transmission of packet with sequence number '%d', dropping it\n",
8633 unsigned int missing_seqnos_added = 0;
8635 ast_debug_rtp(2,
"(%p) RTP received an out of order packet with sequence number '%d' while expecting '%d' from the future\n",
8638 payload =
ast_malloc(
sizeof(*payload) + res);
8649 payload->
size = res;
8650 memcpy(payload->
buf, rtpheader, res);
8662 if (!remove_failed) {
8663 ast_debug_rtp(2,
"(%p) RTP packet with sequence number '%d' is no longer missing\n",
8672 missing_seqno = seqno;
8673 while (remove_failed) {
8677 if (missing_seqno < 0) {
8678 missing_seqno = 65535;
8682 if (missing_seqno == prev_seqno) {
8710 ast_debug_rtp(2,
"(%p) RTP added missing sequence number '%d'\n",
8711 instance, missing_seqno);
8714 missing_seqnos_added++;
8739 rtcpheader =
ast_malloc(
sizeof(*rtcpheader) + data_size);
8741 ast_debug_rtcp(1,
"(%p) RTCP failed to allocate memory for NACK\n", instance);
8745 memset(rtcpheader, 0, data_size);
8749 if (res == 0 || res == 1) {
8758 ast_debug_rtcp(1,
"(%p) RTCP failed to construct NACK, stopping here\n", instance);
8764 res =
rtcp_sendto(instance, rtcpheader, packet_len, 0, &remote_address, &ice);
8766 ast_debug_rtcp(1,
"(%p) RTCP failed to send NACK request out\n", instance);
8768 ast_debug_rtcp(2,
"(%p) RTCP sending a NACK request to get missing packets\n", instance);
8788 ast_debug_rtcp(1,
"(%p) RTCP ignoring duplicate property\n", instance);
8798#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
8799 rtp->
rtcp->dtls.timeout_timer = -1;
8839 AF_INET6 : -1)) < 0) {
8840 ast_debug_rtcp(1,
"(%p) RTCP failed to create a new socket\n", instance);
8849 ast_debug_rtcp(1,
"(%p) RTCP failed to setup RTP instance\n", instance);
8850 close(rtp->
rtcp->
s);
8856#ifdef HAVE_PJPROJECT
8861#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
8862 dtls_setup_rtcp(instance);
8875 if (rtp->
rtcp->
s > -1 && rtp->
rtcp->
s != rtp->
s) {
8876 close(rtp->
rtcp->
s);
8881#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
8882 if (rtp->
rtcp->dtls.ssl && rtp->
rtcp->dtls.ssl != rtp->dtls.ssl) {
8883 SSL_free(rtp->
rtcp->dtls.ssl);
8885 rtp->
rtcp->dtls.ssl = rtp->dtls.ssl;
8900 ast_debug_rtcp(1,
"(%p) RTCP failed to tear down RTCP\n", instance);
8912 ast_debug_rtcp(1,
"(%p) RTCP failed to tear down transport-cc feedback\n", instance);
8919 if (rtp->
rtcp->
s > -1 && rtp->
rtcp->
s != rtp->
s) {
8920 close(rtp->
rtcp->
s);
8922#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
8924 dtls_srtp_stop_timeout_timer(instance, rtp, 1);
8927 if (rtp->
rtcp->dtls.ssl && rtp->
rtcp->dtls.ssl != rtp->dtls.ssl) {
8928 SSL_free(rtp->
rtcp->dtls.ssl);
8994 ast_debug_rtcp(1,
"(%p) RTCP setting address on RTP instance\n", instance);
9026 ast_verb(4,
"%p -- Strict RTP learning after remote address set to: %s\n",
9071 rtp->
red->
ti = buffer_time;
9075 for (x = 0; x < generations; x++) {
9076 rtp->
red->
pt[x] = payloads[x];
9077 rtp->
red->
pt[x] |= 1 << 7;
9098 const unsigned char *primary = red->
buf_data;
9101 if (primary[0] == 0x08 || primary[0] == 0x0a || primary[0] == 0x0d) {
9106 if (primary[0] == 0x08 || primary[0] == 0x0a || primary[0] == 0x0d) {
9235 struct sockaddr_in suggestion_tmp;
9252#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
9256 dtls_srtp_stop_timeout_timer(instance, rtp, 0);
9258 dtls_srtp_stop_timeout_timer(instance, rtp, 1);
9312 unsigned int *rtpheader;
9314 int res, payload = 0;
9328 level = 127 - (level & 0x7f);
9333 rtpheader = (
unsigned int *)data;
9334 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->
seqno));
9335 rtpheader[1] = htonl(rtp->
lastts);
9336 rtpheader[2] = htonl(rtp->
ssrc);
9339 res =
rtp_sendto(instance, (
void *) rtpheader, hdrlen + 1, 0, &remote_address, &ice);
9347 ast_verbose(
"Sent Comfort Noise RTP packet to %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
9349 ice ?
" (via ICE)" :
"",
9439 if (child_rtp->
bundled == parent) {
9484#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
9489 dtls_srtp_add_local_ssrc(parent_rtp, parent, 0, child_rtp->
ssrc, 0);
9505#ifdef HAVE_PJPROJECT
9506static void stunaddr_resolve_callback(
const struct ast_dns_query *query)
9510 const char *stunaddr_resolved_str;
9512 if (!store_stunaddr_resolved(query)) {
9513 ast_log(
LOG_WARNING,
"Failed to resolve stunaddr '%s'. Cancelling recurring resolution.\n", stunaddr_name);
9522 ast_debug_stun(2,
"Resolved stunaddr '%s' to '%s'. Lowest TTL = %d.\n",
9524 stunaddr_resolved_str,
9533static int store_stunaddr_resolved(
const struct ast_dns_query *query)
9543 if (
rr_type == ns_t_a && data_size == 4) {
9545 memcpy(&stunaddr.sin_addr,
data, data_size);
9546 stunaddr.sin_family = AF_INET;
9551 ast_debug_stun(3,
"Unrecognized rr_type '%u' or data_size '%zu' from DNS query for stunaddr '%s'\n",
9559static void clean_stunaddr(
void) {
9560 if (stunaddr_resolver) {
9562 ast_log(
LOG_ERROR,
"Failed to cancel recurring DNS resolution of previous stunaddr.\n");
9564 ao2_ref(stunaddr_resolver, -1);
9565 stunaddr_resolver =
NULL;
9568 memset(&stunaddr, 0,
sizeof(stunaddr));
9573#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
9580#ifdef HAVE_PJPROJECT
9586 ast_debug_dtls(3,
"(%p) DTLS - ast_rtp_activate rtp=%p - setup and perform DTLS'\n", instance, rtp);
9588 dtls_perform_setup(&rtp->dtls);
9589 dtls_perform_handshake(instance, &rtp->dtls, 0);
9592 dtls_perform_setup(&rtp->
rtcp->dtls);
9593 dtls_perform_handshake(instance, &rtp->
rtcp->dtls, 1);
9603 char *debughost =
NULL;
9604 char *debugport =
NULL;
9607 ast_cli(
a->fd,
"Lookup failed for '%s'\n", arg);
9611 ast_cli(
a->fd,
"RTP Packet Debugging Enabled for address: %s\n",
9620 char *debughost =
NULL;
9621 char *debugport =
NULL;
9624 ast_cli(
a->fd,
"Lookup failed for '%s'\n", arg);
9628 ast_cli(
a->fd,
"RTCP Packet Debugging Enabled for address: %s\n",
9638 e->
command =
"rtp set debug {on|off|ip}";
9640 "Usage: rtp set debug {on|off|ip host[:port]}\n"
9641 " Enable/Disable dumping of all RTP packets. If 'ip' is\n"
9642 " specified, limit the dumped packets to those to and from\n"
9643 " the specified 'host' with optional port.\n";
9649 if (
a->argc == e->
args) {
9650 if (!strncasecmp(
a->argv[e->
args-1],
"on", 2)) {
9653 ast_cli(
a->fd,
"RTP Packet Debugging Enabled\n");
9655 }
else if (!strncasecmp(
a->argv[e->
args-1],
"off", 3)) {
9657 ast_cli(
a->fd,
"RTP Packet Debugging Disabled\n");
9660 }
else if (
a->argc == e->
args +1) {
9670#ifdef HAVE_PJPROJECT
9671 struct sockaddr_in stunaddr_copy;
9675 e->
command =
"rtp show settings";
9677 "Usage: rtp show settings\n"
9678 " Display RTP configuration settings\n";
9688 ast_cli(
a->fd,
"\n\nGeneral Settings:\n");
9689 ast_cli(
a->fd,
"----------------\n");
9703#ifdef HAVE_PJPROJECT
9707 memcpy(&stunaddr_copy, &stunaddr,
sizeof(stunaddr));
9709 ast_cli(
a->fd,
" STUN address: %s:%d\n",
ast_inet_ntoa(stunaddr_copy.sin_addr), htons(stunaddr_copy.sin_port));
9719 e->
command =
"rtcp set debug {on|off|ip}";
9721 "Usage: rtcp set debug {on|off|ip host[:port]}\n"
9722 " Enable/Disable dumping of all RTCP packets. If 'ip' is\n"
9723 " specified, limit the dumped packets to those to and from\n"
9724 " the specified 'host' with optional port.\n";
9730 if (
a->argc == e->
args) {
9731 if (!strncasecmp(
a->argv[e->
args-1],
"on", 2)) {
9734 ast_cli(
a->fd,
"RTCP Packet Debugging Enabled\n");
9736 }
else if (!strncasecmp(
a->argv[e->
args-1],
"off", 3)) {
9738 ast_cli(
a->fd,
"RTCP Packet Debugging Disabled\n");
9741 }
else if (
a->argc == e->
args +1) {
9752 e->
command =
"rtcp set stats {on|off}";
9754 "Usage: rtcp set stats {on|off}\n"
9755 " Enable/Disable dumping of RTCP stats.\n";
9761 if (
a->argc != e->
args)
9764 if (!strncasecmp(
a->argv[e->
args-1],
"on", 2))
9766 else if (!strncasecmp(
a->argv[e->
args-1],
"off", 3))
9777static unsigned int use_random(
struct ast_cli_args *
a,
int pos,
unsigned int index)
9780 !strcasecmp(
a->argv[index - 1],
"random");
9785 static const char *
const completions_2[] = {
"stop",
"<N>",
NULL };
9786 static const char *
const completions_3[] = {
"random",
"incoming packets",
NULL };
9787 static const char *
const completions_5[] = {
"on",
"every",
NULL };
9788 static const char *
const completions_units[] = {
"random",
"usec",
"msec",
"sec",
"min",
NULL };
9790 unsigned int use_random_num = 0;
9791 unsigned int use_random_interval = 0;
9792 unsigned int num_to_drop = 0;
9793 unsigned int interval = 0;
9794 const char *interval_s =
NULL;
9795 const char *unit_s =
NULL;
9797 const char *addr_s =
NULL;
9803 "Usage: rtp drop [stop|[<N> [random] incoming packets[ every <N> [random] {usec|msec|sec|min}][ on <ip[:port]>]]\n"
9804 " Drop RTP incoming packets.\n";
9807 use_random_num = use_random(
a,
a->pos, 4);
9808 use_random_interval = use_random(
a,
a->pos, 8 + use_random_num) ||
9809 use_random(
a,
a->pos, 10 + use_random_num);
9811 switch (
a->pos - use_random_num - use_random_interval) {
9819 if (!strcasecmp(
a->argv[
a->pos - 2],
"on")) {
9825 if (!strcasecmp(
a->argv[
a->pos - 2 - use_random_interval],
"every")) {
9830 if (!strcasecmp(
a->argv[
a->pos - 3 - use_random_interval],
"every")) {
9843 use_random_num = use_random(
a,
a->argc, 4);
9844 use_random_interval = use_random(
a,
a->argc, 8 + use_random_num) ||
9845 use_random(
a,
a->argc, 10 + use_random_num);
9847 if (!strcasecmp(
a->argv[2],
"stop")) {
9849 }
else if (
a->argc < 5) {
9852 ast_cli(
a->fd,
"%s is not a valid number of packets to drop\n",
a->argv[2]);
9854 }
else if (
a->argc - use_random_num == 5) {
9856 }
else if (
a->argc - use_random_num >= 7 && !strcasecmp(
a->argv[5 + use_random_num],
"on")) {
9858 addr_s =
a->argv[6 + use_random_num];
9859 if (
a->argc - use_random_num - use_random_interval == 10 &&
9860 !strcasecmp(
a->argv[7 + use_random_num],
"every")) {
9862 interval_s =
a->argv[8 + use_random_num];
9863 unit_s =
a->argv[9 + use_random_num + use_random_interval];
9865 }
else if (
a->argc - use_random_num >= 8 && !strcasecmp(
a->argv[5 + use_random_num],
"every")) {
9867 interval_s =
a->argv[6 + use_random_num];
9868 unit_s =
a->argv[7 + use_random_num + use_random_interval];
9869 if (
a->argc == 10 + use_random_num + use_random_interval &&
9870 !strcasecmp(
a->argv[8 + use_random_num + use_random_interval],
"on")) {
9872 addr_s =
a->argv[9 + use_random_num + use_random_interval];
9878 if (
a->argc - use_random_num >= 8 && !interval_s && !addr_s) {
9883 ast_cli(
a->fd,
"%s is not a valid interval number\n", interval_s);
9887 memset(&addr, 0,
sizeof(addr));
9889 ast_cli(
a->fd,
"%s is not a valid hostname[:port]\n", addr_s);
9893 drop_packets_data.use_random_num = use_random_num;
9894 drop_packets_data.use_random_interval = use_random_interval;
9895 drop_packets_data.num_to_drop = num_to_drop;
9912 AST_CLI_DEFINE(handle_cli_rtp_drop_incoming_packets,
"Drop RTP incoming packets"),
9922#ifdef HAVE_PJPROJECT
9924 struct ast_ice_host_candidate *candidate;
9925 int acl_subscription_flag = 0;
9954#ifdef HAVE_PJPROJECT
9959 turnaddr = pj_str(
NULL);
9960 turnusername = pj_str(
NULL);
9961 turnpassword = pj_str(
NULL);
9962 host_candidate_overrides_clear();
9965#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
9997 ast_log(
LOG_WARNING,
"Disabling RTP checksums is not supported on this operating system!\n");
10003 ast_log(
LOG_WARNING,
"DTMF timeout of '%d' outside range, using default of '%d' instead\n",
10011 }
else if (!strcasecmp(s,
"seqno")) {
10019 ast_log(
LOG_WARNING,
"Value for 'probation' could not be read, using default of '%d' instead\n",
10028#ifdef HAVE_PJPROJECT
10033 stun_software_attribute =
ast_true(s);
10036 char *hostport, *host, *port;
10043 ast_debug_stun(3,
"stunaddr = '%s' does not need name resolution\n",
10055 stunaddr.sin_port = htons(port_parsed);
10058 &stunaddr_resolve_callback,
NULL);
10059 if (!stunaddr_resolver) {
10060 ast_log(
LOG_ERROR,
"Failed to setup recurring DNS resolution of stunaddr '%s'",
10068 struct sockaddr_in addr;
10073 pj_strdup2_with_null(pool, &turnaddr,
ast_inet_ntoa(addr.sin_addr));
10076 turnport = ntohs(addr.sin_port);
10080 pj_strdup2_with_null(pool, &turnusername, s);
10083 pj_strdup2_with_null(pool, &turnpassword, s);
10089 unsigned int include_local_address = 0;
10100 sep = strchr(
var->value,
',');
10105 include_local_address = strcmp(sep,
"include_local_address") == 0;
10113 if (!(candidate =
ast_calloc(1,
sizeof(*candidate)))) {
10118 candidate->include_local = include_local_address;
10134 const char* sense =
NULL;
10136 if (strncasecmp(
var->name,
"ice_", 4) == 0) {
10137 sense =
var->name + 4;
10139 }
else if (strncasecmp(
var->name,
"stun_", 5) == 0) {
10140 sense =
var->name + 5;
10146 if (strcasecmp(sense,
"blacklist") == 0) {
10150 if (strcasecmp(sense,
"acl") && strcasecmp(sense,
"permit") && strcasecmp(sense,
"deny")) {
10167#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP)
10169 if ((sscanf(s,
"%d", &dtls_mtu) != 1) || dtls_mtu < 256) {
10170 ast_log(
LOG_WARNING,
"Value for 'dtls_mtu' could not be read, using default of '%d' instead\n",
10201#ifdef HAVE_PJPROJECT
10202static void rtp_terminate_pjproject(
void)
10204 pj_thread_register_check();
10206 if (timer_thread) {
10207 timer_terminate = 1;
10208 pj_thread_join(timer_thread);
10209 pj_thread_destroy(timer_thread);
10229#ifdef HAVE_PJPROJECT
10235 if (pj_init() != PJ_SUCCESS) {
10239 if (pjlib_util_init() != PJ_SUCCESS) {
10240 rtp_terminate_pjproject();
10244 if (pjnath_init() != PJ_SUCCESS) {
10245 rtp_terminate_pjproject();
10251 pool = pj_pool_create(&
cachingpool.factory,
"timer", 512, 512,
NULL);
10253 if (pj_timer_heap_create(pool, 100, &timer_heap) != PJ_SUCCESS) {
10254 rtp_terminate_pjproject();
10258 if (pj_lock_create_recursive_mutex(pool,
"rtp%p", &
lock) != PJ_SUCCESS) {
10259 rtp_terminate_pjproject();
10263 pj_timer_heap_set_lock(timer_heap,
lock, PJ_TRUE);
10265 if (pj_thread_create(pool,
"timer", &timer_worker_thread,
NULL, 0, 0, &timer_thread) != PJ_SUCCESS) {
10266 rtp_terminate_pjproject();
10272#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP) && defined(HAVE_OPENSSL_BIO_METHOD)
10273 dtls_bio_methods = BIO_meth_new(BIO_TYPE_BIO,
"rtp write");
10274 if (!dtls_bio_methods) {
10275#ifdef HAVE_PJPROJECT
10276 rtp_terminate_pjproject();
10280 BIO_meth_set_write(dtls_bio_methods, dtls_bio_write);
10281 BIO_meth_set_ctrl(dtls_bio_methods, dtls_bio_ctrl);
10282 BIO_meth_set_create(dtls_bio_methods, dtls_bio_new);
10283 BIO_meth_set_destroy(dtls_bio_methods, dtls_bio_free);
10287#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP) && defined(HAVE_OPENSSL_BIO_METHOD)
10288 BIO_meth_free(dtls_bio_methods);
10290#ifdef HAVE_PJPROJECT
10291 rtp_terminate_pjproject();
10297#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP) && defined(HAVE_OPENSSL_BIO_METHOD)
10298 BIO_meth_free(dtls_bio_methods);
10300#ifdef HAVE_PJPROJECT
10302 rtp_terminate_pjproject();
10317#if defined(HAVE_OPENSSL) && (OPENSSL_VERSION_NUMBER >= 0x10001000L) && !defined(OPENSSL_NO_SRTP) && defined(HAVE_OPENSSL_BIO_METHOD)
10318 if (dtls_bio_methods) {
10319 BIO_meth_free(dtls_bio_methods);
10323#ifdef HAVE_PJPROJECT
10324 host_candidate_overrides_clear();
10325 pj_thread_register_check();
10326 rtp_terminate_pjproject();
10329 rtp_unload_acl(&ice_acl_lock, &ice_acl);
10330 rtp_unload_acl(&stun_acl_lock, &stun_acl);
10343#ifdef HAVE_PJPROJECT
10344 .
requires =
"res_pjproject",
Access Control of various sorts.
struct stasis_message_type * ast_named_acl_change_type(void)
a stasis_message_type for changes against a named ACL or the set of all named ACLs
int ast_ouraddrfor(const struct ast_sockaddr *them, struct ast_sockaddr *us)
Get our local IP address when contacting a remote host.
void ast_append_acl(const char *sense, const char *stuff, struct ast_acl_list **path, int *error, int *named_acl_flag)
Add a rule to an ACL struct.
int ast_find_ourip(struct ast_sockaddr *ourip, const struct ast_sockaddr *bindaddr, int family)
Find our IP address.
enum ast_acl_sense ast_apply_acl_nolog(struct ast_acl_list *acl_list, const struct ast_sockaddr *addr)
Apply a set of rules to a given IP address, don't log failure.
struct ast_acl_list * ast_free_acl_list(struct ast_acl_list *acl)
Free a list of ACLs.
static volatile unsigned int seq
Asterisk main include file. File version handling, generic pbx functions.
#define ast_strndup(str, len)
A wrapper for strndup()
#define ast_strdup(str)
A wrapper for strdup()
#define ast_strdupa(s)
duplicate a string in memory from the stack
void ast_free_ptr(void *ptr)
free() wrapper
#define ast_calloc(num, len)
A wrapper for calloc()
#define ast_malloc(len)
A wrapper for malloc()
#define ao2_iterator_next(iter)
#define ao2_link(container, obj)
Add an object to a container.
@ AO2_ALLOC_OPT_LOCK_NOLOCK
@ AO2_ALLOC_OPT_LOCK_MUTEX
int ao2_container_count(struct ao2_container *c)
Returns the number of elements in a container.
#define ao2_find(container, arg, flags)
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
#define ao2_replace(dst, src)
Replace one object reference with another cleaning up the original.
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
#define ao2_alloc_options(data_size, destructor_fn, options)
void * ao2_object_get_lockaddr(void *obj)
Return the mutex lock address of an object.
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
#define ao2_container_alloc_list(ao2_options, container_options, sort_fn, cmp_fn)
Allocate and initialize a list container.
#define ao2_alloc(data_size, destructor_fn)
static struct stasis_subscription * acl_change_sub
static void acl_change_stasis_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message)
static struct ast_sched_context * sched
static char version[AST_MAX_EXTENSION]
static int answer(void *data)
General Asterisk PBX channel definitions.
const struct ast_channel_tech * ast_channel_tech(const struct ast_channel *chan)
Standard Command Line Interface.
#define AST_CLI_YESNO(x)
Return Yes or No depending on the argument.
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
#define AST_CLI_DEFINE(fn, txt,...)
int ast_cli_completion_add(char *value)
Add a result to a request for completion options.
void ast_cli(int fd, const char *fmt,...)
char * ast_cli_complete(const char *word, const char *const choices[], int pos)
#define ast_cli_register_multiple(e, len)
Register multiple commands.
static struct ao2_container * codecs
Registered codecs.
ast_media_type
Types of media.
unsigned int ast_codec_samples_count(struct ast_frame *frame)
Get the number of samples contained within a frame.
const char * ast_codec_media_type2str(enum ast_media_type type)
Conversion function to take a media type and turn it into a string.
static int reconstruct(int sign, int dqln, int y)
Conversion utility functions.
int ast_str_to_uint(const char *str, unsigned int *res)
Convert the given string to an unsigned integer.
void * ast_data_buffer_get(const struct ast_data_buffer *buffer, size_t pos)
Retrieve a data payload from the data buffer.
struct ast_data_buffer * ast_data_buffer_alloc(ast_data_buffer_free_callback free_fn, size_t size)
Allocate a data buffer.
size_t ast_data_buffer_count(const struct ast_data_buffer *buffer)
Return the number of payloads in a data buffer.
void ast_data_buffer_resize(struct ast_data_buffer *buffer, size_t size)
Resize a data buffer.
int ast_data_buffer_put(struct ast_data_buffer *buffer, size_t pos, void *payload)
Place a data payload at a position in the data buffer.
size_t ast_data_buffer_max(const struct ast_data_buffer *buffer)
Return the maximum number of payloads a data buffer can hold.
void * ast_data_buffer_remove(struct ast_data_buffer *buffer, size_t pos)
Remove a data payload from the data buffer.
void ast_data_buffer_free(struct ast_data_buffer *buffer)
Free a data buffer (and all held data payloads)
const struct ast_dns_record * ast_dns_record_get_next(const struct ast_dns_record *record)
Get the next DNS record.
int ast_dns_result_get_lowest_ttl(const struct ast_dns_result *result)
Retrieve the lowest TTL from a result.
const char * ast_dns_record_get_data(const struct ast_dns_record *record)
Retrieve the raw DNS record.
const struct ast_dns_record * ast_dns_result_get_records(const struct ast_dns_result *result)
Get the first record of a DNS Result.
struct ast_dns_result * ast_dns_query_get_result(const struct ast_dns_query *query)
Get the result information for a DNS query.
int ast_dns_record_get_rr_type(const struct ast_dns_record *record)
Get the resource record type of a DNS record.
const char * ast_dns_query_get_name(const struct ast_dns_query *query)
Get the name queried in a DNS query.
size_t ast_dns_record_get_data_size(const struct ast_dns_record *record)
Retrieve the size of the raw DNS record.
Internal DNS structure definitions.
DNS Recurring Resolution API.
int ast_dns_resolve_recurring_cancel(struct ast_dns_query_recurring *recurring)
Cancel an asynchronous recurring DNS resolution.
struct ast_dns_query_recurring * ast_dns_resolve_recurring(const char *name, int rr_type, int rr_class, ast_dns_resolve_callback callback, void *data)
Asynchronously resolve a DNS query, and continue resolving it according to the lowest TTL available.
void ast_verbose(const char *fmt,...)
static int replace(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
struct stasis_message_type * ast_rtp_rtcp_sent_type(void)
Message type for an RTCP message sent from this Asterisk instance.
struct stasis_message_type * ast_rtp_rtcp_received_type(void)
Message type for an RTCP message received from some external source.
void timersub(struct timeval *tvend, struct timeval *tvstart, struct timeval *tvdiff)
char * strsep(char **str, const char *delims)
Configuration File Parser.
struct ast_config * ast_config_load2(const char *filename, const char *who_asked, struct ast_flags flags)
Load a config file.
#define CONFIG_STATUS_FILEUNCHANGED
#define CONFIG_STATUS_FILEINVALID
int ast_parse_arg(const char *arg, enum ast_parse_flags flags, void *p_result,...)
The argument parsing routine.
void ast_config_destroy(struct ast_config *cfg)
Destroys a config.
const char * ast_variable_retrieve(struct ast_config *config, const char *category, const char *variable)
struct ast_variable * ast_variable_browse(const struct ast_config *config, const char *category_name)
@ CONFIG_FLAG_FILEUNCHANGED
Asterisk internal frame definitions.
@ AST_FRFLAG_HAS_SEQUENCE_NUMBER
@ AST_FRFLAG_HAS_TIMING_INFO
#define ast_frame_byteswap_be(fr)
#define ast_frisolate(fr)
Makes a frame independent of any static storage.
void ast_frame_free(struct ast_frame *frame, int cache)
Frees a frame or list of frames.
#define ast_frdup(fr)
Copies a frame.
#define AST_FRIENDLY_OFFSET
Offset into a frame's data buffer.
ast_frame_type
Frame types.
struct ast_frame ast_null_frame
#define DEBUG_ATLEAST(level)
#define ast_debug(level,...)
Log a DEBUG message.
#define ast_verb(level,...)
struct ssl_ctx_st SSL_CTX
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
#define AST_RWLIST_REMOVE_CURRENT
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
#define AST_LIST_HEAD_INIT_NOLOCK(head)
Initializes a list head structure.
#define AST_LIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a list of specified type, statically initialized.
#define AST_LIST_HEAD_NOLOCK(name, type)
Defines a structure to be used to hold a list of specified type (with no lock).
#define AST_RWLIST_TRAVERSE_SAFE_BEGIN
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
#define AST_RWLIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a read/write list of specified type, statically initialized.
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
#define AST_RWLIST_TRAVERSE_SAFE_END
#define AST_LIST_LOCK(head)
Locks a list.
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.
#define AST_LIST_REMOVE(head, elm, field)
Removes a specific entry from a list.
#define AST_RWLIST_INSERT_TAIL
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
#define AST_LIST_UNLOCK(head)
Attempts to unlock a list.
#define AST_LIST_FIRST(head)
Returns the first entry contained in a list.
#define AST_LIST_NEXT(elm, field)
Returns the next entry in the list after the given entry.
Asterisk locking-related definitions:
#define ast_rwlock_wrlock(a)
#define AST_RWLOCK_INIT_VALUE
#define ast_cond_init(cond, attr)
#define ast_cond_timedwait(cond, mutex, time)
#define ast_rwlock_rdlock(a)
pthread_cond_t ast_cond_t
#define ast_rwlock_unlock(a)
#define ast_cond_signal(cond)
#define AST_LOG_CATEGORY_DISABLED
#define AST_LOG_CATEGORY_ENABLED
#define ast_debug_category(sublevel, ids,...)
Log for a debug category.
int ast_debug_category_set_sublevel(const char *name, int sublevel)
Set the debug category's sublevel.
The AMI - Asterisk Manager Interface - is a TCP protocol created to manage Asterisk with third-party ...
Asterisk module definitions.
#define AST_MODULE_INFO(keystr, flags_to_set, desc, fields...)
@ AST_MODPRI_CHANNEL_DEPEND
@ AST_MODULE_SUPPORT_CORE
#define ASTERISK_GPL_KEY
The text the key() function should return.
@ AST_MODULE_LOAD_SUCCESS
@ AST_MODULE_LOAD_DECLINE
Module has failed to load, may be in an inconsistent state.
int ast_sockaddr_ipv4_mapped(const struct ast_sockaddr *addr, struct ast_sockaddr *ast_mapped)
Convert an IPv4-mapped IPv6 address into an IPv4 address.
static char * ast_sockaddr_stringify(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() with default format.
#define ast_sockaddr_port(addr)
Get the port number of a socket address.
static void ast_sockaddr_copy(struct ast_sockaddr *dst, const struct ast_sockaddr *src)
Copies the data from one ast_sockaddr to another.
int ast_sockaddr_is_ipv6(const struct ast_sockaddr *addr)
Determine if this is an IPv6 address.
int ast_bind(int sockfd, const struct ast_sockaddr *addr)
Wrapper around bind(2) that uses struct ast_sockaddr.
#define ast_sockaddr_from_sockaddr(addr, sa)
Converts a struct sockaddr to a struct ast_sockaddr.
int ast_sockaddr_cmp_addr(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
Compares the addresses of two ast_sockaddr structures.
static char * ast_sockaddr_stringify_host(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() to return an address only, suitable for a URL (with brack...
ssize_t ast_sendto(int sockfd, const void *buf, size_t len, int flags, const struct ast_sockaddr *dest_addr)
Wrapper around sendto(2) that uses ast_sockaddr.
int ast_sockaddr_is_any(const struct ast_sockaddr *addr)
Determine if the address type is unspecified, or "any" address.
int ast_sockaddr_split_hostport(char *str, char **host, char **port, int flags)
Splits a string into its host and port components.
int ast_set_qos(int sockfd, int tos, int cos, const char *desc)
Set type of service.
#define ast_sockaddr_to_sin(addr, sin)
Converts a struct ast_sockaddr to a struct sockaddr_in.
int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags)
Parse an IPv4 or IPv6 address string.
static int ast_sockaddr_isnull(const struct ast_sockaddr *addr)
Checks if the ast_sockaddr is null. "null" in this sense essentially means uninitialized,...
ssize_t ast_recvfrom(int sockfd, void *buf, size_t len, int flags, struct ast_sockaddr *src_addr)
Wrapper around recvfrom(2) that uses struct ast_sockaddr.
int ast_sockaddr_cmp(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
Compares two ast_sockaddr structures.
#define ast_sockaddr_set_port(addr, port)
Sets the port number of a socket address.
#define ast_sockaddr_from_sin(addr, sin)
Converts a struct sockaddr_in to a struct ast_sockaddr.
static void ast_sockaddr_setnull(struct ast_sockaddr *addr)
Sets address addr to null.
int ast_sockaddr_is_ipv4(const struct ast_sockaddr *addr)
Determine if the address is an IPv4 address.
const char * ast_inet_ntoa(struct in_addr ia)
thread-safe replacement for inet_ntoa().
Options provided by main asterisk program.
#define AST_PJPROJECT_INIT_LOG_LEVEL()
Get maximum log level pjproject was compiled with.
Core PBX routines and definitions.
static void * cleanup(void *unused)
static char * generate_random_string(char *buf, size_t size)
Generate 32 byte random string (stolen from chan_sip.c)
struct stasis_forward * sub
int ast_sockaddr_to_pj_sockaddr(const struct ast_sockaddr *addr, pj_sockaddr *pjaddr)
Fill a pj_sockaddr from an ast_sockaddr.
void ast_pjproject_caching_pool_destroy(pj_caching_pool *cp)
Destroy caching pool factory and all cached pools.
int ast_sockaddr_pj_sockaddr_cmp(const struct ast_sockaddr *addr, const pj_sockaddr *pjaddr)
Compare an ast_sockaddr to a pj_sockaddr.
void ast_pjproject_caching_pool_init(pj_caching_pool *cp, const pj_pool_factory_policy *policy, pj_size_t max_capacity)
Initialize the caching pool factory.
static struct ast_threadstorage pj_thread_storage
static pj_caching_pool cachingpool
Pool factory used by pjlib to allocate memory.
#define TURN_STATE_WAIT_TIME
static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1)
static void ast_rtp_update_source(struct ast_rtp_instance *instance)
#define TRANSPORT_TURN_RTCP
static int ast_rtp_destroy(struct ast_rtp_instance *instance)
#define RTCP_LENGTH_SHIFT
struct ast_srtp_res * res_srtp
static int ast_rtp_rtcp_handle_nack(struct ast_rtp_instance *instance, unsigned int *nackdata, unsigned int position, unsigned int length)
static int rtp_reload(int reload, int by_external_config)
#define RTCP_PAYLOAD_TYPE_SHIFT
#define DEFAULT_RTP_RECV_BUFFER_SIZE
#define MAX_TIMESTAMP_SKEW
#define DEFAULT_ICESUPPORT
static void ntp2timeval(unsigned int msw, unsigned int lsw, struct timeval *tv)
#define RTCP_FB_NACK_BLOCK_WORD_LENGTH
static struct ast_sockaddr rtpdebugaddr
#define DEFAULT_LEARNING_MIN_SEQUENTIAL
#define FLAG_3389_WARNING
static int rtp_learning_rtp_seq_update(struct rtp_learning_info *info, uint16_t seq)
static int rtp_transport_wide_cc_feedback_produce(const void *data)
#define RTCP_RR_BLOCK_WORD_LENGTH
static struct ast_frame * ast_rtcp_interpret(struct ast_rtp_instance *instance, struct ast_srtp *srtp, const unsigned char *rtcpdata, size_t size, struct ast_sockaddr *addr)
static const char * rtcp_payload_subtype2str(unsigned int pt, unsigned int subtype)
static int ast_rtp_new(struct ast_rtp_instance *instance, struct ast_sched_context *sched, struct ast_sockaddr *addr, void *data)
static char * handle_cli_rtp_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct ast_frame * ast_rtcp_read(struct ast_rtp_instance *instance)
#define RTP_IGNORE_FIRST_PACKETS_COUNT
static int rtp_raw_write(struct ast_rtp_instance *instance, struct ast_frame *frame, int codec)
#define RTCP_SR_BLOCK_WORD_LENGTH
static int ast_rtp_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration)
static int rtcp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
static struct ast_rtp_instance * rtp_find_instance_by_packet_source_ssrc(struct ast_rtp_instance *instance, struct ast_rtp *rtp, unsigned int ssrc)
#define RTCP_REPORT_COUNT_SHIFT
#define RTCP_DEFAULT_INTERVALMS
static void rtp_deallocate_transport(struct ast_rtp_instance *instance, struct ast_rtp *rtp)
#define RTP_DTLS_ESTABLISHED
static int bridge_p2p_rtp_write(struct ast_rtp_instance *instance, struct ast_rtp_instance *instance1, unsigned int *rtpheader, int len, int hdrlen)
#define DEFAULT_DTMF_TIMEOUT
static void put_unaligned_time24(void *p, uint32_t time_msw, uint32_t time_lsw)
#define RTCP_MAX_INTERVALMS
static int ast_rtcp_generate_nack(struct ast_rtp_instance *instance, unsigned char *rtcpheader)
static char * handle_cli_rtp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void rtp_transport_wide_cc_feedback_status_append(unsigned char *rtcpheader, int *packet_len, int *status_vector_chunk_bits, uint16_t *status_vector_chunk, int *run_length_chunk_count, int *run_length_chunk_status, int status)
static int ast_rtp_bundle(struct ast_rtp_instance *child, struct ast_rtp_instance *parent)
static struct ast_rtp_engine asterisk_rtp_engine
static const char * rtcp_payload_type2str(unsigned int pt)
#define DTMF_SAMPLE_RATE_MS
#define TRANSPORT_SOCKET_RTP
static void rtp_instance_parse_transport_wide_cc(struct ast_rtp_instance *instance, struct ast_rtp *rtp, unsigned char *data, int len)
static void calc_rxstamp_and_jitter(struct timeval *tv, struct ast_rtp *rtp, unsigned int rx_rtp_ts, int mark)
static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
static int ast_rtp_dtmf_continuation(struct ast_rtp_instance *instance)
#define SRTP_MASTER_KEY_LEN
static int learning_min_sequential
static int rtp_allocate_transport(struct ast_rtp_instance *instance, struct ast_rtp *rtp)
static char * rtcp_do_debug_ip(struct ast_cli_args *a)
static int ast_rtcp_generate_report(struct ast_rtp_instance *instance, unsigned char *rtcpheader, struct ast_rtp_rtcp_report *rtcp_report, int *sr)
static struct ast_frame * ast_rtp_read(struct ast_rtp_instance *instance, int rtcp)
static char * handle_cli_rtcp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
struct ast_srtp_policy_res * res_srtp_policy
static struct ast_rtp_instance * __rtp_find_instance_by_ssrc(struct ast_rtp_instance *instance, struct ast_rtp *rtp, unsigned int ssrc, int source)
static void calculate_lost_packet_statistics(struct ast_rtp *rtp, unsigned int *lost_packets, int *fraction_lost)
#define RTCP_HEADER_SSRC_LENGTH
static void process_dtmf_rfc2833(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, int payloadtype, int mark, struct frame_list *frames)
static int srtp_replay_protection
static void ast_rtp_set_stream_num(struct ast_rtp_instance *instance, int stream_num)
static int learning_min_duration
static int create_new_socket(const char *type, int af)
static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp)
static int ast_rtcp_generate_compound_prefix(struct ast_rtp_instance *instance, unsigned char *rtcpheader, struct ast_rtp_rtcp_report *report, int *sr)
static void update_jitter_stats(struct ast_rtp *rtp, unsigned int ia_jitter)
#define RTCP_FB_REMB_BLOCK_WORD_LENGTH
static struct ast_frame * process_cn_rfc3389(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, int payloadtype, int mark)
#define DEFAULT_SRTP_REPLAY_PROTECTION
static int reload_module(void)
#define FLAG_NAT_INACTIVE
static int rtcp_debug_test_addr(struct ast_sockaddr *addr)
static int ast_rtp_qos_set(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
static void ast_rtp_change_source(struct ast_rtp_instance *instance)
static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit)
static void calc_mean_and_standard_deviation(double new_sample, double *mean, double *std_dev, unsigned int *count)
static int compare_by_value(int elem, int value)
Helper function to compare an elem in a vector by value.
static int update_rtt_stats(struct ast_rtp *rtp, unsigned int lsr, unsigned int dlsr)
static int rtcp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int *ice)
static struct ast_sockaddr rtcpdebugaddr
static struct ast_rtp_instance * rtp_find_instance_by_media_source_ssrc(struct ast_rtp_instance *instance, struct ast_rtp *rtp, unsigned int ssrc)
#define MAXIMUM_RTP_RECV_BUFFER_SIZE
static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
#define STRICT_RTP_LEARN_TIMEOUT
Strict RTP learning timeout time in milliseconds.
#define RTCP_VERSION_SHIFTED
static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit)
static void rtp_instance_parse_extmap_extensions(struct ast_rtp_instance *instance, struct ast_rtp *rtp, unsigned char *extension, int len)
static int find_by_value(int elem, int value)
Helper function to find an elem in a vector by value.
#define RTCP_REPORT_COUNT_MASK
static void rtp_instance_unlock(struct ast_rtp_instance *instance)
#define DEFAULT_RTP_START
#define TRANSPORT_TURN_RTP
static int rtp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
static struct ast_cli_entry cli_rtp[]
static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
#define RESCALE(in, inmin, inmax, outmin, outmax)
#define MISSING_SEQNOS_ADDED_TRIGGER
#define SRTP_MASTER_SALT_LEN
static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
#define RTCP_PAYLOAD_TYPE_MASK
#define DEFAULT_RTP_SEND_BUFFER_SIZE
#define FLAG_NEED_MARKER_BIT
static int __rtp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp)
#define RTCP_MIN_INTERVALMS
static void ast_rtp_stop(struct ast_rtp_instance *instance)
#define FLAG_REQ_LOCAL_BRIDGE_BIT
static int __rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp, int *via_ice, int use_srtp)
static int load_module(void)
static int ast_rtcp_calculate_sr_rr_statistics(struct ast_rtp_instance *instance, struct ast_rtp_rtcp_report *rtcp_report, struct ast_sockaddr remote_address, int ice, int sr)
#define RTCP_VERSION_MASK_SHIFTED
#define CALC_LEARNING_MIN_DURATION(count)
Calculate the min learning duration in ms.
static int rtp_transport_wide_cc_packet_statistics_cmp(struct rtp_transport_wide_cc_packet_statistics a, struct rtp_transport_wide_cc_packet_statistics b)
#define SSRC_MAPPING_ELEM_CMP(elem, value)
SSRC mapping comparator for AST_VECTOR_REMOVE_CMP_UNORDERED()
static int rtp_debug_test_addr(struct ast_sockaddr *addr)
static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
static int unload_module(void)
static void ast_rtp_set_remote_ssrc(struct ast_rtp_instance *instance, unsigned int ssrc)
static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
#define FLAG_NAT_INACTIVE_NOWARN
static int rtcp_mux(struct ast_rtp *rtp, const unsigned char *packet)
static void rtp_learning_seq_init(struct rtp_learning_info *info, uint16_t seq)
#define TRANSPORT_SOCKET_RTCP
static void rtp_learning_start(struct ast_rtp *rtp)
Start the strictrtp learning mode.
static int ast_rtp_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
static char * rtp_do_debug_ip(struct ast_cli_args *a)
static enum ast_rtp_dtmf_mode ast_rtp_dtmf_mode_get(struct ast_rtp_instance *instance)
static int rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int *ice)
static unsigned int ast_rtp_get_ssrc(struct ast_rtp_instance *instance)
static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr)
static struct ast_frame * ast_rtp_interpret(struct ast_rtp_instance *instance, struct ast_srtp *srtp, const struct ast_sockaddr *remote_address, unsigned char *read_area, int length, int prev_seqno, unsigned int bundled)
static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1)
static struct ast_frame * red_t140_to_red(struct rtp_red *red)
static int ast_rtcp_generate_sdes(struct ast_rtp_instance *instance, unsigned char *rtcpheader, struct ast_rtp_rtcp_report *rtcp_report)
static double calc_media_experience_score(struct ast_rtp_instance *instance, double normdevrtt, double normdev_rxjitter, double stdev_rxjitter, double normdev_rxlost)
Calculate a "media experience score" based on given data.
static void update_reported_mes_stats(struct ast_rtp *rtp)
#define DEFAULT_STRICT_RTP
static int ast_rtp_sendcng(struct ast_rtp_instance *instance, int level)
generate comfort noice (CNG)
static char * handle_cli_rtcp_set_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void update_lost_stats(struct ast_rtp *rtp, unsigned int lost_packets)
static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username)
static const char * ast_rtp_get_cname(struct ast_rtp_instance *instance)
static void rtp_write_rtcp_psfb(struct ast_rtp_instance *instance, struct ast_rtp *rtp, struct ast_frame *frame, struct ast_sockaddr *remote_address)
static struct ast_frame * process_dtmf_cisco(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, int payloadtype, int mark)
static struct ast_frame * create_dtmf_frame(struct ast_rtp_instance *instance, enum ast_frame_type type, int compensate)
static void rtp_write_rtcp_fir(struct ast_rtp_instance *instance, struct ast_rtp *rtp, struct ast_sockaddr *remote_address)
#define DEFAULT_TURN_PORT
#define MAXIMUM_RTP_SEND_BUFFER_SIZE
static int red_write(const void *data)
Write t140 redundancy frame.
#define DEFAULT_STUN_SOFTWARE_ATTRIBUTE
#define DEFAULT_LEARNING_MIN_DURATION
static void update_local_mes_stats(struct ast_rtp *rtp)
static void rtp_transport_wide_cc_feedback_status_vector_append(unsigned char *rtcpheader, int *packet_len, int *status_vector_chunk_bits, uint16_t *status_vector_chunk, int status)
static int ast_rtp_extension_enable(struct ast_rtp_instance *instance, enum ast_rtp_extension extension)
static int ast_rtcp_write(const void *data)
Write a RTCP packet to the far end.
@ AST_AES_CM_128_HMAC_SHA1_80
@ AST_AES_CM_128_HMAC_SHA1_32
Pluggable RTP Architecture.
ast_rtp_dtls_setup
DTLS setup types.
@ AST_RTP_DTLS_SETUP_PASSIVE
@ AST_RTP_DTLS_SETUP_HOLDCONN
@ AST_RTP_DTLS_SETUP_ACTPASS
@ AST_RTP_DTLS_SETUP_ACTIVE
#define AST_RTP_RTCP_PSFB
#define AST_DEBUG_CATEGORY_DTLS
#define ast_debug_rtcp_packet_is_allowed
ast_rtp_ice_role
ICE role during negotiation.
@ AST_RTP_ICE_ROLE_CONTROLLING
@ AST_RTP_ICE_ROLE_CONTROLLED
#define AST_RTP_RTCP_FMT_FIR
#define ast_debug_rtcp(sublevel,...)
Log debug level RTCP information.
ast_rtp_ice_component_type
ICE component types.
@ AST_RTP_ICE_COMPONENT_RTCP
@ AST_RTP_ICE_COMPONENT_RTP
struct ast_rtp_rtcp_report * ast_rtp_rtcp_report_alloc(unsigned int report_blocks)
Allocate an ao2 ref counted instance of ast_rtp_rtcp_report.
struct ast_rtp_payload_type * ast_rtp_codecs_get_payload(struct ast_rtp_codecs *codecs, int payload)
Retrieve rx payload mapped information by payload type.
int ast_rtp_instance_get_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property)
Get the value of an RTP instance property.
ast_rtp_dtls_hash
DTLS fingerprint hashes.
@ AST_RTP_DTLS_HASH_SHA256
int ast_rtp_engine_srtp_is_registered(void)
#define AST_RED_MAX_GENERATION
@ AST_RTP_INSTANCE_RTCP_MUX
@ AST_RTP_INSTANCE_RTCP_STANDARD
void ast_rtp_publish_rtcp_message(struct ast_rtp_instance *rtp, struct stasis_message_type *message_type, struct ast_rtp_rtcp_report *report, struct ast_json *blob)
Publish an RTCP message to Stasis Message Bus API.
struct ast_srtp * ast_rtp_instance_get_srtp(struct ast_rtp_instance *instance, int rtcp)
Obtain the SRTP instance associated with an RTP instance.
#define AST_RTP_STAT_TERMINATOR(combined)
#define AST_RTP_RTCP_RTPFB
struct ast_rtp_instance * ast_rtp_instance_get_bridged(struct ast_rtp_instance *instance)
Get the other RTP instance that an instance is bridged to.
ast_rtp_dtls_verify
DTLS verification settings.
@ AST_RTP_DTLS_VERIFY_FINGERPRINT
@ AST_RTP_DTLS_VERIFY_CERTIFICATE
#define ast_debug_rtp_packet_is_allowed
#define AST_LOG_CATEGORY_RTCP_PACKET
@ AST_RTP_INSTANCE_STAT_LOCAL_MAXRXPLOSS
@ AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVRXPLOSS
@ AST_RTP_INSTANCE_STAT_REMOTE_MAXRXPLOSS
@ AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVMES
@ AST_RTP_INSTANCE_STAT_REMOTE_MINJITTER
@ AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVMES
@ AST_RTP_INSTANCE_STAT_MIN_RTT
@ AST_RTP_INSTANCE_STAT_TXMES
@ AST_RTP_INSTANCE_STAT_CHANNEL_UNIQUEID
@ AST_RTP_INSTANCE_STAT_TXPLOSS
@ AST_RTP_INSTANCE_STAT_MAX_RTT
@ AST_RTP_INSTANCE_STAT_RXPLOSS
@ AST_RTP_INSTANCE_STAT_REMOTE_MAXJITTER
@ AST_RTP_INSTANCE_STAT_LOCAL_MAXJITTER
@ AST_RTP_INSTANCE_STAT_REMOTE_MINMES
@ AST_RTP_INSTANCE_STAT_REMOTE_STDEVJITTER
@ AST_RTP_INSTANCE_STAT_REMOTE_MINRXPLOSS
@ AST_RTP_INSTANCE_STAT_LOCAL_MINMES
@ AST_RTP_INSTANCE_STAT_TXOCTETCOUNT
@ AST_RTP_INSTANCE_STAT_RXMES
@ AST_RTP_INSTANCE_STAT_REMOTE_STDEVMES
@ AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVRXPLOSS
@ AST_RTP_INSTANCE_STAT_REMOTE_STDEVRXPLOSS
@ AST_RTP_INSTANCE_STAT_LOCAL_STDEVRXPLOSS
@ AST_RTP_INSTANCE_STAT_REMOTE_MAXMES
@ AST_RTP_INSTANCE_STAT_TXCOUNT
@ AST_RTP_INSTANCE_STAT_STDEVRTT
@ AST_RTP_INSTANCE_STAT_COMBINED_MES
@ AST_RTP_INSTANCE_STAT_LOCAL_MAXMES
@ AST_RTP_INSTANCE_STAT_RXJITTER
@ AST_RTP_INSTANCE_STAT_LOCAL_MINRXPLOSS
@ AST_RTP_INSTANCE_STAT_LOCAL_SSRC
@ AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVJITTER
@ AST_RTP_INSTANCE_STAT_COMBINED_JITTER
@ AST_RTP_INSTANCE_STAT_TXJITTER
@ AST_RTP_INSTANCE_STAT_LOCAL_MINJITTER
@ AST_RTP_INSTANCE_STAT_COMBINED_LOSS
@ AST_RTP_INSTANCE_STAT_LOCAL_STDEVJITTER
@ AST_RTP_INSTANCE_STAT_COMBINED_RTT
@ AST_RTP_INSTANCE_STAT_NORMDEVRTT
@ AST_RTP_INSTANCE_STAT_RTT
@ AST_RTP_INSTANCE_STAT_RXOCTETCOUNT
@ AST_RTP_INSTANCE_STAT_LOCAL_STDEVMES
@ AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVJITTER
@ AST_RTP_INSTANCE_STAT_RXCOUNT
@ AST_RTP_INSTANCE_STAT_REMOTE_SSRC
void * ast_rtp_instance_get_data(struct ast_rtp_instance *instance)
Get the data portion of an RTP instance.
#define ast_rtp_instance_get_remote_address(instance, address)
Get the address of the remote endpoint that we are sending RTP to.
enum ast_media_type ast_rtp_codecs_get_stream_type(struct ast_rtp_codecs *codecs)
Determine the type of RTP stream media from the codecs mapped.
#define AST_RTP_RTCP_FMT_NACK
#define ast_debug_rtp(sublevel,...)
Log debug level RTP information.
void ast_rtp_instance_set_last_tx(struct ast_rtp_instance *rtp, time_t time)
Set the last RTP transmission time.
void ast_rtp_instance_set_data(struct ast_rtp_instance *instance, void *data)
Set the data portion of an RTP instance.
void ast_rtp_instance_set_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
Set the value of an RTP instance property.
int ast_rtp_codecs_find_payload_code(struct ast_rtp_codecs *codecs, int payload)
Search for the tx payload type in the ast_rtp_codecs structure.
void ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the local address that we are expecting RTP on.
@ AST_RTP_ICE_CANDIDATE_TYPE_RELAYED
@ AST_RTP_ICE_CANDIDATE_TYPE_SRFLX
@ AST_RTP_ICE_CANDIDATE_TYPE_HOST
#define AST_DEBUG_CATEGORY_ICE
int ast_rtp_instance_set_local_address(struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
Set the address that we are expecting to receive RTP on.
int ast_rtp_get_rate(const struct ast_format *format)
Retrieve the sample rate of a format according to RTP specifications.
int ast_rtp_codecs_payload_code_tx(struct ast_rtp_codecs *codecs, int asterisk_format, const struct ast_format *format, int code)
Retrieve a tx mapped payload type based on whether it is an Asterisk format and the code.
ast_rtp_extension
Known RTP extensions.
@ AST_RTP_EXTENSION_TRANSPORT_WIDE_CC
@ AST_RTP_EXTENSION_ABS_SEND_TIME
#define ast_rtp_instance_set_remote_address(instance, address)
Set the address of the remote endpoint that we are sending RTP to.
#define AST_RTP_RTCP_FMT_REMB
ast_rtp_dtls_connection
DTLS connection states.
@ AST_RTP_DTLS_CONNECTION_NEW
@ AST_RTP_DTLS_CONNECTION_EXISTING
#define ast_debug_dtls(sublevel,...)
Log debug level DTLS information.
@ AST_RTP_PROPERTY_RETRANS_RECV
@ AST_RTP_PROPERTY_RETRANS_SEND
@ AST_RTP_PROPERTY_ASYMMETRIC_CODEC
@ AST_RTP_PROPERTY_DTMF_COMPENSATE
#define ast_debug_dtls_packet_is_allowed
#define AST_LOG_CATEGORY_RTP_PACKET
#define AST_RTP_STAT_STRCPY(current_stat, combined, placement, value)
#define ast_debug_ice(sublevel,...)
Log debug level ICE information.
void ast_rtp_instance_get_requested_target_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the requested target address of the remote endpoint.
int ast_rtp_instance_set_incoming_source_address(struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
Set the incoming source address of the remote endpoint that we are sending RTP to.
int ast_rtp_instance_extmap_get_id(struct ast_rtp_instance *instance, enum ast_rtp_extension extension)
Retrieve the id for an RTP extension.
int ast_rtp_engine_unregister(struct ast_rtp_engine *engine)
Unregister an RTP engine.
#define AST_RTP_RTCP_FMT_TRANSPORT_WIDE_CC
struct ast_rtp_codecs * ast_rtp_instance_get_codecs(struct ast_rtp_instance *instance)
Get the codecs structure of an RTP instance.
const char * ast_rtp_instance_get_channel_id(struct ast_rtp_instance *instance)
Get the unique ID of the channel that owns this RTP instance.
unsigned int ast_rtp_codecs_get_framing(struct ast_rtp_codecs *codecs)
Get the framing used for a set of codecs.
unsigned int ast_rtp_instance_get_ssrc(struct ast_rtp_instance *rtp)
Retrieve the local SSRC value that we will be using.
#define AST_RTP_STAT_SET(current_stat, combined, placement, value)
int ast_rtp_instance_add_srtp_policy(struct ast_rtp_instance *instance, struct ast_srtp_policy *remote_policy, struct ast_srtp_policy *local_policy, int rtcp)
Add or replace the SRTP policies for the given RTP instance.
#define AST_RTP_RTCP_FMT_PLI
#define ast_rtp_engine_register(engine)
#define AST_RTP_CISCO_DTMF
#define AST_SCHED_DEL_UNREF(sched, id, refcall)
schedule task to get deleted and call unref function
#define AST_SCHED_DEL(sched, id)
Remove a scheduler entry.
int ast_sched_del(struct ast_sched_context *con, int id) attribute_warn_unused_result
Deletes a scheduled event.
int ast_sched_add(struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
Adds a scheduled event.
Security Event Reporting API.
struct stasis_topic * ast_security_topic(void)
A stasis_topic which publishes messages for security related issues.
Asterisk internal frame definitions.
void ast_smoother_set_flags(struct ast_smoother *smoother, int flags)
#define ast_smoother_feed_be(s, f)
int ast_smoother_test_flag(struct ast_smoother *s, int flag)
void ast_smoother_free(struct ast_smoother *s)
#define AST_SMOOTHER_FLAG_FORCED
struct ast_frame * ast_smoother_read(struct ast_smoother *s)
#define ast_smoother_feed(s, f)
struct ast_smoother * ast_smoother_new(int bytes)
#define AST_SMOOTHER_FLAG_BE
struct stasis_message_type * stasis_message_type(const struct stasis_message *msg)
Get the message type for a stasis_message.
@ STASIS_SUBSCRIPTION_FILTER_SELECTIVE
int stasis_subscription_accept_message_type(struct stasis_subscription *subscription, const struct stasis_message_type *type)
Indicate to a subscription that we are interested in a message type.
int stasis_subscription_set_filter(struct stasis_subscription *subscription, enum stasis_subscription_message_filter filter)
Set the message type filtering level on a subscription.
struct stasis_subscription * stasis_unsubscribe_and_join(struct stasis_subscription *subscription)
Cancel a subscription, blocking until the last message is processed.
#define stasis_subscribe(topic, callback, data)
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
static force_inline int attribute_pure ast_strlen_zero(const char *s)
int attribute_pure ast_false(const char *val)
Make sure something is false. Determine if a string containing a boolean value is "false"....
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
char * ast_skip_blanks(const char *str)
Gets a pointer to the first non-whitespace character in a string.
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Wrapper for an ast_acl linked list.
Main Channel structure associated with a channel.
descriptor for a cli entry.
int args
This gets set in ast_cli_register()
Data buffer containing fixed number of data payloads.
char data[0]
The raw DNS record.
int rr_type
Resource record type.
The result of a DNS query.
Structure used to handle boolean flags.
unsigned int frame_ending
struct ast_format * format
Data structure associated with a single frame of data.
struct ast_frame_subclass subclass
union ast_frame::@226 data
enum ast_frame_type frametype
Abstract JSON element (object, array, string, int, ...).
Structure defining an RTCP session.
unsigned int received_prior
unsigned char frame_buf[512+AST_FRIENDLY_OFFSET]
double reported_maxjitter
unsigned int reported_mes_count
double reported_normdev_lost
double reported_normdev_mes
unsigned int lastsrtxcount
unsigned int reported_lost
double reported_stdev_jitter
unsigned int reported_jitter_count
double accumulated_transit
double reported_stdev_lost
enum ast_rtp_instance_rtcp type
unsigned int rxjitter_count
unsigned int reported_lost_count
double reported_stdev_mes
double reported_normdev_jitter
unsigned int rxlost_count
double reported_minjitter
unsigned int expected_prior
DTLS configuration structure.
enum ast_rtp_dtls_setup default_setup
enum ast_rtp_dtls_verify verify
enum ast_rtp_dtls_hash hash
unsigned int ephemeral_cert
enum ast_srtp_suite suite
Structure that represents the optional DTLS SRTP support within an RTP engine.
int(* set_configuration)(struct ast_rtp_instance *instance, const struct ast_rtp_dtls_cfg *dtls_cfg)
Structure for an ICE candidate.
struct ast_sockaddr address
enum ast_rtp_ice_component_type id
struct ast_sockaddr relay_address
enum ast_rtp_ice_candidate_type type
Structure that represents the optional ICE support within an RTP engine.
void(* set_authentication)(struct ast_rtp_instance *instance, const char *ufrag, const char *password)
struct ast_rtp_engine_dtls * dtls
double remote_stdevrxploss
double local_normdevjitter
double local_normdevrxploss
unsigned int rxoctetcount
double remote_normdevrxploss
double local_stdevrxploss
double remote_normdevjitter
unsigned int txoctetcount
char channel_uniqueid[MAX_CHANNEL_ID]
double remote_stdevjitter
An object that represents data received in a feedback report.
struct ast_rtp_rtcp_feedback_remb remb
Structure for storing RTP packets for retransmission.
A report block within a SR/RR report.
unsigned int highest_seq_no
struct ast_rtp_rtcp_report_block::@272 lost_count
An object that represents data sent during a SR/RR RTCP report.
struct ast_rtp_rtcp_report::@273 sender_information
unsigned short reception_report_count
unsigned int rtp_timestamp
struct ast_rtp_rtcp_report_block * report_block[0]
struct timeval ntp_timestamp
unsigned int packet_count
unsigned int lastividtimestamp
unsigned int dtmf_duration
struct ast_format * lasttxformat
struct rtp_transport_wide_cc_statistics transport_wide_cc
struct ast_smoother * smoother
struct ast_sched_context * sched
unsigned short seedrxseqno
unsigned int remote_seed_rx_rtp_ts_stable
enum ast_rtp_dtmf_mode dtmfmode
struct ast_sockaddr strict_rtp_address
enum strict_rtp_state strict_rtp_state
unsigned int rxoctetcount
unsigned int themssrc_valid
unsigned int dtmf_timeout
char cname[AST_UUID_STR_LEN]
unsigned char rawdata[8192+AST_FRIENDLY_OFFSET]
unsigned int last_transit_time_samples
unsigned int lastovidtimestamp
unsigned int asymmetric_codec
struct ast_rtp::@471 missing_seqno
struct ast_data_buffer * recv_buffer
optional_ts last_end_timestamp
unsigned int lastotexttimestamp
struct ast_sockaddr bind_address
struct ast_data_buffer * send_buffer
struct rtp_learning_info rtp_source_learn
struct ast_rtp_instance * owner
The RTP instance owning us (used for debugging purposes) We don't hold a reference to the instance be...
unsigned int remote_seed_rx_rtp_ts
unsigned int lastitexttimestamp
unsigned int txoctetcount
struct ast_rtp_instance * bundled
struct ast_rtp::@472 ssrc_mapping
struct ast_format * lastrxformat
Structure for rwlock and tracking information.
Socket address structure.
void(* destroy)(struct ast_srtp_policy *policy)
int(* set_master_key)(struct ast_srtp_policy *policy, const unsigned char *key, size_t key_len, const unsigned char *salt, size_t salt_len)
void(* set_ssrc)(struct ast_srtp_policy *policy, unsigned long ssrc, int inbound)
int(* set_suite)(struct ast_srtp_policy *policy, enum ast_srtp_suite suite)
struct ast_srtp_policy *(* alloc)(void)
int(* unprotect)(struct ast_srtp *srtp, void *buf, int *size, int rtcp)
int(* change_source)(struct ast_srtp *srtp, unsigned int from_ssrc, unsigned int to_ssrc)
int(* protect)(struct ast_srtp *srtp, void **buf, int *size, int rtcp)
struct ast_rtp_instance * rtp
Structure for variables, used for configurations and for channel variables.
structure to hold extensions
RTP learning mode tracking information.
enum ast_media_type stream_type
struct ast_sockaddr proposed_address
unsigned char t140red_data[64000]
unsigned char ts[AST_RED_MAX_GENERATION]
unsigned char len[AST_RED_MAX_GENERATION]
unsigned char buf_data[64000]
unsigned char pt[AST_RED_MAX_GENERATION]
Structure used for mapping an incoming SSRC to an RTP instance.
unsigned int ssrc
The received SSRC.
struct ast_rtp_instance * instance
The RTP instance this SSRC belongs to.
Packet statistics (used for transport-cc)
Statistics information (used for transport-cc)
struct rtp_transport_wide_cc_statistics::@470 packet_statistics
unsigned int last_extended_seqno
unsigned int feedback_count
int ast_stun_request(int s, struct sockaddr_in *dst, const char *username, struct sockaddr_in *answer)
Generic STUN request.
int ast_stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, size_t len, stun_cb_f *stun_cb, void *arg)
handle an incoming STUN message.
#define ast_debug_stun(sublevel,...)
Log debug level STUN information.
#define AST_DEBUG_CATEGORY_STUN
static const int STANDARD_STUN_PORT
#define ast_test_suite_event_notify(s, f,...)
void * ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size)
Retrieve thread storage.
#define AST_THREADSTORAGE(name)
Define a thread storage variable.
int64_t ast_tvdiff_us(struct timeval end, struct timeval start)
Computes the difference (in microseconds) between two struct timeval instances.
struct timeval ast_samp2tv(unsigned int _nsamp, unsigned int _rate)
Returns a timeval corresponding to the duration of n samples at rate r. Useful to convert samples to ...
int ast_tvzero(const struct timeval t)
Returns true if the argument is 0,0.
int ast_tvcmp(struct timeval _a, struct timeval _b)
Compress two struct timeval instances returning -1, 0, 1 if the first arg is smaller,...
struct timeval ast_time_create_by_unit(unsigned long val, enum TIME_UNIT unit)
Convert the given unit value, and create a timeval object from it.
double ast_samp2sec(unsigned int _nsamp, unsigned int _rate)
Returns the duration in seconds of _nsamp samples at rate _rate.
unsigned int ast_sec2samp(double _seconds, int _rate)
Returns the number of samples at _rate in the duration in _seconds.
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
struct timeval ast_time_create_by_unit_str(unsigned long val, const char *unit)
Convert the given unit value, and create a timeval object from it.
struct timeval ast_tvsub(struct timeval a, struct timeval b)
Returns the difference of two timevals a - b.
double ast_tv2double(const struct timeval *tv)
Returns a double corresponding to the number of seconds in the timeval tv.
ast_suseconds_t ast_time_tv_to_usec(const struct timeval *tv)
Convert a timeval structure to microseconds.
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec)
Returns a timeval from sec, usec.
static void destroy(struct ast_trans_pvt *pvt)
Handle unaligned data access.
static void put_unaligned_uint16(void *p, unsigned short datum)
static void put_unaligned_uint32(void *p, unsigned int datum)
int error(const char *format,...)
static void statistics(void)
#define ast_test_flag(p, flag)
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
#define ast_socket_nonblock(domain, type, protocol)
Create a non-blocking socket.
#define ast_clear_flag(p, flag)
long int ast_random(void)
#define ast_set_flag(p, flag)
Universally unique identifier support.
char * ast_uuid_generate_str(char *buf, size_t size)
Generate a UUID string.
#define AST_VECTOR_RESET(vec, cleanup)
Reset vector.
#define AST_VECTOR_ELEM_CLEANUP_NOOP(elem)
Vector element cleanup that does nothing.
#define AST_VECTOR_SIZE(vec)
Get the number of elements in a vector.
#define AST_VECTOR_REMOVE_CMP_ORDERED(vec, value, cmp, cleanup)
Remove an element from a vector that matches the given comparison while maintaining order.
#define AST_VECTOR_FREE(vec)
Deallocates this vector.
#define AST_VECTOR_REMOVE_CMP_UNORDERED(vec, value, cmp, cleanup)
Remove an element from a vector that matches the given comparison.
#define AST_VECTOR_GET_CMP(vec, value, cmp)
Get an element from a vector that matches the given comparison.
#define AST_VECTOR_ADD_SORTED(vec, elem, cmp)
Add an element into a sorted vector.
#define AST_VECTOR_INIT(vec, size)
Initialize a vector.
#define AST_VECTOR_APPEND(vec, elem)
Append an element to a vector, growing the vector if needed.
#define AST_VECTOR(name, type)
Define a vector structure.
#define AST_VECTOR_GET_ADDR(vec, idx)
Get an address of element in a vector.