semaphore_t *
semaphore_allocate (int entry_count)
{
NEW_VAR (pthread_mutex_t, ptm);
NEW_VAR (semaphore_t, sem);
int rc;
memset ((void *) ptm, 0, sizeof (pthread_mutex_t));
#ifndef OLD_PTHREADS
rc = pthread_mutex_init (ptm, &_mutex_attr);
#else
rc = pthread_mutex_init (ptm, _mutex_attr);
#endif
CKRET (rc);
sem->sem_entry_count = entry_count;
sem->sem_handle = (void *) ptm;
#ifdef SEM_NO_ORDER
sem->sem_cv = _alloc_cv ();
if (!sem->sem_cv) goto failed;
sem->sem_any_signalled = 0;
#endif
thread_queue_init (&sem->sem_waiting);
return sem;
failed:
dk_free ((void *) ptm, sizeof (pthread_mutex_t));
dk_free (sem, sizeof (semaphore_t));
return NULL;
}
C_ProtocolControl::C_ProtocolControl(C_TransportControl *P_transport_control) {
GEN_DEBUG(1, "C_ProtocolControl::C_ProtocolControl() start");
NEW_VAR(m_name_map, T_ProtocolNameMap());
m_name_map->clear() ;
m_protocol_table = NULL ;
m_protocol_name_table = NULL ;
m_protocol_table_size = 0 ;
NEW_VAR(m_id_gen, C_IdGenerator());
m_transport_control = P_transport_control ;
GEN_DEBUG(1, "C_ProtocolControl::C_ProtocolControl() end");
}
C_DataLogRTDistrib::C_DataLogRTDistrib(size_t P_max_data,
size_t P_max_data_log,
char *P_file_name,
unsigned long P_period,
unsigned long P_rtdistrib)
: C_DataLogControl(P_max_data,
P_max_data_log,
P_file_name,
P_period){
size_t L_i ;
GEN_DEBUG(0, "C_DataLogRTDistrib::C_DataLogRTDistrib()");
m_rtdistrib = P_rtdistrib ;
NEW_TABLE( m_p_rt_distrib, unsigned long, m_rtdistrib+1);
NEW_TABLE( m_c_rt_distrib, unsigned long, m_rtdistrib+1);
NEW_VAR(m_sem_rt, C_Semaphore()) ;
m_sem_rt->P();
for (L_i=0 ; L_i <= m_rtdistrib ; L_i++) {
m_p_rt_distrib[L_i] = 0;
m_c_rt_distrib[L_i] = 0;
}
m_p_min_rt_distrib = m_rtdistrib ;
m_p_max_rt_distrib = 0 ;
m_c_min_rt_distrib = m_rtdistrib ;
m_c_max_rt_distrib = 0 ;
m_counter_rt = 0 ;
m_sem_rt->V();
}
C_Socket* C_SecureSocketListen::create_socket_server(int *P_ret) {
C_SecureSocketServer* L_socket ;
NEW_VAR(L_socket, C_SecureSocketServer(m_ssl_ctx, this, m_channel_id,
m_read_buf_size, m_segm_buf_size));
(*P_ret) = L_socket->_open(m_buffer_size, m_protocol) ;
return (L_socket);
}
/*
* NAME: data->get_varmap()
* DESCRIPTION: get the variable mapping for an object
*/
static unsigned short *d_get_varmap(object **obj, Uint update, unsigned short *nvariables)
{
object *tmpl;
unsigned short nvar, *vmap;
tmpl = OBJ((*obj)->prev);
if (O_UPGRADING(*obj)) {
/* in the middle of an upgrade */
tmpl = OBJ(tmpl->prev);
}
vmap = o_control(tmpl)->vmap;
nvar = tmpl->ctrl->vmapsize;
if (tmpl->update != update) {
unsigned short *m1, *m2, n;
m1 = vmap;
vmap = ALLOC(unsigned short, n = nvar);
do {
tmpl = OBJ(tmpl->prev);
m2 = o_control(tmpl)->vmap;
while (n > 0) {
*vmap++ = (NEW_VAR(*m1)) ? *m1++ : m2[*m1++];
--n;
}
n = nvar;
vmap -= n;
m1 = vmap;
} while (tmpl->update != update);
}
C_ChannelControl::C_ChannelControl() {
GEN_DEBUG(1, "C_ChannelControl::C_ChannelControl() start");
NEW_VAR(m_name_map, T_ChannelNameMap());
// m_name_map->clear() ;
m_channel_table = NULL ;
m_channel_table_size = 0 ;
m_nb_global_channel = 0 ;
NEW_VAR(m_id_gen, C_IdGenerator()) ;
m_channel_to_ctxt_table = NULL ;
m_ctxt_to_channel_table = NULL ;
m_transport_table = NULL ;
m_nb_transport = 0 ;
m_reconnect = false ;
m_sem_reconnect = NULL ;
GEN_DEBUG(1, "C_ChannelControl::C_ChannelControl() end");
}
void C_LogProtocolStatControl::init(unsigned long P_period, string_t& P_fileName) {
GEN_DEBUG(0, "C_LogProtocolStatControl::init() start");
m_stat -> set_file_name ((char*)P_fileName.c_str());
NEW_VAR(m_sem, C_SemaphoreTimed(P_period));
m_sem -> P();
C_TaskControl::init() ;
GEN_DEBUG(0, "C_LogProtocolStatControl::init() end");
}
semaphore_t *
semaphore_allocate (int entry_count)
{
NEW_VAR (semaphore_t, sem);
sem->sem_entry_count = entry_count;
thread_queue_init (&sem->sem_waiting);
return sem;
}
void C_RampControl::init(unsigned long P_duration,
unsigned long P_current_rate,
unsigned long P_sub_rate,
bool P_increase) {
m_duration = P_duration;
m_current_rate = P_current_rate;
m_sub_rate = P_sub_rate;
m_increase = P_increase;
NEW_VAR(m_sem, C_SemaphoreTimed(1));
m_sem -> P();
C_TaskControl::init() ;
}
void
basket_add (basket_t * bsk, void *token)
{
NEW_VAR (basket_t, newn);
if (bsk->bsk_count == 0)
basket_init (bsk);
newn->bsk_pointer = token;
LISTPUTBEFORE (bsk, newn, bsk_next, bsk_prev);
bsk->bsk_count++;
}
void C_RemoteControl::createRampThread(unsigned long P_duration,
unsigned long P_current_rate,
unsigned long P_diff_rate,
bool P_increase) {
// create thread
C_RampControl *L_rampCtrl ;
NEW_VAR(L_rampCtrl, C_RampControl(m_gen));
L_rampCtrl->init(P_duration,
P_current_rate,
P_diff_rate,
P_increase);
(void)start_thread_control(L_rampCtrl);
}
bool C_ResponseTimeLog::Init
(
)
{
fstream_output* L_stream ;
NEW_VAR(L_stream, fstream_output(m_rsptime_log_filename.c_str()));
if (!L_stream->good())
{
iostream_error << "Unable to open file [" << m_rsptime_log_filename.c_str() << "]" ;
return false ;
}
m_RspTimeTraceStream = L_stream ;
return true;
}
/*
* Allocates a condition variable
*/
static void *
_alloc_cv (void)
{
NEW_VAR (pthread_cond_t, cv);
int rc;
memset ((void *) cv, 0, sizeof (pthread_cond_t));
#ifndef OLD_PTHREADS
rc = pthread_cond_init (cv, NULL);
#else
rc = pthread_cond_init (cv, pthread_condattr_default);
#endif
CKRET (rc);
return (void *) cv;
failed:
dk_free ((void *) cv, sizeof (pthread_cond_t));
return NULL;
}
C_RemoteControl::C_RemoteControl(C_Generator * P_gen,
C_ProtocolControl* P_protocol_control,
char *P_address):C_TaskControl(){
m_gen = P_gen ;
m_call_select = &select ;
m_events = NULL ;
m_protocol_ctrl = P_protocol_control ;
m_transport = NULL ;
ALLOC_TABLE(m_address,
char*,
sizeof(char),
strlen(P_address)+1);
strcpy(m_address, P_address);
NEW_VAR(m_msg_remote_list, T_RcvMsgCtxtList());
m_protocol_frame = NULL ;
m_protocol_text = NULL ;
m_stat = NULL ;
}
int C_ProtocolBinaryBodyNotInterpreted::xml_interpretor(C_XmlData *P_def) {
C_XmlData *L_data ;
T_pXmlData_List L_subList ;
T_XmlData_List::iterator L_listIt ;
char *L_value ;
int L_ret = 0 ;
bool L_headerFound = false ;
GEN_DEBUG(1, "C_ProtocolBinaryBodyNotInterpreted::xml_interpretor() start");
m_nb_header_values = 0 ;
m_header_value_table = NULL ;
m_body_value_table = NULL ;
NEW_VAR(m_header_value_id_map, T_IdMap());
NEW_VAR(m_header_decode_map, T_DecodeMap());
m_header_value_id_map->clear();
m_header_decode_map->clear();
m_nb_header_body_values = 0 ;
m_header_body_value_table = NULL ;
NEW_VAR(m_header_body_value_id_map, T_IdMap());
NEW_VAR(m_header_body_decode_map, T_DecodeMap());
m_header_body_value_id_map->clear();
m_header_body_decode_map->clear();
NEW_VAR(m_header_body_position_size_map, T_HeaderBodyPositionSizeMap());
m_header_body_position_size_map->clear();
L_subList = P_def->get_sub_data() ;
if (L_subList == NULL) {
GEN_ERROR(E_GEN_FATAL_ERROR, "No protocol definition");
L_ret = -1 ;
} else {
for(L_listIt = L_subList->begin() ;
L_listIt != L_subList->end() ;
L_listIt++) {
L_data = *L_listIt ;
L_value = L_data->get_name() ;
// Type definition
if (strcmp(L_value, "types") == 0) {
L_ret = analyze_types_from_xml (L_data) ;
if (L_ret == -1) break ;
}
// Message Header definition
if (strcmp(L_value, "header") ==0) {
L_headerFound = true ;
L_ret = analyze_header_from_xml (L_data) ;
if (L_ret == -1) break ;
}
// Message Body definition
if (strcmp(L_value, "body") ==0) {
L_ret = analyze_body_from_xml (L_data);
if (L_ret == -1) break ;
} // body
// Message dictionary for "fields" and "Message" definition
if (strcmp(L_value, (char*)"dictionary") ==0) {
L_ret = analyze_dictionnary_from_xml (L_data);
if (L_ret == -1) break ;
} // L_value == dico
} // L_listIt
if (L_headerFound == false) {
L_ret = -1 ;
GEN_ERROR(E_GEN_FATAL_ERROR, "No header definition found for protocol");
}
}
GEN_DEBUG(1, "C_ProtocolBinaryBodyNotInterpreted::xml_interpretor() end");
return (L_ret);
}
T_pTransport create_cipsctpio_instance () {
C_TransSCTP* L_inst ;
NEW_VAR(L_inst, C_TransSCTP());
return (L_inst);
}
C_Socket* C_TransSCTP::open (int P_channel_id,
T_pIpAddr P_Addr,
T_pOpenStatus P_status,
C_ProtocolBinaryFrame *P_protocol) {
int L_rc ;
C_Socket *L_socket_created = NULL ;
GEN_DEBUG(1, "C_TransIPTLS::open ()");
switch (P_Addr->m_umode) {
case E_IP_USAGE_MODE_SERVER: {
if (m_trans_type == E_SOCKET_TCP_MODE) {
C_SocketSCTPListen *L_Socket ;
NEW_VAR(L_Socket, C_SocketSCTPListen(m_trans_type,
P_Addr,
P_channel_id,
m_read_buffer_size,
m_decode_buffer_size));
L_rc = L_Socket->_open(m_buffer_size, P_protocol) ;
if (L_rc == 0) {
L_socket_created = L_Socket ;
*P_status = E_OPEN_OK ;
} else {
DELETE_VAR(L_Socket) ;
*P_status = E_OPEN_FAILED ;
}
} else {
C_SocketSCTPServer *L_Socket ;
NEW_VAR(L_Socket, C_SocketSCTPServer(m_trans_type,
P_Addr,
P_channel_id,
m_read_buffer_size,
m_decode_buffer_size));
L_rc = L_Socket->_open_udp(m_buffer_size, P_protocol) ;
if (L_rc == 0) {
L_socket_created = L_Socket ;
*P_status = E_OPEN_OK ;
} else {
DELETE_VAR(L_Socket) ;
*P_status = E_OPEN_FAILED ;
}
}
}
break ;
case E_IP_USAGE_MODE_CLIENT: {
C_SocketSCTPClient *L_Socket ;
NEW_VAR(L_Socket, C_SocketSCTPClient(m_trans_type,
P_Addr,
P_channel_id,
m_read_buffer_size,
m_decode_buffer_size));
L_rc = L_Socket->_open(P_status, m_buffer_size, P_protocol) ;
if (L_rc == 0) {
L_socket_created = L_Socket ;
} else {
DELETE_VAR(L_Socket) ;
*P_status = E_OPEN_FAILED ;
}
}
break ;
case E_IP_USAGE_MODE_UNKNOWN:
GEN_ERROR(1, "OPEN failed: Unsupported mode");
*P_status = E_OPEN_FAILED ;
break ;
}
return (L_socket_created);
}
C_TcapStack* create_tcap_itu_stack(char *P_library_name) {
C_TcapStack *L_stack ;
NEW_VAR(L_stack, C_TcapStackITU(P_library_name));
return (L_stack);
}
bool C_ProtocolControl::fromXml (C_XmlData *P_data,
T_pConfigValueList P_config_value_list,
bool P_display_protocol_stats) {
bool L_ret = true ;
T_pXmlData_List L_subList ;
T_XmlData_List::iterator L_subListIt ;
C_XmlData *L_data ;
char *L_protocol_name,
*L_protocol_type ;
int L_protocol_id ;
T_ProtocolInstList L_protocol_inst_list ;
T_pProtocolInstanceInfo L_protocol_info ;
T_ProtocolInstList::iterator L_it ;
GEN_DEBUG(1, "C_ProtocolControl::fromXml() start");
if (P_data != NULL) {
if ((L_subList = P_data->get_sub_data()) != NULL) {
for (L_subListIt = L_subList->begin() ;
L_subListIt != L_subList->end() ;
L_subListIt++) {
L_data = *L_subListIt ;
if (L_data != NULL) {
if (strcmp(L_data->get_name(), XML_PROTOCOL_SECTION) == 0) {
// protocol section definition found
L_protocol_name = get_protocol_name (L_data) ;
// check protocol type for creation
L_protocol_type = get_protocol_type (L_data) ;
// check name/type presence
if (L_protocol_name == NULL) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"name mandatory for section " << XML_PROTOCOL_SECTION);
L_ret = false ;
break ;
}
if (L_protocol_type == NULL) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"type mandatory for section " << XML_PROTOCOL_SECTION);
L_ret = false ;
break ;
}
// check protocol name unicity
if (m_name_map->find(T_ProtocolNameMap::key_type(L_protocol_name))
!= m_name_map->end()) {
GEN_ERROR(E_GEN_FATAL_ERROR,
XML_PROTOCOL_SECTION << " with name ["
<< L_protocol_name << "] already defined");
L_ret = false ;
break ;
}
// check protocol type or sub type
if (strcmp(L_protocol_type, "binary") == 0) {
// create protocol instance
C_ProtocolBinary *L_protocol_instance = NULL ;
T_ConstructorResult L_res ;
NEW_VAR(L_protocol_instance,
C_ProtocolBinary());
L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ;
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
// store new instance
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "binary-tlv") == 0) {
// create protocol instance
C_ProtocolTlv *L_protocol_instance = NULL ;
T_ConstructorResult L_res ;
NEW_VAR(L_protocol_instance,
C_ProtocolTlv());
L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ;
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
// store new instance
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "binary-body-not-interpreted") == 0) {
// create protocol instance
C_ProtocolBinaryBodyNotInterpreted *L_protocol_instance = NULL ;
T_ConstructorResult L_res ;
NEW_VAR(L_protocol_instance,
C_ProtocolBinaryBodyNotInterpreted());
L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ;
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
// store new instance
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "binary-separator") == 0) {
// create protocol instance
C_ProtocolBinarySeparator *L_protocol_instance = NULL ;
T_ConstructorResult L_res ;
NEW_VAR(L_protocol_instance,
C_ProtocolBinarySeparator());
L_protocol_instance
->construction_data(L_data, &L_protocol_name, &L_res) ;
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
// store new instance
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "external-library") == 0) {
C_ProtocolExternal *L_protocol_instance = NULL ;
T_ConstructorResult L_res = E_CONSTRUCTOR_OK ;
NEW_VAR(L_protocol_instance,
C_ProtocolExternal(m_transport_control,
L_data, &L_protocol_name,
P_config_value_list,
&L_res));
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
// store new instance
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else if (strcmp(L_protocol_type, "text") == 0) {
C_ProtocolText *L_protocol_instance = NULL ;
T_ConstructorResult L_res = E_CONSTRUCTOR_OK ;
NEW_VAR(L_protocol_instance,
C_ProtocolText());
L_protocol_instance->analyze_data(L_data,
&L_protocol_name,
P_config_value_list,
&L_res);
if (L_res != E_CONSTRUCTOR_OK) {
GEN_ERROR(E_GEN_FATAL_ERROR,
"Error found in protocol definition");
DELETE_VAR(L_protocol_instance);
L_ret = false ;
break ;
} else {
if (P_display_protocol_stats == true) {
C_ProtocolStats *L_protocol_stats ;
NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance));
L_protocol_instance->set_stats(L_protocol_stats);
}
// store new instance
L_protocol_id = m_id_gen->new_id() ;
ALLOC_VAR(L_protocol_info,
T_pProtocolInstanceInfo,
sizeof(T_ProtocolInstanceInfo));
L_protocol_info->m_instance = L_protocol_instance ;
L_protocol_info->m_id = L_protocol_id ;
L_protocol_info->m_name = L_protocol_name ;
L_protocol_inst_list.push_back(L_protocol_info);
m_name_map
->insert(T_ProtocolNameMap::value_type(L_protocol_name,
L_protocol_id)) ;
}
} else {
GEN_ERROR(E_GEN_FATAL_ERROR,
XML_PROTOCOL_SECTION
<< " ["
<< L_protocol_name
<< "] with type ["
<< L_protocol_type << "] unsupported");
L_ret = false ;
}
}
}
}
if (L_ret != false) {
if (!L_protocol_inst_list.empty()) {
m_protocol_table_size = L_protocol_inst_list.size() ;
ALLOC_TABLE(m_protocol_table,
T_pC_ProtocolFrame*,
sizeof(T_pC_ProtocolFrame),
m_protocol_table_size) ;
ALLOC_TABLE(m_protocol_name_table,
char**,
sizeof(char*),
m_protocol_table_size) ;
for (L_it = L_protocol_inst_list.begin();
L_it != L_protocol_inst_list.end() ;
L_it++) {
L_protocol_info = *L_it ;
m_protocol_table[L_protocol_info->m_id]
= L_protocol_info->m_instance ;
m_protocol_name_table[L_protocol_info->m_id]
= L_protocol_info->m_name ;
}
} else {
GEN_ERROR(E_GEN_FATAL_ERROR,
"No protocol definition found");
L_ret = false ;
}
} // if L_ret != false
if (!L_protocol_inst_list.empty()) {
for (L_it = L_protocol_inst_list.begin();
L_it != L_protocol_inst_list.end() ;
L_it++) {
FREE_VAR(*L_it);
}
L_protocol_inst_list.erase(L_protocol_inst_list.begin(),
L_protocol_inst_list.end());
}
}
C_GeneratorConfig::C_GeneratorConfig (int P_argc, char** P_argv) {
int L_result ;
int L_i ;
NEW_VAR (m_option_dico_file_list, T_charPlist);
NEW_VAR (m_configValueList, T_ConfigValueList);
C_GeneratorConfig::T_value_type one_value_string [] = {
C_GeneratorConfig::E_VT_STRING
} ;
C_GeneratorConfig::T_command_option L_command_opt [] = {
{ E_CMDLINE_conf_file, (char*)"conf",
C_GeneratorConfig::E_OT_MANDATORY, 1 , one_value_string,
(char*)"<configuration file name>", (char*)""},
{ E_CMDLINE_scen_file, (char*)"scen",
C_GeneratorConfig::E_OT_MANDATORY, 1 , one_value_string,
(char*)"<scenario file name>", (char*)""},
{ E_CMDLINE_dico_file, (char*)"dico",
C_GeneratorConfig::E_OT_MANDATORY, 1 , one_value_string,
(char*)"<protocol dictionary file name>", (char*)"can be used more than once"},
{ E_CMDLINE_log_file, (char*)"log",
C_GeneratorConfig::E_OT_OPTIONAL, 1 , one_value_string,
(char*)"<logging file name>", (char*)""},
{ E_CMDLINE_log_level, (char*)"llevel",
C_GeneratorConfig::E_OT_OPTIONAL, 1 , one_value_string,
(char*)"<logging level mask>",
(char*)"levels: \n M: msg, B: buffer, E: error,\n W: warning, N: no error, T: traffic error,\n V: Verdict, U: User, A: all. Default E"},
{ E_CMDLINE_help, (char*)"help",
C_GeneratorConfig::E_OT_OPTIONAL, 0, NULL,
(char*)"", (char*)"display syntax command line"},
{ E_CMDLINE_bg_mode, (char*)"bg",
C_GeneratorConfig::E_OT_OPTIONAL, 0, NULL,
(char*)"", (char*)"background mode"},
{ E_CMDLINE_timestamp_log, (char*)"notimelog",
C_GeneratorConfig::E_OT_OPTIONAL, 0, NULL,
(char*)"", (char*)"no time stamp on the log (default time stamp)"},
{ E_CMDLINE_check_msg, (char*)"msgcheck",
C_GeneratorConfig::E_OT_OPTIONAL, 0, NULL,
(char*)"",
(char*)"check the field of the messages received (default no check)"},
{ E_CMDLINE_remote_cmd, (char*)"ctrl",
C_GeneratorConfig::E_OT_OPTIONAL, 1, one_value_string,
(char*)"",
(char*)"remote control active on @IP:port (default no remote)"},
{ E_CMDLINE_remote_dico_path, (char*)"ctrldicopath",
C_GeneratorConfig::E_OT_OPTIONAL, 1, one_value_string,
(char*)"",
(char*)"remote dictionary path (default remote-ctrl.xml in\n /usr/local/share/seagull/config)"}
} ;
// general command line description
C_GeneratorConfig::T_command_line L_command_descr = {
E_CMDLINE_nbOptions, // options number
E_CMDLINE_help, // option index for help: -1 => no help option
L_command_opt // command options table
} ;
// Init to default values
m_option_log_file = DEF_OPTION_LOG_FILE ;
m_option_conf_file = DEF_OPTION_CONF_FILE ;
m_option_scen_file = DEF_OPTION_SCEN_FILE ;
m_option_log_level = gen_mask_table[DEF_OPTION_LOG_LEVEL] ;
m_option_bg_mode = DEF_OPTION_BG_MODE ;
m_call_rate = DEF_CALL_RATE ;
m_burst_limit = DEF_BURST_LIMIT ;
m_max_send = DEF_MAX_SEND ;
m_max_receive = DEF_MAX_RECEIVE ;
m_select_timeout = DEF_SELECT_TIMEOUT_MS ;
m_max_simultaneous_calls = DEF_MAX_SIMULTANEOUS_CALLS ;
m_call_timeout = DEF_CALL_TIMEOUT ;
m_msg_buffer_size = DEF_MSG_BUFFER_SIZE ;
m_display_period = DEF_DISPLAY_PERIOD ;
m_log_stat_period = DEF_LOG_STAT_PERIOD ;
m_log_stat_file = DEF_LOG_STAT_FILE ;
m_external_data_file = DEF_EXTERNAL_DATA_FILE ;
m_external_data_select = DEF_EXTERNAL_DATA_SELECT ; // by default sequential
m_resp_time_repart = DEF_RESP_TIME_REPART ;
m_number_calls = DEF_NUMBER_CALLS ;
m_option_timestamp_log = DEF_TIMESTAMP_LOG ;
m_option_check_msg = DEF_CHECK_MSG ;
m_check_level_mask = _check_level_mask[DEF_CHECK_LEVEL] ;
m_check_behaviour = DEF_CHECK_BEHAVIOUR ;
m_data_log_file = DEF_DATA_LOG_FILE ;
m_data_log_period = DEF_DATA_LOG_PERIOD ;
m_data_log_number = DEF_DATA_LOG_NUMBER ;
m_data_log_rtdistrib = DEF_DATA_LOG_RTDISTRIB ;
m_log_protocol_stat_period = DEF_LOG_PROTOCOL_STAT_PERIOD ;
m_log_protocol_stat_name = DEF_LOG_PROTOCOL_STAT ;
m_log_protocol_stat_file = DEF_LOG_PROTOCOL_STAT_FILE ;
m_display_protocol_stat = DEF_DISPLAY_PROTOCOL_STAT ;
m_display_scenario_stat = DEF_DISPLAY_SCENARIO_STAT ;
m_files_no_timestamp = DEF_FILES_NO_TIMESTAMP ;
m_call_timeout_beh_abr = DEF_CALL_TIMEOUT_BEH_ABRT ;
m_execute_check_action = DEF_EXECUTE_CHECK_ACTION ;
m_open_timeout = DEF_OPEN_TIMEOUT ;
m_max_retrans = DEF_MAX_RETRANS ;
m_retrans_enabled = DEF_RETRANS_ENABLED ;
m_model_traffic_select = DEF_MODEL_TRAFFIC_SELECT ; // by default to be define
m_call_rate_scale = DEF_CALL_RATE_SCALE ;
m_option_remote_cmd = DEF_OPTION_REMOTE_CMD ;
m_option_remote_dico_path = DEF_REMOTE_DICO_PATH ;
ALLOC_TABLE(m_conf_opt_set, bool*, sizeof(bool), E_CFG_OPT_Number);
for(L_i=0; L_i < E_CFG_OPT_Number; L_i++) {
m_conf_opt_set[L_i] = false ;
}
L_result =
startAnalyzeCommandLine (P_argc, (char**) P_argv, &L_command_descr) ;
if (L_result == -1) {
GEN_ERROR(E_GEN_FATAL_ERROR, "Analyze command line error");
}
}
C_TcapStack* create_tcap_ansi_stack(char *P_library_name) {
C_TcapStack *L_stack ;
NEW_VAR(L_stack, C_TcapStackANSI(P_library_name));
return (L_stack);
}
