/**
* init nio function
*/
int nio_intercept_init(void)
{
int route_no;
pv_spec_t avp_spec;
route_no=route_get(&event_rt, "network:msg");
if (route_no==-1)
{
LM_ERR("failed to find event_route[network:msg]\n");
return -1;
}
if (event_rt.rlist[route_no]==0)
{
LM_ERR("event_route[network:msg] is empty\n");
return -1;
}
nio_route_no=route_no;
if (nio_min_msg_len < 0)
{
LM_WARN("min_msg_len is less then zero, setting it to zero");
nio_min_msg_len = 0;
}
if (nio_msg_avp_param.s && nio_msg_avp_param.len > 0)
{
if (pv_parse_spec(&nio_msg_avp_param, &avp_spec)==0
|| avp_spec.type!=PVT_AVP)
{
LM_ERR("malformed or non AVP %.*s AVP definition\n",
nio_msg_avp_param.len, nio_msg_avp_param.s);
return -1;
}
if(pv_get_avp_name(0, &(avp_spec.pvp), &nio_msg_avp_name,
&nio_msg_avp_type)!=0)
{
LM_ERR("[%.*s]- invalid AVP definition\n",
nio_msg_avp_param.len, nio_msg_avp_param.s);
return -1;
}
} else {
LM_WARN("no AVP defined to store modified message\n");
}
/* register network hooks */
sr_event_register_cb(SREV_NET_DATA_IN, nio_msg_received);
sr_event_register_cb(SREV_NET_DATA_OUT, nio_msg_sent);
#ifdef USE_TCP
tcp_set_clone_rcvbuf(1);
#endif
return 0;
}
int register_core_stats(void)
{
/* register core statistics */
if (register_module_stats( "core", core_stats)!=0 ) {
LM_ERR("failed to register core statistics\n");
return -1;
}
/* register sh_mem statistics */
if (register_module_stats( "shmem", shm_stats)!=0 ) {
LM_ERR("failed to register sh_mem statistics\n");
return -1;
}
if (register_script_cb(km_cb_req_stats, PRE_SCRIPT_CB|REQUEST_CB, 0)<0 ) {
LM_ERR("failed to register PRE request callback\n");
return -1;
}
if (register_script_cb(km_cb_rpl_stats, PRE_SCRIPT_CB|ONREPLY_CB, 0)<0 ) {
LM_ERR("failed to register PRE request callback\n");
return -1;
}
if (stats_proc_stats_init_rpc()<0) return -1;
sr_event_register_cb(SREV_CORE_STATS, sts_update_core_stats);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(msrp_sruid_init()<0) {
LM_ERR("cannot init msrp uid\n");
return -1;
}
if(msrp_cmap_init_rpc()<0)
{
LM_ERR("failed to register cmap RPC commands\n");
return -1;
}
if(msrp_cmap_size>0) {
if(msrp_cmap_size>16)
msrp_cmap_size = 16;
if(msrp_cmap_init(1<<msrp_cmap_size)<0) {
LM_ERR("Cannot init internal cmap\n");
return -1;
}
if(msrp_timer_interval<=0)
msrp_timer_interval = 60;
register_sync_timers(1);
}
sr_event_register_cb(SREV_TCP_MSRP_FRAME, msrp_frame_received);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(_gzc_sanity_checks!=0)
{
if(sanity_load_api(&scb)<0)
{
LM_ERR("cannot bind to sanity module\n");
goto error;
}
}
sr_event_register_cb(SREV_NET_DATA_IN, gzc_msg_received);
sr_event_register_cb(SREV_NET_DATA_OUT, gzc_msg_sent);
#ifdef USE_TCP
tcp_set_clone_rcvbuf(1);
#endif
return 0;
error:
return -1;
}
/**
* init module function
*/
static int mod_init(void)
{
/* Find a database module */
if (db_bind_mod(&_tps_db_url, &_tpsdbf)) {
LM_ERR("unable to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(_tpsdbf, DB_CAP_ALL)) {
LM_CRIT("database modules does not "
"provide all functions needed\n");
return -1;
}
if(_tps_sanity_checks!=0) {
if(sanity_load_api(&scb)<0) {
LM_ERR("cannot bind to sanity module\n");
goto error;
}
}
if(tps_storage_lock_set_init()<0) {
LM_ERR("failed to initialize locks set\n");
return -1;
}
if(sruid_init(&_tps_sruid, '-', "tpsh", SRUID_INC)<0)
return -1;
sr_event_register_cb(SREV_NET_DATA_IN, tps_msg_received);
sr_event_register_cb(SREV_NET_DATA_OUT, tps_msg_sent);
#ifdef USE_TCP
tcp_set_clone_rcvbuf(1);
#endif
if(sr_wtimer_add(tps_storage_clean, NULL, _tps_clean_interval)<0)
return -1;
return 0;
error:
return -1;
}
int dbg_init_bp_list(void)
{
if(_dbg_bp_list!=NULL)
return -1;
_dbg_bp_list = (dbg_bp_t*)shm_malloc(sizeof(dbg_bp_t));
if(_dbg_bp_list==NULL)
return -1;
memset(_dbg_bp_list, 0, sizeof(dbg_bp_t));
if(_dbg_breakpoint==1)
_dbg_bp_list->set |= DBG_ABKPOINT_ON;
if(_dbg_cfgtrace==1)
_dbg_bp_list->set |= DBG_CFGTRACE_ON;
sr_event_register_cb(SREV_CFG_RUN_ACTION, dbg_cfg_trace);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(msrp_sruid_init()<0) {
LM_ERR("cannot init msrp uid\n");
return -1;
}
if(msrp_cmap_init_rpc()<0)
{
LM_ERR("failed to register cmap RPC commands\n");
return -1;
}
if(msrp_cmap_size>0) {
if(msrp_cmap_size>16)
msrp_cmap_size = 16;
if(msrp_cmap_init(1<<msrp_cmap_size)<0) {
LM_ERR("Cannot init internal cmap\n");
return -1;
}
if(msrp_timer_interval<=0)
msrp_timer_interval = 60;
register_sync_timers(1);
}
sr_event_register_cb(SREV_TCP_MSRP_FRAME, msrp_frame_received);
if(!module_loaded("tls")) {
LM_WARN("\"tls\" module is not loaded. TLS is mandatory for"
" MSRP Relays. To comply with RFC 4976 you must use"
" TLS.\n");
} else {
msrp_tls_module_loaded = 1;
}
return 0;
}
static int mod_init(void)
{
if (sl_load_api(&ws_slb) != 0)
{
LM_ERR("binding to SL\n");
goto error;
}
if (sr_event_register_cb(SREV_TCP_WS_FRAME_IN, ws_frame_receive) != 0)
{
LM_ERR("registering WebSocket receive call-back\n");
goto error;
}
if (sr_event_register_cb(SREV_TCP_WS_FRAME_OUT, ws_frame_transmit) != 0)
{
LM_ERR("registering WebSocket transmit call-back\n");
goto error;
}
if (register_module_stats(exports.name, stats) != 0)
{
LM_ERR("registering core statistics\n");
goto error;
}
if (register_mi_mod(exports.name, mi_cmds) != 0)
{
LM_ERR("registering MI commands\n");
goto error;
}
if (wsconn_init() < 0)
{
LM_ERR("initialising WebSocket connections table\n");
goto error;
}
if (ws_ping_application_data.len < 1
|| ws_ping_application_data.len > 125)
{
ws_ping_application_data.s = DEFAULT_PING_APPLICATION_DATA + 8;
ws_ping_application_data.len =
DEFAULT_PING_APPLICATION_DATA_LEN - 8;
}
if (ws_keepalive_mechanism != KEEPALIVE_MECHANISM_NONE)
{
if (ws_keepalive_timeout < 1 || ws_keepalive_timeout > 3600)
ws_keepalive_timeout = DEFAULT_KEEPALIVE_TIMEOUT;
switch(ws_keepalive_mechanism)
{
case KEEPALIVE_MECHANISM_PING:
case KEEPALIVE_MECHANISM_PONG:
break;
default:
ws_keepalive_mechanism = DEFAULT_KEEPALIVE_MECHANISM;
break;
}
if (ws_keepalive_interval < 1 || ws_keepalive_interval > 60)
ws_keepalive_interval = DEFAULT_KEEPALIVE_INTERVAL;
if (ws_keepalive_processes < 1 || ws_keepalive_processes > 16)
ws_keepalive_processes = DEFAULT_KEEPALIVE_PROCESSES;
/* Add extra process/timer for the keepalive process */
register_sync_timers(ws_keepalive_processes);
}
if (ws_sub_protocols & SUB_PROTOCOL_MSRP
&& !sr_event_enabled(SREV_TCP_MSRP_FRAME))
ws_sub_protocols &= ~SUB_PROTOCOL_MSRP;
if ((ws_sub_protocols & SUB_PROTOCOL_ALL) == 0)
{
LM_ERR("no sub-protocols enabled\n");
goto error;
}
if ((ws_sub_protocols | SUB_PROTOCOL_ALL) != SUB_PROTOCOL_ALL)
{
LM_ERR("unrecognised sub-protocols enabled\n");
goto error;
}
if (ws_cors_mode < 0 || ws_cors_mode > 2)
{
LM_ERR("bad value for cors_mode\n");
goto error;
}
if (cfg_declare("websocket", ws_cfg_def, &default_ws_cfg,
cfg_sizeof(websocket), &ws_cfg))
{
LM_ERR("declaring configuration\n");
return -1;
}
cfg_get(websocket, ws_cfg, keepalive_timeout) = ws_keepalive_timeout;
if (!module_loaded("xhttp"))
{
LM_ERR("\"xhttp\" must be loaded to use WebSocket.\n");
return -1;
}
if (((ws_sub_protocols & SUB_PROTOCOL_SIP) == SUB_PROTOCOL_SIP)
&& !module_loaded("nathelper")
&& !module_loaded("outbound"))
{
LM_WARN("neither \"nathelper\" nor \"outbound\" modules are"
" loaded. At least one of these is required for correct"
" routing of SIP over WebSocket.\n");
}
return 0;
error:
wsconn_destroy();
return -1;
}
/*! \brief Initialize sipcapture module */
static int mod_init(void) {
struct ip_addr *ip = NULL;
#ifdef STATISTICS
/* register statistics */
if (register_module_stats(exports.name, sipcapture_stats)!=0)
{
LM_ERR("failed to register core statistics\n");
return -1;
}
#endif
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(sipcapture_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
db_url.len = strlen(db_url.s);
table_name.len = strlen(table_name.s);
hash_source.len = strlen (hash_source.s);
mt_mode.len = strlen(mt_mode.s);
date_column.len = strlen(date_column.s);
micro_ts_column.len = strlen(micro_ts_column.s);
method_column.len = strlen(method_column.s);
reply_reason_column.len = strlen(reply_reason_column.s);
ruri_column.len = strlen(ruri_column.s);
ruri_user_column.len = strlen(ruri_user_column.s);
from_user_column.len = strlen(from_user_column.s);
from_tag_column.len = strlen(from_tag_column.s);
to_user_column.len = strlen(to_user_column.s);
pid_user_column.len = strlen(pid_user_column.s);
contact_user_column.len = strlen(contact_user_column.s);
auth_user_column.len = strlen(auth_user_column.s);
callid_column.len = strlen(callid_column.s);
via_1_column.len = strlen(via_1_column.s);
via_1_branch_column.len = strlen(via_1_branch_column.s);
cseq_column.len = strlen(cseq_column.s);
diversion_column.len = strlen(diversion_column.s);
reason_column.len = strlen(reason_column.s);
content_type_column.len = strlen(content_type_column.s);
authorization_column.len = strlen(authorization_column.s);
user_agent_column.len = strlen(user_agent_column.s);
source_ip_column.len = strlen(source_ip_column.s);
source_port_column.len = strlen(source_port_column.s);
dest_ip_column.len = strlen(dest_ip_column.s);
dest_port_column.len = strlen(dest_port_column.s);
contact_ip_column.len = strlen(contact_ip_column.s);
contact_port_column.len = strlen(contact_port_column.s);
orig_ip_column.len = strlen(orig_ip_column.s);
orig_port_column.len = strlen(orig_port_column.s);
proto_column.len = strlen(proto_column.s);
family_column.len = strlen(family_column.s);
type_column.len = strlen(type_column.s);
rtp_stat_column.len = strlen(rtp_stat_column.s);
node_column.len = strlen(node_column.s);
msg_column.len = strlen(msg_column.s);
capture_node.len = strlen(capture_node.s);
if(raw_socket_listen.s)
raw_socket_listen.len = strlen(raw_socket_listen.s);
if(raw_interface.s)
raw_interface.len = strlen(raw_interface.s);
/* Find a database module */
if (db_bind_mod(&db_url, &db_funcs))
{
LM_ERR("unable to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(db_funcs, DB_CAP_INSERT))
{
LM_ERR("database modules does not provide all functions needed"
" by module\n");
return -1;
}
/*Check the table name*/
if(!table_name.len) {
LM_ERR("ERROR: sipcapture: mod_init: table_name is not defined or empty\n");
return -1;
}
if (mt_init () <0)
{
return -1;
}
if(db_insert_mode) {
LM_INFO("INFO: sipcapture: mod_init: you have enabled INSERT DELAYED \
Make sure your DB can support it\n");
}
capture_on_flag = (int*)shm_malloc(sizeof(int));
if(capture_on_flag==NULL) {
LM_ERR("no more shm memory left\n");
return -1;
}
*capture_on_flag = capture_on;
/* register DGRAM event */
if(sr_event_register_cb(SREV_NET_DGRAM_IN, hep_msg_received) < 0) {
LM_ERR("failed to register SREV_NET_DGRAM_IN event\n");
return -1;
}
if(ipip_capture_on && moni_capture_on) {
LM_ERR("only one RAW mode is supported. Please disable ipip_capture_on or moni_capture_on\n");
return -1;
}
/* raw processes for IPIP encapsulation */
if (ipip_capture_on || moni_capture_on) {
register_procs(raw_sock_children);
if(extract_host_port() && (((ip=str2ip(&raw_socket_listen)) == NULL)
#ifdef USE_IPV6
&& ((ip=str2ip6(&raw_socket_listen)) == NULL)
#endif
))
{
LM_ERR("sipcapture mod_init: bad RAW IP: %.*s\n", raw_socket_listen.len, raw_socket_listen.s);
return -1;
}
if(moni_capture_on && !moni_port_start) {
LM_ERR("ERROR:sipcapture:mod_init: Please define port/portrange in 'raw_socket_listen', before \
activate monitoring capture\n");
return -1;
}
int register_pkg_proc_stats(void)
{
sr_event_register_cb(SREV_PKG_UPDATE_STATS, pkg_proc_update_stats);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
sip_uri_t puri;
char buri[MAX_URI_SIZE];
_th_eventrt_outgoing = route_lookup(&event_rt, _th_eventrt_name.s);
if(_th_eventrt_outgoing<0
|| event_rt.rlist[_th_eventrt_outgoing]==NULL) {
_th_eventrt_outgoing = -1;
}
if(faked_msg_init()<0) {
LM_ERR("failed to init fmsg\n");
return -1;
}
if(th_sanity_checks!=0)
{
if(sanity_load_api(&scb)<0)
{
LM_ERR("cannot bind to sanity module\n");
goto error;
}
}
if(th_ip.len<=0)
{
LM_ERR("mask IP parameter is invalid\n");
goto error;
}
if(th_ip.len + 32 >= MAX_URI_SIZE) {
LM_ERR("mask address is too long\n");
goto error;
}
memcpy(buri, "sip:", 4);
memcpy(buri+4, th_ip.s, th_ip.len);
buri[th_ip.len+8] = '\0';
if(parse_uri(buri, th_ip.len+4, &puri)<0) {
LM_ERR("mask uri is invalid\n");
goto error;
}
if(check_self(&puri.host, puri.port_no, 0)==1)
{
th_mask_addr_myself = 1;
LM_INFO("mask address matches myself [%.*s]\n",
th_ip.len, th_ip.s);
}
/* 'SIP/2.0/UDP ' + ip + ';' + param + '=' + prefix (+ '\0') */
th_via_prefix.len = 12 + th_ip.len + 1 + th_vparam_name.len + 1
+ th_vparam_prefix.len;
th_via_prefix.s = (char*)pkg_malloc(th_via_prefix.len+1);
if(th_via_prefix.s==NULL)
{
LM_ERR("via prefix parameter is invalid\n");
goto error;
}
/* 'sip:' + ip + ';' + param + '=' + prefix (+ '\0') */
th_uri_prefix.len = 4 + th_ip.len + 1 + th_uparam_name.len + 1
+ th_uparam_prefix.len;
th_uri_prefix.s = (char*)pkg_malloc(th_uri_prefix.len+1);
if(th_uri_prefix.s==NULL)
{
LM_ERR("uri prefix parameter is invalid\n");
goto error;
}
/* build via prefix */
memcpy(th_via_prefix.s, "SIP/2.0/UDP ", 12);
memcpy(th_via_prefix.s+12, th_ip.s, th_ip.len);
th_via_prefix.s[12+th_ip.len] = ';';
memcpy(th_via_prefix.s+12+th_ip.len+1, th_vparam_name.s,
th_vparam_name.len);
th_via_prefix.s[12+th_ip.len+1+th_vparam_name.len] = '=';
memcpy(th_via_prefix.s+12+th_ip.len+1+th_vparam_name.len+1,
th_vparam_prefix.s, th_vparam_prefix.len);
th_via_prefix.s[th_via_prefix.len] = '\0';
LM_DBG("VIA prefix: [%s]\n", th_via_prefix.s);
/* build uri prefix */
memcpy(th_uri_prefix.s, "sip:", 4);
memcpy(th_uri_prefix.s+4, th_ip.s, th_ip.len);
th_uri_prefix.s[4+th_ip.len] = ';';
memcpy(th_uri_prefix.s+4+th_ip.len+1, th_uparam_name.s, th_uparam_name.len);
th_uri_prefix.s[4+th_ip.len+1+th_uparam_name.len] = '=';
memcpy(th_uri_prefix.s+4+th_ip.len+1+th_uparam_name.len+1,
th_uparam_prefix.s, th_uparam_prefix.len);
th_uri_prefix.s[th_uri_prefix.len] = '\0';
LM_DBG("URI prefix: [%s]\n", th_uri_prefix.s);
th_mask_init();
sr_event_register_cb(SREV_NET_DATA_IN, th_msg_received);
sr_event_register_cb(SREV_NET_DATA_OUT, th_msg_sent);
#ifdef USE_TCP
tcp_set_clone_rcvbuf(1);
#endif
return 0;
error:
return -1;
}
int dlg_register_cseq_callbacks(void)
{
sr_event_register_cb(SREV_NET_DATA_IN, dlg_cseq_msg_received);
sr_event_register_cb(SREV_NET_DATA_OUT, dlg_cseq_msg_sent);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(th_sanity_checks!=0)
{
if(sanity_load_api(&scb)<0)
{
LM_ERR("cannot bind to sanity module\n");
goto error;
}
}
th_cookie_name.len = strlen(th_cookie_name.s);
th_ip.len = strlen(th_ip.s);
if(th_ip.len<=0)
{
LM_ERR("mask IP parameter is invalid\n");
goto error;
}
if(check_self(&th_ip, 0, 0)==1)
{
LM_ERR("mask IP must be different than SIP server local IP\n");
goto error;
}
th_uparam_name.len = strlen(th_uparam_name.s);
th_uparam_prefix.len = strlen(th_uparam_prefix.s);
th_vparam_name.len = strlen(th_vparam_name.s);
th_vparam_prefix.len = strlen(th_vparam_prefix.s);
th_callid_prefix.len = strlen(th_callid_prefix.s);
/* 'SIP/2.0/UDP ' + ip + ';' + param + '=' + prefix (+ '\0') */
th_via_prefix.len = 12 + th_ip.len + 1 + th_vparam_name.len + 1
+ th_vparam_prefix.len;
th_via_prefix.s = (char*)pkg_malloc(th_via_prefix.len+1);
if(th_via_prefix.s==NULL)
{
LM_ERR("via prefix parameter is invalid\n");
goto error;
}
/* 'sip:' + ip + ';' + param + '=' + prefix (+ '\0') */
th_uri_prefix.len = 4 + th_ip.len + 1 + th_uparam_name.len + 1
+ th_uparam_prefix.len;
th_uri_prefix.s = (char*)pkg_malloc(th_uri_prefix.len+1);
if(th_uri_prefix.s==NULL)
{
LM_ERR("uri prefix parameter is invalid\n");
goto error;
}
/* build via prefix */
memcpy(th_via_prefix.s, "SIP/2.0/UDP ", 12);
memcpy(th_via_prefix.s+12, th_ip.s, th_ip.len);
th_via_prefix.s[12+th_ip.len] = ';';
memcpy(th_via_prefix.s+12+th_ip.len+1, th_vparam_name.s,
th_vparam_name.len);
th_via_prefix.s[12+th_ip.len+1+th_vparam_name.len] = '=';
memcpy(th_via_prefix.s+12+th_ip.len+1+th_vparam_name.len+1,
th_vparam_prefix.s, th_vparam_prefix.len);
th_via_prefix.s[th_via_prefix.len] = '\0';
LM_DBG("VIA prefix: [%s]\n", th_via_prefix.s);
/* build uri prefix */
memcpy(th_uri_prefix.s, "sip:", 4);
memcpy(th_uri_prefix.s+4, th_ip.s, th_ip.len);
th_uri_prefix.s[4+th_ip.len] = ';';
memcpy(th_uri_prefix.s+4+th_ip.len+1, th_uparam_name.s, th_uparam_name.len);
th_uri_prefix.s[4+th_ip.len+1+th_uparam_name.len] = '=';
memcpy(th_uri_prefix.s+4+th_ip.len+1+th_uparam_name.len+1,
th_uparam_prefix.s, th_uparam_prefix.len);
th_uri_prefix.s[th_uri_prefix.len] = '\0';
LM_DBG("URI prefix: [%s]\n", th_uri_prefix.s);
th_mask_init();
sr_event_register_cb(SREV_NET_DATA_IN, th_msg_received);
sr_event_register_cb(SREV_NET_DATA_OUT, th_msg_sent);
#ifdef USE_TCP
tcp_set_clone_rcvbuf(1);
#endif
return 0;
error:
return -1;
}
/*! \brief Initialize siptrace module */
static int mod_init(void)
{
pv_spec_t avp_spec;
sl_cbelem_t slcb;
#ifdef STATISTICS
/* register statistics */
if (register_module_stats(exports.name, siptrace_stats)!=0)
{
LM_ERR("failed to register core statistics\n");
return -1;
}
#endif
if(siptrace_init_rpc() != 0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
if (trace_flag<0 || trace_flag>(int)MAX_FLAG)
{
LM_ERR("invalid trace flag %d\n", trace_flag);
return -1;
}
trace_flag = 1<<trace_flag;
trace_to_database_flag = (int*)shm_malloc(sizeof(int));
if(trace_to_database_flag==NULL) {
LM_ERR("no more shm memory left\n");
return -1;
}
*trace_to_database_flag = trace_to_database;
if(hep_version != 1 && hep_version != 2) {
LM_ERR("unsupported version of HEP");
return -1;
}
/* Find a database module if needed */
if(trace_to_database_flag!=NULL && *trace_to_database_flag!=0) {
if (db_bind_mod(&db_url, &db_funcs))
{
LM_ERR("unable to bind database module\n");
return -1;
}
if (trace_to_database_flag && !DB_CAPABILITY(db_funcs, DB_CAP_INSERT))
{
LM_ERR("database modules does not provide all functions needed"
" by module\n");
return -1;
}
}
if(hep_version != 1 && hep_version != 2) {
LM_ERR("unsupported version of HEP");
return -1;
}
trace_on_flag = (int*)shm_malloc(sizeof(int));
if(trace_on_flag==NULL) {
LM_ERR("no more shm memory left\n");
return -1;
}
*trace_on_flag = trace_on;
xheaders_write_flag = (int*)shm_malloc(sizeof(int));
xheaders_read_flag = (int*)shm_malloc(sizeof(int));
if (!(xheaders_write_flag && xheaders_read_flag)) {
LM_ERR("no more shm memory left\n");
return -1;
}
*xheaders_write_flag = xheaders_write;
*xheaders_read_flag = xheaders_read;
/* register callbacks to TM */
if (load_tm_api(&tmb)!=0) {
LM_WARN("can't load tm api. Will not install tm callbacks.\n");
} else if(tmb.register_tmcb( 0, 0, TMCB_REQUEST_IN, trace_onreq_in, 0, 0) <=0) {
LM_ERR("can't register trace_onreq_in\n");
return -1;
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_WARN("cannot bind to SL API. Will not install sl callbacks.\n");
} else {
/* register sl callbacks */
memset(&slcb, 0, sizeof(sl_cbelem_t));
slcb.type = SLCB_REPLY_READY;
slcb.cbf = trace_sl_onreply_out;
if (slb.register_cb(&slcb) != 0) {
LM_ERR("can't register for SLCB_REPLY_READY\n");
return -1;
}
if(trace_sl_acks)
{
slcb.type = SLCB_ACK_FILTERED;
slcb.cbf = trace_sl_ack_in;
if (slb.register_cb(&slcb) != 0) {
LM_ERR("can't register for SLCB_ACK_FILTERED\n");
return -1;
}
}
}
if(dup_uri_str.s!=0)
{
dup_uri = (struct sip_uri *)pkg_malloc(sizeof(struct sip_uri));
if(dup_uri==0)
{
LM_ERR("no more pkg memory left\n");
return -1;
}
memset(dup_uri, 0, sizeof(struct sip_uri));
if(parse_uri(dup_uri_str.s, dup_uri_str.len, dup_uri)<0)
{
LM_ERR("bad dup uri\n");
return -1;
}
}
if(force_send_sock_str.s!=0)
{
force_send_sock_str.len = strlen(force_send_sock_str.s);
force_send_sock_uri = (struct sip_uri *)pkg_malloc(sizeof(struct sip_uri));
if(force_send_sock_uri==0)
{
LM_ERR("no more pkg memory left\n");
return -1;
}
memset(force_send_sock_uri, 0, sizeof(struct sip_uri));
if(parse_uri(force_send_sock_str.s, force_send_sock_str.len, force_send_sock_uri)<0)
{
LM_ERR("bad dup uri\n");
return -1;
}
}
if(traced_user_avp_str.s && traced_user_avp_str.len > 0)
{
if (pv_parse_spec(&traced_user_avp_str, &avp_spec)==0
|| avp_spec.type!=PVT_AVP)
{
LM_ERR("malformed or non AVP %.*s AVP definition\n",
traced_user_avp_str.len, traced_user_avp_str.s);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &traced_user_avp,
&traced_user_avp_type)!=0)
{
LM_ERR("[%.*s] - invalid AVP definition\n",
traced_user_avp_str.len, traced_user_avp_str.s);
return -1;
}
} else {
traced_user_avp.n = 0;
traced_user_avp_type = 0;
}
if(trace_table_avp_str.s && trace_table_avp_str.len > 0)
{
if (pv_parse_spec(&trace_table_avp_str, &avp_spec)==0
|| avp_spec.type!=PVT_AVP)
{
LM_ERR("malformed or non AVP %.*s AVP definition\n",
trace_table_avp_str.len, trace_table_avp_str.s);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &trace_table_avp,
&trace_table_avp_type)!=0)
{
LM_ERR("[%.*s] - invalid AVP definition\n",
trace_table_avp_str.len, trace_table_avp_str.s);
return -1;
}
} else {
trace_table_avp.n = 0;
trace_table_avp_type = 0;
}
if(_siptrace_mode==1) {
sr_event_register_cb(SREV_NET_DATA_RECV, siptrace_net_data_recv);
sr_event_register_cb(SREV_NET_DATA_SEND, siptrace_net_data_send);
}
return 0;
}
