kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
freeswitch/test/pc/zrtp_test_core.c

867 lines
27 KiB
C
Raw Blame History

/*
* libZRTP SDK library, implements the ZRTP secure VoIP protocol.
* Copyright (c) 2006-2009 Philip R. Zimmermann. All rights reserved.
* Contact: http://philzimmermann.com
* For licensing and other legal details, see the file zrtp_legal.c.
*
* Viktor Krykun <v.krikun at zfoneproject.com>
*/
#include "zrtp.h"
#include "zrtp_test_core.h"
#include "zrtp_test_queue.h"
#if (ZRTP_PLATFORM == ZP_WIN32) || (ZRTP_PLATFORM == ZP_WINCE)
#include <windows.h>
#elif (ZRTP_PLATFORM == ZP_DARWIN) || (ZRTP_PLATFORM == ZP_LINUX)
#include <pthread.h>
#include <string.h>
#endif
#define _ZTU_ "TEST"
#define ZRTP_TEST_PACKET_MAX_SIZE 256
#define ZRTP_TEST_STREAMS_COUNT 1
#define ZRTP_ENABLE_TEST 0
extern uint8_t hash_word_list_odd[256][12];
extern uint8_t hash_word_list_even[256][10];
/*! Global data storage */
typedef struct zrtp_test_global
{
mlist_t channels_head; /*! List of test channels*/
zrtp_mutex_t* channels_protector; /*! Protector from list modifications */
unsigned char is_log_enabled; /*! Allows debug messages logging */
unsigned packets_rate; /*! Delay in miliseconds between RTP injection */
unsigned channels_count; /*! Active channels count */
unsigned secure_count; /*! Active channels count */
zrtp_queue_t* queue; /*! Queue which emulate communication channel between ZRTP endpoints */
unsigned char is_running; /*! Main test loop work while this is not 0 */
} zrtp_test_global_t;
zrtp_test_global_t test_global; /*! zrtp test global data */
zrtp_global_t* zrtp_global; /*! libzrtp global data */
typedef struct zrtp_test_session zrtp_test_session_t;
typedef struct zrtp_test_stream zrtp_test_stream_t;
typedef struct zrtp_test_channel zrtp_test_channel_t;
#define ZRTP_TEST_PACKET_HEADER_LENGTH 16
typedef struct zrtp_test_packet
{
uint32_t is_rtp; /*! Defines is packet RTP or RTCP */
uint32_t length; /*! Packet Length in bytes */
char body[1024]; /*! Packet body */
} zrtp_test_packet_t;
struct zrtp_test_stream
{
zrtp_stream_t* zrtp_stream; /*! ZRTP stream associated test stream */
zrtp_test_session_t* session; /*! Pointer to the parent test session */
uint16_t seq; /*! RTP sequence number for media packets construction */
uint32_t ssrc; /*! RTP local SSRC for media packets exchanging */
uint32_t peer_ssrc; /*! RTP remote SSRC for media packets exchanging */
};
struct zrtp_test_session
{
zrtp_test_stream_t streams[ZRTP_MAX_STREAMS_PER_SESSION]; /*! Streams array */
unsigned streams_count; /*! Active streams counter */
zrtp_session_t* zrtp_session; /*! ZRTP session associated test session */
zrtp_test_channel_t *channel;
mlist_t _list;
};
struct zrtp_test_channel
{
zrtp_test_channel_id_t id; /*! Channel ID*/
zrtp_test_session_t ses_left; /*! Left test session */
zrtp_test_session_t ses_right; /*! Right test session */
mlist_t _mlist;
};
zrtp_test_channel_t* find_channel_by_index(zrtp_test_channel_id_t chan_id);
zrtp_test_channel_t* find_channel_with_closest_index(zrtp_test_channel_id_t chan_id);
zrtp_test_stream_t* find_peer_stream_by_ssrc(uint32_t ssrc);
/*============================================================================*/
/* ZRTP Interfaces */
/*============================================================================*/
static void on_zrtp_protocol_event(zrtp_stream_t *ctx, zrtp_protocol_event_t event)
{
}
static void on_zrtp_security_event(zrtp_stream_t *ctx, zrtp_security_event_t event)
{
}
static void on_zrtp_secure(zrtp_stream_t *ctx)
{
zrtp_test_stream_t *stream = (zrtp_test_stream_t*) zrtp_stream_get_userdata(ctx);
zrtp_test_channel_t *channel = stream->session->channel;
unsigned i = 0;
unsigned char not_secure = 0;
ZRTP_LOG(1, (_ZTU_,"Stream is SECURE ssrc=%u ctx=%d\n", ctx->media_ctx.ssrc, ctx));
for (i=0; i<channel->ses_left.streams_count; i++) {
if (ZRTP_STATE_SECURE != channel->ses_left.streams[i].zrtp_stream->state) {
not_secure = 1;
}
}
if (0 == not_secure) {
for (i=0; i<channel->ses_right.streams_count; i++) {
if (ZRTP_STATE_SECURE != channel->ses_right.streams[i].zrtp_stream->state) {
not_secure = 1;
}
}
}
if (0 == not_secure) {
zrtp_session_info_t session_info;
zrtp_stream_info_t a_stream_info;
test_global.secure_count++;
ZRTP_LOG(1, (_ZTU_,"===================================================\n"));
ZRTP_LOG(1, (_ZTU_,"Entire Channel is SECURE. Total Secure count=%d\n", test_global.secure_count));
ZRTP_LOG(1, (_ZTU_,"===================================================\n"));
zrtp_session_get(channel->ses_left.zrtp_session, &session_info);
zrtp_stream_get(channel->ses_left.streams[0].zrtp_stream , &a_stream_info);
zrtp_log_print_sessioninfo(&session_info);
zrtp_log_print_streaminfo(&a_stream_info);
}
}
static int on_send_packet(const zrtp_stream_t* ctx, char* message, unsigned int length)
{
zrtp_queue_elem_t* elem = zrtp_sys_alloc(sizeof(zrtp_queue_elem_t));
if (elem) {
zrtp_test_packet_t* packet = (zrtp_test_packet_t*) elem->data;
elem->size = length;
packet->is_rtp = 1;
packet->length = length;
zrtp_memcpy(packet->body, message, length);
ZRTP_LOG(1, (_ZTU_,"\tSend message to ssrc=%u length=%d\n", ctx->media_ctx.ssrc, length));
zrtp_test_queue_push(test_global.queue, elem);
return zrtp_status_ok;
} else {
return zrtp_status_alloc_fail;
}
}
void zrtp_def_get_cache_path(char *path, uint32_t length)
{
#if (ZRTP_PLATFORM == ZP_WIN32) || (ZRTP_PLATFORM == ZP_WINCE)
strncpy_s(path, length, "./zrtp_test_cache.dat", length);
#else
strncpy(path, "./zrtp_test_cache.dat", length);
#endif
}
/*============================================================================*/
/* Sessions Life-Cycle Logic */
/*============================================================================*/
/*----------------------------------------------------------------------------*/
#if (ZRTP_PLATFORM == ZP_WIN32) || (ZRTP_PLATFORM == ZP_WINCE)
DWORD WINAPI process_incoming(void *param)
#else
void *process_incoming(void *param)
#endif
{
ZRTP_LOG(1, (_ZTU_,"======> STARTING Incoming processor\n"));
while (test_global.is_running)
{
zrtp_test_packet_t* packet = NULL;
zrtp_queue_elem_t* elem = NULL;
zrtp_status_t s = zrtp_status_fail;
zrtp_test_stream_t *stream = NULL;
int is_protocol = 0;
/* Get packet from the "Network" and find aapropriate stream to process it */
elem = zrtp_test_queue_pop(test_global.queue);
packet = (zrtp_test_packet_t*) elem->data;
/* We have ssrc in the packet, which indetifies stream that had send it to us.
* so now we have to find appropriate stream which has to process that packet.
*/
if (packet->is_rtp) {
ZRTP_UNALIGNED(zrtp_rtp_hdr_t) *hdr = (zrtp_rtp_hdr_t*) (packet->body);
if (ZRTP_PACKETS_MAGIC == zrtp_ntoh32(hdr->ts)) {
is_protocol = 1;
ZRTP_LOG(1, (_ZTU_,"\n"));
}
stream = find_peer_stream_by_ssrc(hdr->ssrc);
} else {
ZRTP_UNALIGNED(zrtp_rtcp_hdr_t) *hdr = (zrtp_rtcp_hdr_t*) (packet->body);
stream = find_peer_stream_by_ssrc(hdr->ssrc);
}
if (!stream) {
zrtp_sys_free(elem);
ZRTP_LOG(1, (_ZTU_,"process_incoming(): ERROR! can't found peer stream!\n"));
continue;
}
/*
* Process incoming packet by libzrtp. Is this a RTP media packet - copy it to the buffer
* to print out later.
*/
if (packet->is_rtp) {
s = zrtp_process_srtp(stream->zrtp_stream, packet->body, &packet->length);
} else {
s = zrtp_process_srtcp(stream->zrtp_stream, packet->body, &packet->length);
}
if (!is_protocol)
{
char *body;
if (packet->is_rtp) {
body = packet->body + sizeof(zrtp_rtp_hdr_t);
body[packet->length - sizeof(zrtp_rtp_hdr_t)] = 0;
} else {
body = packet->body + sizeof(zrtp_rtcp_hdr_t);
body[packet->length - sizeof(zrtp_rtcp_hdr_t)] = 0;
}
switch (s)
{
case zrtp_status_ok: {
ZRTP_LOG(1, (_ZTU_,"Incoming: (%s) [%p:ssrc=%u] INPUT. <%s> decrypted %d bytes.\n",
zrtp_log_state2str(stream->zrtp_stream->state), stream->zrtp_stream, stream->ssrc, body, packet->length));
} break;
case zrtp_status_drop: {
ZRTP_LOG(1, (_ZTU_,"Incoming: (%s) [%p:ssrc=%u] INPUT DROPPED. <%s>\n",
zrtp_log_state2str(stream->zrtp_stream->state), stream->zrtp_stream, stream->ssrc, body));
} break;
case zrtp_status_fail: {
ZRTP_LOG(1, (_ZTU_,"Incoming: (%s) [%p:ssrc=%u] DECRYPT FAILED. <%s>\n",
zrtp_log_state2str(stream->zrtp_stream->state), stream->zrtp_stream, stream->ssrc, body));
} break;
default:
break;
}
}
zrtp_sys_free(elem);
/*
* When zrtp_stream is in the pending clear state and other side wants to send plain
* traffic. We have to call zrtp_clear_stream().
*/
if (stream->zrtp_stream->state == ZRTP_STATE_PENDINGCLEAR) {
zrtp_stream_clear(stream->zrtp_stream);
}
} /* while is running */
#if (ZRTP_PLATFORM == ZP_WIN32) || (ZRTP_PLATFORM == ZP_WINCE)
return 0;
#else
return NULL;
#endif
}
/*----------------------------------------------------------------------------*/
#if (ZRTP_PLATFORM == ZP_WIN32) || (ZRTP_PLATFORM == ZP_WINCE)
DWORD WINAPI process_outgoing(void *param)
#else
void *process_outgoing(void *param)
#endif
{
unsigned packets_counter = 0;
ZRTP_LOG(1, (_ZTU_,"======> STARTING Outgoing processor\n"));
while (test_global.is_running)
{
zrtp_test_channel_id_t channel_id = 0;
zrtp_test_channel_t* channel = NULL;
zrtp_test_session_t* session = NULL;
unsigned i;
zrtp_sleep(test_global.packets_rate);
if ((0 == test_global.channels_count) || (0 == test_global.secure_count)) {
continue;
}
/* Get random channel to operate with and select random peer */
zrtp_randstr(zrtp_global, (unsigned char*)&channel_id, sizeof(zrtp_test_channel_id_t));
channel = find_channel_with_closest_index(channel_id);
if (!channel) {
continue;
}
ZRTP_LOG(1, (_ZTU_,"\n"));
ZRTP_LOG(1, (_ZTU_,"Out. Generate packet by channel N=%u and %s session.\n",
channel->id, ((channel_id % 100) > 50) ? "RIGHT": "LEFT"));
session = ((channel_id % 100) > 50) ? &channel->ses_right : &channel->ses_left;
/* Generate RTP or RTCP packet for every stream within the session */
for (i=0; i<session->streams_count; i++)
{
zrtp_status_t s = zrtp_status_fail;
zrtp_test_packet_t* packet;
zrtp_queue_elem_t* elem;
zrtp_test_stream_t* stream = &session->streams[i];
char* word = NULL;
elem = zrtp_sys_alloc(sizeof(zrtp_queue_elem_t));
if (!elem) {
break;
}
packet = (zrtp_test_packet_t*) elem->data;
packet->is_rtp = (packets_counter++ % 20); /* Every 20-th packet is RTCP */
/*
* Construct RTP/RTCP Packet
*/
if (packet->is_rtp)
{
ZRTP_UNALIGNED(zrtp_rtp_hdr_t) *rtp_hdr = (zrtp_rtp_hdr_t*)packet->body;
/* Fill RTP Header according to the specification */
zrtp_memset(rtp_hdr, 0, sizeof(zrtp_rtp_hdr_t));
rtp_hdr->version = 2; /* Current RTP version 2 */
rtp_hdr->pt = 0; /* PCMU padding type */
rtp_hdr->ssrc = stream->ssrc; /* Use ssrc for addressing like in real RTP */
if (stream->seq >= 0xFFFF) {
stream->seq = 0;
}
rtp_hdr->seq = zrtp_hton16(stream->seq++);
rtp_hdr->ts = zrtp_hton32((uint32_t)(zrtp_time_now()/1000));
/* Get RTP body from PGP words lists */
word = (char*)(i ? hash_word_list_odd[packets_counter % 256] : hash_word_list_even[packets_counter % 256]);
zrtp_memcpy(packet->body + sizeof(zrtp_rtp_hdr_t), word, (uint32_t)strlen(word));
packet->length = sizeof(zrtp_rtp_hdr_t) + (uint32_t)strlen(word);
/* Process RTP media with libzrtp */
s = zrtp_process_rtp(stream->zrtp_stream, packet->body, &packet->length);
}
else
{
ZRTP_UNALIGNED(zrtp_rtcp_hdr_t) *rtcp_hdr = (zrtp_rtcp_hdr_t*)packet->body;
/* Fill RTCP Header according to the specification */
rtcp_hdr->rc = 0;
rtcp_hdr->version = 2;
rtcp_hdr->ssrc = stream->ssrc;
/* Get RTP body from PGP words lists. Put RTCP marker at the beginning */
zrtp_memcpy(packet->body + sizeof(zrtp_rtcp_hdr_t), "RTCP", 4);
word = (char*)( i ? hash_word_list_odd[packets_counter % 256] : hash_word_list_even[packets_counter % 256]);
zrtp_memcpy(packet->body + sizeof(zrtp_rtcp_hdr_t) + 4, word, (uint32_t)strlen(word));
packet->length = sizeof(zrtp_rtcp_hdr_t) + (uint32_t)strlen(word) + 4;
/* RTCP packets sould be 32 byes aligned */
packet->length += (packet->length % 4) ? (4 - packet->length % 4) : 0;
/* Process RTCP control with libzrtp */
s = zrtp_process_rtcp(stream->zrtp_stream, packet->body, &packet->length);
}
/* Handle zrtp_process_xxx() instructions */
switch (s)
{
/* Put the packet to the queue ==> send packet to the other side pear */
case zrtp_status_ok: {
ZRTP_LOG(3, (_ZTU_,"Outgoing: (%s) [%p:ssrc=%u] OUTPUT. <%s%s> encrypted %d bytes.\n",
zrtp_log_state2str(stream->zrtp_stream->state), stream->zrtp_stream, stream->ssrc, packet->is_rtp ? "" : "RTCP", word, packet->length));
zrtp_test_queue_push(test_global.queue, elem);
} break;
case zrtp_status_drop: {
ZRTP_LOG(1, (_ZTU_,"Outgoing: (%s) [%p:ssrc=%u] OUTPUT DROPPED.\n",
zrtp_log_state2str(stream->zrtp_stream->state), stream->zrtp_stream, stream->ssrc));
} break;
case zrtp_status_fail: {
ZRTP_LOG(1, (_ZTU_,"Outgoing: (%s) [%p:ssrc=%u] ENCRYPT FAILED.\n",
zrtp_log_state2str(stream->zrtp_stream->state), stream->zrtp_stream, stream->ssrc));
} break;
default:
break;
}
if (zrtp_status_ok != s) {
zrtp_sys_free(packet);
}
} /* for (every stream within the session) */
} /* while is running */
#if (ZRTP_PLATFORM == ZP_WIN32) || (ZRTP_PLATFORM == ZP_WINCE)
return 0;
#else
return NULL;
#endif
}
/*----------------------------------------------------------------------------*/
static zrtp_status_t init_test_session( zrtp_test_session_t *session,
zrtp_profile_t *zrtp_profile,
unsigned nstreams)
{
unsigned i = 0;
zrtp_zid_t zid;
zrtp_status_t s = zrtp_status_fail;
session->streams_count = nstreams;
/* Allocate ZRTP session */
zrtp_randstr(zrtp_global, (unsigned char*)&zid, sizeof(zrtp_zid_t));
ZRTP_LOG(3, (_ZTU_,"INITIALIZE NEW SESSION ctx=%p:\n", session));
ZRTP_LOG(3, (_ZTU_,"---------------------------------------------------\n"));
s = zrtp_session_init(zrtp_global, zrtp_profile, zid, 1, &session->zrtp_session);
if (zrtp_status_ok != s) {
ZRTP_LOG(3, (_ZTU_,"ERROR! can't initalize ZRTP session d=%d.\n", s));
return s;
}
zrtp_session_set_userdata(session->zrtp_session, session);
ZRTP_LOG(3, (_ZTU_,"Attach %d ZRTP streams.\n", session->streams_count));
/* ZRTP session is ready for use. Now it's time to attach streams to it */
for (i=0; i<session->streams_count; i++)
{
zrtp_test_stream_t *stream = &session->streams[i];
/* Create random sequence number and ssrc for packets generation */
zrtp_randstr(zrtp_global, (unsigned char*)&stream->seq, sizeof(stream->seq));
zrtp_randstr(zrtp_global, (unsigned char*)&stream->ssrc, sizeof(stream->ssrc));
ZRTP_LOG(3, (_ZTU_,"Created stream N%d ssrc=%u seq=%d ctx=%p\n", i, stream->ssrc, stream->seq, stream));
/* Attach zrtp_stream to zrtp_session */
s = zrtp_stream_attach(session->zrtp_session, &stream->zrtp_stream);
if (zrtp_status_ok != s) {
ZRTP_LOG(3, (_ZTU_,"ERROR! can't attach ZRTP stream.\n"));
break;
}
zrtp_stream_set_userdata(stream->zrtp_stream, stream);
stream->session = session;
}
if (i != session->streams_count) {
zrtp_session_down(session->zrtp_session);
return zrtp_status_fail;
}
return zrtp_status_ok;
};
/*----------------------------------------------------------------------------*/
int zrtp_test_channel_create( const zrtp_test_channel_config_t* config,
zrtp_test_channel_id_t* chan_id)
{
zrtp_status_t s = zrtp_status_fail;
zrtp_test_channel_t* channel = NULL;
unsigned streams_number = 1;
/*
* Create two connection for each side of the call.
* They will have the same id in order to simplify calls managing.
*/
channel = zrtp_sys_alloc(sizeof(zrtp_test_channel_t));
if (!channel) {
return -1;
}
zrtp_memset(channel, 0, sizeof(zrtp_test_channel_t));
/* Generate new unique ID for the channel */
zrtp_randstr(zrtp_global, (unsigned char*)chan_id, sizeof(zrtp_test_channel_id_t));
ZRTP_LOG(1, (_ZTU_,"=====> CREATE NEW CHANNEL ID=%u ctx=%p.\n", chan_id, channel));
/*
* Alloacte and initalize ZRTP crypto stuffs
*/
do {
zrtp_profile_t zrtp_profile;
unsigned i = 0;
/*
* Use default ZRTP configuration with slitely changes:
* - enable "allowclear" to be able to test more scenarios
*/
zrtp_profile_defaults(&zrtp_profile, zrtp_global);
zrtp_profile.allowclear = 1;
zrtp_profile.autosecure = 1;
channel->ses_left.streams_count = streams_number;
#if (ZRTP_ENABLE_TEST == 1)
zrtp_profile.pk_schemes[0] = ZRTP_PKTYPE_EC384P;
zrtp_profile.pk_schemes[1] = ZRTP_PKTYPE_DH3072;
zrtp_profile.pk_schemes[2] = ZRTP_PKTYPE_MULT;
zrtp_profile.pk_schemes[3] = 0;
#endif
s = init_test_session(&channel->ses_left, &zrtp_profile, 1);
if (zrtp_status_ok != s) {
break;
}
channel->ses_left.channel = channel;
channel->ses_right.streams_count = streams_number;
#if (ZRTP_ENABLE_TEST == 1)
zrtp_profile.autosecure = 1;
zrtp_profile.pk_schemes[0] = ZRTP_PKTYPE_EC384P;
zrtp_profile.pk_schemes[1] = ZRTP_PKTYPE_DH2048;
zrtp_profile.pk_schemes[2] = ZRTP_PKTYPE_DH3072;
zrtp_profile.pk_schemes[3] = ZRTP_PKTYPE_MULT;
zrtp_profile.pk_schemes[4] = 0;
#endif
s = init_test_session(&channel->ses_right, &zrtp_profile, 1);
if (zrtp_status_ok != s) {
break;
}
channel->ses_right.channel = channel;
/* Make cross-references to allow left stream to communicate with the right one. */
for (i=0; i<streams_number; i++) {
channel->ses_left.streams[i].peer_ssrc = channel->ses_right.streams[i].ssrc;
channel->ses_right.streams[i].peer_ssrc = channel->ses_left.streams[i].ssrc;
}
} while (0);
if (zrtp_status_ok != s) {
zrtp_sys_free(channel);
} else {
channel->id = *chan_id;
zrtp_mutex_lock(test_global.channels_protector);
mlist_add(&test_global.channels_head, &channel->_mlist);
zrtp_mutex_unlock(test_global.channels_protector);
}
test_global.channels_count++;
return s;
}
/*----------------------------------------------------------------------------*/
static void down_test_session(zrtp_test_session_t *session)
{
zrtp_session_down(session->zrtp_session);
};
int zrtp_test_channel_delete(zrtp_test_channel_id_t chan_id)
{
zrtp_test_channel_t* channel = find_channel_by_index(chan_id);
if (channel)
{
test_global.channels_count--;
zrtp_mutex_lock(test_global.channels_protector);
mlist_del(&channel->_mlist);
zrtp_mutex_unlock(test_global.channels_protector);
down_test_session(&channel->ses_left);
down_test_session(&channel->ses_right);
zrtp_sys_free(channel);
return 0;
} else {
return -1;
}
}
/*----------------------------------------------------------------------------*/
typedef enum
{
TEST_ACTION_START = 0,
TEST_ACTION_SECURE,
TEST_ACTION_CLEAR,
TEST_ACTION_STOP
} zrtp_test_session_action_t;
static void test_session_do_action(zrtp_test_session_t *session, zrtp_test_session_action_t action)
{
unsigned i = 0;
if (session->zrtp_session)
{
for (i=0; i<session->streams_count; i++) {
switch (action) {
case TEST_ACTION_START:
{
char buff[65];
ZRTP_LOG(1, (_ZTU_,"=====> START TEST SESSION ID=%u ctx=%p.\n", session->channel->id, session->channel));
zrtp_stream_start(session->streams[i].zrtp_stream, zrtp_ntoh32(session->streams[i].ssrc));
zrtp_signaling_hash_get(session->streams[i].zrtp_stream, buff, sizeof(buff));
break;
}
case TEST_ACTION_STOP:
ZRTP_LOG(1, (_ZTU_,"=====> STOP TEST SESSION ID=%u ctx=%p.\n", session->channel->id, session->channel));
zrtp_stream_stop(session->streams[i].zrtp_stream);
break;
case TEST_ACTION_SECURE:
ZRTP_LOG(1, (_ZTU_,"=====> SECURE TEST SESSION ID=%u ctx=%p.\n", session->channel->id, session->channel));
zrtp_stream_secure(session->streams[i].zrtp_stream);
break;
case TEST_ACTION_CLEAR:
ZRTP_LOG(1, (_ZTU_,"=====> CLEAR TEST SESSION ID=%u ctx=%p.\n", session->channel->id, session->channel));
zrtp_stream_clear(session->streams[i].zrtp_stream);
break;
}
}
}
};
static int test_channel_do_action(zrtp_test_channel_id_t chan_id, zrtp_test_session_action_t action)
{
zrtp_test_channel_t* channel = find_channel_by_index(chan_id);
if (channel) {
test_session_do_action(&channel->ses_left, action);
test_session_do_action(&channel->ses_right, action);
return 0;
} else {
return -1;
}
}
int zrtp_test_channel_start(zrtp_test_channel_id_t chan_id) {
return test_channel_do_action(chan_id, TEST_ACTION_START);
}
int zrtp_test_channel_secure(zrtp_test_channel_id_t chan_id) {
return test_channel_do_action(chan_id, TEST_ACTION_SECURE);
}
int zrtp_test_channel_clear(zrtp_test_channel_id_t chan_id) {
return test_channel_do_action(chan_id, TEST_ACTION_CLEAR);
}
int zrtp_test_channel_stop(zrtp_test_channel_id_t chan_id) {
return test_channel_do_action(chan_id, TEST_ACTION_STOP);
}
/*============================================================================*/
/* Test Routine */
/*============================================================================*/
/*---------------------------------------------------------------------------*/
static int start_processors(int count)
{
int32_t i;
for (i = 0; i<count; i++)
{
if (0 != zrtp_thread_create(process_incoming, NULL)) {
return -1;
}
if (0 != zrtp_thread_create(process_outgoing, NULL)) {
return -1;
}
}
return 0;
}
int zrtp_test_zrtp_init()
{
int result = -1;
zrtp_status_t s = zrtp_status_ok;
zrtp_config_t zrtp_config;
ZRTP_LOG(1, (_ZTU_,"=====>Start ZRTP Test-Unite Core initalization.\n"));
zrtp_memset(&test_global, 0, sizeof(test_global));
ZRTP_LOG(1, (_ZTU_,"Create internal components...\n"));
do {
/* Create global objects: channels list and communication queue */
init_mlist(&test_global.channels_head);
s = zrtp_mutex_init(&test_global.channels_protector);
if (zrtp_status_ok != s) {
ZRTP_LOG(1, (_ZTU_,"ERROR! Can't create channels protector %d\n", s));
break;
}
s = zrtp_test_queue_create(&test_global.queue);
if (zrtp_status_ok != s) {
ZRTP_LOG(1, (_ZTU_,"ERROR! Can't create global queue: %s\n", s));
break;
}
/* Start several threads to process test zrtp channels */
test_global.is_running = 1;
result = start_processors(ZRTP_TEST_STREAMS_COUNT);
if (0 != result) {
break;
}
ZRTP_LOG(1, (_ZTU_,"Configuring and Initalizing ZRTP engine...\n"));
/* Reset global values to defaults */
test_global.is_log_enabled = 1;
test_global.packets_rate = 500;
test_global.channels_count = 0;
/* Initalize ZRTP Engine */
zrtp_config_defaults(&zrtp_config);
zrtp_config.lic_mode = ZRTP_LICENSE_MODE_ACTIVE;
zrtp_memcpy(zrtp_config.client_id, "ZRTP Test Unite!", 16);
zrtp_config.cb.event_cb.on_zrtp_secure = on_zrtp_secure;
zrtp_config.cb.event_cb.on_zrtp_security_event = on_zrtp_security_event;
zrtp_config.cb.event_cb.on_zrtp_protocol_event = on_zrtp_protocol_event;
zrtp_config.cb.misc_cb.on_send_packet = on_send_packet;
s = zrtp_init(&zrtp_config, &zrtp_global);
if (zrtp_status_ok != s) {
ZRTP_LOG(1, (_ZTU_,"ERROR! zrtp_init() failed with status=%d.\n", s));
break;
}
result = 0;
} while (0);
if (0 != result) {
if (!test_global.channels_protector) {
zrtp_mutex_destroy(test_global.channels_protector);
}
if (!test_global.queue) {
zrtp_test_queue_destroy(test_global.queue);
}
}
return result;
}
/*----------------------------------------------------------------------------*/
int zrtp_test_zrtp_down()
{
mlist_t* node = NULL,* tmp = NULL;
ZRTP_LOG(1, (_ZTU_,"=====> Destroying ZRTP Test Application:\n"));
ZRTP_LOG(1, (_ZTU_,"Stop all running threads.\n"));
/* Stop Main Processing Loop */
test_global.is_running = 0;
ZRTP_LOG(1, (_ZTU_,"Destroy all active connections.\n"));
/* Stop and destroy all active sessions */
zrtp_mutex_lock(test_global.channels_protector);
mlist_for_each_safe(node, tmp, &test_global.channels_head) {
zrtp_test_channel_t* result = (zrtp_test_channel_t*) mlist_get_struct(zrtp_test_channel_t, _mlist, node);
zrtp_test_channel_delete(result->id);
}
zrtp_mutex_unlock(test_global.channels_protector);
ZRTP_LOG(1, (_ZTU_,"Destroy ZRTP Engine.\n"));
/* Destroy libzrtp and all utility components */
zrtp_down(zrtp_global);
if (!test_global.channels_protector) {
zrtp_mutex_destroy(test_global.channels_protector);
}
if (!test_global.queue) {
zrtp_test_queue_destroy(test_global.queue);
}
return 0;
}
/*----------------------------------------------------------------------------*/
zrtp_test_channel_t* find_channel_by_index(zrtp_test_channel_id_t chan_id)
{
unsigned char is_found = 0;
mlist_t* node = NULL,* tmp = NULL;
zrtp_test_channel_t* result = NULL;
zrtp_mutex_lock(test_global.channels_protector);
mlist_for_each_safe(node, tmp, &test_global.channels_head) {
result = (zrtp_test_channel_t*) mlist_get_struct(zrtp_test_channel_t, _mlist, node);
if (result->id == chan_id) {
is_found = 1;
break;
}
}
zrtp_mutex_unlock(test_global.channels_protector);
return (is_found) ? result : NULL;
}
zrtp_test_channel_t* find_channel_with_closest_index(zrtp_test_channel_id_t chan_id)
{
unsigned char is_found = 0;
mlist_t* node = NULL,* tmp = NULL;
zrtp_test_channel_t* result = NULL;
zrtp_test_channel_t* left = NULL;
zrtp_mutex_lock(test_global.channels_protector);
mlist_for_each_safe(node, tmp, &test_global.channels_head) {
result = (zrtp_test_channel_t*) mlist_get_struct(zrtp_test_channel_t, _mlist, node);
if (result->id > chan_id) {
is_found = 1;
break;
} else {
left = result;
}
}
zrtp_mutex_unlock(test_global.channels_protector);
return (is_found) ? result : left;
}
zrtp_test_stream_t* find_peer_stream_by_ssrc(uint32_t ssrc)
{
unsigned char is_found = 0;
mlist_t *node = NULL, *tmp = NULL;
zrtp_test_stream_t *result = NULL;
zrtp_mutex_lock(test_global.channels_protector);
mlist_for_each_safe(node, tmp, &test_global.channels_head)
{
zrtp_test_channel_t *channel = (zrtp_test_channel_t*) mlist_get_struct(zrtp_test_channel_t, _mlist, node);
unsigned i = 0;
for (i=0; i<channel->ses_left.streams_count; i++) {
zrtp_test_stream_t *stream = &channel->ses_left.streams[i];
if (stream->ssrc == ssrc) {
is_found = 1;
result = &channel->ses_right.streams[i];
break;
}
}
for (i=0; i<channel->ses_right.streams_count; i++) {
zrtp_test_stream_t *stream = &channel->ses_right.streams[i];
if (stream->ssrc == ssrc) {
is_found = 1;
result = &channel->ses_left.streams[i];
break;
}
}
if (is_found) {
break;
}
}
zrtp_mutex_unlock(test_global.channels_protector);
return (is_found) ? result : NULL;
}
Reference in New Issue View Git Blame Copy Permalink