static int mod_init(void)
{
LM_INFO("Call Center module - initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
init_db_url( acc_db_url , 0 /*cannot be null*/);
b2b_scenario.len = strlen(b2b_scenario.s);
/* Load B2BUA API */
if (load_b2b_logic_api( &b2b_api) != 0) {
LM_ERR("Can't load B2B-UA hooks, missing 'b2b_logic' module ?\n");
return -1;
}
if (register_timer( "cc_agents", cc_timer_agents, NULL, 1)<0) {
LM_ERR("failed to register agents timer function\n");
return -1;
}
if (register_timer( "cc_cleanup", cc_timer_cleanup, NULL, 5)<0) {
LM_ERR("failed to register cleaup timer function\n");
return -1;
}
/* main CC data */
data = init_cc_data();
if (data==0) {
LM_CRIT("failed to get shm mem for data\n");
return -1;
}
/* init and open DB connection */
if (init_cc_db( &db_url )!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
if (init_cc_acc_db( &acc_db_url )!=0) {
LM_ERR("failed to initialize the acc DB support\n");
return -1;
}
/* load data */
if ( cc_load_db_data( data )!=0 ) {
LM_CRIT("failed to load callcenter data\n");
return -1;
}
clean_cc_old_data(data);
/* restore calls */
if ( cc_db_restore_calls( data )!=0 ) {
LM_CRIT("failed to load callcenter data\n");
return -1;
}
/* close DB connection */
cc_close_db();
return 0;
}
static int mod_init(void)
{
LM_DBG("initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
user_column.len = strlen(user_column.s);
domain_column.len = strlen(domain_column.s);
sd_user_column.len = strlen(sd_user_column.s);
sd_domain_column.len = strlen(sd_domain_column.s);
new_uri_column.len = strlen(new_uri_column.s);
if (domain_prefix.s)
domain_prefix.len = strlen(domain_prefix.s);
/* Find a database module */
if (db_bind_mod(&db_url, &db_funcs))
{
LM_ERR("failed to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(db_funcs, DB_CAP_QUERY))
{
LM_ERR("Database modules does not "
"provide all functions needed by SPEEDDIAL module\n");
return -1;
}
if (domain_prefix.s && domain_prefix.len > 0) {
dstrip_s.s = domain_prefix.s;
dstrip_s.len = domain_prefix.len;
}
return 0;
}
static int mod_init(void)
{
LM_DBG("Initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
user_column.len = strlen(user_column.s);
domain_column.len = strlen(domain_column.s);
cd_user_column.len = strlen(cd_user_column.s);
cd_domain_column.len = strlen(cd_domain_column.s);
group_id_column.len = strlen(group_id_column.s);
new_uri_column.len = strlen(new_uri_column.s);
/* Find a database module */
if (db_bind_mod(&db_url, &db_functions) == -1) {
LM_ERR("Failed to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(db_functions, DB_CAP_QUERY)) {
LM_ERR("Database modules does not "
"provide all functions needed by closeddial module.\n");
return -1;
}
return 0;
}
/** Module init function */
static int mod_init(void)
{
if(load_uac_auth_api(&uac_auth_api)<0){
LM_ERR("Failed to load uac_auth api\n");
return -1;
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1) {
LM_ERR("can't load tm functions\n");
return -1;
}
if(default_expires<15){
LM_ERR("default_expires to short: [%d]<15\n", default_expires);
return -1;
}
if(timer_interval<10){
LM_ERR("timer_interval to short: [%d]<10\n", timer_interval);
return -1;
}
if(reg_hsize<1 || reg_hsize>20) {
LM_ERR("Wrong hash size: 20<[%d]<1\n", reg_hsize);
}
reg_hsize = 1<<reg_hsize;
if(init_reg_htable()<0) {
LM_ERR("Failed to initialize registrant hash table\n");
return -1;
}
reg_table_name.len = strlen(reg_table_name.s);
registrar_column.len = strlen(registrar_column.s);
proxy_column.len = strlen(proxy_column.s);
aor_column.len = strlen(aor_column.s);
third_party_registrant_column.len =
strlen(third_party_registrant_column.s);
username_column.len = strlen(username_column.s);
password_column.len = strlen(password_column.s);
binding_URI_column.len = strlen(binding_URI_column.s);
binding_params_column.len = strlen(binding_params_column.s);
expiry_column.len = strlen(expiry_column.s);
forced_socket_column.len = strlen(forced_socket_column.s);
init_db_url(db_url , 0 /*cannot be null*/);
if (init_reg_db(&db_url) != 0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
register_timer("uac_reg_check", timer_check, 0,
timer_interval/reg_hsize);
return 0;
}
/**
* Initialises the module, i.e. it binds the necessary API functions
* and registers the fifo commands
*
* @return 0 on success, -1 on failure
*/
static int mod_init(void) {
init_db_url( db_url , 0 /*cannot be null*/);
db_table.len = strlen(db_table.s);
carrier_table.len = strlen(carrier_table.s);
subscriber_table.len = strlen(subscriber_table.s);
id_col.len = strlen(id_col.s);
carrier_col.len = strlen(carrier_col.s);
domain_col.len = strlen(domain_col.s);
scan_prefix_col.len = strlen(scan_prefix_col.s);
flags_col.len = strlen(flags_col.s);
mask_col.len = strlen(mask_col.s);
prob_col.len = strlen(prob_col.s);
rewrite_host_col.len = strlen(rewrite_host_col.s);
strip_col.len = strlen(strip_col.s);
rewrite_prefix_col.len = strlen(rewrite_prefix_col.s);
rewrite_suffix_col.len = strlen(rewrite_suffix_col.s);
comment_col.len = strlen(comment_col.s);
username_col.len = strlen(username_col.s);
subscriber_domain_col.len = strlen(subscriber_domain_col.s);
cr_preferred_carrier_col.len = strlen(cr_preferred_carrier_col.s);
carrier_id_col.len = strlen(carrier_id_col.s);
carrier_name_col.len = strlen(carrier_name_col.s);
failure_id_col.len = strlen(failure_id_col.s);
failure_carrier_col.len = strlen(failure_carrier_col.s);
failure_domain_col.len = strlen(failure_domain_col.s);
failure_scan_prefix_col.len = strlen(failure_scan_prefix_col.s);
failure_host_name_col.len = strlen(failure_host_name_col.s);
failure_reply_code_col.len = strlen(failure_reply_code_col.s);
failure_flags_col.len = strlen(failure_flags_col.s);
failure_mask_col.len = strlen(failure_mask_col.s);
failure_next_domain_col.len = strlen(failure_next_domain_col.s);
failure_comment_col.len = strlen(failure_comment_col.s);
default_tree.len = strlen(default_tree.s);
if (init_route_data(config_source) < 0) {
LM_ERR("could not init route data\n");
return -1;
}
if (prepare_route_tree() == -1) {
LM_ERR("could not prepare route tree\n");
return -1;
}
if(data_main_finalize() < 0) {
return -1;
}
LM_INFO("module initialized, pid [%d]\n", getpid());
return 0;
}
static int mod_init(void)
{
bind_auth_t bind_auth;
LM_INFO("initializing...\n");
init_db_url( db_url , 0 /*cannot be null*/);
user_column.len = strlen(user_column.s);
domain_column.len = strlen(domain_column.s);
pass_column.len = strlen(pass_column.s);
pass_column_2.len = strlen(pass_column_2.s);
/* Find a database module */
if (db_bind_mod(&db_url, &auth_dbf) < 0){
LM_ERR("unable to bind to a database driver\n");
return -1;
}
/* bind to auth module and import the API */
bind_auth = (bind_auth_t)find_export("bind_auth", 0, 0);
if (!bind_auth) {
LM_ERR("unable to find bind_auth function. Check if you load the auth module.\n");
return -2;
}
if (bind_auth(&auth_api) < 0) {
LM_ERR("unable to bind auth module\n");
return -3;
}
/* load SIGNALING API */
if(load_sig_api(&sigb)< 0) {
LM_ERR("can't load signaling functions\n");
return -1;
}
/* process additional list of credentials */
if (parse_aaa_avps( credentials_list, &credentials, &credentials_n)!=0) {
LM_ERR("failed to parse credentials\n");
return -5;
}
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
init_db_url( xcap_db_url , 0 /*cannot be null*/);
xcap_db_table.len = strlen(xcap_db_table.s);
/* binding to mysql module */
if (db_bind_mod(&xcap_db_url, &xcap_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(xcap_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
xcap_db = xcap_dbf.init(&xcap_db_url);
if (!xcap_db)
{
LM_ERR("while connecting to database\n");
return -1;
}
if(db_check_table_version(&xcap_dbf, xcap_db, &xcap_db_table, XCAP_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
curl_global_init(CURL_GLOBAL_ALL);
if(periodical_query)
{
register_timer(query_xcap_update, 0, query_period);
}
if(xcap_db)
xcap_dbf.close(xcap_db);
xcap_db = NULL;
return 0;
}
/*
* module initialization function
*/
static int mod_init(void)
{
LM_DBG("initializing...\n");
init_db_url( db_url , 1 /*can be null*/);
address_table.len = strlen(address_table.s);
ip_col.len = strlen(ip_col.s);
proto_col.len = strlen(proto_col.s);
pattern_col.len = strlen(pattern_col.s);
info_col.len = strlen(info_col.s);
grp_col.len = strlen(grp_col.s);
mask_col.len = strlen(mask_col.s);
port_col.len = strlen(port_col.s);
allow[0].filename = get_pathname(default_allow_file);
allow[0].rules = parse_config_file(allow[0].filename);
if (allow[0].rules) {
LM_DBG("default allow file (%s) parsed\n", allow[0].filename);
} else {
LM_INFO("default allow file (%s) not found => empty rule set\n",
allow[0].filename);
}
deny[0].filename = get_pathname(default_deny_file);
deny[0].rules = parse_config_file(deny[0].filename);
if (deny[0].rules) {
LM_DBG("default deny file (%s) parsed\n", deny[0].filename);
} else {
LM_INFO("default deny file (%s) not found => empty rule set\n",
deny[0].filename);
}
if (init_address() != 0) {
LM_ERR("failed to initialize the allow_address function\n");
return -1;
}
rules_num = 1;
return 0;
}
/*
* set default partition url
*/
int set_default_db_url(modparam_t type, void *val)
{
str db_str;
db_str.s = (char *)val;
db_str.len = strlen(db_str.s);
str_trim_spaces_lr(db_str);
if (default_partition == NULL)
if (alloc_default_partition() == NULL)
goto out_nomem;
default_partition->url.s = (char *)val;
init_db_url( default_partition->url, 1 /* can be null */);
return 0;
out_nomem:
LM_ERR("no more memory!\n");
return -1;
}
/* initialize function */
static int mod_init(void)
{
LM_INFO("Cluster-Info - initializing\n");
/* check the module params */
init_db_url(clusterer_db_url, 0 /*cannot be null*/);
if (server_id < 1) {
LM_ERR("invalid machine id\n");
return -1;
}
if (persistent_state < 0 || persistent_state > 1) {
LM_WARN("invalid value for persistent state - presistence disabled\n");
persistent_state = 0;
}
db_table.len = strlen(db_table.s);
cluster_id_col.len = strlen(cluster_id_col.s);
machine_id_col.len = strlen(machine_id_col.s);
id_col.len = strlen(id_col.s);
state_col.len = strlen(state_col.s);
url_col.len = strlen(url_col.s);
description_col.len = strlen(description_col.s);
last_attempt_col.len = strlen(last_attempt_col.s);
duration_col.len = strlen(duration_col.s);
failed_attempts_col.len = strlen(failed_attempts_col.s);
no_tries_col.len = strlen(no_tries_col.s);
/* create & init lock */
if ((ref_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
goto error;
}
/* data pointer in shm */
tdata = shm_malloc(sizeof *tdata);
if (!tdata) {
LM_CRIT("failed to get shm mem for data ptr\n");
goto error;
}
*tdata = NULL;
/* bind to the mysql module */
if (db_bind_mod(&clusterer_db_url, &dr_dbf)) {
LM_CRIT("cannot bind to database module! "
"Did you forget to load a database module ?\n");
goto error;
}
if (!DB_CAPABILITY(dr_dbf, DB_CAP)) {
LM_CRIT("given SQL DB does not provide query types needed by this module!\n");
goto error;
}
/* register timer */
if (persistent_state) {
/* register function to flush changes in state */
if (register_timer("update database", update_db_handler,
NULL, prob_interval, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("unable to synchronize with the database\n");
goto error;
}
}
if (register_timer("update servers", update_nodes_handler,
NULL, prob_interval, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("unable to update status for incoming clients\n");
goto error;
}
/* everything is OK */
return 0;
error:
if (ref_lock) {
lock_destroy_rw(ref_lock);
ref_lock = 0;
}
if (tdata) {
shm_free(tdata);
tdata = 0;
}
return -1;
}
static int mod_init(void)
{
str proto_url;
int checkver=-1;
db_func_t db_funcs;
db_con_t *db_conn = NULL;
LM_DBG("initializing\n");
init_db_url( db_url , 1 /*can be null*/);
if (db_url.s) {
if (db_url.len == 0) {
if (use_uri_table != 0) {
LM_ERR("configuration error - no database URL, "
"but use_uri_table is set!\n");
return -1;
}
return 0;
}
if (db_table.s == NULL) {
/* no table set -> use defaults */
if (use_uri_table != 0){
db_table.s = URI_TABLE;
}
else {
db_table.s = SUBSCRIBER_TABLE;
}
}
db_table.len = strlen(db_table.s);
uridb_user_col.len = strlen(uridb_user_col.s);
uridb_domain_col.len = strlen(uridb_domain_col.s);
uridb_uriuser_col.len = strlen(uridb_uriuser_col.s);
if ( db_bind_mod(&db_url, &db_funcs) != 0 ) {
LM_ERR("No database module found\n");
return -1;
}
db_conn = db_funcs.init(&db_url);
if( db_conn == NULL ) {
LM_ERR("Could not connect to database\n");
return -1;
}
checkver = db_check_table_version( &db_funcs, db_conn, &db_table,
use_uri_table?URI_TABLE_VERSION:SUBSCRIBER_TABLE_VERSION );
/** If checkver == -1, table validation failed */
if( checkver == -1 ) {
LM_ERR("Invalid table version.\n");
db_funcs.close(db_conn);
return -1;
}
db_funcs.close(db_conn);
/* done with checkings - init the working connection */
if (uridb_db_bind(&db_url)!=0) {
LM_ERR("Failed to bind to a DB module\n");
return -1;
}
}
if (aaa_proto_url) {
memset(attrs, 0, sizeof(attrs));
memset(vals, 0, sizeof(vals));
attrs[A_SERVICE_TYPE].name = "Service-Type";
attrs[A_USER_NAME].name = "User-Name";
if (use_sip_uri_host)
attrs[A_SIP_URI_HOST].name = "SIP-URI-Host";
attrs[A_SIP_AVP].name = "SIP-AVP";
attrs[A_ACCT_SESSION_ID].name = "Acct-Session-Id";
vals[V_CALL_CHECK].name = "Call-Check";
proto_url.s = aaa_proto_url;
proto_url.len = strlen(aaa_proto_url);
if(aaa_prot_bind(&proto_url, &proto)) {
LM_ERR("aaa protocol bind failure\n");
return -1;
}
conn = proto.init_prot(&proto_url);
if (!conn) {
LM_ERR("aaa protocol initialization failure\n");
return -2;
}
INIT_AV(proto, conn, attrs, A_MAX, vals, V_MAX, "uri", -3, -4);
if (service_type != -1)
vals[V_CALL_CHECK].value = service_type;
}
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
load_tm_f load_tm;
LM_DBG("...\n");
if(min_expires< 0)
min_expires= 0;
if(default_expires< 600)
default_expires= 3600;
/* import the TM auto-loading function */
if((load_tm=(load_tm_f)find_export("load_tm", 0, 0))==NULL)
{
LM_ERR("can't import load_tm\n");
return -1;
}
/* let the auto-loading function load all TM stuff */
if(load_tm(&tmb)==-1)
{
LM_ERR("can't load tm functions\n");
return -1;
}
init_db_url( db_url , 0 /*cannot be null*/);
db_table.len = strlen(db_table.s);
/* binding to database module */
if (db_bind_mod(&db_url, &pua_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pua_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions needed"
" by the module\n");
return -1;
}
pua_db = pua_dbf.init(&db_url);
if (!pua_db)
{
LM_ERR("while connecting database\n");
return -1;
}
/* verify table version */
if(db_check_table_version(&pua_dbf, pua_db, &db_table, PUA_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
if(HASH_SIZE<=1)
HASH_SIZE= 512;
else
HASH_SIZE = 1<<HASH_SIZE;
HashT= new_htable();
if(HashT== NULL)
{
LM_ERR("while creating new hash table\n");
return -1;
}
if(db_restore()< 0)
{
LM_ERR("while restoring hash_table\n");
return -1;
}
if(update_period<=0)
{
LM_ERR("wrong clean_period\n");
return -1;
}
if ( init_puacb_list() < 0)
{
LM_ERR("callbacks initialization failed\n");
return -1;
}
pua_evlist= init_pua_evlist();
if(pua_evlist==0)
{
LM_ERR("when initializing pua_evlist\n");
return -1;
}
if(pua_add_events()< 0)
{
LM_ERR("while adding events\n");
return -1;
}
register_timer("pua_clean", hashT_clean, 0, update_period-5,
TIMER_FLAG_DELAY_ON_DELAY);
register_timer("pua_dbupdate", db_update, 0, update_period,
TIMER_FLAG_SKIP_ON_DELAY);
if(pua_db)
pua_dbf.close(pua_db);
pua_db = NULL;
return 0;
}
/** Module init function */
static int mod_init(void)
{
unsigned int i;
LM_DBG("start\n");
init_db_url( db_url , 0 /*cannot be null*/);
/* load tm api */
if(load_tm_api(&tmb)==-1)
{
LM_ERR("can't load tm functions\n");
return -1;
}
/* load pua api */
if(load_pua_api(&pua_api) < 0)
{
LM_ERR("Can't bind pua\n");
return -1;
}
/* add event in pua module */
if(pua_api.add_event(CALLINFO_EVENT, "call-info", NULL, 0) < 0) {
LM_ERR("failed to add 'call-info' event to pua module\n");
return -1;
}
/* load b2b_logic api */
if(load_b2b_logic_api(&b2bl_api)< 0)
{
LM_ERR("Failed to load b2b_logic api\n");
return -1;
}
if(b2b_sca_hsize<1 || b2b_sca_hsize>20)
{
LM_ERR("Wrong hash size. Needs to be greater than 1"
" and smaller than 20. Be aware that you should set the log 2"
" value of the real size\n");
return -1;
}
b2b_sca_hsize = 1<<b2b_sca_hsize;
if(presence_server.s)
presence_server.len = strlen(presence_server.s);
LM_DBG("fix db columns\n");
sca_table_name.len = strlen(sca_table_name.s);
shared_line_column.len = strlen(shared_line_column.s);
watchers_column.len = strlen(watchers_column.s);
for (i=0; i<MAX_APPEARANCE_INDEX; i++) {
app_shared_entity_column[i].len = strlen(app_shared_entity_column[i].s);
app_call_state_column[i].len = strlen(app_call_state_column[i].s);
app_call_info_uri_column[i].len = strlen(app_call_info_uri_column[i].s);
app_call_info_appearance_uri_column[i].len =
strlen(app_call_info_appearance_uri_column[i].s);
app_b2bl_key_column[i].len = strlen(app_b2bl_key_column[i].s);
}
LM_DBG("fix AVP spec\n");
/* fix AVP spec */
if(watchers_avp_spec.s)
{
watchers_avp_spec.len = strlen(watchers_avp_spec.s);
if(pv_parse_spec(&watchers_avp_spec, &watchers_spec)==NULL ||
watchers_spec.type != PVT_AVP)
{
LM_ERR("failed to parse watchers spec [%.*s]\n",
watchers_avp_spec.len, watchers_avp_spec.s);
return E_CFG;
}
if(pv_get_avp_name(NULL, &(watchers_spec.pvp), &(watchers_avp_name),
&(watchers_avp_type) )!=0)
{
LM_ERR("[%.*s]- invalid AVP definition for watchers_avp_spec\n",
watchers_avp_spec.len, watchers_avp_spec.s);
}
} else {
watchers_avp_name = -1;
watchers_avp_type = 0;
}
if(shared_line_spec_param.s)
{
shared_line_spec_param.len = strlen(shared_line_spec_param.s);
if(pv_parse_spec(&shared_line_spec_param, &shared_line_spec)==NULL)
{
LM_ERR("failed to parse shared_line spec\n");
return E_CFG;
}
switch(shared_line_spec.type) {
case PVT_NONE:
case PVT_EMPTY:
case PVT_NULL:
case PVT_MARKER:
case PVT_COLOR:
LM_ERR("invalid shared_line spec\n");
return -3;
default: ;
}
}
if(appearance_name_addr_spec_param.s)
{
appearance_name_addr_spec_param.len = strlen(appearance_name_addr_spec_param.s);
if(pv_parse_spec(&appearance_name_addr_spec_param, &appearance_name_addr_spec)==NULL)
{
LM_ERR("failed to parse appearance_name_addr spec\n");
return E_CFG;
}
switch(appearance_name_addr_spec.type) {
case PVT_NONE:
case PVT_EMPTY:
case PVT_NULL:
case PVT_MARKER:
case PVT_COLOR:
LM_ERR("invalid appearance_name_addr spec\n");
return -3;
default: ;
}
}
if(init_b2b_sca_htable() < 0) {
LM_ERR("Failed to initialize b2b_sca hash table\n");
return -1;
}
if (sca_db_mode==DB_MODE_NONE) {
db_url.s = NULL; db_url.len = 0;
} else {
if (sca_db_mode!=DB_MODE_REALTIME) {
LM_ERR("unsupported db_mode %d\n", sca_db_mode);
return -1;
}
if ( !db_url.s || db_url.len==0 ) {
LM_ERR("db_url not configured for db_mode %d\n", sca_db_mode);
return -1;
}
if (init_sca_db(&db_url, b2b_sca_hsize)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
}
return 0;
}
static int mod_init(void)
{
LM_INFO("Load-Balancer module - initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
/* Load dialog API */
if (load_dlg_api(&lb_dlg_binds) != 0) {
LM_ERR("Can't load dialog hooks\n");
return -1;
}
if (fetch_freeswitch_stats) {
if (load_fs_api(&fs_api) == -1) {
LM_ERR("failed to load the FS API!\n");
return -1;
}
}
/* data pointer in shm */
curr_data = (struct lb_data**)shm_malloc( sizeof(struct lb_data*) );
if (curr_data==0) {
LM_CRIT("failed to get shm mem for data ptr\n");
return -1;
}
*curr_data = 0;
/* create & init lock */
if ((ref_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
return -1;
}
if (init_lb_bls()) {
LM_ERR("BL INIT failed\n");
return -1;
}
/* init and open DB connection */
if (init_lb_db(&db_url, table_name)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
/* load data */
if ( lb_reload_data()!=0 ) {
LM_CRIT("failed to load load-balancing data\n");
return -1;
}
/* close DB connection */
lb_close_db();
/* arm a function for probing */
if (lb_prob_interval) {
/* load TM API */
if (load_tm_api(&lb_tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* probing method */
lb_probe_method.len = strlen(lb_probe_method.s);
lb_probe_from.len = strlen(lb_probe_from.s);
if (lb_probe_replies.s)
lb_probe_replies.len = strlen(lb_probe_replies.s);
/* register pinger function */
if (register_timer( "lb-pinger", lb_prob_handler , NULL,
lb_prob_interval, TIMER_FLAG_DELAY_ON_DELAY)<0) {
LM_ERR("failed to register probing handler\n");
return -1;
}
/* Register the max load recalculation timer */
if (fetch_freeswitch_stats &&
register_timer("lb-update-max-load", lb_update_max_loads, NULL,
fs_api.stats_update_interval, TIMER_FLAG_SKIP_ON_DELAY)<0) {
LM_ERR("failed to register timer for max load recalc!\n");
return -1;
}
if (lb_probe_replies.s) {
lb_probe_replies.len = strlen(lb_probe_replies.s);
if(parse_reply_codes( &lb_probe_replies, &probing_reply_codes,
&probing_codes_no )< 0) {
LM_ERR("Bad format for options_reply_code parameter"
" - Need a code list separated by commas\n");
return -1;
}
}
}
/* parse avps */
if (parse_avp_spec(&group_avp_name_s, &group_avp_name)) {
LM_ERR("cannot parse group avp\n");
return -1;
}
if (parse_avp_spec(&flags_avp_name_s, &flags_avp_name)) {
LM_ERR("cannot parse flags avp\n");
return -1;
}
if (parse_avp_spec(&mask_avp_name_s, &mask_avp_name)) {
LM_ERR("cannot parse mask avp\n");
return -1;
}
if (parse_avp_spec(&id_avp_name_s, &id_avp_name)) {
LM_ERR("cannot parse id avp\n");
return -1;
}
if (parse_avp_spec(&res_avp_name_s, &res_avp_name)) {
LM_ERR("cannot parse resources avp\n");
return -1;
}
if (lb_init_event() < 0) {
LM_ERR("cannot init event\n");
return -1;
}
if (lb_repl_cluster < 0) {
LM_ERR("Invalid replication_cluster, must be 0 or "
"a positive cluster id\n");
return -1;
}
if (lb_repl_cluster && load_clusterer_api(&clusterer_api)!=0) {
LM_DBG("failed to find clusterer API - is clusterer module loaded?\n");
return -1;
}
/* register handler for processing load_balancer replication packets to the clusterer module */
if (lb_repl_cluster > 0 &&
clusterer_api.register_capability(&status_repl_cap,
receive_lb_binary_packet, NULL, lb_repl_cluster, 0, NODE_CMP_ANY) < 0) {
LM_ERR("cannot register binary packet callback to clusterer module!\n");
return -1;
}
return 0;
}
static int mod_init( void )
{
LM_INFO("initializing...\n");
init_db_url(db_url, 1 /* can be null */);
db_table_acc.len = strlen(db_table_acc.s);
db_table_mc.len = strlen(db_table_mc.s);
acc_method_col.len = strlen(acc_method_col.s);
acc_fromtag_col.len = strlen(acc_fromtag_col.s);
acc_totag_col.len = strlen(acc_totag_col.s);
acc_callid_col.len = strlen(acc_callid_col.s);
acc_sipcode_col.len = strlen(acc_sipcode_col.s);
acc_sipreason_col.len = strlen(acc_sipreason_col.s);
acc_time_col.len = strlen(acc_time_col.s);
acc_created_avp_name.len = strlen(acc_created_avp_name.s);
if (log_facility_str) {
int tmp = str2facility(log_facility_str);
if (tmp != -1)
acc_log_facility = tmp;
else {
LM_ERR("invalid log facility configured\n");
return -1;
}
}
/* load the TM API */
if (load_tm_api(&tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* if detect_direction is enabled, load rr also */
if (detect_direction) {
if (load_rr_api(&rrb)!=0) {
LM_ERR("can't load RR API\n");
return -1;
}
/* we need the append_fromtag on in RR */
if (!rrb.append_fromtag) {
LM_ERR("'append_fromtag' RR param is not enabled!"
" - required by 'detect_direction'\n");
return -1;
}
}
/* init the extra engine */
init_acc_extra();
/* ----------- SYSLOG INIT SECTION ----------- */
acc_log_init();
/* ----------- DATABASE INIT SECTION ----------- */
if (db_url.s) {
if (acc_db_init(&db_url)<0){
LM_ERR("failed! bad db url / missing db module ?\n");
return -1;
}
} else {
if (db_extra_tags || db_leg_tags) {
LM_ERR("DB leg and/or extra fields defined but no DB url!\n");
return -1;
}
}
/* ------------ AAA PROTOCOL INIT SECTION ----------- */
if (aaa_proto_url && aaa_proto_url[0]) {
if (init_acc_aaa(aaa_proto_url, service_type)!=0 ) {
LM_ERR("failed to init radius\n");
return -1;
}
} else {
if (aaa_extra_tags || aaa_leg_tags) {
LM_ERR("AAA leg and/or extra fields defined but no AAA url!\n");
return -1;
}
aaa_proto_url = NULL;
}
/* ----------- EVENT INTERFACE INIT SECTION ----------- */
if (init_acc_evi() < 0) {
LM_ERR("cannot init acc events\n");
return -1;
}
acc_flags_ctx_idx = context_register_ptr(CONTEXT_GLOBAL, unref_acc_ctx);
acc_tm_flags_ctx_idx = tmb.t_ctx_register_ptr(unref_acc_ctx);
return 0;
}
/************************** FIXUP functions ****************************/
static int fixup_init_dburl(void **param)
{
if (!db_url.s || db_url.len == 0)
init_db_url(db_url, 1 /* can be null */);
return 0;
}
static int mod_init(void)
{
LM_INFO("initializing module...\n");
init_db_url( dp_db_url , 0 /*cannot be null*/);
dp_table_name.len = strlen(dp_table_name.s);
dpid_column.len = strlen( dpid_column.s);
pr_column.len = strlen(pr_column.s);
match_op_column.len = strlen(match_op_column.s);
match_exp_column.len= strlen(match_exp_column.s);
match_len_column.len= strlen(match_len_column.s);
subst_exp_column.len= strlen(subst_exp_column.s);
repl_exp_column.len = strlen(repl_exp_column.s);
attrs_column.len = strlen(attrs_column.s);
disabled_column.len = strlen(disabled_column.s);
if(attr_pvar_s.s) {
attr_pvar = (pv_spec_t *)shm_malloc(sizeof(pv_spec_t));
if(!attr_pvar){
LM_ERR("out of shm memory\n");
return -1;
}
attr_pvar_s.len = strlen(attr_pvar_s.s);
if (pv_parse_spec(&attr_pvar_s, attr_pvar)==NULL) {
LM_ERR("invalid pvar name\n");
return E_CFG;
}
if ( attr_pvar->type==PVT_NULL || attr_pvar->type==PVT_EMPTY
|| attr_pvar->type==PVT_NONE ) {
LM_ERR("NULL/EMPTY Parameter TYPE for ATTR PVAR\n");\
return E_CFG;
}
if (attr_pvar->setf==NULL) {
LM_ERR("the ATTR PVAR is read-only!!\n");
return E_CFG;
}
}
default_par2 = (dp_param_p)shm_malloc(sizeof(dp_param_t));
if(default_par2 == NULL){
LM_ERR("no shm more memory\n");
return -1;
}
memset(default_par2, 0, sizeof(dp_param_t));
default_param_s.len = strlen(default_param_s.s);
if (pv_parse_spec( &default_param_s, &default_par2->v.sp[0])==NULL) {
LM_ERR("input pv is invalid\n");
return -1;
}
default_param_s.len = strlen(default_param_s.s);
if (pv_parse_spec( &default_param_s, &default_par2->v.sp[1])==NULL) {
LM_ERR("output pv is invalid\n");
return -1;
}
/* create & init lock */
if ((ref_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
return -1;
}
if(init_data() != 0) {
LM_ERR("could not initialize data\n");
return -1;
}
return 0;
}
static int cpl_init(void)
{
bind_usrloc_t bind_usrloc;
struct stat stat_t;
char *ptr;
int val;
init_db_url( db_url , 0 /*cannot be null*/);
db_table.len = strlen(db_table.s);
LM_INFO("initializing...\n");
if (proxy_route && proxy_route[0]) {
cpl_env.proxy_route = get_script_route_ID_by_name( proxy_route,
rlist, RT_NO);
if (cpl_env.proxy_route==-1) {
LM_ERR("route <%s> does not exist\n",proxy_route);
return -1;
}
}
if (cpl_env.proxy_recurse>MAX_PROXY_RECURSE) {
LM_CRIT("value of proxy_recurse param (%d) exceeds "
"the maximum safety value (%d)\n",
cpl_env.proxy_recurse,MAX_PROXY_RECURSE);
goto error;
}
if (dtd_file==0) {
LM_CRIT("mandatory parameter \"cpl_dtd_file\" found empty\n");
goto error;
} else {
/* check if the dtd file exists */
if (stat( dtd_file, &stat_t)==-1) {
LM_ERR("checking file \"%s\" status failed; stat returned %s\n",
dtd_file,strerror(errno));
goto error;
}
if ( !S_ISREG( stat_t.st_mode ) ) {
LM_ERR("dir \"%s\" is not a regular file!\n", dtd_file);
goto error;
}
if (access( dtd_file, R_OK )==-1) {
LM_ERR("checking file \"%s\" for permissions "
"failed; access returned %s\n",dtd_file,strerror(errno));
goto error;
}
}
if (cpl_env.log_dir==0) {
LM_INFO("log_dir param found empty -> logging disabled!\n");
} else {
if ( strlen(cpl_env.log_dir)>MAX_LOG_DIR_SIZE ) {
LM_ERR("dir \"%s\" has a too long name :-(!\n", cpl_env.log_dir);
goto error;
}
/* check if the dir exists */
if (stat( cpl_env.log_dir, &stat_t)==-1) {
LM_ERR("checking dir \"%s\" status failed;"
" stat returned %s\n",cpl_env.log_dir,strerror(errno));
goto error;
}
if ( !S_ISDIR( stat_t.st_mode ) ) {
LM_ERR("dir \"%s\" is not a directory!\n", cpl_env.log_dir);
goto error;
}
if (access( cpl_env.log_dir, R_OK|W_OK )==-1) {
LM_ERR("checking dir \"%s\" for permissions failed; access "
"returned %s\n", cpl_env.log_dir, strerror(errno));
goto error;
}
}
/* bind to the mysql module */
if (cpl_db_bind(&db_url, &db_table)<0) goto error;
/* load TM API */
if (load_tm_api(&cpl_fct.tmb)!=0) {
LM_ERR("can't load TM API\n");
goto error;
}
/* load SIGNALING API */
if(load_sig_api(&cpl_fct.sigb)< 0) {
LM_ERR("can't load signaling functions\n");
return -1;
}
/* bind to usrloc module if requested */
if (lookup_domain) {
/* import all usrloc functions */
bind_usrloc = (bind_usrloc_t)find_export("ul_bind_usrloc", 1, 0);
if (!bind_usrloc) {
LM_ERR("can't bind usrloc\n");
goto error;
}
if (bind_usrloc( &(cpl_fct.ulb) ) < 0) {
LM_ERR("importing usrloc failed\n");
goto error;
}
/* convert lookup_domain from char* to udomain_t* pointer */
if (cpl_fct.ulb.register_udomain( lookup_domain, &cpl_env.lu_domain)
< 0) {
LM_ERR("failed to register domain <%s>\n",lookup_domain);
goto error;
}
} else {
LM_NOTICE("no lookup_domain given -> disable lookup node\n");
}
/* build a pipe for sending commands to aux process */
if ( pipe( cpl_env.cmd_pipe )==-1 ) {
LM_CRIT("cannot create command pipe: %s!\n", strerror(errno) );
goto error;
}
/* set the writing non blocking */
if ( (val=fcntl(cpl_env.cmd_pipe[1], F_GETFL, 0))<0 ) {
LM_ERR("getting flags from pipe[1] failed: fcntl said %s!\n",
strerror(errno));
goto error;
}
if ( fcntl(cpl_env.cmd_pipe[1], F_SETFL, val|O_NONBLOCK) ) {
LM_ERR("setting flags to pipe[1] failed: fcntl said %s!\n",
strerror(errno));
goto error;
}
/* init the CPL parser */
if (init_CPL_parser( dtd_file )!=1 ) {
LM_ERR("init_CPL_parser failed!\n");
goto error;
}
/* make a copy of the original TZ env. variable */
ptr = getenv("TZ");
cpl_env.orig_tz.len = 3/*"TZ="*/ + (ptr?(strlen(ptr)+1):0);
if ( (cpl_env.orig_tz.s=shm_malloc( cpl_env.orig_tz.len ))==0 ) {
LM_ERR("no more shm mem. for saving TZ!\n");
goto error;
}
memcpy(cpl_env.orig_tz.s,"TZ=",3);
if (ptr)
strcpy(cpl_env.orig_tz.s+3,ptr);
/* convert realm_prefix from string null terminated to str */
if (cpl_env.realm_prefix.s) {
cpl_env.realm_prefix.len = strlen(cpl_env.realm_prefix.s);
/* convert the realm_prefix to lower cases */
strlower( &cpl_env.realm_prefix );
}
return 0;
error:
return -1;
}
static int mod_init(void)
{
str def_str = str_init(DEFAULT_PARTITION);
dp_head_p el = dp_get_head(def_str);
LM_INFO("initializing module...\n");
init_db_url( default_dp_db_url , 0 /*can be null*/);
dpid_column.len = strlen(dpid_column.s);
pr_column.len = strlen(pr_column.s);
match_op_column.len = strlen(match_op_column.s);
match_exp_column.len = strlen(match_exp_column.s);
match_flags_column.len = strlen(match_flags_column.s);
subst_exp_column.len = strlen(subst_exp_column.s);
repl_exp_column.len = strlen(repl_exp_column.s);
attrs_column.len = strlen(attrs_column.s);
timerec_column.len = strlen(timerec_column.s);
disabled_column.len = strlen(disabled_column.s);
if (default_dp_db_url.s) {
default_dp_db_url.len = strlen(default_dp_db_url.s);
if (!el) {
default_dp_partition.len = sizeof(DEFAULT_PARTITION) - 1;
default_dp_partition.s = pkg_malloc(default_dp_partition.len);
if (!default_dp_partition.s) {
LM_ERR("No more pkg memory\n");
return -1;
}
memcpy(default_dp_partition.s, DEFAULT_PARTITION,
default_dp_partition.len);
} else {
default_dp_partition.s = el->partition.s;
default_dp_partition.len = el->partition.len;
}
dp_head_insert( DP_TYPE_URL, &default_dp_db_url,
&default_dp_partition);
}
if (default_dp_table.s) {
if (!default_dp_partition.s) {
if (!el) {
LM_ERR("DB URL not defined for default partition!\n");
return -1;
} else {
default_dp_partition.s = el->partition.s;
default_dp_partition.len = el->partition.len;
}
}
default_dp_table.len = strlen(default_dp_table.s);
dp_head_insert( DP_TYPE_TABLE, &default_dp_table,
&default_dp_partition);
}
el = dp_hlist;
for (el = dp_hlist; el ; el = el->next) {
//db_url must be set
if (!el->dp_db_url.s) {
LM_ERR("DB URL is not defined for partition %.*s!\n",
el->partition.len,el->partition.s);
return -1;
}
if (!el->dp_table_name.s) {
el->dp_table_name.len = sizeof(DP_TABLE_NAME) - 1;
el->dp_table_name.s = pkg_malloc(el->dp_table_name.len);
if(!el->dp_table_name.s){
LM_ERR("No more pkg mem\n");
return -1;
}
memcpy(el->dp_table_name.s, DP_TABLE_NAME,
el->dp_table_name.len);
}
}
default_par2 = (dp_param_p)shm_malloc(sizeof(dp_param_t));
if(default_par2 == NULL){
LM_ERR("no shm more memory\n");
return -1;
}
memset(default_par2, 0, sizeof(dp_param_t));
default_param_s.len = strlen(default_param_s.s);
if (pv_parse_spec( &default_param_s, &default_par2->v.sp[0])==NULL) {
LM_ERR("input pv is invalid\n");
return -1;
}
default_param_s.len = strlen(default_param_s.s);
if (pv_parse_spec( &default_param_s, &default_par2->v.sp[1])==NULL) {
LM_ERR("output pv is invalid\n");
return -1;
}
dp_print_list();
if(init_data() != 0) {
LM_ERR("could not initialize data\n");
return -1;
}
return 0;
#undef init_db_url_part
}
static int mod_init(void)
{
LM_INFO("Load-Balancer module - initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
/* Load dialog API */
if (load_dlg_api(&lb_dlg_binds) != 0) {
LM_ERR("Can't load dialog hooks");
return -1;
}
/* data pointer in shm */
curr_data = (struct lb_data**)shm_malloc( sizeof(struct lb_data*) );
if (curr_data==0) {
LM_CRIT("failed to get shm mem for data ptr\n");
return -1;
}
*curr_data = 0;
/* create & init lock */
if ((ref_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
return -1;
}
if (init_lb_bls()) {
LM_ERR("BL INIT failed\n");
return -1;
}
/* init and open DB connection */
if (init_lb_db(&db_url, table_name)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
/* load data */
if ( lb_reload_data()!=0 ) {
LM_CRIT("failed to load load-balancing data\n");
return -1;
}
/* close DB connection */
lb_close_db();
/* arm a function for probing */
if (lb_prob_interval) {
/* load TM API */
if (load_tm_api(&lb_tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* probing method */
lb_probe_method.len = strlen(lb_probe_method.s);
lb_probe_from.len = strlen(lb_probe_from.s);
if (lb_probe_replies.s)
lb_probe_replies.len = strlen(lb_probe_replies.s);
/* register pinger function */
if (register_timer( "lb-pinger", lb_prob_handler , NULL,
lb_prob_interval)<0) {
LM_ERR("failed to register probing handler\n");
return -1;
}
if (lb_probe_replies.s) {
lb_probe_replies.len = strlen(lb_probe_replies.s);
if(parse_reply_codes( &lb_probe_replies, &probing_reply_codes,
&probing_codes_no )< 0) {
LM_ERR("Bad format for options_reply_code parameter"
" - Need a code list separated by commas\n");
return -1;
}
}
}
/* parse avps */
if (parse_avp_spec(&grp_avp_name_s, &grp_avp_name)) {
LM_ERR("cannot parse group avp\n");
return -1;
}
if (parse_avp_spec(&mask_avp_name_s, &mask_avp_name)) {
LM_ERR("cannot parse mask avp\n");
return -1;
}
if (parse_avp_spec(&id_avp_name_s, &id_avp_name)) {
LM_ERR("cannot parse id avp\n");
return -1;
}
return 0;
}
static int mod_init(void)
{
int heartbeats_timer_interval;
cluster_info_t *cl;
LM_INFO("Clusterer module - initializing\n");
db_table.len = strlen(db_table.s);
id_col.len = strlen(id_col.s);
cluster_id_col.len = strlen(cluster_id_col.s);
node_id_col.len = strlen(node_id_col.s);
url_col.len = strlen(url_col.s);
state_col.len = strlen(state_col.s);
no_ping_retries_col.len = strlen(no_ping_retries_col.s);
priority_col.len = strlen(priority_col.s);
sip_addr_col.len = strlen(sip_addr_col.s);
flags_col.len = strlen(flags_col.s);
description_col.len = strlen(description_col.s);
/* only allow the DB URL to be skipped in "P2P discovery" mode */
init_db_url(clusterer_db_url, db_mode == 0);
if (current_id < 1) {
LM_CRIT("Invalid 'my_node_id' parameter\n");
return -1;
}
if (ping_interval <= 0) {
LM_WARN("Invalid ping_interval parameter, using default value\n");
ping_interval = DEFAULT_PING_INTERVAL;
}
if (node_timeout < 0) {
LM_WARN("Invalid node_timeout parameter, using default value\n");
node_timeout = DEFAULT_NODE_TIMEOUT;
}
if (ping_timeout <= 0) {
LM_WARN("Invalid ping_timeout parameter, using default value\n");
ping_timeout = DEFAULT_PING_TIMEOUT;
}
/* create & init lock */
if ((cl_list_lock = lock_init_rw()) == NULL) {
LM_CRIT("Failed to init lock\n");
return -1;
}
/* data pointer in shm */
if (cluster_list == NULL) {
cluster_list = shm_malloc(sizeof *cluster_list);
if (!cluster_list) {
LM_CRIT("No more shm memory\n");
goto error;
}
*cluster_list = NULL;
} else {
/* sanity check of my_node_id if node_id also set in a my_node_info param */
for (cl = *cluster_list; cl; cl = cl->next)
if (cl->current_node->node_id != current_id) {
LM_ERR("Bad 'my_node_id' parameter, value: %d different than"
" the node_id property in the 'my_node_info' parameter\n", current_id);
goto error;
}
}
if (db_mode) {
/* bind to the mysql module */
if (db_bind_mod(&clusterer_db_url, &dr_dbf)) {
LM_CRIT("Cannot bind to database module! "
"Did you forget to load a database module ?\n");
goto error;
}
if (!DB_CAPABILITY(dr_dbf, DB_CAP_QUERY)) {
LM_CRIT("Given SQL DB does not provide query types needed by this module!\n");
goto error;
}
/* init DB connection */
if ((db_hdl = dr_dbf.init(&clusterer_db_url)) == 0) {
LM_ERR("cannot initialize database connection\n");
goto error;
}
if (load_db_info(&dr_dbf, db_hdl, &db_table, cluster_list) < 0) {
LM_ERR("Failed to load info from DB\n");
goto error;
}
}
/* register timer */
heartbeats_timer_interval = gcd(ping_interval*1000, ping_timeout);
heartbeats_timer_interval = gcd(heartbeats_timer_interval, node_timeout*1000);
if (heartbeats_timer_interval % 1000 == 0) {
if (register_timer("clstr-heartbeats-timer", heartbeats_timer_handler,
NULL, heartbeats_timer_interval/1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("Unable to register clusterer heartbeats timer\n");
goto error;
}
} else {
if (register_utimer("clstr-heartbeats-utimer", heartbeats_utimer_handler,
NULL, heartbeats_timer_interval*1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("Unable to register clusterer heartbeats timer\n");
goto error;
}
}
if (bin_register_cb(&cl_internal_cap, bin_rcv_cl_packets, NULL) < 0) {
LM_CRIT("Cannot register clusterer binary packet callback!\n");
goto error;
}
if (bin_register_cb(&cl_extra_cap, bin_rcv_cl_extra_packets, NULL) < 0) {
LM_CRIT("Cannot register extra clusterer binary packet callback!\n");
goto error;
}
/* create generic message receiving events */
if (gen_rcv_evs_init() < 0) {
LM_ERR("cannot create cluster message received event\n");
return -1;
}
return 0;
error:
lock_destroy_rw(cl_list_lock);
cl_list_lock = NULL;
if (cluster_list) {
shm_free(cluster_list);
cluster_list = 0;
}
return -1;
}
/**
* init module function
*/
static int mod_init(void)
{
#ifdef HAVE_IHTTP
load_ih_f load_ih;
#endif
int i;
init_db_url( db_url , 0 /*cannot be null*/);
LM_INFO("initializing ...\n");
if(!jdomain)
{
LM_ERR("jdomain is NULL\n");
return -1;
}
/* import mysql functions */
if (db_bind_mod(&db_url, &jabber_dbf)<0)
{
LM_ERR("database module not found\n");
return -1;
}
if (!DB_CAPABILITY(jabber_dbf, DB_CAP_QUERY)) {
LM_ERR("database module does not implement 'query' function\n");
return -1;
}
db_con = (db_con_t**)shm_malloc(nrw*sizeof(db_con_t*));
if (db_con == NULL)
{
LM_ERR("no more shm memory\n");
return -1;
}
/* load the TM API */
if (load_tm_api(&tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
#ifdef HAVE_IHTTP
/* import the iHTTP auto-loading function */
if ( !(load_ih=(load_ih_f)find_export("load_ih", IH_NO_SCRIPT_F, 0))) {
LM_ERR("can't import load_ih\n");
return -1;
}
/* let the auto-loading function load all TM stuff */
if (load_ih( &ihb )==-1)
return -1;
#endif
pipes = (int**)pkg_malloc(nrw*sizeof(int*));
if (pipes == NULL)
{
LM_ERR("no more pkg memory (pipes)\n");
return -1;
}
for(i=0; i<nrw; i++)
{
pipes[i] = (int*)pkg_malloc(2*sizeof(int));
if (!pipes[i])
{
LM_ERR("no more pkg memory (pipes)\n");
return -1;
}
}
for(i=0; i<nrw; i++)
{
db_con[i] = jabber_dbf.init(&db_url);
if (!db_con[i])
{
LM_ERR("failed to connect to the database\n");
return -1;
}
else
{
if (jabber_dbf.use_table(db_con[i], &db_table) < 0) {
LM_ERR("use_table failed\n");
return -1;
}
LM_DBG("database connection opened successfully\n");
}
}
/** creating the pipes */
for(i=0;i<nrw;i++)
{
/* create the pipe*/
if (pipe(pipes[i])==-1) {
LM_ERR("cannot create pipe!\n");
return -1;
}
LM_DBG("pipe[%d] = <%d>-<%d>\n", i, pipes[i][0], pipes[i][1]);
}
if((jwl = xj_wlist_init(pipes,nrw,max_jobs,cache_time,sleep_time,
delay_time)) == NULL)
{
LM_ERR("failed to initialize workers list\n");
return -1;
}
if(xj_wlist_set_aliases(jwl, jaliases, jdomain, proxy) < 0)
{
LM_ERR("failed to set aliases and outbound proxy\n");
return -1;
}
LM_DBG("initialized ...\n");
return 0;
}
/*! \brief
* Module initialization function
*/
static int mod_init(void)
{
LM_DBG("initializing\n");
/* Compute the lengths of string parameters */
init_db_url( db_url , 1 /*can be null*/);
user_col.len = strlen(user_col.s);
domain_col.len = strlen(domain_col.s);
contact_col.len = strlen(contact_col.s);
expires_col.len = strlen(expires_col.s);
q_col.len = strlen(q_col.s);
callid_col.len = strlen(callid_col.s);
cseq_col.len = strlen(cseq_col.s);
flags_col.len = strlen(flags_col.s);
cflags_col.len = strlen(cflags_col.s);
user_agent_col.len = strlen(user_agent_col.s);
received_col.len = strlen(received_col.s);
path_col.len = strlen(path_col.s);
sock_col.len = strlen(sock_col.s);
methods_col.len = strlen(methods_col.s);
sip_instance_col.len = strlen(sip_instance_col.s);
attr_col.len = strlen(attr_col.s);
last_mod_col.len = strlen(last_mod_col.s);
if(ul_hash_size<=1)
ul_hash_size = 512;
else
ul_hash_size = 1<<ul_hash_size;
ul_locks_no = ul_hash_size;
/* check matching mode */
switch (matching_mode) {
case CONTACT_ONLY:
case CONTACT_CALLID:
break;
default:
LM_ERR("invalid matching mode %d\n", matching_mode);
}
if(ul_init_locks()!=0)
{
LM_ERR("locks array initialization failed\n");
return -1;
}
/* Register cache timer */
register_timer( "ul-timer", timer, 0, timer_interval,
TIMER_FLAG_DELAY_ON_DELAY);
/* init the callbacks list */
if ( init_ulcb_list() < 0) {
LM_ERR("usrloc/callbacks initialization failed\n");
return -1;
}
/* Shall we use database ? */
if (db_mode != NO_DB) { /* Yes */
if (db_url.s==NULL || db_url.len==0) {
LM_ERR("selected db_mode requires a db connection -> db_url \n");
return -1;
}
if (db_bind_mod(&db_url, &ul_dbf) < 0) { /* Find database module */
LM_ERR("failed to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(ul_dbf, DB_CAP_ALL)) {
LM_ERR("database module does not implement all functions"
" needed by the module\n");
return -1;
}
if (db_mode != DB_ONLY && (sync_lock = lock_init_rw()) == NULL) {
LM_ERR("cannot init rw lock\n");
return -1;
}
}
fix_flag_name(nat_bflag_str, nat_bflag);
nat_bflag = get_flag_id_by_name(FLAG_TYPE_BRANCH, nat_bflag_str);
if (nat_bflag==(unsigned int)-1) {
nat_bflag = 0;
} else if ( nat_bflag>=8*sizeof(nat_bflag) ) {
LM_ERR("bflag index (%d) too big!\n", nat_bflag);
return -1;
} else {
nat_bflag = 1<<nat_bflag;
}
if (ul_event_init() < 0) {
LM_ERR("cannot initialize USRLOC events\n");
return -1;
}
/* register handler for processing usrloc packets from the bin interface */
if (accept_replicated_udata &&
bin_register_cb(repl_module_name.s, receive_binary_packet) < 0) {
LM_ERR("cannot register binary packet callback!\n");
return -1;
}
if(ul_replicate_cluster > 0 && load_clusterer_api(&clusterer_api)!=0){
LM_DBG("failed to find clusterer API - is clusterer module loaded?\n");
return -1;
}
if(ul_replicate_cluster < 0){
ul_replicate_cluster = 0;
}
init_flag = 1;
return 0;
}
static int mod_init(void){
str s;
int n;
LM_INFO("initializing TLS protocol\n");
if (tls_db_enabled != 0 && tls_db_enabled != 1) {
tls_db_enabled = 1;
}
if (tls_db_enabled) {
/* create & init lock */
if ((dom_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
return -1;
}
init_db_url(tls_db_url, 0 /*cannot be null*/);
tls_db_table.len = strlen(tls_db_table.s);
if (tls_db_table.len == 0) {
LM_ERR("db url not specified\n");
return -1;
}
id_col.len = strlen(id_col.s);
address_col.len = strlen(address_col.s);
type_col.len = strlen(type_col.s);
method_col.len = strlen(method_col.s);
verify_cert_col.len = strlen(verify_cert_col.s);
require_cert_col.len = strlen(require_cert_col.s);
certificate_col.len = strlen(certificate_col.s);
pk_col.len = strlen(pk_col.s);
crl_check_col.len = strlen(crl_check_col.s);
calist_col.len = strlen(calist_col.s);
cadir_col.len = strlen(cadir_col.s);
cplist_col.len = strlen(cplist_col.s);
dhparams_col.len = strlen(dhparams_col.s);
eccurve_col.len = strlen(eccurve_col.s);
if (db_bind_mod(&tls_db_url, &dr_dbf)) {
LM_CRIT("cannot bind to database module! "
"Did you forget to load a database module ?\n");
return -1;
}
/* init DB connection */
if ((db_hdl = dr_dbf.init(&tls_db_url)) == 0) {
LM_CRIT("cannot initialize database connection\n");
return -1;
}
if (dr_dbf.use_table(db_hdl, &tls_db_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", tls_db_table.len, tls_db_table.s);
return -1;
}
}
if (tls_domain_avp) {
s.s = tls_domain_avp;
s.len = strlen(s.s);
if (parse_avp_spec( &s, &tls_client_domain_avp)) {
LM_ERR("cannot parse tls_client_avp");
return -1;
}
}
/*
* this has to be called before any function calling CRYPTO_malloc,
* CRYPTO_malloc will set allow_customize in openssl to 0
*/
if (!CRYPTO_set_mem_functions(os_malloc, os_realloc, os_free)) {
LM_ERR("unable to set the memory allocation functions\n");
LM_ERR("NOTE: check if you have openssl 1.0.1e-fips, as this "
"version is know to be broken; if so, you need to upgrade or "
"downgrade to a differen openssl version !!\n");
return -1;
}
#if !defined(OPENSSL_NO_COMP)
STACK_OF(SSL_COMP)* comp_methods;
/* disabling compression */
LM_WARN("disabling compression due ZLIB problems\n");
comp_methods = SSL_COMP_get_compression_methods();
if (comp_methods==0) {
LM_INFO("openssl compression already disabled\n");
} else {
sk_SSL_COMP_zero(comp_methods);
}
#endif
if (tls_init_multithread() < 0) {
LM_ERR("failed to init multi-threading support\n");
return -1;
}
SSL_library_init();
SSL_load_error_strings();
init_ssl_methods();
n = check_for_krb();
if (n==-1) {
LM_ERR("kerberos check failed\n");
return -1;
}
if ( ( n ^
#ifndef OPENSSL_NO_KRB5
1
#else
0
#endif
)!=0 ) {
LM_ERR("compiled agaist an openssl with %s"
"kerberos, but run with one with %skerberos\n",
(n==1)?"":"no ",(n!=1)?"no ":"");
return -1;
}
/*
* finish setting up the tls default domains
*/
tls_default_client_domain.type = TLS_DOMAIN_DEF|TLS_DOMAIN_CLI ;
tls_default_client_domain.addr.af = AF_INET;
tls_default_server_domain.type = TLS_DOMAIN_DEF|TLS_DOMAIN_SRV;
tls_default_server_domain.addr.af = AF_INET;
/*
* now initialize tls default domains
*/
if ( (n=init_tls_domains(&tls_default_server_domain)) ) {
return n;
}
if ( (n=init_tls_domains(&tls_default_client_domain)) ) {
return n;
}
/*
* now initialize tls virtual domains
*/
if (tls_db_enabled && load_info(&dr_dbf, db_hdl, &tls_db_table, &tls_server_domains,
&tls_client_domains)){
return -1;
}
if ( (n=init_tls_domains(tls_server_domains)) ) {
return n;
}
if ( (n=init_tls_domains(tls_client_domains)) ) {
return n;
}
/*
* we are all set
*/
return 0;
}
static int mod_init(void)
{
unsigned int n;
LM_INFO("Dialog module - initializing\n");
if (timeout_spec.s)
timeout_spec.len = strlen(timeout_spec.s);
init_db_url( db_url , 1 /*can be null*/);
dlg_id_column.len = strlen(dlg_id_column.s);
call_id_column.len = strlen(call_id_column.s);
from_uri_column.len = strlen(from_uri_column.s);
from_tag_column.len = strlen(from_tag_column.s);
to_uri_column.len = strlen(to_uri_column.s);
to_tag_column.len = strlen(to_tag_column.s);
state_column.len = strlen(state_column.s);
start_time_column.len = strlen(start_time_column.s);
timeout_column.len = strlen(timeout_column.s);
to_cseq_column.len = strlen(to_cseq_column.s);
from_cseq_column.len = strlen(from_cseq_column.s);
to_route_column.len = strlen(to_route_column.s);
from_route_column.len = strlen(from_route_column.s);
to_contact_column.len = strlen(to_contact_column.s);
from_contact_column.len = strlen(from_contact_column.s);
to_sock_column.len = strlen(to_sock_column.s);
from_sock_column.len = strlen(from_sock_column.s);
profiles_column.len = strlen(profiles_column.s);
vars_column.len = strlen(vars_column.s);
sflags_column.len = strlen(sflags_column.s);
dialog_table_name.len = strlen(dialog_table_name.s);
/* param checkings */
if( log_profile_hash_size <= 0)
{
LM_ERR("invalid value for log_profile_hash_size:%d!!\n",
log_profile_hash_size);
return -1;
}
if (rr_param.s==0 || rr_param.s[0]==0) {
LM_ERR("empty rr_param!!\n");
return -1;
}
rr_param.len = strlen(rr_param.s);
if (rr_param.len>MAX_DLG_RR_PARAM_NAME) {
LM_ERR("rr_param too long (max=%d)!!\n", MAX_DLG_RR_PARAM_NAME);
return -1;
}
if (timeout_spec.s) {
if ( pv_parse_spec(&timeout_spec, &timeout_avp)==0
&& (timeout_avp.type!=PVT_AVP)){
LM_ERR("malformed or non AVP timeout "
"AVP definition in '%.*s'\n", timeout_spec.len,timeout_spec.s);
return -1;
}
}
if (default_timeout<=0) {
LM_ERR("0 default_timeout not accepted!!\n");
return -1;
}
if (ping_interval<=0) {
LM_ERR("Non-positive ping interval not accepted!!\n");
return -1;
}
/* update the len of the extra headers */
if (dlg_extra_hdrs.s)
dlg_extra_hdrs.len = strlen(dlg_extra_hdrs.s);
if (seq_match_mode!=SEQ_MATCH_NO_ID &&
seq_match_mode!=SEQ_MATCH_FALLBACK &&
seq_match_mode!=SEQ_MATCH_STRICT_ID ) {
LM_ERR("invalid value %d for seq_match_mode param!!\n",seq_match_mode);
return -1;
}
/* if statistics are disabled, prevent their registration to core */
if (dlg_enable_stats==0)
exports.stats = 0;
/* we are only interested in these parameters if the cachedb url was defined */
if (cdb_url.s) {
cdb_url.len = strlen(cdb_url.s);
if (init_cachedb_utils() <0) {
LM_ERR("cannot init cachedb utils\n");
return -1;
}
cdb_val_prefix.len = strlen(cdb_val_prefix.s);
cdb_noval_prefix.len = strlen(cdb_noval_prefix.s);
cdb_size_prefix.len = strlen(cdb_size_prefix.s);
}
/* create profile hashes */
if (add_profile_definitions( profiles_nv_s, 0)!=0 ) {
LM_ERR("failed to add profiles without value\n");
return -1;
}
if (add_profile_definitions( profiles_wv_s, 1)!=0 ) {
LM_ERR("failed to add profiles with value\n");
return -1;
}
/* load the TM API */
if (load_tm_api(&d_tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* load RR API also */
if (load_rr_api(&d_rrb)!=0) {
LM_ERR("can't load RR API\n");
return -1;
}
/* register callbacks*/
/* listen for all incoming requests */
if ( d_tmb.register_tmcb( 0, 0, TMCB_REQUEST_IN, dlg_onreq, 0, 0 ) <=0 ) {
LM_ERR("cannot register TMCB_REQUEST_IN callback\n");
return -1;
}
/* listen for all routed requests */
if ( d_rrb.register_rrcb( dlg_onroute, 0, 1 ) <0 ) {
LM_ERR("cannot register RR callback\n");
return -1;
}
if (register_script_cb( dialog_cleanup, POST_SCRIPT_CB|REQ_TYPE_CB,0)<0) {
LM_ERR("cannot regsiter script callback");
return -1;
}
if (accept_replicated_dlg &&
bin_register_cb("dialog", receive_binary_packet) < 0) {
LM_ERR("Cannot register binary packet callback!\n");
return -1;
}
if (dlg_have_own_timer_proc) {
LM_INFO("Running with dedicated dialog timer process\n");
dlg_own_timer_proc = register_timer_process( "dlg-timer",
dlg_timer_routine, NULL,1,TIMER_PROC_INIT_FLAG );
if (dlg_own_timer_proc == NULL) {
LM_ERR("Failed to init dialog own timer proc\n");
return -1;
}
if (append_timer_to_process("dlg-pinger", dlg_ping_routine, NULL,
ping_interval,dlg_own_timer_proc) < 0) {
LM_ERR("Failed to append ping timer \n");
return -1;
}
}
else {
if ( register_timer( "dlg-timer", dlg_timer_routine, NULL, 1)<0 ) {
LM_ERR("failed to register timer \n");
return -1;
}
if ( register_timer( "dlg-pinger", dlg_ping_routine, NULL,
ping_interval)<0) {
LM_ERR("failed to register timer 2 \n");
return -1;
}
}
/* init handlers */
init_dlg_handlers(timeout_spec.s?&timeout_avp:0, default_timeout);
/* init timer */
if (init_dlg_timer(dlg_ontimeout)!=0) {
LM_ERR("cannot init timer list\n");
return -1;
}
if (init_dlg_ping_timer()!=0) {
LM_ERR("cannot init ping timer\n");
return -1;
}
/* initialized the hash table */
for( n=0 ; n<(8*sizeof(n)) ; n++) {
if (dlg_hash_size==(1<<n))
break;
if (dlg_hash_size<(1<<n)) {
LM_WARN("hash_size is not a power "
"of 2 as it should be -> rounding from %d to %d\n",
dlg_hash_size, 1<<(n-1));
dlg_hash_size = 1<<(n-1);
break;
}
}
if ( init_dlg_table(dlg_hash_size)<0 ) {
LM_ERR("failed to create hash table\n");
return -1;
}
/* if a database should be used to store the dialogs' information */
if (dlg_db_mode==DB_MODE_NONE) {
db_url.s = 0; db_url.len = 0;
} else {
if (dlg_db_mode!=DB_MODE_REALTIME &&
dlg_db_mode!=DB_MODE_DELAYED && dlg_db_mode!=DB_MODE_SHUTDOWN ) {
LM_ERR("unsupported db_mode %d\n", dlg_db_mode);
return -1;
}
if ( !db_url.s || db_url.len==0 ) {
LM_ERR("db_url not configured for db_mode %d\n", dlg_db_mode);
return -1;
}
if (init_dlg_db(&db_url, dlg_hash_size, db_update_period)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
run_load_callbacks();
}
/* if profiles should be kept in cachedb's */
destroy_dlg_callbacks( DLGCB_LOADED );
destroy_cachedb(0);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
pv_spec_t avp_spec;
LM_DBG("initializing ...\n");
/* Load stuff from DB */
init_db_url( ds_db_url , 0 /*cannot be null*/);
ds_table_name.len = strlen(ds_table_name.s);
ds_set_id_col.len = strlen(ds_set_id_col.s);
ds_dest_uri_col.len = strlen(ds_dest_uri_col.s);
ds_dest_sock_col.len = strlen(ds_dest_sock_col.s);
ds_dest_state_col.len = strlen(ds_dest_state_col.s);
ds_dest_weight_col.len = strlen(ds_dest_weight_col.s);
ds_dest_attrs_col.len = strlen(ds_dest_attrs_col.s);
/* handle AVPs spec */
dst_avp_param.len = strlen(dst_avp_param.s);
if (pv_parse_spec(&dst_avp_param, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n",
dst_avp_param.len, dst_avp_param.s);
return -1;
}
if(pv_get_avp_name(0, &(avp_spec.pvp), &dst_avp_name,&dst_avp_type)!=0) {
LM_ERR("[%.*s]- invalid AVP definition\n", dst_avp_param.len,
dst_avp_param.s);
return -1;
}
grp_avp_param.len=strlen(grp_avp_param.s);
if (pv_parse_spec(&grp_avp_param, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n",
grp_avp_param.len, grp_avp_param.s);
return -1;
}
if(pv_get_avp_name(0, &(avp_spec.pvp), &grp_avp_name,&grp_avp_type)!=0) {
LM_ERR("[%.*s]- invalid AVP definition\n", grp_avp_param.len,
grp_avp_param.s);
return -1;
}
cnt_avp_param.len=strlen(cnt_avp_param.s);
if (pv_parse_spec(&cnt_avp_param, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n",
cnt_avp_param.len, cnt_avp_param.s);
return -1;
}
if(pv_get_avp_name(0, &(avp_spec.pvp), &cnt_avp_name,&cnt_avp_type)!=0) {
LM_ERR("[%.*s]- invalid AVP definition\n", cnt_avp_param.len,
cnt_avp_param.s);
return -1;
}
sock_avp_param.len=strlen(sock_avp_param.s);
if (pv_parse_spec(&sock_avp_param, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n",
sock_avp_param.len, sock_avp_param.s);
return -1;
}
if(pv_get_avp_name(0, &(avp_spec.pvp), &sock_avp_name,&sock_avp_type)!=0){
LM_ERR("[%.*s]- invalid AVP definition\n", sock_avp_param.len,
sock_avp_param.s);
return -1;
}
if (attrs_avp_param.s && (attrs_avp_param.len=strlen(attrs_avp_param.s)) > 0) {
if (pv_parse_spec(&attrs_avp_param, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n",
attrs_avp_param.len, attrs_avp_param.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &attrs_avp_name,
&attrs_avp_type)!=0){
LM_ERR("[%.*s]- invalid AVP definition\n", attrs_avp_param.len,
attrs_avp_param.s);
return -1;
}
} else {
attrs_avp_name = -1;
attrs_avp_type = 0;
}
if (hash_pvar_param.s && (hash_pvar_param.len=strlen(hash_pvar_param.s))>0 ) {
if(pv_parse_format(&hash_pvar_param, &hash_param_model) < 0
|| hash_param_model==NULL) {
LM_ERR("malformed PV string: %s\n", hash_pvar_param.s);
return -1;
}
} else {
hash_param_model = NULL;
}
if (ds_setid_pvname.s && (ds_setid_pvname.len=strlen(ds_setid_pvname.s))>0 ) {
if(pv_parse_spec(&ds_setid_pvname, &ds_setid_pv)==NULL
|| !pv_is_w(&ds_setid_pv))
{
LM_ERR("[%s]- invalid setid_pvname\n", ds_setid_pvname.s);
return -1;
}
}
pvar_algo_param.len = strlen(pvar_algo_param.s);
if (pvar_algo_param.len)
ds_pvar_parse_pattern(pvar_algo_param);
if (init_ds_bls()!=0) {
LM_ERR("failed to init DS blacklists\n");
return E_CFG;
}
if (init_ds_data()!=0) {
LM_ERR("failed to init DS data holder\n");
return -1;
}
/* open DB connection to load provisioning data */
if (init_ds_db()!= 0) {
LM_ERR("failed to init database support\n");
return -1;
}
/* do the actula data load */
if (ds_reload_db()!=0) {
LM_ERR("failed to load data from DB\n");
return -1;
}
/* close DB connection */
ds_disconnect_db();
/* Only, if the Probing-Timer is enabled the TM-API needs to be loaded: */
if (ds_ping_interval > 0)
{
load_tm_f load_tm;
str host;
int port,proto;
if (ds_ping_from.s)
ds_ping_from.len = strlen(ds_ping_from.s);
if (ds_ping_method.s)
ds_ping_method.len = strlen(ds_ping_method.s);
/* parse the list of reply codes to be counted as success */
if(options_reply_codes_str.s) {
options_reply_codes_str.len = strlen(options_reply_codes_str.s);
if(parse_reply_codes( &options_reply_codes_str, &options_reply_codes,
&options_codes_no )< 0) {
LM_ERR("Bad format for options_reply_code parameter"
" - Need a code list separated by commas\n");
return -1;
}
}
/* parse and look for the socket to ping from */
if (probing_sock_s && probing_sock_s[0]!=0 ) {
if (parse_phostport( probing_sock_s, strlen(probing_sock_s),
&host.s, &host.len, &port, &proto)!=0 ) {
LM_ERR("socket description <%s> is not valid\n",
probing_sock_s);
return -1;
}
probing_sock = grep_sock_info( &host, port, proto);
if (probing_sock==NULL) {
LM_ERR("socket <%s> is not local to opensips (we must listen "
"on it\n", probing_sock_s);
return -1;
}
}
/* TM-Bindings */
load_tm=(load_tm_f)find_export("load_tm", 0, 0);
if (load_tm==NULL) {
LM_ERR("failed to bind to the TM-Module - required for probing\n");
return -1;
}
/* let the auto-loading function load all TM stuff */
if (load_tm( &tmb ) == -1) {
LM_ERR("could not load the TM-functions - disable DS ping\n");
return -1;
}
/* Register the PING-Timer */
if (register_timer("ds-pinger",ds_check_timer,NULL,ds_ping_interval)<0){
LM_ERR("failed to register timer for probing!\n");
return -1;
}
}
/* register timer to flush the state of destination back to DB */
if (register_timer("ds-flusher",ds_flusher_routine,NULL, 30)<0){
LM_ERR("failed to register timer for DB flushing!\n");
return -1;
}
dispatch_evi_id = evi_publish_event(dispatcher_event);
if (dispatch_evi_id == EVI_ERROR)
LM_ERR("cannot register dispatcher event\n");
return 0;
}
static int mod_init(void)
{
int ver;
LM_INFO("initializing...\n");
init_db_url( db_url , 0 /*cannot be null*/);
domainpolicy_table.len = strlen(domainpolicy_table.s);
domainpolicy_col_rule.len = strlen(domainpolicy_col_rule.s);
domainpolicy_col_type.len = strlen(domainpolicy_col_type.s);
domainpolicy_col_att.len = strlen(domainpolicy_col_att.s);
domainpolicy_col_val.len = strlen(domainpolicy_col_val.s);
LM_INFO("check for DB module\n");
/* Check if database module has been loaded */
if (domainpolicy_db_bind(&db_url)<0) {
LM_ERR("no database module loaded!"
" Please make sure that a DB module is loaded first\n");
return -1;
}
LM_INFO("update length of module variables\n");
/* Update length of module variables */
port_override_avp.len = strlen(port_override_avp.s);
transport_override_avp.len = strlen(transport_override_avp.s);
domain_prefix_avp.len = strlen(domain_prefix_avp.s);
domain_suffix_avp.len = strlen(domain_suffix_avp.s);
domain_replacement_avp.len = strlen(domain_replacement_avp.s);
send_socket_avp.len = strlen(send_socket_avp.s);
/* Check table version */
ver = domainpolicy_db_ver(&db_url, &domainpolicy_table);
if (ver < 0) {
LM_ERR("failed to query table version\n");
return -1;
} else if (ver < DOMAINPOLICY_TABLE_VERSION) {
LM_ERR("invalid table version of domainpolicy table\n");
return -1;
}
/* Assign AVP parameter names */
LM_INFO("AVP\n");
if (parse_avp_spec(&port_override_avp, &port_override_name) < 0) {
LM_ERR("invalid port_override_avp!\n");
return -1;
}
if (parse_avp_spec(&transport_override_avp, &transport_override_name) < 0) {
LM_ERR("invalid transport_override_avp!\n");
return -1;
}
if (parse_avp_spec(&domain_prefix_avp, &domain_prefix_name) < 0) {
LM_ERR("invalid domain_prefix_avp!\n");
return -1;
}
if (parse_avp_spec(&domain_suffix_avp, &domain_suffix_name) < 0) {
LM_ERR("invalid domain_suffix_avp!\n");
return -1;
}
if (parse_avp_spec(&domain_replacement_avp, &domain_replacement_name) < 0) {
LM_ERR("invalid domain_replacement_avp!\n");
return -1;
}
if (parse_avp_spec(&send_socket_avp, &send_socket_name) < 0) {
LM_ERR("invalid send_socket_avp!\n");
return -1;
}
return 0;
}
static int mod_init(void)
{
pv_spec_t avp_spec;
int i;
init_db_url( db_url , 0 /*cannot be null*/);
siptrace_table.len = strlen(siptrace_table.s);
date_column.len = strlen(date_column.s);
callid_column.len = strlen(callid_column.s);
traced_user_column.len = strlen(traced_user_column.s);
msg_column.len = strlen(msg_column.s);
method_column.len = strlen(method_column.s);
status_column.len = strlen(status_column.s);
fromproto_column.len = strlen(fromproto_column.s);
fromip_column.len = strlen(fromip_column.s);
fromport_column.len = strlen(fromport_column.s);
toproto_column.len = strlen(toproto_column.s);
toip_column.len = strlen(toip_column.s);
toport_column.len = strlen(toport_column.s);
fromtag_column.len = strlen(fromtag_column.s);
direction_column.len = strlen(direction_column.s);
if (traced_user_avp_str.s)
traced_user_avp_str.len = strlen(traced_user_avp_str.s);
if (trace_table_avp_str.s)
trace_table_avp_str.len = strlen(trace_table_avp_str.s);
if (dup_uri_str.s)
dup_uri_str.len = strlen(dup_uri_str.s);
if (trace_local_ip.s)
parse_trace_local_ip();
LM_INFO("initializing...\n");
fix_flag_name(trace_flag_str, trace_flag);
trace_flag = get_flag_id_by_name(FLAG_TYPE_MSG, trace_flag_str);
if (flag_idx2mask(&trace_flag)<0)
return -1;
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(trace_to_database_flag!=NULL && *trace_to_database_flag!=0) {
/* Find a database module */
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 ((db_con = db_funcs.init(&db_url)) == 0) {
LM_CRIT("Cannot connect to DB\n");
return -1;
}
if(db_check_table_version(&db_funcs, db_con,
&siptrace_table, SIPTRACE_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
db_funcs.close(db_con);
db_con = 0;
}
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;
/* register callbacks to TM */
if (load_tm_api(&tmb)!=0)
{
LM_ERR("can't load tm api\n");
return -1;
}
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;
}
/* register sl callback */
register_slcb_f = (register_slcb_t)find_export("register_slcb", 0, 0);
if(register_slcb_f==NULL)
{
LM_ERR("can't load sl api\n");
return -1;
}
if(register_slcb_f(SLCB_REPLY_OUT,trace_sl_onreply_out, NULL)!=0)
{
LM_ERR("can't register trace_sl_onreply_out\n");
return -1;
}
if(register_fwdcb(trace_msg_out_w)!=0)
{
LM_ERR("can't register trace_sl_ack_out\n");
return -1;
}
if(enable_ack_trace&®ister_slcb_f(SLCB_ACK_IN,trace_sl_ack_in,NULL)!=0)
{
LM_ERR("can't register trace_sl_ack_in\n");
return -1;
}
if(dup_uri_str.s!=0) {
dup_uri_str.len = strlen(dup_uri_str.s);
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(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 = -1;
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 = -1;
trace_table_avp_type = 0;
}
if (duplicate_with_hep) {
load_hep = (load_hep_f)find_export("load_hep", 1, 0);
if (!load_hep) {
LM_ERR("Can't bind proto hep!\n");
return -1;
}
if (load_hep(&hep_api)) {
LM_ERR("can't bind proto hep\n");
return -1;
}
}
/* init the DB keys for future queries */
db_keys[0] = &msg_column;
db_keys[1] = &callid_column;
db_keys[2] = &method_column;
db_keys[3] = &status_column;
db_keys[4] = &fromproto_column;
db_keys[5] = &fromip_column;
db_keys[6] = &fromport_column;
db_keys[7] = &toproto_column;
db_keys[8] = &toip_column;
db_keys[9] = &toport_column;
db_keys[10] = &date_column;
db_keys[11] = &direction_column;
db_keys[12] = &fromtag_column;
db_keys[13] = &traced_user_column;
/* init DB values info which is constant ( type, null ) */
db_vals[0].type = DB_BLOB;
db_vals[1].type = DB_STR;
db_vals[2].type = DB_STR;
db_vals[3].type = DB_STR;
db_vals[4].type = DB_STR;
db_vals[5].type = DB_STR;
db_vals[6].type = DB_INT;
db_vals[7].type = DB_STR;
db_vals[8].type = DB_STR;
db_vals[9].type = DB_INT;
db_vals[10].type = DB_DATETIME;
db_vals[11].type = DB_STRING;
db_vals[12].type = DB_STR;
db_vals[13].type = DB_STR;
/* no field can be null */
for (i=0;i<NR_KEYS;i++)
db_vals[i].nul = 0;
return 0;
}
static int mod_init(void)
{
int i;
LM_DBG("Initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
domain_table.len = strlen(domain_table.s);
domain_col.len = strlen(domain_col.s);
domain_attrs_col.len = strlen(domain_attrs_col.s);
/* Check if database module has been loaded */
if (domain_db_bind(&db_url) < 0) return -1;
/* Check if cache needs to be loaded from domain table */
if (db_mode != 0) {
if (domain_db_init(&db_url)<0) return -1;
/* Check table version */
if (domain_db_ver(&domain_table, TABLE_VERSION) < 0) {
LM_ERR("error during check of domain table version\n");
goto error;
}
/* Initializing hash tables and hash table variable */
hash_table_1 = (struct domain_list **)shm_malloc
(sizeof(struct domain_list *) * DOM_HASH_SIZE);
if (hash_table_1 == 0) {
LM_ERR("No memory for hash table\n");
goto error;
}
hash_table_2 = (struct domain_list **)shm_malloc
(sizeof(struct domain_list *) * DOM_HASH_SIZE);
if (hash_table_2 == 0) {
LM_ERR("No memory for hash table\n");
goto error;
}
for (i = 0; i < DOM_HASH_SIZE; i++) {
hash_table_1[i] = hash_table_2[i] = (struct domain_list *)0;
}
hash_table = (struct domain_list ***)shm_malloc
(sizeof(struct domain_list *));
*hash_table = hash_table_1;
if (reload_domain_table() == -1) {
LM_ERR("Domain table reload failed\n");
goto error;
}
domain_db_close();
}
/* register the alias check function to core */
if (register_alias_fct(is_domain_alias)!=0) {
LM_ERR("failed to register the alias check function\n");
goto error;
}
return 0;
error:
domain_db_close();
return -1;
}
/**
* init module function
*/
static int mod_init(void)
{
LM_INFO("initializing...\n");
init_db_url( db_url , 0 /*cannot be null*/);
db_table.len = strlen(db_table.s);
sdomain_column.len = strlen(sdomain_column.s);
prefix_column.len = strlen(prefix_column.s);
domain_column.len = strlen(domain_column.s);
prefix.len = strlen(prefix.s);
pdt_char_list.len = strlen(pdt_char_list.s);
if(pdt_char_list.len<=0)
{
LM_ERR("invalid pdt char list\n");
return -1;
}
LM_INFO("pdt_char_list=%s \n",pdt_char_list.s);
/* binding to mysql module */
if(db_bind_mod(&db_url, &pdt_dbf))
{
LM_ERR("database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pdt_dbf, DB_CAP_ALL))
{
LM_ERR("database module does not "
"implement all functions needed by the module\n");
return -1;
}
/* open a connection with the database */
db_con = pdt_dbf.init(&db_url);
if(db_con==NULL)
{
LM_ERR("failed to connect to the database\n");
return -1;
}
if (pdt_dbf.use_table(db_con, &db_table) < 0)
{
LM_ERR("failed to use_table\n");
goto error1;
}
LM_DBG("database connection opened successfully\n");
/* create & init lock */
if ((pdt_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
goto error1;
}
/* tree pointer in shm */
_ptree = (pdt_tree_t**)shm_malloc( sizeof(pdt_tree_t*) );
if (_ptree==0) {
LM_ERR("out of shm mem for pdtree\n");
goto error1;
}
*_ptree=0;
/* loading all information from database */
if(pdt_load_db()!=0)
{
LM_ERR("cannot load info from database\n");
goto error1;
}
pdt_dbf.close(db_con);
db_con = 0;
#if 0
pdt_print_tree(*_ptree);
#endif
/* success code */
return 0;
error1:
if (pdt_lock)
{
lock_destroy_rw( pdt_lock );
pdt_lock = 0;
}
if(_ptree!=0)
shm_free(_ptree);
if(db_con!=NULL)
{
pdt_dbf.close(db_con);
db_con = 0;
}
return -1;
}