--- /dev/null
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ * Copyright (C) 2005-2009, Anthony Minessale II <anthm@freeswitch.org>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ *
+ * The Initial Developer of the Original Code is
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Marcel Barbulescu <marcelbarbulescu@gmail.com>
+ *
+ *
+ * switch_rtp.c -- RTP
+ *
+ */
+//#define DEBUG_2833
+//#define RTP_DEBUG_WRITE_DELTA
+#include <switch.h>
+#include <switch_stun.h>
+#undef PACKAGE_NAME
+#undef PACKAGE_STRING
+#undef PACKAGE_TARNAME
+#undef PACKAGE_VERSION
+#undef PACKAGE_BUGREPORT
+#undef VERSION
+#undef PACKAGE
+#undef inline
+#include <datatypes.h>
+#include <srtp.h>
+
+#define READ_INC(rtp_session) switch_mutex_lock(rtp_session->read_mutex); rtp_session->reading++
+#define READ_DEC(rtp_session) switch_mutex_unlock(rtp_session->read_mutex); rtp_session->reading--
+#define WRITE_INC(rtp_session) switch_mutex_lock(rtp_session->write_mutex); rtp_session->writing++
+#define WRITE_DEC(rtp_session) switch_mutex_unlock(rtp_session->write_mutex); rtp_session->writing--
+
+#include "stfu.h"
+
+#define rtp_header_len 12
+#define RTP_START_PORT 16384
+#define RTP_END_PORT 32768
+#define MASTER_KEY_LEN 30
+#define RTP_MAGIC_NUMBER 42
+#define MAX_SRTP_ERRS 10
+
+static switch_port_t START_PORT = RTP_START_PORT;
+static switch_port_t END_PORT = RTP_END_PORT;
+static switch_port_t NEXT_PORT = RTP_START_PORT;
+static switch_mutex_t *port_lock = NULL;
+
+typedef srtp_hdr_t rtp_hdr_t;
+
+#ifdef ENABLE_ZRTP
+#include <libzrtp/zrtp.h>
+static zrtp_global_t *zrtp_global;
+static zrtp_zid_t zid = { "FreeSWITCH01" };
+static int zrtp_on = 0;
+#define ZRTP_MITM_TRIES 100
+#endif
+
+#ifdef _MSC_VER
+#pragma pack(4)
+#endif
+
+#ifdef _MSC_VER
+#pragma pack()
+#endif
+
+static switch_hash_t *alloc_hash = NULL;
+
+typedef struct {
+ srtp_hdr_t header;
+ char body[SWITCH_RTP_MAX_BUF_LEN];
+} rtp_msg_t;
+
+struct switch_rtp_vad_data {
+ switch_core_session_t *session;
+ switch_codec_t vad_codec;
+ switch_codec_t *read_codec;
+ uint32_t bg_level;
+ uint32_t bg_count;
+ uint32_t bg_len;
+ uint32_t diff_level;
+ uint8_t hangunder;
+ uint8_t hangunder_hits;
+ uint8_t hangover;
+ uint8_t hangover_hits;
+ uint8_t cng_freq;
+ uint8_t cng_count;
+ switch_vad_flag_t flags;
+ uint32_t ts;
+ uint8_t start;
+ uint8_t start_count;
+ uint8_t scan_freq;
+ time_t next_scan;
+};
+
+struct switch_rtp_rfc2833_data {
+ switch_queue_t *dtmf_queue;
+ char out_digit;
+ unsigned char out_digit_packet[4];
+ unsigned int out_digit_sofar;
+ unsigned int out_digit_sub_sofar;
+ unsigned int out_digit_dur;
+ uint16_t in_digit_seq;
+ uint32_t in_digit_ts;
+ uint32_t in_digit_sanity;
+ uint32_t timestamp_dtmf;
+ uint16_t last_duration;
+ uint32_t flip;
+ char first_digit;
+ char last_digit;
+ switch_queue_t *dtmf_inqueue;
+ switch_mutex_t *dtmf_mutex;
+};
+
+struct switch_rtp {
+ /*
+ * Two sockets are needed because we might be transcoding protocol families
+ * (e.g. receive over IPv4 and send over IPv6). In case the protocol
+ * families are equal, sock_input == sock_output and only one socket is
+ * used.
+ */
+ switch_socket_t *sock_input, *sock_output;
+ switch_pollfd_t *read_pollfd;
+ switch_pollfd_t *jb_pollfd;
+
+ switch_sockaddr_t *local_addr;
+ rtp_msg_t send_msg;
+
+ switch_sockaddr_t *remote_addr;
+ rtp_msg_t recv_msg;
+
+
+ switch_sockaddr_t *remote_stun_addr;
+
+ uint32_t autoadj_window;
+ uint32_t autoadj_tally;
+
+ srtp_ctx_t *send_ctx;
+ srtp_ctx_t *recv_ctx;
+ srtp_policy_t send_policy;
+ srtp_policy_t recv_policy;
+ uint32_t srtp_errs;
+
+ uint16_t seq;
+ uint32_t ssrc;
+ uint8_t sending_dtmf;
+ switch_payload_t payload;
+ switch_payload_t rpayload;
+ switch_rtp_invalid_handler_t invalid_handler;
+ void *private_data;
+ uint32_t ts;
+ uint32_t last_write_ts;
+ uint32_t last_write_samplecount;
+ uint32_t next_write_samplecount;
+ switch_time_t last_write_timestamp;
+ uint32_t flags;
+ switch_memory_pool_t *pool;
+ switch_sockaddr_t *from_addr;
+ char *rx_host;
+ switch_port_t rx_port;
+ char *ice_user;
+ char *user_ice;
+ char *timer_name;
+ char *remote_host_str;
+ switch_time_t last_stun;
+ uint32_t samples_per_interval;
+ uint32_t samples_per_second;
+ uint32_t conf_samples_per_interval;
+ uint32_t rsamples_per_interval;
+ uint32_t ms_per_packet;
+ switch_port_t remote_port;
+ uint32_t stuncount;
+ uint32_t funny_stun;
+ uint32_t default_stuncount;
+ struct switch_rtp_vad_data vad_data;
+ struct switch_rtp_rfc2833_data dtmf_data;
+ switch_payload_t te;
+ switch_payload_t cng_pt;
+ switch_mutex_t *flag_mutex;
+ switch_mutex_t *read_mutex;
+ switch_mutex_t *write_mutex;
+ switch_timer_t timer;
+ uint8_t ready;
+ uint8_t cn;
+ stfu_instance_t *jb;
+ uint32_t max_missed_packets;
+ uint32_t missed_count;
+ rtp_msg_t write_msg;
+ switch_rtp_crypto_key_t *crypto_keys[SWITCH_RTP_CRYPTO_MAX];
+ int reading;
+ int writing;
+ char *stun_ip;
+ switch_port_t stun_port;
+ int from_auto;
+ uint32_t cng_count;
+ switch_rtp_bug_flag_t rtp_bugs;
+ switch_rtp_stats_t stats;
+ uint32_t hot_hits;
+ uint32_t sync_packets;
+
+#ifdef ENABLE_ZRTP
+ zrtp_session_t *zrtp_session;
+ zrtp_profile_t *zrtp_profile;
+ zrtp_stream_t *zrtp_ctx;
+ int zrtp_mitm_tries;
+#endif
+
+#ifdef RTP_DEBUG_WRITE_DELTA
+ switch_time_t send_time;
+#endif
+
+};
+
+static int global_init = 0;
+static int rtp_common_write(switch_rtp_t *rtp_session,
+ rtp_msg_t *send_msg, void *data, uint32_t datalen, switch_payload_t payload, uint32_t timestamp, switch_frame_flag_t *flags);
+
+
+static switch_status_t do_stun_ping(switch_rtp_t *rtp_session)
+{
+ uint8_t buf[256] = { 0 };
+ uint8_t *start = buf;
+ switch_stun_packet_t *packet;
+ //unsigned int elapsed;
+ switch_size_t bytes;
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+ switch_assert(rtp_session != NULL);
+
+ WRITE_INC(rtp_session);
+
+ if (rtp_session->stuncount != 0) {
+ rtp_session->stuncount--;
+ goto end;
+ }
+
+#if 0
+ if (rtp_session->last_stun) {
+ elapsed = (unsigned int) ((switch_micro_time_now() - rtp_session->last_stun) / 1000);
+
+ if (elapsed > 30000) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No stun for a long time (PUNT!)\n");
+ status = SWITCH_STATUS_FALSE;
+ goto end;
+ }
+ }
+#endif
+
+ if (rtp_session->funny_stun) {
+ *start++ = 0;
+ *start++ = 0;
+ *start++ = 0x22;
+ *start++ = 0x22;
+ }
+
+ packet = switch_stun_packet_build_header(SWITCH_STUN_BINDING_REQUEST, NULL, start);
+ bytes = switch_stun_packet_length(packet);
+
+ if (rtp_session->funny_stun) {
+ packet = (switch_stun_packet_t *) buf;
+ bytes += 4;
+ }
+
+
+ switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_stun_addr, 0, (void *) packet, &bytes);
+ rtp_session->stuncount = rtp_session->default_stuncount;
+
+ end:
+ WRITE_DEC(rtp_session);
+
+ return status;
+}
+
+static switch_status_t ice_out(switch_rtp_t *rtp_session)
+{
+ uint8_t buf[256] = { 0 };
+ switch_stun_packet_t *packet;
+ unsigned int elapsed;
+ switch_size_t bytes;
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+ switch_assert(rtp_session != NULL);
+ switch_assert(rtp_session->ice_user != NULL);
+
+ WRITE_INC(rtp_session);
+
+ if (rtp_session->stuncount != 0) {
+ rtp_session->stuncount--;
+ goto end;
+ }
+
+ if (rtp_session->last_stun) {
+ elapsed = (unsigned int) ((switch_micro_time_now() - rtp_session->last_stun) / 1000);
+
+ if (elapsed > 30000) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No stun for a long time (PUNT!)\n");
+ status = SWITCH_STATUS_FALSE;
+ goto end;
+ }
+ }
+
+ packet = switch_stun_packet_build_header(SWITCH_STUN_BINDING_REQUEST, NULL, buf);
+ switch_stun_packet_attribute_add_username(packet, rtp_session->ice_user, 32);
+ bytes = switch_stun_packet_length(packet);
+ switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, (void *) packet, &bytes);
+ rtp_session->stuncount = rtp_session->default_stuncount;
+
+ end:
+ WRITE_DEC(rtp_session);
+
+ return status;
+}
+
+
+static void handle_stun_ping_reply(switch_rtp_t *rtp_session, void *data, switch_size_t len)
+{
+ if (!switch_rtp_ready(rtp_session)) {
+ return;
+ }
+
+ rtp_session->last_stun = switch_micro_time_now();
+}
+
+static void handle_ice(switch_rtp_t *rtp_session, void *data, switch_size_t len)
+{
+ switch_stun_packet_t *packet;
+ switch_stun_packet_attribute_t *attr;
+ void *end_buf;
+ char username[33] = { 0 };
+ unsigned char buf[512] = { 0 };
+ switch_size_t cpylen = len;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return;
+ }
+
+ READ_INC(rtp_session);
+ WRITE_INC(rtp_session);
+
+ if (!switch_rtp_ready(rtp_session)) {
+ goto end;
+ }
+
+
+ if (cpylen > 512) {
+ cpylen = 512;
+ }
+
+ memcpy(buf, data, cpylen);
+ packet = switch_stun_packet_parse(buf, sizeof(buf));
+ if (!packet) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid STUN/ICE packet received\n");
+ goto end;
+ }
+ end_buf = buf + ((sizeof(buf) > packet->header.length) ? packet->header.length : sizeof(buf));
+
+ rtp_session->last_stun = switch_micro_time_now();
+
+ switch_stun_packet_first_attribute(packet, attr);
+
+ do {
+ switch (attr->type) {
+ case SWITCH_STUN_ATTR_MAPPED_ADDRESS:
+ if (attr->type) {
+ char ip[16];
+ uint16_t port;
+ switch_stun_packet_attribute_get_mapped_address(attr, ip, &port);
+ }
+ break;
+ case SWITCH_STUN_ATTR_USERNAME:
+ if (attr->type) {
+ switch_stun_packet_attribute_get_username(attr, username, 32);
+ }
+ break;
+ }
+ } while (switch_stun_packet_next_attribute(attr, end_buf));
+
+ if ((packet->header.type == SWITCH_STUN_BINDING_REQUEST) && !strcmp(rtp_session->user_ice, username)) {
+ uint8_t stunbuf[512];
+ switch_stun_packet_t *rpacket;
+ const char *remote_ip;
+ switch_size_t bytes;
+ char ipbuf[25];
+
+ memset(stunbuf, 0, sizeof(stunbuf));
+ rpacket = switch_stun_packet_build_header(SWITCH_STUN_BINDING_RESPONSE, packet->header.id, stunbuf);
+ switch_stun_packet_attribute_add_username(rpacket, username, 32);
+ remote_ip = switch_get_addr(ipbuf, sizeof(ipbuf), rtp_session->from_addr);
+ switch_stun_packet_attribute_add_binded_address(rpacket, (char *) remote_ip, switch_sockaddr_get_port(rtp_session->from_addr));
+ bytes = switch_stun_packet_length(rpacket);
+ switch_socket_sendto(rtp_session->sock_output, rtp_session->from_addr, 0, (void *) rpacket, &bytes);
+ }
+
+ end:
+
+ READ_DEC(rtp_session);
+ WRITE_DEC(rtp_session);
+}
+
+#ifdef ENABLE_ZRTP
+SWITCH_STANDARD_SCHED_FUNC(zrtp_cache_save_callback)
+{
+ zrtp_status_t status = zrtp_status_ok;
+
+ status = zrtp_def_cache_store(zrtp_global);
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Saving ZRTP cache: %s\n", zrtp_status_ok == status ? "OK" : "FAIL");
+ task->runtime = switch_epoch_time_now(NULL) + 900;
+}
+
+static int zrtp_send_rtp_callback(const zrtp_stream_t* stream, char* rtp_packet, unsigned int rtp_packet_length)
+{
+ switch_rtp_t *rtp_session = zrtp_stream_get_userdata(stream);
+ switch_size_t len = rtp_packet_length;
+ zrtp_status_t status = zrtp_status_ok;
+
+ switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, rtp_packet, &len);
+ return status;
+}
+
+static void zrtp_event_callback(zrtp_stream_t *stream, unsigned event)
+{
+ switch_rtp_t *rtp_session = zrtp_stream_get_userdata(stream);
+ switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
+ switch_channel_t *channel = switch_core_session_get_channel(session);
+ switch_event_t *fsevent = NULL;
+
+ zrtp_session_info_t zrtp_session_info;
+
+ switch (event) {
+ case ZRTP_EVENT_IS_SECURE:
+ {
+ switch_set_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_SEND);
+ switch_set_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_RECV);
+ switch_set_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
+ switch_set_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
+ if (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info)) {
+ if (zrtp_session_info.sas_is_ready) {
+
+ switch_channel_set_variable(channel, "zrtp_secure_media_confirmed", "true");
+ switch_channel_set_variable(channel, "zrtp_sas1_string", rtp_session->zrtp_session->sas1.buffer);
+ switch_channel_set_variable(channel, "zrtp_sas2_string", rtp_session->zrtp_session->sas2.buffer);
+
+ zrtp_verified_set(zrtp_global, &rtp_session->zrtp_session->zid,
+ &rtp_session->zrtp_session->peer_zid, zrtp_session_info.sas_is_verified^1);
+
+ }
+ }
+ }
+ if (switch_event_create(&fsevent, SWITCH_EVENT_CALL_SECURE) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "zrtp:%s:%s",
+ rtp_session->zrtp_session->sas1.buffer, rtp_session->zrtp_session->sas2.buffer);
+ switch_event_add_header_string(fsevent, SWITCH_STACK_BOTTOM, "caller-unique-id", switch_channel_get_uuid(channel));
+ switch_event_fire(&fsevent);
+ }
+ break;
+#if 0
+ case ZRTP_EVENT_NO_ZRTP_QUICK:
+ {
+ if (rtp_session->zrtp_ctx != NULL) {
+ zrtp_stream_stop(rtp_session->zrtp_ctx);
+ }
+ }
+ break;
+#endif
+ case ZRTP_EVENT_IS_CLIENT_ENROLLMENT:
+ {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Enrolled complete!\n");
+ switch_channel_set_variable(channel, "zrtp_enroll_complete", "true");
+ }
+ break;
+
+ case ZRTP_EVENT_USER_ALREADY_ENROLLED:
+ {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "User already enrolled!\n");
+ switch_channel_set_variable(channel, "zrtp_already_enrolled", "true");
+
+ if (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info)) {
+ if (zrtp_session_info.sas_is_ready) {
+ zrtp_verified_set(zrtp_global, &rtp_session->zrtp_session->zid,
+ &rtp_session->zrtp_session->peer_zid, zrtp_session_info.sas_is_verified^1);
+ }
+ }
+ }
+ break;
+
+ case ZRTP_EVENT_NEW_USER_ENROLLED:
+ {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "New user enrolled!\n");
+ switch_channel_set_variable(channel, "zrtp_new_user_enrolled", "true");
+
+ if (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info)) {
+ if (zrtp_session_info.sas_is_ready) {
+ zrtp_verified_set(zrtp_global, &rtp_session->zrtp_session->zid,
+ &rtp_session->zrtp_session->peer_zid, zrtp_session_info.sas_is_verified^1);
+ }
+ }
+ }
+ break;
+
+ case ZRTP_EVENT_USER_UNENROLLED:
+ {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "User unenrolled!\n");
+ switch_channel_set_variable(channel, "zrtp_user_unenrolled", "true");
+
+ if (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info)) {
+ if (zrtp_session_info.sas_is_ready) {
+ zrtp_verified_set(zrtp_global, &rtp_session->zrtp_session->zid,
+ &rtp_session->zrtp_session->peer_zid, zrtp_session_info.sas_is_verified^1);
+ }
+ }
+ }
+ break;
+
+ case ZRTP_EVENT_IS_PENDINGCLEAR:
+ {
+ switch_channel_set_variable(channel, "zrtp_secure_media_confirmed", "false");
+ switch_clear_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_SEND);
+ switch_clear_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_RECV);
+ switch_clear_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
+ switch_clear_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
+ rtp_session->zrtp_mitm_tries = 0;
+ }
+ break;
+
+ case ZRTP_EVENT_NO_ZRTP:
+ {
+ switch_channel_set_variable(channel, "zrtp_secure_media_confirmed", "false");
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void zrtp_logger(int level, const char *data, int len)
+{
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s", data);
+}
+
+static void zrtp_handler(switch_rtp_t *rtp_session, switch_socket_t *sock, void *data, switch_size_t datalen, switch_sockaddr_t *from_addr)
+{
+ zrtp_status_t status = zrtp_status_fail;
+ unsigned int len = datalen;
+
+ status = zrtp_process_srtp(rtp_session->zrtp_ctx, (char*)data, &len);
+ switch(status) {
+ case zrtp_status_ok:
+ break;
+ case zrtp_status_drop:
+ break;
+ case zrtp_status_fail:
+ break;
+ default:
+ break;
+ }
+}
+#endif
+
+SWITCH_DECLARE(void) switch_rtp_init(switch_memory_pool_t *pool)
+{
+#ifdef ENABLE_ZRTP
+ const char *zid_string = switch_core_get_variable("switch_serial");
+ const char *zrtp_enabled = switch_core_get_variable("zrtp_enabled");
+ zrtp_on = zrtp_enabled ? switch_true(zrtp_enabled) : 0;
+ zrtp_config_t zrtp_config;
+ char zrtp_cache_path[256] = "";
+#endif
+ if (global_init) {
+ return;
+ }
+ switch_core_hash_init(&alloc_hash, pool);
+#ifdef ENABLE_ZRTP
+ if (zrtp_on) {
+ zrtp_config_defaults(&zrtp_config);
+ strcpy(zrtp_config.client_id, "FreeSWITCH");
+ zrtp_config.is_mitm = 1;
+ zrtp_config.lic_mode = ZRTP_LICENSE_MODE_ACTIVE;
+ switch_snprintf(zrtp_cache_path, sizeof(zrtp_cache_path), "%s%szrtp.dat", SWITCH_GLOBAL_dirs.db_dir, SWITCH_PATH_SEPARATOR);
+ zrtp_zstrcpyc( ZSTR_GV(zrtp_config.def_cache_path), zrtp_cache_path);
+ zrtp_config.cb.event_cb.on_zrtp_protocol_event = zrtp_event_callback;
+ zrtp_config.cb.misc_cb.on_send_packet = zrtp_send_rtp_callback;
+ zrtp_config.cb.event_cb.on_zrtp_security_event = zrtp_event_callback;
+
+ zrtp_log_set_log_engine(zrtp_logger);
+ zrtp_log_set_level(4);
+ if (zrtp_status_ok == zrtp_init(&zrtp_config, &zrtp_global)) {
+
+ memcpy(zid, zid_string, 12);
+ switch_scheduler_add_task(switch_epoch_time_now(NULL) + 900, zrtp_cache_save_callback, "zrtp_cache_save", "core", 0, NULL, SSHF_NONE | SSHF_NO_DEL);
+ } else {
+ switch_core_set_variable("zrtp_enabled", NULL);
+ zrtp_on = 0;
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "ZRTP init failed!\n");
+ }
+
+ }
+#endif
+ srtp_init();
+ switch_mutex_init(&port_lock, SWITCH_MUTEX_NESTED, pool);
+ global_init = 1;
+}
+
+SWITCH_DECLARE(void) switch_rtp_get_random(void *buf, uint32_t len)
+{
+ crypto_get_random(buf, len);
+}
+
+
+SWITCH_DECLARE(void) switch_rtp_shutdown(void)
+{
+ switch_core_port_allocator_t *alloc = NULL;
+ switch_hash_index_t *hi;
+ const void *var;
+ void *val;
+
+ switch_mutex_lock(port_lock);
+
+ for (hi = switch_hash_first(NULL, alloc_hash); hi; hi = switch_hash_next(hi)) {
+ switch_hash_this(hi, &var, NULL, &val);
+ if ((alloc = (switch_core_port_allocator_t *) val)) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Destroy port allocator for %s\n", (char *)var);
+ switch_core_port_allocator_destroy(&alloc);
+ }
+ }
+
+ switch_core_hash_destroy(&alloc_hash);
+ switch_mutex_unlock(port_lock);
+
+#ifdef ENABLE_ZRTP
+ if (zrtp_on) {
+ zrtp_status_t status = zrtp_status_ok;
+
+ status = zrtp_def_cache_store(zrtp_global);
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Saving ZRTP cache: %s\n", zrtp_status_ok == status ? "OK" : "FAIL");
+ zrtp_down(zrtp_global);
+ }
+#endif
+ crypto_kernel_shutdown();
+
+}
+
+SWITCH_DECLARE(switch_port_t) switch_rtp_set_start_port(switch_port_t port)
+{
+ if (port) {
+ if (port_lock) {
+ switch_mutex_lock(port_lock);
+ }
+ if (NEXT_PORT == START_PORT) {
+ NEXT_PORT = port;
+ }
+ START_PORT = port;
+ if (NEXT_PORT < START_PORT) {
+ NEXT_PORT = START_PORT;
+ }
+ if (port_lock) {
+ switch_mutex_unlock(port_lock);
+ }
+ }
+ return START_PORT;
+}
+
+SWITCH_DECLARE(switch_port_t) switch_rtp_set_end_port(switch_port_t port)
+{
+ if (port) {
+ if (port_lock) {
+ switch_mutex_lock(port_lock);
+ }
+ END_PORT = port;
+ if (NEXT_PORT > END_PORT) {
+ NEXT_PORT = START_PORT;
+ }
+ if (port_lock) {
+ switch_mutex_unlock(port_lock);
+ }
+ }
+ return END_PORT;
+}
+
+SWITCH_DECLARE(void) switch_rtp_release_port(const char *ip, switch_port_t port)
+{
+ switch_core_port_allocator_t *alloc = NULL;
+
+ if (!ip) {
+ return;
+ }
+
+ switch_mutex_lock(port_lock);
+ if ((alloc = switch_core_hash_find(alloc_hash, ip))) {
+ switch_core_port_allocator_free_port(alloc, port);
+ }
+ switch_mutex_unlock(port_lock);
+
+}
+
+SWITCH_DECLARE(switch_port_t) switch_rtp_request_port(const char *ip)
+{
+ switch_port_t port = 0;
+ switch_core_port_allocator_t *alloc = NULL;
+
+ switch_mutex_lock(port_lock);
+ alloc = switch_core_hash_find(alloc_hash, ip);
+ if (!alloc) {
+ if (switch_core_port_allocator_new(START_PORT, END_PORT, SPF_EVEN, &alloc) != SWITCH_STATUS_SUCCESS) {
+ abort();
+ }
+
+ switch_core_hash_insert(alloc_hash, ip, alloc);
+ }
+
+ if (switch_core_port_allocator_request_port(alloc, &port) != SWITCH_STATUS_SUCCESS) {
+ port = 0;
+ }
+
+ switch_mutex_unlock(port_lock);
+ return port;
+}
+
+SWITCH_DECLARE(void) switch_rtp_intentional_bugs(switch_rtp_t *rtp_session, switch_rtp_bug_flag_t bugs)
+{
+ rtp_session->rtp_bugs = bugs;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_set_local_address(switch_rtp_t *rtp_session, const char *host, switch_port_t port, const char **err)
+{
+ switch_socket_t *new_sock = NULL, *old_sock = NULL;
+ switch_status_t status = SWITCH_STATUS_FALSE;
+#ifndef WIN32
+ char o[5] = "TEST", i[5] = "";
+ switch_size_t len, ilen = 0;
+ int x;
+#endif
+
+ if (rtp_session->ready != 1) {
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ WRITE_INC(rtp_session);
+ READ_INC(rtp_session);
+
+ if (!switch_rtp_ready(rtp_session)) {
+ goto done;
+ }
+ }
+
+
+ *err = NULL;
+
+ if (zstr(host) || !port) {
+ *err = "Address Error";
+ goto done;
+ }
+
+ if (switch_sockaddr_info_get(&rtp_session->local_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
+ *err = "Local Address Error!";
+ goto done;
+ }
+
+ if (rtp_session->sock_input) {
+ switch_rtp_kill_socket(rtp_session);
+ }
+
+ if (switch_socket_create(&new_sock, switch_sockaddr_get_family(rtp_session->local_addr), SOCK_DGRAM, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
+ *err = "Socket Error!";
+ goto done;
+ }
+
+ if (switch_socket_opt_set(new_sock, SWITCH_SO_REUSEADDR, 1) != SWITCH_STATUS_SUCCESS) {
+ *err = "Socket Error!";
+ goto done;
+ }
+
+ if (switch_socket_bind(new_sock, rtp_session->local_addr) != SWITCH_STATUS_SUCCESS) {
+ *err = "Bind Error!";
+ goto done;
+ }
+#ifndef WIN32
+ len = sizeof(i);
+ switch_socket_opt_set(new_sock, SWITCH_SO_NONBLOCK, TRUE);
+
+ switch_socket_sendto(new_sock, rtp_session->local_addr, 0, (void *) o, &len);
+
+ x = 0;
+ while (!ilen) {
+ switch_status_t status;
+ ilen = len;
+ status = switch_socket_recvfrom(rtp_session->from_addr, new_sock, 0, (void *) i, &ilen);
+
+ if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
+ break;
+ }
+
+ if (++x > 1000) {
+ break;
+ }
+ switch_cond_next();
+ }
+ switch_socket_opt_set(new_sock, SWITCH_SO_NONBLOCK, FALSE);
+
+#endif
+
+ old_sock = rtp_session->sock_input;
+ rtp_session->sock_input = new_sock;
+ new_sock = NULL;
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER) || switch_test_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK)) {
+ switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, TRUE);
+ switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
+ }
+
+ switch_socket_create_pollfd(&rtp_session->read_pollfd, rtp_session->sock_input, SWITCH_POLLIN | SWITCH_POLLERR, rtp_session->pool);
+
+ status = SWITCH_STATUS_SUCCESS;
+ *err = "Success";
+ switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_IO);
+
+ done:
+
+ if (new_sock) {
+ switch_socket_close(new_sock);
+ }
+
+ if (old_sock) {
+ switch_socket_close(old_sock);
+ }
+
+ if (rtp_session->ready != 1) {
+ WRITE_DEC(rtp_session);
+ READ_DEC(rtp_session);
+ }
+
+ return status;
+}
+
+SWITCH_DECLARE(void) switch_rtp_set_max_missed_packets(switch_rtp_t *rtp_session, uint32_t max)
+{
+ if (rtp_session->missed_count >= max) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
+ "new max missed packets(%d->%d) greater than current missed packets(%d). RTP will timeout.\n",
+ rtp_session->missed_count, max, rtp_session->missed_count);
+ }
+
+ rtp_session->max_missed_packets = max;
+}
+
+SWITCH_DECLARE(void) switch_rtp_reset_media_timer(switch_rtp_t *rtp_session)
+{
+ rtp_session->missed_count = 0;
+}
+
+SWITCH_DECLARE(char *) switch_rtp_get_remote_host(switch_rtp_t *rtp_session)
+{
+ return zstr(rtp_session->remote_host_str) ? "0.0.0.0" : rtp_session->remote_host_str;
+}
+
+SWITCH_DECLARE(switch_port_t) switch_rtp_get_remote_port(switch_rtp_t *rtp_session)
+{
+ return rtp_session->remote_port;
+}
+
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_set_remote_address(switch_rtp_t *rtp_session, const char *host, switch_port_t port,
+ switch_bool_t change_adv_addr, const char **err)
+{
+ switch_sockaddr_t *remote_addr;
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+ *err = "Success";
+
+ if (switch_sockaddr_info_get(&remote_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !remote_addr) {
+ *err = "Remote Address Error!";
+ return SWITCH_STATUS_FALSE;
+ }
+
+ switch_mutex_lock(rtp_session->write_mutex);
+
+ rtp_session->remote_addr = remote_addr;
+
+ if (change_adv_addr) {
+ rtp_session->remote_host_str = switch_core_strdup(rtp_session->pool, host);
+ rtp_session->remote_port = port;
+ }
+
+ if (rtp_session->sock_input &&
+ switch_sockaddr_get_family(rtp_session->remote_addr) ==
+ switch_sockaddr_get_family(rtp_session->local_addr)) {
+ rtp_session->sock_output = rtp_session->sock_input;
+ }
+ else {
+ if (rtp_session->sock_output &&
+ rtp_session->sock_output != rtp_session->sock_input) {
+ switch_socket_close(rtp_session->sock_output);
+ }
+ if ((status = switch_socket_create(&rtp_session->sock_output,
+ switch_sockaddr_get_family(rtp_session->remote_addr),
+ SOCK_DGRAM, 0, rtp_session->pool)) !=
+ SWITCH_STATUS_SUCCESS)
+ {
+ *err = "Socket Error!";
+ }
+ }
+
+ switch_mutex_unlock(rtp_session->write_mutex);
+
+ return status;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_add_crypto_key(switch_rtp_t *rtp_session,
+ switch_rtp_crypto_direction_t direction,
+ uint32_t index, switch_rtp_crypto_key_type_t type, unsigned char *key, switch_size_t keylen)
+{
+ switch_rtp_crypto_key_t *crypto_key;
+ srtp_policy_t *policy;
+ err_status_t stat;
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+ switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
+ switch_channel_t *channel = switch_core_session_get_channel(session);
+ switch_event_t *fsevent = NULL;
+
+ if (direction >= SWITCH_RTP_CRYPTO_MAX || keylen > SWITCH_RTP_MAX_CRYPTO_LEN) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ crypto_key = switch_core_alloc(rtp_session->pool, sizeof(*crypto_key));
+
+ if (direction == SWITCH_RTP_CRYPTO_RECV) {
+ policy = &rtp_session->recv_policy;
+ } else {
+ policy = &rtp_session->send_policy;
+ }
+
+ crypto_key->type = type;
+ crypto_key->index = index;
+ memcpy(crypto_key->key, key, keylen);
+ crypto_key->next = rtp_session->crypto_keys[direction];
+ rtp_session->crypto_keys[direction] = crypto_key;
+
+ memset(policy, 0, sizeof(*policy));
+
+ switch (crypto_key->type) {
+ case AES_CM_128_HMAC_SHA1_80:
+ crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy->rtp);
+ if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
+ switch_channel_set_variable(channel, "sip_has_crypto", "AES_CM_128_HMAC_SHA1_80");
+ }
+ break;
+ case AES_CM_128_HMAC_SHA1_32:
+ crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy->rtp);
+ if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
+ switch_channel_set_variable(channel, "sip_has_crypto", "AES_CM_128_HMAC_SHA1_32");
+ }
+ break;
+ case AES_CM_128_NULL_AUTH:
+ crypto_policy_set_aes_cm_128_null_auth(&policy->rtp);
+ if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
+ switch_channel_set_variable(channel, "sip_has_crypto", "AES_CM_128_NULL_AUTH");
+ }
+ break;
+ default:
+ break;
+ }
+
+ policy->next = NULL;
+ policy->key = (uint8_t *) crypto_key->key;
+ crypto_policy_set_rtcp_default(&policy->rtcp);
+ policy->rtcp.sec_serv = sec_serv_none;
+
+ policy->rtp.sec_serv = sec_serv_conf_and_auth;
+ switch (direction) {
+ case SWITCH_RTP_CRYPTO_RECV:
+ policy->ssrc.type = ssrc_any_inbound;
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_RECV)) {
+ switch_set_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_RECV_RESET);
+ } else {
+ if ((stat = srtp_create(&rtp_session->recv_ctx, policy))) {
+ status = SWITCH_STATUS_FALSE;
+ }
+
+ if (status == SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Activating Secure RTP RECV\n");
+ switch_set_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_RECV);
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error allocating srtp [%d]\n", stat);
+ return status;
+ }
+ }
+ break;
+ case SWITCH_RTP_CRYPTO_SEND:
+ policy->ssrc.type = ssrc_specific;
+ policy->ssrc.value = rtp_session->ssrc;
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND)) {
+ switch_set_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET);
+ } else {
+ if ((stat = srtp_create(&rtp_session->send_ctx, policy))) {
+ status = SWITCH_STATUS_FALSE;
+ }
+
+ if (status == SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Activating Secure RTP SEND\n");
+ switch_set_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND);
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error allocating SRTP [%d]\n", stat);
+ return status;
+ }
+ }
+
+ break;
+ default:
+ abort();
+ break;
+ }
+
+ if (switch_event_create(&fsevent, SWITCH_EVENT_CALL_SECURE) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "srtp:%s", switch_channel_get_variable(channel, "sip_has_crypto"));
+ switch_event_add_header_string(fsevent, SWITCH_STACK_BOTTOM, "caller-unique-id", switch_channel_get_uuid(channel));
+ switch_event_fire(&fsevent);
+ }
+
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_set_interval(switch_rtp_t *rtp_session, uint32_t ms_per_packet, uint32_t samples_per_interval)
+{
+ rtp_session->ms_per_packet = ms_per_packet;
+ rtp_session->samples_per_interval = rtp_session->conf_samples_per_interval = samples_per_interval;
+ rtp_session->missed_count = 0;
+ rtp_session->samples_per_second = (uint32_t)((double)(1000.0f / (double)(rtp_session->ms_per_packet / 1000)) * (double)rtp_session->samples_per_interval);
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_change_interval(switch_rtp_t *rtp_session, uint32_t ms_per_packet, uint32_t samples_per_interval)
+{
+
+ switch_rtp_set_interval(rtp_session, ms_per_packet, samples_per_interval);
+
+ if (rtp_session->timer_name) {
+ if (rtp_session->timer.timer_interface) {
+ switch_core_timer_destroy(&rtp_session->timer);
+ }
+ if (switch_core_timer_init(&rtp_session->timer,
+ rtp_session->timer_name, ms_per_packet / 1000, samples_per_interval, rtp_session->pool) == SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
+ "RE-Starting timer [%s] %d bytes per %dms\n", rtp_session->timer_name, samples_per_interval, ms_per_packet);
+ } else {
+ memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+ "Problem RE-Starting timer [%s] %d bytes per %dms\n", rtp_session->timer_name, samples_per_interval, ms_per_packet / 1000);
+ return SWITCH_STATUS_FALSE;
+ }
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_create(switch_rtp_t **new_rtp_session,
+ switch_payload_t payload,
+ uint32_t samples_per_interval,
+ uint32_t ms_per_packet,
+ switch_rtp_flag_t flags, char *timer_name, const char **err, switch_memory_pool_t *pool)
+{
+ switch_rtp_t *rtp_session = NULL;
+ switch_core_session_t *session = switch_core_memory_pool_get_data(pool, "__session");
+
+ *new_rtp_session = NULL;
+
+ if (samples_per_interval > SWITCH_RTP_MAX_BUF_LEN) {
+ *err = "Packet Size Too Large!";
+ return SWITCH_STATUS_FALSE;
+ }
+
+ if (!(rtp_session = switch_core_alloc(pool, sizeof(*rtp_session)))) {
+ *err = "Memory Error!";
+ return SWITCH_STATUS_MEMERR;
+ }
+
+ rtp_session->pool = pool;
+ rtp_session->te = 101;
+
+
+ switch_mutex_init(&rtp_session->flag_mutex, SWITCH_MUTEX_NESTED, pool);
+ switch_mutex_init(&rtp_session->read_mutex, SWITCH_MUTEX_NESTED, pool);
+ switch_mutex_init(&rtp_session->write_mutex, SWITCH_MUTEX_NESTED, pool);
+ switch_mutex_init(&rtp_session->dtmf_data.dtmf_mutex, SWITCH_MUTEX_NESTED, pool);
+ switch_queue_create(&rtp_session->dtmf_data.dtmf_queue, 100, rtp_session->pool);
+ switch_queue_create(&rtp_session->dtmf_data.dtmf_inqueue, 100, rtp_session->pool);
+
+ switch_rtp_set_flag(rtp_session, flags);
+
+ /* for from address on recvfrom calls */
+ switch_sockaddr_info_get(&rtp_session->from_addr, NULL, SWITCH_UNSPEC, 0, 0, pool);
+
+
+ rtp_session->seq = (uint16_t) rand();
+ rtp_session->ssrc = (uint32_t) ((intptr_t) &rtp_session + (uint32_t) switch_epoch_time_now(NULL));
+ rtp_session->send_msg.header.ssrc = htonl(rtp_session->ssrc);
+ rtp_session->send_msg.header.ts = 0;
+ rtp_session->send_msg.header.m = 0;
+ rtp_session->send_msg.header.pt = (switch_payload_t) htonl(payload);
+ rtp_session->send_msg.header.version = 2;
+ rtp_session->send_msg.header.p = 0;
+ rtp_session->send_msg.header.x = 0;
+ rtp_session->send_msg.header.cc = 0;
+
+ rtp_session->recv_msg.header.ssrc = 0;
+ rtp_session->recv_msg.header.ts = 0;
+ rtp_session->recv_msg.header.seq = 0;
+ rtp_session->recv_msg.header.m = 0;
+ rtp_session->recv_msg.header.pt = (switch_payload_t) htonl(payload);
+ rtp_session->recv_msg.header.version = 2;
+ rtp_session->recv_msg.header.p = 0;
+ rtp_session->recv_msg.header.x = 0;
+ rtp_session->recv_msg.header.cc = 0;
+
+ rtp_session->payload = payload;
+
+ switch_rtp_set_interval(rtp_session, ms_per_packet, samples_per_interval);
+ rtp_session->conf_samples_per_interval = samples_per_interval;
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER) && zstr(timer_name)) {
+ timer_name = "soft";
+ }
+
+ if (!zstr(timer_name) && !strcasecmp(timer_name, "none")) {
+ timer_name = NULL;
+ }
+
+ if (!zstr(timer_name)) {
+ rtp_session->timer_name = switch_core_strdup(pool, timer_name);
+ switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
+ switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
+
+ if (switch_core_timer_init(&rtp_session->timer, timer_name, ms_per_packet / 1000, samples_per_interval, pool) == SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
+ "Starting timer [%s] %d bytes per %dms\n", timer_name, samples_per_interval, ms_per_packet / 1000);
+ } else {
+ memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error starting timer [%s], async RTP disabled\n", timer_name);
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
+ }
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Not using a timer\n");
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
+ }
+
+#ifdef ENABLE_ZRTP
+ if (zrtp_on) {
+ int initiator = 0;
+ switch_channel_t *channel = switch_core_session_get_channel(session);
+ const char *zrtp_enabled = switch_channel_get_variable(channel, "zrtp_secure_media");
+ const char *srtp_enabled = switch_channel_get_variable(channel, "sip_secure_media");
+
+ if (switch_true(srtp_enabled) && switch_true(zrtp_enabled)) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "You can not have ZRTP and SRTP enabled simultaneously, ZRTP will be disabled for this call!\n");
+ switch_channel_set_variable(channel, "zrtp_secure_media", NULL);
+ zrtp_enabled = NULL;
+ }
+
+ if (switch_true(zrtp_enabled)) {
+ if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
+ initiator = 1;
+ }
+
+ rtp_session->zrtp_profile = switch_core_alloc(rtp_session->pool, sizeof(*rtp_session->zrtp_profile));
+ zrtp_profile_defaults(rtp_session->zrtp_profile, zrtp_global);
+
+ rtp_session->zrtp_profile->allowclear = 0;
+ rtp_session->zrtp_profile->disclose_bit = 0;
+ rtp_session->zrtp_profile->cache_ttl = -1;
+
+ if (zrtp_status_ok != zrtp_session_init(zrtp_global, rtp_session->zrtp_profile, zid, initiator, &rtp_session->zrtp_session)) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! zRTP INIT Failed\n");
+ zrtp_session_down(rtp_session->zrtp_session);
+ rtp_session->zrtp_session = NULL;
+ }
+
+ zrtp_session_set_userdata(rtp_session->zrtp_session, rtp_session);
+
+ if (zrtp_status_ok != zrtp_stream_attach(rtp_session->zrtp_session, &rtp_session->zrtp_ctx)) {
+ abort();
+ }
+ zrtp_stream_set_userdata(rtp_session->zrtp_ctx, rtp_session);
+
+ if (switch_true(switch_channel_get_variable(channel, "zrtp_enrollment"))) {
+ zrtp_stream_registration_start(rtp_session->zrtp_ctx, rtp_session->ssrc);
+ } else {
+ zrtp_stream_start(rtp_session->zrtp_ctx, rtp_session->ssrc);
+ }
+ }
+ }
+#endif
+
+ rtp_session->ready = 1;
+ *new_rtp_session = rtp_session;
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(const char *rx_host,
+ switch_port_t rx_port,
+ const char *tx_host,
+ switch_port_t tx_port,
+ switch_payload_t payload,
+ uint32_t samples_per_interval,
+ uint32_t ms_per_packet,
+ switch_rtp_flag_t flags, char *timer_name, const char **err, switch_memory_pool_t *pool)
+{
+ switch_rtp_t *rtp_session = NULL;
+
+ if (zstr(rx_host)) {
+ *err = "Missing local host";
+ goto end;
+ }
+
+ if (!rx_port) {
+ *err = "Missing local port";
+ goto end;
+ }
+
+ if (zstr(tx_host)) {
+ *err = "Missing remote host";
+ goto end;
+ }
+
+ if (!tx_port) {
+ *err = "Missing remote port";
+ goto end;
+ }
+
+ if (switch_rtp_create(&rtp_session, payload, samples_per_interval, ms_per_packet, flags, timer_name, err, pool) != SWITCH_STATUS_SUCCESS) {
+ goto end;
+ }
+
+ switch_mutex_lock(rtp_session->flag_mutex);
+
+ if (switch_rtp_set_local_address(rtp_session, rx_host, rx_port, err) != SWITCH_STATUS_SUCCESS) {
+ switch_mutex_unlock(rtp_session->flag_mutex);
+ rtp_session = NULL;
+ goto end;
+ }
+
+ if (switch_rtp_set_remote_address(rtp_session, tx_host, tx_port, SWITCH_TRUE, err) != SWITCH_STATUS_SUCCESS) {
+ switch_mutex_unlock(rtp_session->flag_mutex);
+ rtp_session = NULL;
+ goto end;
+ }
+
+ end:
+
+ if (rtp_session) {
+ switch_mutex_unlock(rtp_session->flag_mutex);
+ rtp_session->ready = 2;
+ rtp_session->rx_host = switch_core_strdup(rtp_session->pool, rx_host);
+ rtp_session->rx_port = rx_port;
+ } else {
+ switch_rtp_release_port(rx_host, rx_port);
+ }
+
+ return rtp_session;
+}
+
+SWITCH_DECLARE(void) switch_rtp_set_telephony_event(switch_rtp_t *rtp_session, switch_payload_t te)
+{
+ if (te > 95) {
+ rtp_session->te = te;
+ }
+}
+
+SWITCH_DECLARE(void) switch_rtp_set_cng_pt(switch_rtp_t *rtp_session, switch_payload_t pt)
+{
+ rtp_session->cng_pt = pt;
+ switch_set_flag(rtp_session, SWITCH_RTP_FLAG_AUTO_CNG);
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_activate_stun_ping(switch_rtp_t *rtp_session, const char *stun_ip, switch_port_t stun_port,
+ uint32_t packet_count, switch_bool_t funny)
+{
+
+ if (switch_sockaddr_info_get(&rtp_session->remote_stun_addr, stun_ip, SWITCH_UNSPEC,
+ stun_port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !rtp_session->remote_stun_addr) {
+
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error resolving stun ping addr\n");
+ return SWITCH_STATUS_FALSE;
+ }
+
+ if (funny) {
+ rtp_session->funny_stun++;
+ }
+
+ rtp_session->stun_port = stun_port;
+
+ rtp_session->default_stuncount = packet_count;
+
+ rtp_session->stun_ip = switch_core_strdup(rtp_session->pool, stun_ip);
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_activate_jitter_buffer(switch_rtp_t *rtp_session, uint32_t queue_frames)
+{
+
+ rtp_session->jb = stfu_n_init(queue_frames);
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_activate_ice(switch_rtp_t *rtp_session, char *login, char *rlogin)
+{
+ char ice_user[80];
+ char user_ice[80];
+
+ switch_snprintf(ice_user, sizeof(ice_user), "%s%s", login, rlogin);
+ switch_snprintf(user_ice, sizeof(user_ice), "%s%s", rlogin, login);
+ rtp_session->ice_user = switch_core_strdup(rtp_session->pool, ice_user);
+ rtp_session->user_ice = switch_core_strdup(rtp_session->pool, user_ice);
+ rtp_session->default_stuncount = 25;
+
+ if (rtp_session->ice_user) {
+ if (ice_out(rtp_session) != SWITCH_STATUS_SUCCESS) {
+ return SWITCH_STATUS_FALSE;
+ }
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+static void ping_socket(switch_rtp_t *rtp_session)
+{
+ uint32_t o = UINT_MAX;
+ switch_size_t len = sizeof(o);
+ switch_socket_sendto(rtp_session->sock_input, rtp_session->local_addr, 0, (void *) &o, &len);
+}
+
+SWITCH_DECLARE(void) switch_rtp_break(switch_rtp_t *rtp_session)
+{
+ if (!switch_rtp_ready(rtp_session)) {
+ return;
+ }
+
+ switch_mutex_lock(rtp_session->flag_mutex);
+ switch_set_flag(rtp_session, SWITCH_RTP_FLAG_BREAK);
+ switch_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK)) {
+ switch_mutex_unlock(rtp_session->flag_mutex);
+ return;
+ }
+
+ if (rtp_session->sock_input) {
+ ping_socket(rtp_session);
+ }
+ switch_mutex_unlock(rtp_session->flag_mutex);
+}
+
+SWITCH_DECLARE(void) switch_rtp_kill_socket(switch_rtp_t *rtp_session)
+{
+ switch_assert(rtp_session != NULL);
+ switch_mutex_lock(rtp_session->flag_mutex);
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_IO)) {
+ switch_clear_flag(rtp_session, SWITCH_RTP_FLAG_IO);
+ if (rtp_session->sock_input) {
+ ping_socket(rtp_session);
+ switch_socket_shutdown(rtp_session->sock_input, SWITCH_SHUTDOWN_READWRITE);
+ }
+ if (rtp_session->sock_output && rtp_session->sock_output != rtp_session->sock_input) {
+ switch_socket_shutdown(rtp_session->sock_output, SWITCH_SHUTDOWN_READWRITE);
+ }
+ }
+ switch_mutex_unlock(rtp_session->flag_mutex);
+}
+
+SWITCH_DECLARE(uint8_t) switch_rtp_ready(switch_rtp_t *rtp_session)
+{
+ uint8_t ret;
+
+ if (!rtp_session || !rtp_session->flag_mutex || switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SHUTDOWN)) {
+ return 0;
+ }
+
+ switch_mutex_lock(rtp_session->flag_mutex);
+ ret = (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_IO) && rtp_session->sock_input && rtp_session->sock_output && rtp_session->remote_addr && rtp_session->ready == 2) ? 1 : 0;
+ switch_mutex_unlock(rtp_session->flag_mutex);
+
+ return ret;
+}
+
+SWITCH_DECLARE(void) switch_rtp_destroy(switch_rtp_t **rtp_session)
+{
+ void *pop;
+ switch_socket_t *sock;
+
+ if (!rtp_session || !*rtp_session || !(*rtp_session)->ready) {
+ return;
+ }
+
+ switch_set_flag_locked((*rtp_session), SWITCH_RTP_FLAG_SHUTDOWN);
+
+ READ_INC((*rtp_session));
+ WRITE_INC((*rtp_session));
+
+ (*rtp_session)->ready = 0;
+
+ READ_DEC((*rtp_session));
+ WRITE_DEC((*rtp_session));
+
+ switch_mutex_lock((*rtp_session)->flag_mutex);
+
+ switch_rtp_kill_socket(*rtp_session);
+
+ while (switch_queue_trypop((*rtp_session)->dtmf_data.dtmf_inqueue, &pop) == SWITCH_STATUS_SUCCESS) {
+ switch_safe_free(pop);
+ }
+
+ while (switch_queue_trypop((*rtp_session)->dtmf_data.dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
+ switch_safe_free(pop);
+ }
+
+ if ((*rtp_session)->jb) {
+ stfu_n_destroy(&(*rtp_session)->jb);
+ }
+
+ sock = (*rtp_session)->sock_input;
+ (*rtp_session)->sock_input = NULL;
+ switch_socket_close(sock);
+
+ if ( (*rtp_session)->sock_output != sock ) {
+ sock = (*rtp_session)->sock_output;
+ (*rtp_session)->sock_output = NULL;
+ switch_socket_close(sock);
+ }
+
+ if (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_VAD)) {
+ switch_rtp_disable_vad(*rtp_session);
+ }
+
+ if (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE_SEND)) {
+ srtp_dealloc((*rtp_session)->send_ctx);
+ (*rtp_session)->send_ctx = NULL;
+ switch_clear_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE_SEND);
+ }
+
+ if (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE_RECV)) {
+ srtp_dealloc((*rtp_session)->recv_ctx);
+ (*rtp_session)->recv_ctx = NULL;
+ switch_clear_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE_RECV);
+ }
+#ifdef ENABLE_ZRTP
+ /* ZRTP */
+ if (zrtp_on) {
+
+ if ((*rtp_session)->zrtp_ctx != NULL) {
+ zrtp_stream_stop((*rtp_session)->zrtp_ctx);
+ }
+
+ if (switch_test_flag((*rtp_session), SWITCH_ZRTP_FLAG_SECURE_SEND)) {
+ switch_clear_flag((*rtp_session), SWITCH_ZRTP_FLAG_SECURE_SEND);
+ }
+
+ if (switch_test_flag((*rtp_session), SWITCH_ZRTP_FLAG_SECURE_RECV)) {
+ switch_clear_flag((*rtp_session), SWITCH_ZRTP_FLAG_SECURE_RECV);
+ }
+
+ if ((*rtp_session)->zrtp_session) {
+ zrtp_session_down((*rtp_session)->zrtp_session);
+ (*rtp_session)->zrtp_session = NULL;
+ }
+ }
+#endif
+ if ((*rtp_session)->timer.timer_interface) {
+ switch_core_timer_destroy(&(*rtp_session)->timer);
+ }
+
+ switch_rtp_release_port((*rtp_session)->rx_host, (*rtp_session)->rx_port);
+ switch_mutex_unlock((*rtp_session)->flag_mutex);
+
+ return;
+}
+
+SWITCH_DECLARE(switch_socket_t *) switch_rtp_get_rtp_socket(switch_rtp_t *rtp_session)
+{
+ return rtp_session->sock_input;
+}
+
+SWITCH_DECLARE(uint32_t) switch_rtp_get_default_samples_per_interval(switch_rtp_t *rtp_session)
+{
+ return rtp_session->samples_per_interval;
+}
+
+SWITCH_DECLARE(void) switch_rtp_set_default_payload(switch_rtp_t *rtp_session, switch_payload_t payload)
+{
+ rtp_session->payload = payload;
+}
+
+SWITCH_DECLARE(uint32_t) switch_rtp_get_default_payload(switch_rtp_t *rtp_session)
+{
+ return rtp_session->payload;
+}
+
+SWITCH_DECLARE(void) switch_rtp_set_invald_handler(switch_rtp_t *rtp_session, switch_rtp_invalid_handler_t on_invalid)
+{
+ rtp_session->invalid_handler = on_invalid;
+}
+
+SWITCH_DECLARE(void) switch_rtp_set_flag(switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
+{
+ switch_set_flag_locked(rtp_session, flags);
+ if (flags & SWITCH_RTP_FLAG_AUTOADJ) {
+ rtp_session->autoadj_window = 20;
+ rtp_session->autoadj_tally = 0;
+ }
+}
+
+SWITCH_DECLARE(uint32_t) switch_rtp_test_flag(switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
+{
+ return (uint32_t) switch_test_flag(rtp_session, flags);
+}
+
+SWITCH_DECLARE(void) switch_rtp_clear_flag(switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
+{
+ switch_clear_flag_locked(rtp_session, flags);
+}
+
+static void do_2833(switch_rtp_t *rtp_session)
+{
+ switch_frame_flag_t flags = 0;
+ uint32_t samples = rtp_session->samples_per_interval;
+
+ if (rtp_session->dtmf_data.out_digit_dur > 0) {
+ int x, loops = 1;
+ rtp_session->dtmf_data.out_digit_sofar += samples;
+ rtp_session->dtmf_data.out_digit_sub_sofar += samples;
+
+ if (rtp_session->dtmf_data.out_digit_sub_sofar > 0xFFFF) {
+ rtp_session->dtmf_data.out_digit_sub_sofar = samples;
+ rtp_session->dtmf_data.timestamp_dtmf += 0xFFFF;
+ }
+
+ if (rtp_session->dtmf_data.out_digit_sofar >= rtp_session->dtmf_data.out_digit_dur) {
+ rtp_session->dtmf_data.out_digit_packet[1] |= 0x80;
+ loops = 3;
+ }
+
+ rtp_session->dtmf_data.out_digit_packet[2] = (unsigned char) (rtp_session->dtmf_data.out_digit_sub_sofar >> 8);
+ rtp_session->dtmf_data.out_digit_packet[3] = (unsigned char) rtp_session->dtmf_data.out_digit_sub_sofar;
+
+ for (x = 0; x < loops; x++) {
+ switch_size_t wrote = switch_rtp_write_manual(rtp_session,
+ rtp_session->dtmf_data.out_digit_packet, 4, 0,
+ rtp_session->te, rtp_session->dtmf_data.timestamp_dtmf, &flags);
+
+ rtp_session->stats.outbound.raw_bytes += wrote;
+ rtp_session->stats.outbound.dtmf_packet_count++;
+
+
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Send %s packet for [%c] ts=%u dur=%d/%d/%d seq=%d\n",
+ loops == 1 ? "middle" : "end", rtp_session->dtmf_data.out_digit,
+ rtp_session->dtmf_data.timestamp_dtmf,
+ rtp_session->dtmf_data.out_digit_sofar,
+ rtp_session->dtmf_data.out_digit_sub_sofar, rtp_session->dtmf_data.out_digit_dur, rtp_session->seq);
+ if (rtp_session->rtp_bugs & RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833) {
+ rtp_session->dtmf_data.timestamp_dtmf = rtp_session->last_write_ts + samples;
+ }
+ }
+
+ if (loops != 1) {
+ rtp_session->last_write_ts = rtp_session->dtmf_data.timestamp_dtmf + rtp_session->dtmf_data.out_digit_sub_sofar;
+ rtp_session->sending_dtmf = 0;
+ if (rtp_session->timer.interval) {
+ rtp_session->last_write_samplecount = rtp_session->timer.samplecount;
+ rtp_session->next_write_samplecount = rtp_session->timer.samplecount + samples * 5;
+ }
+ rtp_session->dtmf_data.out_digit_dur = 0;
+ }
+ }
+
+ if (!rtp_session->dtmf_data.out_digit_dur && rtp_session->dtmf_data.dtmf_queue && switch_queue_size(rtp_session->dtmf_data.dtmf_queue)) {
+ void *pop;
+
+ if (rtp_session->timer.interval) {
+ if (rtp_session->timer.samplecount < rtp_session->next_write_samplecount) {
+ return;
+ }
+ }
+
+ if (switch_queue_trypop(rtp_session->dtmf_data.dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
+ switch_dtmf_t *rdigit = pop;
+ int64_t offset;
+ switch_size_t wrote;
+ rtp_session->sending_dtmf = 1;
+
+ memset(rtp_session->dtmf_data.out_digit_packet, 0, 4);
+ rtp_session->dtmf_data.out_digit_sofar = samples;
+ rtp_session->dtmf_data.out_digit_sub_sofar = samples;
+ rtp_session->dtmf_data.out_digit_dur = rdigit->duration;
+ rtp_session->dtmf_data.out_digit = rdigit->digit;
+ rtp_session->dtmf_data.out_digit_packet[0] = (unsigned char) switch_char_to_rfc2833(rdigit->digit);
+ rtp_session->dtmf_data.out_digit_packet[1] = 7;
+ rtp_session->dtmf_data.out_digit_packet[2] = (unsigned char) (rtp_session->dtmf_data.out_digit_sub_sofar >> 8);
+ rtp_session->dtmf_data.out_digit_packet[3] = (unsigned char) rtp_session->dtmf_data.out_digit_sub_sofar;
+
+
+ rtp_session->dtmf_data.timestamp_dtmf = rtp_session->last_write_ts + samples;
+ if (rtp_session->timer.interval) {
+ offset = rtp_session->timer.samplecount - rtp_session->last_write_samplecount;
+ if (offset > 0) {
+ rtp_session->dtmf_data.timestamp_dtmf = (uint32_t) (rtp_session->dtmf_data.timestamp_dtmf + offset);
+ }
+ }
+
+ wrote = switch_rtp_write_manual(rtp_session,
+ rtp_session->dtmf_data.out_digit_packet,
+ 4,
+ rtp_session->rtp_bugs & RTP_BUG_CISCO_SKIP_MARK_BIT_2833 ? 0 : 1,
+ rtp_session->te, rtp_session->dtmf_data.timestamp_dtmf, &flags);
+
+ rtp_session->stats.outbound.raw_bytes += wrote;
+ rtp_session->stats.outbound.dtmf_packet_count++;
+
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Send start packet for [%c] ts=%u dur=%d/%d/%d seq=%d\n",
+ rtp_session->dtmf_data.out_digit,
+ rtp_session->dtmf_data.timestamp_dtmf,
+ rtp_session->dtmf_data.out_digit_sofar,
+ rtp_session->dtmf_data.out_digit_sub_sofar, rtp_session->dtmf_data.out_digit_dur, rtp_session->seq);
+
+ free(rdigit);
+ }
+ }
+}
+
+SWITCH_DECLARE(void) rtp_flush_read_buffer(switch_rtp_t *rtp_session, switch_rtp_flush_t flush)
+{
+ if (switch_rtp_ready(rtp_session) && !switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA)) {
+ switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_FLUSH);
+ switch (flush) {
+ case SWITCH_RTP_FLUSH_STICK:
+ switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
+ break;
+ case SWITCH_RTP_FLUSH_UNSTICK:
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+static void do_flush(switch_rtp_t *rtp_session)
+{
+ int was_blocking = 0;
+ switch_size_t bytes;
+ switch_status_t status;
+
+ if (!switch_rtp_ready(rtp_session) || switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA)) {
+ return;
+ }
+
+ READ_INC(rtp_session);
+
+ if (switch_rtp_ready(rtp_session)) {
+ if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK)) {
+ was_blocking = 1;
+ switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
+ switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, TRUE);
+ }
+
+ do {
+ if (switch_rtp_ready(rtp_session)) {
+ bytes = sizeof(rtp_msg_t);
+ status = switch_socket_recvfrom(rtp_session->from_addr, rtp_session->sock_input, 0, (void *) &rtp_session->recv_msg, &bytes);
+ if (bytes) {
+ rtp_session->stats.inbound.raw_bytes += bytes;
+ rtp_session->stats.inbound.flush_packet_count++;
+ rtp_session->stats.inbound.packet_count++;
+ }
+ } else {
+ break;
+ }
+ } while(bytes > 0);
+
+ if (was_blocking && switch_rtp_ready(rtp_session)) {
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
+ switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, FALSE);
+ }
+ }
+
+ READ_DEC(rtp_session);
+}
+
+#define return_cng_frame() do_cng = 1; goto timer_check
+
+static switch_status_t read_rtp_packet(switch_rtp_t *rtp_session, switch_size_t *bytes, switch_frame_flag_t *flags)
+{
+ switch_status_t status = SWITCH_STATUS_FALSE;
+ stfu_frame_t *jb_frame;
+
+ switch_assert(bytes);
+
+ *bytes = sizeof(rtp_msg_t);
+ status = switch_socket_recvfrom(rtp_session->from_addr, rtp_session->sock_input, 0, (void *) &rtp_session->recv_msg, bytes);
+
+ if (*bytes) {
+ rtp_session->stats.inbound.raw_bytes += *bytes;
+ if (rtp_session->te && rtp_session->recv_msg.header.pt == rtp_session->te) {
+ rtp_session->stats.inbound.dtmf_packet_count++;
+ } else if (rtp_session->cng_pt && (rtp_session->recv_msg.header.pt == rtp_session->cng_pt || rtp_session->recv_msg.header.pt == 13)) {
+ rtp_session->stats.inbound.cng_packet_count++;
+ } else {
+ rtp_session->stats.inbound.media_packet_count++;
+ rtp_session->stats.inbound.media_bytes += *bytes;
+ }
+
+ rtp_session->stats.inbound.packet_count++;
+ }
+
+ if (rtp_session->jb && rtp_session->recv_msg.header.version == 2 && *bytes) {
+ if (rtp_session->recv_msg.header.m && rtp_session->recv_msg.header.pt != rtp_session->te) {
+ stfu_n_reset(rtp_session->jb);
+ }
+
+ stfu_n_eat(rtp_session->jb, ntohl(rtp_session->recv_msg.header.ts), rtp_session->recv_msg.body, *bytes - rtp_header_len);
+ *bytes = 0;
+ status = SWITCH_STATUS_FALSE;
+ }
+
+ if (rtp_session->jb) {
+ if ((jb_frame = stfu_n_read_a_frame(rtp_session->jb))) {
+ memcpy(rtp_session->recv_msg.body, jb_frame->data, jb_frame->dlen);
+ if (jb_frame->plc) {
+ *flags |= SFF_PLC;
+ } else {
+ rtp_session->stats.inbound.jb_packet_count++;
+ }
+ *bytes = jb_frame->dlen + rtp_header_len;
+ rtp_session->recv_msg.header.ts = htonl(jb_frame->ts);
+ rtp_session->recv_msg.header.pt = rtp_session->payload;
+ status = SWITCH_STATUS_SUCCESS;
+ }
+ }
+
+ return status;
+}
+
+static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
+{
+ switch_size_t bytes = 0;
+ switch_status_t status = SWITCH_STATUS_SUCCESS, poll_status = SWITCH_STATUS_SUCCESS;
+ int check = 0;
+ int ret = -1;
+ int sleep_mss = 1000;
+ int poll_sec = 5;
+ int poll_loop = 0;
+ int fdr = 0;
+ int hot_socket = 0;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return -1;
+ }
+
+ if (rtp_session->timer.interval) {
+ sleep_mss = rtp_session->timer.interval * 1000;
+ }
+
+ READ_INC(rtp_session);
+
+ while (switch_rtp_ready(rtp_session)) {
+ int do_cng = 0;
+
+ if (rtp_session->timer.interval) {
+ if ((switch_test_flag(rtp_session, SWITCH_RTP_FLAG_AUTOFLUSH) || switch_test_flag(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH)) &&
+ rtp_session->read_pollfd) {
+ if (switch_poll(rtp_session->read_pollfd, 1, &fdr, 1) == SWITCH_STATUS_SUCCESS) {
+ rtp_session->hot_hits += rtp_session->samples_per_interval;
+
+ if (rtp_session->hot_hits >= rtp_session->samples_per_second * 5) {
+ switch_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
+ hot_socket = 1;
+ }
+ } else {
+ rtp_session->hot_hits = 0;
+ }
+ }
+
+ if (hot_socket) {
+ rtp_session->sync_packets++;
+ switch_core_timer_sync(&rtp_session->timer);
+ } else {
+ if (rtp_session->sync_packets) {
+#if 0
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
+ "Auto-Flush catching up %d packets (%d)ms.\n",
+ rtp_session->sync_packets, (rtp_session->ms_per_packet * rtp_session->sync_packets) / 1000);
+#endif
+ rtp_session->sync_packets = 0;
+ }
+ switch_core_timer_next(&rtp_session->timer);
+ }
+ }
+
+ recvfrom:
+
+ if (!switch_rtp_ready(rtp_session)) {
+ break;
+ }
+
+ if (!rtp_session->timer.interval && rtp_session->read_pollfd) {
+ int pt = poll_sec * 1000000;
+
+ if (rtp_session->dtmf_data.out_digit_dur > 0) {
+ pt = 20000;
+ }
+ poll_status = switch_poll(rtp_session->read_pollfd, 1, &fdr, pt);
+ if (rtp_session->dtmf_data.out_digit_dur > 0) {
+ do_2833(rtp_session);
+ }
+ }
+
+ if (poll_status == SWITCH_STATUS_SUCCESS) {
+ status = read_rtp_packet(rtp_session, &bytes, flags);
+ } else {
+ if (!SWITCH_STATUS_IS_BREAK(poll_status) && poll_status != SWITCH_STATUS_TIMEOUT) {
+ ret = -1;
+ goto end;
+ }
+
+ poll_loop = 1;
+ rtp_session->missed_count += (poll_sec * 1000 ) / (rtp_session->ms_per_packet ? rtp_session->ms_per_packet : 20 / 1000);
+ bytes = 0;
+ }
+
+ if (bytes < 0) {
+ ret = (int) bytes;
+ goto end;
+ }
+
+ if (rtp_session->max_missed_packets) {
+ if (bytes) {
+ rtp_session->missed_count = 0;
+ } else if (++rtp_session->missed_count >= rtp_session->max_missed_packets) {
+ ret = -2;
+ goto end;
+ }
+ }
+
+ check = !bytes;
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_BREAK) || (bytes && bytes == 4 && *((int *)&rtp_session->recv_msg) == UINT_MAX)) {
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_BREAK);
+ do_2833(rtp_session);
+ bytes = 0;
+ return_cng_frame();
+ }
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH)) {
+ do_flush(rtp_session);
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_FLUSH);
+ bytes = 0;
+ }
+
+ if (bytes && bytes < 5) {
+ continue;
+ }
+
+ if (!bytes && poll_loop) {
+ goto recvfrom;
+ }
+
+ if (bytes && rtp_session->recv_msg.header.m && rtp_session->recv_msg.header.pt != rtp_session->te) {
+ rtp_flush_read_buffer(rtp_session, SWITCH_RTP_FLUSH_ONCE);
+ }
+
+ if (bytes && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ) && switch_sockaddr_get_port(rtp_session->from_addr)) {
+ if (++rtp_session->autoadj_tally >= 10) {
+ const char *tx_host;
+ const char *old_host;
+ char bufa[30], bufb[30];
+
+ tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->from_addr);
+ old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
+ if ((switch_sockaddr_get_port(rtp_session->from_addr) != rtp_session->remote_port) || strcmp(tx_host, old_host)) {
+ const char *err;
+ uint32_t old = rtp_session->remote_port;
+
+ if (!zstr(tx_host) && switch_sockaddr_get_port(rtp_session->from_addr) > 0) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,
+ "Auto Changing port from %s:%u to %s:%u\n", old_host, old, tx_host,
+ switch_sockaddr_get_port(rtp_session->from_addr));
+ switch_rtp_set_remote_address(rtp_session, tx_host, switch_sockaddr_get_port(rtp_session->from_addr), SWITCH_FALSE, &err);
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
+ }
+ }
+ }
+ }
+
+ if (bytes && rtp_session->autoadj_window) {
+ if (--rtp_session->autoadj_window == 0) {
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
+ }
+ }
+
+ if (bytes && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA)) {
+ /* Fast PASS! */
+ *flags |= SFF_PROXY_PACKET;
+ ret = (int) bytes;
+ goto end;
+ }
+
+ if (bytes) {
+ rtp_session->missed_count = 0;
+
+ if (rtp_session->recv_msg.header.pt && (rtp_session->recv_msg.header.pt == rtp_session->cng_pt || rtp_session->recv_msg.header.pt == 13)) {
+ return_cng_frame();
+ }
+ }
+
+ if (!bytes && (io_flags & SWITCH_IO_FLAG_NOBLOCK)) {
+ return_cng_frame();
+ }
+
+
+ if (check && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_AUTO_CNG) &&
+ rtp_session->timer.samplecount >= (rtp_session->last_write_samplecount + (rtp_session->samples_per_interval * 50))) {
+ uint8_t data[10] = { 0 };
+ switch_frame_flag_t frame_flags = SFF_NONE;
+ data[0] = 65;
+ rtp_session->cn++;
+ rtp_common_write(rtp_session, NULL, (void *) data, 2, rtp_session->cng_pt, 0, &frame_flags);
+ }
+
+ if (check || bytes) {
+ do_2833(rtp_session);
+ }
+
+ if (bytes && rtp_session->recv_msg.header.version != 2) {
+ uint8_t *data = (uint8_t *) rtp_session->recv_msg.body;
+ if (rtp_session->recv_msg.header.version == 0) {
+#ifdef ENABLE_ZRTP
+ if (zrtp_on && ZRTP_PACKETS_MAGIC == zrtp_ntoh32(rtp_session->recv_msg.header.ts)) {
+ zrtp_handler(rtp_session, rtp_session->sock_input, (void *) &rtp_session->recv_msg, bytes, rtp_session->from_addr);
+ } else {
+#endif
+ if (rtp_session->ice_user) {
+ handle_ice(rtp_session, (void *) &rtp_session->recv_msg, bytes);
+ } else if (rtp_session->remote_stun_addr) {
+ handle_stun_ping_reply(rtp_session, (void *) &rtp_session->recv_msg, bytes);
+ }
+#ifdef ENABLE_ZRTP
+ }
+#endif
+ }
+
+ if (rtp_session->invalid_handler) {
+ rtp_session->invalid_handler(rtp_session, rtp_session->sock_input, (void *) &rtp_session->recv_msg, bytes, rtp_session->from_addr);
+ }
+
+ memset(data, 0, 2);
+ data[0] = 65;
+
+ rtp_session->recv_msg.header.pt = (uint32_t) rtp_session->cng_pt ? rtp_session->cng_pt : SWITCH_RTP_CNG_PAYLOAD;
+ *flags |= SFF_CNG;
+ *payload_type = (switch_payload_t) rtp_session->recv_msg.header.pt;
+ ret = 2 + rtp_header_len;
+ goto end;
+ }
+
+ if (bytes && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_RECV)) {
+ int sbytes = (int) bytes;
+ err_status_t stat = 0;
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_RECV_RESET)) {
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_SECURE_RECV_RESET);
+ srtp_dealloc(rtp_session->recv_ctx);
+ rtp_session->recv_ctx = NULL;
+ if ((stat = srtp_create(&rtp_session->recv_ctx, &rtp_session->recv_policy))) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error! RE-Activating Secure RTP RECV\n");
+ ret = -1;
+ goto end;
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "RE-Activating Secure RTP RECV\n");
+ rtp_session->srtp_errs = 0;
+ }
+ }
+
+ stat = srtp_unprotect(rtp_session->recv_ctx, &rtp_session->recv_msg.header, &sbytes);
+
+ if (stat && rtp_session->recv_msg.header.pt != rtp_session->te && rtp_session->recv_msg.header.pt != rtp_session->cng_pt) {
+ if (++rtp_session->srtp_errs >= MAX_SRTP_ERRS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+ "Error: SRTP unprotect failed with code %d%s\n", stat,
+ stat == err_status_replay_fail ? " (replay check failed)" : stat ==
+ err_status_auth_fail ? " (auth check failed)" : "");
+ ret = -1;
+ goto end;
+ } else {
+ sbytes = 0;
+ }
+ } else {
+ rtp_session->srtp_errs = 0;
+ }
+
+ bytes = sbytes;
+ }
+
+#ifdef ENABLE_ZRTP
+ /* ZRTP Recv */
+ if (bytes && switch_test_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_RECV)) {
+ unsigned int sbytes = (int) bytes;
+ zrtp_status_t stat = 0;
+
+ stat = zrtp_process_srtp(rtp_session->zrtp_ctx, (void *)&rtp_session->recv_msg, &sbytes);
+
+ switch (stat) {
+ case zrtp_status_ok:
+ break;
+ case zrtp_status_drop:
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
+ break;
+ case zrtp_status_fail:
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
+ ret = -1;
+ goto end;
+ default:
+ break;
+ }
+ bytes = sbytes;
+ }
+#endif
+
+#ifdef DEBUG_2833
+ if (rtp_session->dtmf_data.in_digit_sanity && !(rtp_session->dtmf_data.in_digit_sanity % 100)) {
+ printf("sanity %d\n", rtp_session->dtmf_data.in_digit_sanity);
+ }
+#endif
+
+ if (rtp_session->dtmf_data.in_digit_sanity && !--rtp_session->dtmf_data.in_digit_sanity) {
+ rtp_session->dtmf_data.last_digit = 0;
+ rtp_session->dtmf_data.in_digit_ts = 0;
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed DTMF sanity check.\n");
+ }
+
+ /* RFC2833 ... like all RFC RE: VoIP, guaranteed to drive you to insanity!
+ We know the real rules here, but if we enforce them, it's an interop nightmare so,
+ we put up with as much as we can so we don't have to deal with being punished for
+ doing it right. Nice guys finish last!
+ */
+ if (bytes && !switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA) &&
+ !switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PASS_RFC2833) && rtp_session->recv_msg.header.pt == rtp_session->te) {
+ switch_size_t len = bytes - rtp_header_len;
+ unsigned char *packet = (unsigned char *) rtp_session->recv_msg.body;
+ int end;
+ uint16_t duration;
+ char key;
+ uint16_t in_digit_seq;
+ uint32_t ts;
+
+
+ if (!(packet[0] || packet[1] || packet[2] || packet[3]) && len >= 8) {
+ packet += 4;
+ len -= 4;
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "DTMF payload offset by 4 bytes.\n");
+ }
+
+ if (!(packet[0] || packet[1] || packet[2] || packet[3])) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed DTMF payload check.\n");
+ rtp_session->dtmf_data.last_digit = 0;
+ rtp_session->dtmf_data.in_digit_ts = 0;
+ }
+
+ end = packet[1] & 0x80 ? 1 : 0;
+ duration = (packet[2] << 8) + packet[3];
+ key = switch_rfc2833_to_char(packet[0]);
+ in_digit_seq = ntohs((uint16_t) rtp_session->recv_msg.header.seq);
+ ts = htonl(rtp_session->recv_msg.header.ts);
+
+ if (in_digit_seq < rtp_session->dtmf_data.in_digit_seq) {
+ if (rtp_session->dtmf_data.in_digit_seq - in_digit_seq > 100) {
+ rtp_session->dtmf_data.in_digit_seq = 0;
+ }
+ }
+#ifdef DEBUG_2833
+ printf("packet[%d]: %02x %02x %02x %02x\n", (int) len, (unsigned) packet[0],(unsigned)
+ packet[1], (unsigned) packet[2], (unsigned) packet[3]);
+#endif
+
+ if (in_digit_seq > rtp_session->dtmf_data.in_digit_seq) {
+
+ rtp_session->dtmf_data.in_digit_seq = in_digit_seq;
+#ifdef DEBUG_2833
+
+ printf("read: %c %u %u %u %u %d %d %s\n",
+ key, in_digit_seq, rtp_session->dtmf_data.in_digit_seq,
+ ts, duration, rtp_session->recv_msg.header.m, end, end && !rtp_session->dtmf_data.in_digit_ts ? "ignored" : "");
+#endif
+ /* only set sanity if we do NOT ignore the packet */
+ if (rtp_session->dtmf_data.in_digit_ts) {
+ rtp_session->dtmf_data.in_digit_sanity = 2000;
+ }
+
+ if (rtp_session->dtmf_data.last_duration > duration && ts == rtp_session->dtmf_data.in_digit_ts) {
+ rtp_session->dtmf_data.flip++;
+ }
+
+ if (end) {
+ if (rtp_session->dtmf_data.in_digit_ts) {
+ switch_dtmf_t dtmf = { key, duration };
+
+ if (ts > rtp_session->dtmf_data.in_digit_ts) {
+ dtmf.duration += (ts - rtp_session->dtmf_data.in_digit_ts);
+ }
+ if (rtp_session->dtmf_data.flip) {
+ dtmf.duration += rtp_session->dtmf_data.flip * 0xFFFF;
+ rtp_session->dtmf_data.flip = 0;
+#ifdef DEBUG_2833
+ printf("you're welcome!\n");
+#endif
+ }
+
+#ifdef DEBUG_2833
+ printf("done digit=%c ts=%u start_ts=%u dur=%u ddur=%u\n",
+ dtmf.digit, ts, rtp_session->dtmf_data.in_digit_ts, duration, dtmf.duration);
+#endif
+ switch_rtp_queue_rfc2833_in(rtp_session, &dtmf);
+ rtp_session->dtmf_data.last_digit = rtp_session->dtmf_data.first_digit;
+
+ rtp_session->dtmf_data.in_digit_ts = 0;
+ rtp_session->dtmf_data.in_digit_sanity = 0;
+ do_cng = 1;
+ } else {
+ if (!switch_rtp_ready(rtp_session)) {
+ goto end;
+ }
+ switch_cond_next();
+ goto recvfrom;
+ }
+
+ } else if (!rtp_session->dtmf_data.in_digit_ts) {
+ rtp_session->dtmf_data.in_digit_ts = ts;
+ rtp_session->dtmf_data.first_digit = key;
+ rtp_session->dtmf_data.in_digit_sanity = 2000;
+ }
+
+ rtp_session->dtmf_data.last_duration = duration;
+ } else {
+#ifdef DEBUG_2833
+ printf("drop: %c %u %u %u %u %d %d\n",
+ key, in_digit_seq, rtp_session->dtmf_data.in_digit_seq, ts, duration, rtp_session->recv_msg.header.m, end);
+#endif
+ switch_cond_next();
+ goto recvfrom;
+ }
+ }
+
+ if (rtp_session->dtmf_data.in_digit_ts) {
+ if (!switch_rtp_ready(rtp_session)) {
+ goto end;
+ }
+ switch_cond_next();
+ goto recvfrom;
+ }
+
+ timer_check:
+
+ if (do_cng) {
+ uint8_t *data = (uint8_t *) rtp_session->recv_msg.body;
+ int fdr;
+
+ if ((poll_status = switch_poll(rtp_session->read_pollfd, 1, &fdr, 1)) == SWITCH_STATUS_SUCCESS) {
+ goto recvfrom;
+ }
+
+ memset(data, 0, 2);
+ data[0] = 65;
+ rtp_session->recv_msg.header.pt = (uint32_t) rtp_session->cng_pt ? rtp_session->cng_pt : SWITCH_RTP_CNG_PAYLOAD;
+ *flags |= SFF_CNG;
+ *payload_type = (switch_payload_t) rtp_session->recv_msg.header.pt;
+ ret = 2 + rtp_header_len;
+ rtp_session->stats.inbound.skip_packet_count++;
+ goto end;
+ }
+
+ if (check || (bytes && !rtp_session->timer.interval)) {
+ if (!bytes && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER)) { /* We're late! We're Late! */
+ if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK) && status == SWITCH_STATUS_BREAK) {
+ switch_cond_next();
+ continue;
+ }
+
+ return_cng_frame();
+ }
+ }
+
+ if (status == SWITCH_STATUS_BREAK || bytes == 0) {
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_DATAWAIT)) {
+ goto do_continue;
+ }
+ ret = 0;
+ goto end;
+ }
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_GOOGLEHACK) && rtp_session->recv_msg.header.pt == 102) {
+ rtp_session->recv_msg.header.pt = 97;
+ }
+
+ rtp_session->rpayload = (switch_payload_t) rtp_session->recv_msg.header.pt;
+
+ break;
+
+ do_continue:
+
+ if (!bytes && !rtp_session->timer.interval) {
+ switch_yield(sleep_mss);
+ }
+
+ }
+
+ if (switch_rtp_ready(rtp_session)) {
+ *payload_type = (switch_payload_t) rtp_session->recv_msg.header.pt;
+
+ if (*payload_type == SWITCH_RTP_CNG_PAYLOAD) {
+ *flags |= SFF_CNG;
+ }
+
+ ret = (int) bytes;
+ } else {
+ ret = -1;
+ }
+
+ end:
+
+ READ_DEC(rtp_session);
+
+ return ret;
+}
+
+SWITCH_DECLARE(switch_size_t) switch_rtp_has_dtmf(switch_rtp_t *rtp_session)
+{
+ switch_size_t has = 0;
+
+ if (switch_rtp_ready(rtp_session)) {
+ switch_mutex_lock(rtp_session->dtmf_data.dtmf_mutex);
+ has = switch_queue_size(rtp_session->dtmf_data.dtmf_inqueue);
+ switch_mutex_unlock(rtp_session->dtmf_data.dtmf_mutex);
+ }
+
+ return has;
+}
+
+SWITCH_DECLARE(switch_size_t) switch_rtp_dequeue_dtmf(switch_rtp_t *rtp_session, switch_dtmf_t *dtmf)
+{
+ switch_size_t bytes = 0;
+ switch_dtmf_t *_dtmf = NULL;
+ void *pop;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return bytes;
+ }
+
+ switch_mutex_lock(rtp_session->dtmf_data.dtmf_mutex);
+ if (switch_queue_trypop(rtp_session->dtmf_data.dtmf_inqueue, &pop) == SWITCH_STATUS_SUCCESS) {
+ _dtmf = (switch_dtmf_t *) pop;
+ *dtmf = *_dtmf;
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "RTP RECV DTMF %c:%d\n", dtmf->digit, dtmf->duration);
+ bytes++;
+ free(pop);
+ }
+ switch_mutex_unlock(rtp_session->dtmf_data.dtmf_mutex);
+
+ return bytes;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_queue_rfc2833(switch_rtp_t *rtp_session, const switch_dtmf_t *dtmf)
+{
+
+ switch_dtmf_t *rdigit;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ if ((rdigit = malloc(sizeof(*rdigit))) != 0) {
+ *rdigit = *dtmf;
+ if (rdigit->duration < switch_core_min_dtmf_duration(0)) {
+ rdigit->duration = switch_core_min_dtmf_duration(0);
+ }
+
+ if ((switch_queue_trypush(rtp_session->dtmf_data.dtmf_queue, rdigit)) != SWITCH_STATUS_SUCCESS) {
+ free(rdigit);
+ return SWITCH_STATUS_FALSE;
+ }
+ } else {
+ abort();
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_queue_rfc2833_in(switch_rtp_t *rtp_session, const switch_dtmf_t *dtmf)
+{
+ switch_dtmf_t *rdigit;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ if ((rdigit = malloc(sizeof(*rdigit))) != 0) {
+ *rdigit = *dtmf;
+ if (rdigit->duration < switch_core_min_dtmf_duration(0)) {
+ rdigit->duration = switch_core_min_dtmf_duration(0);
+ }
+
+ if ((switch_queue_trypush(rtp_session->dtmf_data.dtmf_inqueue, rdigit)) != SWITCH_STATUS_SUCCESS) {
+ free(rdigit);
+ return SWITCH_STATUS_FALSE;
+ }
+ } else {
+ abort();
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_read(switch_rtp_t *rtp_session, void *data, uint32_t *datalen,
+ switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
+{
+ int bytes = 0;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ bytes = rtp_common_read(rtp_session, payload_type, flags, io_flags);
+
+ if (bytes < 0) {
+ *datalen = 0;
+ return bytes == -2 ? SWITCH_STATUS_TIMEOUT : SWITCH_STATUS_GENERR;
+ } else if (bytes == 0) {
+ *datalen = 0;
+ return SWITCH_STATUS_BREAK;
+ } else {
+ bytes -= rtp_header_len;
+ }
+
+ *datalen = bytes;
+
+ memcpy(data, rtp_session->recv_msg.body, bytes);
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_zerocopy_read_frame(switch_rtp_t *rtp_session, switch_frame_t *frame, switch_io_flag_t io_flags)
+{
+ int bytes = 0;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ bytes = rtp_common_read(rtp_session, &frame->payload, &frame->flags, io_flags);
+
+ frame->data = rtp_session->recv_msg.body;
+ frame->packet = &rtp_session->recv_msg;
+ frame->packetlen = bytes;
+ frame->source = __FILE__;
+ switch_set_flag(frame, SFF_RAW_RTP);
+ if (frame->payload == rtp_session->te) {
+ switch_set_flag(frame, SFF_RFC2833);
+ }
+ frame->timestamp = ntohl(rtp_session->recv_msg.header.ts);
+ frame->seq = (uint16_t) ntohs((uint16_t) rtp_session->recv_msg.header.seq);
+ frame->ssrc = ntohl(rtp_session->recv_msg.header.ssrc);
+ frame->m = rtp_session->recv_msg.header.m ? SWITCH_TRUE : SWITCH_FALSE;
+
+#ifdef ENABLE_ZRTP
+ if (zrtp_on && switch_test_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV)) {
+ zrtp_session_info_t zrtp_session_info;
+
+ if (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info)) {
+ if (zrtp_session_info.sas_is_ready) {
+ frame->extra_data = rtp_session->zrtp_ctx;
+ switch_set_flag(frame, SFF_ZRTP);
+ if (rtp_session->zrtp_mitm_tries > ZRTP_MITM_TRIES) {
+ zrtp_verified_set(zrtp_global, &rtp_session->zrtp_session->zid,
+ &rtp_session->zrtp_session->peer_zid, zrtp_session_info.sas_is_verified^1);
+ switch_clear_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
+ }
+ rtp_session->zrtp_mitm_tries++;
+ }
+ }
+ }
+#endif
+
+ if (bytes < 0) {
+ frame->datalen = 0;
+ return bytes == -2 ? SWITCH_STATUS_TIMEOUT : SWITCH_STATUS_GENERR;
+ } else if (bytes == 0) {
+ frame->datalen = 0;
+ return SWITCH_STATUS_BREAK;
+ } else {
+ bytes -= rtp_header_len;
+ }
+
+ frame->datalen = bytes;
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_zerocopy_read(switch_rtp_t *rtp_session,
+ void **data, uint32_t *datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags,
+ switch_io_flag_t io_flags)
+{
+ int bytes = 0;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ bytes = rtp_common_read(rtp_session, payload_type, flags, io_flags);
+ *data = rtp_session->recv_msg.body;
+
+ if (bytes < 0) {
+ *datalen = 0;
+ return SWITCH_STATUS_GENERR;
+ } else {
+ bytes -= rtp_header_len;
+ }
+
+ *datalen = bytes;
+ return SWITCH_STATUS_SUCCESS;
+}
+
+static int rtp_common_write(switch_rtp_t *rtp_session,
+ rtp_msg_t *send_msg, void *data, uint32_t datalen, switch_payload_t payload, uint32_t timestamp, switch_frame_flag_t *flags)
+{
+ switch_size_t bytes;
+ uint8_t send = 1;
+ uint32_t this_ts = 0;
+ int ret;
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ WRITE_INC(rtp_session);
+
+ if (send_msg) {
+ bytes = datalen;
+ if (flags && *flags & SFF_RFC2833) {
+ send_msg->header.pt = rtp_session->te;
+ }
+ data = send_msg->body;
+ datalen -= rtp_header_len;
+ } else {
+ uint8_t m = 0;
+
+ if (*flags & SFF_RFC2833) {
+ payload = rtp_session->te;
+ }
+
+ send_msg = &rtp_session->send_msg;
+ send_msg->header.pt = payload;
+
+ if (timestamp) {
+ rtp_session->ts = (uint32_t) timestamp;
+ } else if (rtp_session->timer.timer_interface) {
+ rtp_session->ts = rtp_session->timer.samplecount;
+
+ if (rtp_session->ts <= rtp_session->last_write_ts) {
+ rtp_session->ts = rtp_session->last_write_ts + rtp_session->samples_per_interval;
+ }
+ } else {
+ rtp_session->ts += rtp_session->samples_per_interval;
+ }
+
+ rtp_session->send_msg.header.ts = htonl(rtp_session->ts);
+
+
+ if ((rtp_session->ts > (rtp_session->last_write_ts + (rtp_session->samples_per_interval * 10)))
+ || rtp_session->ts == rtp_session->samples_per_interval) {
+ m++;
+ }
+
+ if (rtp_session->timer.interval &&
+ (rtp_session->timer.samplecount - rtp_session->last_write_samplecount) > rtp_session->samples_per_interval * 10) {
+ m++;
+ }
+
+ if (!rtp_session->timer.interval &&
+ ((unsigned)((switch_micro_time_now() - rtp_session->last_write_timestamp))) > (rtp_session->ms_per_packet * 10)) {
+ m++;
+ }
+
+ if (rtp_session->cn && payload != rtp_session->cng_pt) {
+ rtp_session->cn = 0;
+ m++;
+ }
+
+ send_msg->header.m = m ? 1 : 0;
+
+ memcpy(send_msg->body, data, datalen);
+ bytes = datalen + rtp_header_len;
+ }
+
+ send_msg->header.ssrc = htonl(rtp_session->ssrc);
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_GOOGLEHACK) && rtp_session->send_msg.header.pt == 97) {
+ rtp_session->recv_msg.header.pt = 102;
+ }
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD) &&
+ rtp_session->recv_msg.header.pt == rtp_session->vad_data.read_codec->implementation->ianacode) {
+
+ int16_t decoded[SWITCH_RECOMMENDED_BUFFER_SIZE / sizeof(int16_t)] = { 0 };
+ uint32_t rate = 0;
+ uint32_t codec_flags = 0;
+ uint32_t len = sizeof(decoded);
+ time_t now = switch_epoch_time_now(NULL);
+ send = 0;
+
+ if (rtp_session->vad_data.scan_freq && rtp_session->vad_data.next_scan <= now) {
+ rtp_session->vad_data.bg_count = rtp_session->vad_data.bg_level = 0;
+ rtp_session->vad_data.next_scan = now + rtp_session->vad_data.scan_freq;
+ }
+
+ if (switch_core_codec_decode(&rtp_session->vad_data.vad_codec,
+ rtp_session->vad_data.read_codec,
+ data,
+ datalen,
+ rtp_session->vad_data.read_codec->implementation->actual_samples_per_second,
+ decoded, &len, &rate, &codec_flags) == SWITCH_STATUS_SUCCESS) {
+
+ uint32_t energy = 0;
+ uint32_t x, y = 0, z = len / sizeof(int16_t);
+ uint32_t score = 0;
+ int divisor = 0;
+ if (z) {
+
+ if (!(divisor = rtp_session->vad_data.read_codec->implementation->actual_samples_per_second / 8000)) {
+ divisor = 1;
+ }
+
+ for (x = 0; x < z; x++) {
+ energy += abs(decoded[y]);
+ y += rtp_session->vad_data.read_codec->implementation->number_of_channels;
+ }
+
+ if (++rtp_session->vad_data.start_count < rtp_session->vad_data.start) {
+ send = 1;
+ } else {
+ score = (energy / (z / divisor));
+ if (score && (rtp_session->vad_data.bg_count < rtp_session->vad_data.bg_len)) {
+ rtp_session->vad_data.bg_level += score;
+ if (++rtp_session->vad_data.bg_count == rtp_session->vad_data.bg_len) {
+ rtp_session->vad_data.bg_level /= rtp_session->vad_data.bg_len;
+ }
+ send = 1;
+ } else {
+ if (score > rtp_session->vad_data.bg_level && !switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
+ uint32_t diff = score - rtp_session->vad_data.bg_level;
+
+ if (rtp_session->vad_data.hangover_hits) {
+ rtp_session->vad_data.hangover_hits--;
+ }
+
+ if (diff >= rtp_session->vad_data.diff_level || ++rtp_session->vad_data.hangunder_hits >= rtp_session->vad_data.hangunder) {
+
+ switch_set_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING);
+ send_msg->header.m = 1;
+ rtp_session->vad_data.hangover_hits = rtp_session->vad_data.hangunder_hits = rtp_session->vad_data.cng_count = 0;
+ if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_TALK)) {
+ switch_event_t *event;
+ if (switch_event_create(&event, SWITCH_EVENT_TALK) == SWITCH_STATUS_SUCCESS) {
+ switch_channel_event_set_data(switch_core_session_get_channel(rtp_session->vad_data.session), event);
+ switch_event_fire(&event);
+ }
+ }
+ }
+ } else {
+ if (rtp_session->vad_data.hangunder_hits) {
+ rtp_session->vad_data.hangunder_hits--;
+ }
+ if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
+ if (++rtp_session->vad_data.hangover_hits >= rtp_session->vad_data.hangover) {
+ switch_clear_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING);
+ rtp_session->vad_data.hangover_hits = rtp_session->vad_data.hangunder_hits = rtp_session->vad_data.cng_count = 0;
+ if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_NOTALK)) {
+ switch_event_t *event;
+ if (switch_event_create(&event, SWITCH_EVENT_NOTALK) == SWITCH_STATUS_SUCCESS) {
+ switch_channel_event_set_data(switch_core_session_get_channel(rtp_session->vad_data.session), event);
+ switch_event_fire(&event);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
+ send = 1;
+ }
+ }
+ } else {
+ ret = -1;
+ goto end;
+ }
+ }
+
+ this_ts = ntohl(send_msg->header.ts);
+
+ if (!switch_rtp_ready(rtp_session) || rtp_session->sending_dtmf || !this_ts) {
+ send = 0;
+ }
+
+ if (send) {
+ send_msg->header.seq = htons(++rtp_session->seq);
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND)) {
+ int sbytes = (int) bytes;
+ err_status_t stat;
+
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET)) {
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET);
+ srtp_dealloc(rtp_session->send_ctx);
+ rtp_session->send_ctx = NULL;
+ if ((stat = srtp_create(&rtp_session->send_ctx, &rtp_session->send_policy))) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error! RE-Activating Secure RTP SEND\n");
+ ret = -1;
+ goto end;
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "RE-Activating Secure RTP SEND\n");
+ }
+ }
+
+
+ stat = srtp_protect(rtp_session->send_ctx, &send_msg->header, &sbytes);
+ if (stat) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: SRTP protection failed with code %d\n", stat);
+ }
+
+ bytes = sbytes;
+ }
+#ifdef ENABLE_ZRTP
+ /* ZRTP Send */
+ if (switch_test_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_SEND)) {
+ unsigned int sbytes = (int) bytes;
+ zrtp_status_t stat = zrtp_status_fail;
+
+ stat = zrtp_process_rtp(rtp_session->zrtp_ctx, (void*)send_msg, &sbytes);
+
+ switch (stat) {
+ case zrtp_status_ok:
+ break;
+ case zrtp_status_drop:
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
+ break;
+ case zrtp_status_fail:
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
+ break;
+ default:
+ break;
+ }
+
+ bytes = sbytes;
+ }
+#endif
+
+#ifdef RTP_DEBUG_WRITE_DELTA
+ {
+ switch_time_t now = switch_time_now();
+ int delta = (int) (now - rtp_session->send_time) / 1000;
+ printf("WRITE %d delta %d\n", (int)bytes, delta);
+ rtp_session->send_time = now;
+ }
+#endif
+
+
+ if (switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, (void *) send_msg, &bytes) != SWITCH_STATUS_SUCCESS) {
+ rtp_session->seq--;
+ ret = -1;
+ goto end;
+ }
+
+ rtp_session->stats.outbound.raw_bytes += bytes;
+ rtp_session->stats.outbound.packet_count++;
+
+ if (send_msg->header.pt == rtp_session->cng_pt) {
+ rtp_session->stats.outbound.cng_packet_count++;
+ } else {
+ rtp_session->stats.outbound.media_packet_count++;
+ rtp_session->stats.outbound.media_bytes += bytes;
+ }
+
+ if (rtp_session->timer.interval) {
+ rtp_session->last_write_samplecount = rtp_session->timer.samplecount;
+ } else {
+ rtp_session->last_write_timestamp = (uint32_t) switch_micro_time_now();
+ }
+
+ rtp_session->last_write_ts = this_ts;
+ }
+
+ if (rtp_session->remote_stun_addr) {
+ do_stun_ping(rtp_session);
+ }
+
+ if (rtp_session->ice_user) {
+ if (ice_out(rtp_session) != SWITCH_STATUS_SUCCESS) {
+ ret = -1;
+ goto end;
+ }
+ }
+
+ ret = (int) bytes;
+
+ end:
+
+ WRITE_DEC(rtp_session);
+
+ return ret;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_disable_vad(switch_rtp_t *rtp_session)
+{
+
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD)) {
+ return SWITCH_STATUS_GENERR;
+ }
+ switch_core_codec_destroy(&rtp_session->vad_data.vad_codec);
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_VAD);
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_rtp_enable_vad(switch_rtp_t *rtp_session, switch_core_session_t *session, switch_codec_t *codec,
+ switch_vad_flag_t flags)
+{
+ if (!switch_rtp_ready(rtp_session)) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD)) {
+ return SWITCH_STATUS_GENERR;
+ }
+ memset(&rtp_session->vad_data, 0, sizeof(rtp_session->vad_data));
+
+ if (switch_core_codec_init(&rtp_session->vad_data.vad_codec,
+ codec->implementation->iananame,
+ NULL,
+ codec->implementation->samples_per_second,
+ codec->implementation->microseconds_per_packet / 1000,
+ codec->implementation->number_of_channels,
+ SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n");
+ return SWITCH_STATUS_FALSE;
+ }
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Activate VAD codec %s %dms\n", codec->implementation->iananame,
+ codec->implementation->microseconds_per_packet / 1000);
+ rtp_session->vad_data.diff_level = 400;
+ rtp_session->vad_data.hangunder = 15;
+ rtp_session->vad_data.hangover = 40;
+ rtp_session->vad_data.bg_len = 5;
+ rtp_session->vad_data.bg_count = 5;
+ rtp_session->vad_data.bg_level = 300;
+ rtp_session->vad_data.read_codec = codec;
+ rtp_session->vad_data.session = session;
+ rtp_session->vad_data.flags = flags;
+ rtp_session->vad_data.cng_freq = 50;
+ rtp_session->vad_data.ts = 1;
+ rtp_session->vad_data.start = 0;
+ rtp_session->vad_data.next_scan = switch_epoch_time_now(NULL);
+ rtp_session->vad_data.scan_freq = 0;
+ switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_VAD);
+ switch_set_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_CNG);
+ return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(int) switch_rtp_write_frame(switch_rtp_t *rtp_session, switch_frame_t *frame)
+{
+ uint8_t fwd = 0;
+ void *data = NULL;
+ uint32_t len, ts = 0;
+ switch_payload_t payload;
+ rtp_msg_t *send_msg = NULL;
+
+ if (!switch_rtp_ready(rtp_session) || !rtp_session->remote_addr) {
+ return -1;
+ }
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA)) {
+ switch_size_t bytes;
+
+ /* Fast PASS! */
+ if (!switch_test_flag(frame, SFF_PROXY_PACKET)) {
+ return 0;
+ }
+ bytes = frame->packetlen;
+ if (switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, frame->packet, &bytes) != SWITCH_STATUS_SUCCESS) {
+ return -1;
+ }
+
+ rtp_session->stats.outbound.raw_bytes += bytes;
+ rtp_session->stats.outbound.media_bytes += bytes;
+ rtp_session->stats.outbound.media_packet_count++;
+ rtp_session->stats.outbound.packet_count++;
+
+ return (int) bytes;
+ }
+
+#ifdef ENABLE_ZRTP
+ if (zrtp_on && switch_test_flag(frame, SFF_ZRTP) && switch_test_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND)) {
+ zrtp_session_info_t zrtp_session_info;
+
+ if (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info)) {
+ if (zrtp_session_info.sas_is_ready) {
+ if (rtp_session->zrtp_mitm_tries > ZRTP_MITM_TRIES) {
+ switch_clear_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
+ } else if(zrtp_status_ok == zrtp_resolve_mitm_call(frame->extra_data, rtp_session->zrtp_ctx)) {
+ switch_clear_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
+ zrtp_verified_set(zrtp_global, &rtp_session->zrtp_session->zid,
+ &rtp_session->zrtp_session->peer_zid, zrtp_session_info.sas_is_verified^1);
+ rtp_session->zrtp_mitm_tries++;
+ }
+ }
+ }
+ }
+#endif
+
+ fwd = (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_RAW_WRITE) && switch_test_flag(frame, SFF_RAW_RTP)) ? 1 : 0;
+
+ switch_assert(frame != NULL);
+
+ if (switch_test_flag(frame, SFF_CNG)) {
+ payload = rtp_session->cng_pt;
+ } else {
+ payload = rtp_session->payload;
+ }
+
+ if (switch_test_flag(frame, SFF_RTP_HEADER)) {
+ switch_size_t wrote = switch_rtp_write_manual(rtp_session, frame->data, frame->datalen,
+ frame->m, frame->payload, (uint32_t) (frame->timestamp), &frame->flags);
+
+ rtp_session->stats.outbound.raw_bytes += wrote;
+ rtp_session->stats.outbound.media_bytes += wrote;
+ rtp_session->stats.outbound.media_packet_count++;
+ rtp_session->stats.outbound.packet_count++;
+ }
+
+ if (fwd) {
+ send_msg = frame->packet;
+ len = frame->packetlen;
+ ts = 0;
+ if (frame->codec && frame->codec->agreed_pt == frame->payload) {
+ send_msg->header.pt = payload;
+ }
+ } else {
+ data = frame->data;
+ len = frame->datalen;
+ ts = switch_test_flag(rtp_session, SWITCH_RTP_FLAG_RAW_WRITE) ? (uint32_t) frame->timestamp : 0;
+ }
+
+ return rtp_common_write(rtp_session, send_msg, data, len, payload, ts, &frame->flags);
+}
+
+SWITCH_DECLARE(switch_rtp_stats_t *) switch_rtp_get_stats(switch_rtp_t *rtp_session, switch_memory_pool_t *pool)
+{
+ switch_rtp_stats_t *s;
+
+ if (pool) {
+ s = switch_core_alloc(pool, sizeof(*s));
+ *s = rtp_session->stats;
+ } else {
+ s = &rtp_session->stats;
+ }
+
+ return s;
+}
+
+SWITCH_DECLARE(int) switch_rtp_write_manual(switch_rtp_t *rtp_session,
+ void *data, uint32_t datalen, uint8_t m, switch_payload_t payload, uint32_t ts, switch_frame_flag_t *flags)
+{
+ switch_size_t bytes;
+ int ret = -1;
+
+ if (!switch_rtp_ready(rtp_session) || !rtp_session->remote_addr || datalen > SWITCH_RTP_MAX_BUF_LEN) {
+ return -1;
+ }
+
+ WRITE_INC(rtp_session);
+
+ rtp_session->write_msg = rtp_session->send_msg;
+ rtp_session->write_msg.header.seq = htons(++rtp_session->seq);
+ rtp_session->write_msg.header.ts = htonl(ts);
+ rtp_session->write_msg.header.pt = payload;
+ rtp_session->write_msg.header.m = m ? 1 : 0;
+ memcpy(rtp_session->write_msg.body, data, datalen);
+
+ bytes = rtp_header_len + datalen;
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND)) {
+ int sbytes = (int) bytes;
+ err_status_t stat;
+
+ if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET)) {
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET);
+ srtp_dealloc(rtp_session->send_ctx);
+ rtp_session->send_ctx = NULL;
+ if ((stat = srtp_create(&rtp_session->send_ctx, &rtp_session->send_policy))) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error! RE-Activating Secure RTP SEND\n");
+ ret = -1;
+ goto end;
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "RE-Activating Secure RTP SEND\n");
+ }
+ }
+
+ stat = srtp_protect(rtp_session->send_ctx, &rtp_session->write_msg.header, &sbytes);
+ if (stat) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: SRTP protection failed with code %d\n", stat);
+ }
+ bytes = sbytes;
+ }
+#ifdef ENABLE_ZRTP
+ /* ZRTP Send */
+ if (switch_test_flag(rtp_session, SWITCH_ZRTP_FLAG_SECURE_SEND)) {
+ unsigned int sbytes = (int) bytes;
+ zrtp_status_t stat = zrtp_status_fail;
+
+ stat = zrtp_process_rtp(rtp_session->zrtp_ctx, (void*)&rtp_session->write_msg, &sbytes);
+
+ switch (stat) {
+ case zrtp_status_ok:
+ break;
+ case zrtp_status_drop:
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
+ break;
+ case zrtp_status_fail:
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
+ break;
+ default:
+ break;
+ }
+
+ bytes = sbytes;
+ }
+#endif
+ if (switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, (void *) &rtp_session->write_msg, &bytes) != SWITCH_STATUS_SUCCESS) {
+ rtp_session->seq--;
+ ret = -1;
+ goto end;
+ }
+
+ rtp_session->last_write_ts = ts;
+
+ ret = (int) bytes;
+
+ end:
+
+ WRITE_DEC(rtp_session);
+
+ return ret;
+}
+
+SWITCH_DECLARE(uint32_t) switch_rtp_get_ssrc(switch_rtp_t *rtp_session)
+{
+ return rtp_session->send_msg.header.ssrc;
+}
+
+SWITCH_DECLARE(void) switch_rtp_set_private(switch_rtp_t *rtp_session, void *private_data)
+{
+ rtp_session->private_data = private_data;
+}
+
+SWITCH_DECLARE(void *) switch_rtp_get_private(switch_rtp_t *rtp_session)
+{
+ return rtp_session->private_data;
+}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
projects / thirdparty / freeswitch.git / commitdiff
