/**
* init module function
*/
static int mod_init(void)
{
/* load the TM API */
if (load_tm_api(&_tmx_tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
#ifdef STATISTICS
/* register statistics */
if (register_module_stats( exports.name, mod_stats)!=0 ) {
LM_ERR("failed to register statistics\n");
return -1;
}
#endif
pv_tmx_data_init();
if (register_script_cb(tmx_cfg_callback,
POST_SCRIPT_CB|REQUEST_CB,0)<0) {
LM_ERR("cannot register post-script callback\n");
return -1;
}
return 0;
}
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(dialplan_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(dp_db_url.s), dp_db_url.len,dp_db_url.s);
if(attr_pvar_s.s && attr_pvar_s.len>0) {
attr_pvar = pv_cache_get(&attr_pvar_s);
if( (attr_pvar==NULL) ||
((attr_pvar->type != PVT_AVP) &&
(attr_pvar->type != PVT_XAVP) &&
(attr_pvar->type!=PVT_SCRIPTVAR))) {
LM_ERR("invalid pvar name\n");
return -1;
}
}
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));
/* emulate "$rU/$rU" as second parameter for dp_translate() */
default_param_s.len = strlen(default_param_s.s);
default_par2->v.sp[0] = pv_cache_get(&default_param_s);
if (default_par2->v.sp[0]==NULL) {
LM_ERR("input pv is invalid\n");
return -1;
}
default_param_s.len = strlen(default_param_s.s);
default_par2->v.sp[1] = pv_cache_get(&default_param_s);
if (default_par2->v.sp[1]==NULL) {
LM_ERR("output pv is invalid\n");
return -1;
}
if(dp_fetch_rows<=0)
dp_fetch_rows = 1000;
if(init_data() != 0) {
LM_ERR("could not initialize data\n");
return -1;
}
return 0;
}
int init_mi_core(void)
{
if (register_mi_mod( "core", mi_core_cmds)<0) {
LM_ERR("unable to register core MI cmds\n");
return -1;
}
return 0;
}
int register_mi_stats(void)
{
/* register MI commands */
if (register_mi_mod("core", mi_stat_cmds)<0) {
LM_ERR("unable to register MI cmds\n");
return -1;
}
return 0;
}
/**
* mi init function
*/
int pdt_init_mi(char *mod)
{
if(register_mi_mod(mod, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
return 0;
}
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(htable_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(ht_init_tables()!=0)
return -1;
ht_db_init_params();
if(ht_db_url.len>0)
{
if(ht_db_init_con()!=0)
return -1;
if(ht_db_open_con()!=0)
return -1;
if(ht_db_load_tables()!=0)
{
ht_db_close_con();
return -1;
}
ht_db_close_con();
}
if(ht_has_autoexpire())
{
LM_DBG("starting auto-expire timer\n");
if(ht_timer_interval<=0)
ht_timer_interval = 20;
if(ht_timer_procs<=0) {
if(register_timer(ht_timer, 0, ht_timer_interval)<0)
{
LM_ERR("failed to register timer function\n");
return -1;
}
} else {
register_sync_timers(ht_timer_procs);
}
}
if (ht_enable_dmq>0 && ht_dmq_initialize()!=0) {
LM_ERR("failed to initialize dmq integration\n");
return -1;
}
ht_iterator_init();
return 0;
}
/*
* module initialization function
*/
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(permissions_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
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_trusted() != 0) {
LM_ERR("failed to initialize the allow_trusted function\n");
return -1;
}
if (init_tag_avp(&tag_avp_param) < 0) {
LM_ERR("failed to process peer_tag_avp AVP param\n");
return -1;
}
if (init_addresses() != 0) {
LM_ERR("failed to initialize the allow_address function\n");
return -1;
}
if ((db_mode != DISABLE_CACHE) && (db_mode != ENABLE_CACHE)) {
LM_ERR("invalid db_mode value: %d\n", db_mode);
return -1;
}
rules_num = 1;
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(!mq_head_defined())
LM_WARN("no mqueue defined\n");
if(register_mi_mod(exports.name, mi_cmds) != 0) {
LM_ERR("failed to register MI commands\n");
return 1;
}
return 0;
}
static int mod_init(void)
{
bind_auth_s_t bind_auth;
if (register_mi_mod(exports.name, mi_cmds) != 0)
{
LM_ERR("registering MI commands\n");
return -1;
}
if (secret_list == NULL)
{
LM_ERR("secret modparam not set\n");
return -1;
}
switch(autheph_username_format)
{
case AUTHEPH_USERNAME_NON_IETF:
LM_WARN("the %d value for the username_format modparam is "
"deprecated. You should update the web-service that "
"generates credentials to use the format specified in "
"draft-uberti-rtcweb-turn-rest.\n",
autheph_username_format);
/* Fall-thru */
case AUTHEPH_USERNAME_IETF:
break;
default:
LM_ERR("bad value for username_format modparam: %d\n",
autheph_username_format);
return -1;
}
bind_auth = (bind_auth_s_t) find_export("bind_auth_s", 0, 0);
if (bind_auth)
{
if (bind_auth(&eph_auth_api) < 0)
{
LM_ERR("unable to bind to auth module\n");
return -1;
}
}
else
{
memset(&eph_auth_api, 0, sizeof(auth_api_s_t));
LM_INFO("auth module not loaded - digest authentication and "
"check functions will not be available\n");
}
return 0;
}
/*
* mod_init
* Called by Kamailio at init time
*/
static int mod_init(void) {
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
bm_mycfg = (bm_cfg_t*)shm_malloc(sizeof(bm_cfg_t));
memset(bm_mycfg, 0, sizeof(bm_cfg_t));
bm_mycfg->enable_global = bm_enable_global;
bm_mycfg->granularity = bm_granularity;
bm_mycfg->loglevel = bm_loglevel;
return 0;
}
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(pv_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
pv_init_sbranch();
return 0;
}
int init_stats_collector(void)
{
/* init the collector */
collector = (stats_collector*)shm_malloc(sizeof(stats_collector));
if (collector==0) {
LM_ERR("no more shm mem\n");
goto error;
}
memset( collector, 0 , sizeof(stats_collector));
#ifdef NO_ATOMIC_OPS
/* init BIG (really BIG) lock */
stat_lock = lock_alloc();
if (stat_lock==0 || lock_init( stat_lock )==0 ) {
LM_ERR("failed to init the really BIG lock\n");
goto error;
}
#endif
/* register MI commands */
if (register_mi_mod( "statistics", mi_stat_cmds)<0) {
LM_ERR("unable to register MI cmds\n");
goto error;
}
/* register core statistics */
if (register_module_stats( "core", core_stats)!=0 ) {
LM_ERR("failed to register core statistics\n");
goto error;
}
/* register sh_mem statistics */
if (register_module_stats( "shmem", shm_stats)!=0 ) {
LM_ERR("failed to register sh_mem statistics\n");
goto error;
}
/* register sh_mem statistics */
if (register_module_stats( "net", net_stats)!=0 ) {
LM_ERR("failed to register network statistics\n");
goto error;
}
LM_DBG("statistics manager successfully initialized\n");
return 0;
error:
return -1;
}
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0) {
LM_ERR("failed to register MI commands\n");
return -1;
}
if(matrix_rpc_init()<0) {
LM_ERR("failed to init RPC commands");
return -1;
}
if (init_shmlock() != 0) return -1;
if (matrix_db_init() != 0) return -1;
if (matrix_db_open() != 0) return -1;
if (init_matrix() != 0) return -1;
matrix_db_close();
return 0;
}
int init_mi_core(void)
{
if (cfg_register_ctx(&_kex_cfg_ctx, NULL)) {
LM_ERR("failed to register cfg context\n");
return -1;
}
if (register_mi_mod( "core", mi_core_cmds)<0) {
LM_ERR("unable to register core MI cmds\n");
return -1;
}
if(init_mi_uptime()<0) {
return -1;
}
return 0;
}
static int init_mod( struct sr_module* m )
{
if (m) {
/* iterate through the list; if error occurs,
propagate it up the stack
*/
if (init_mod(m->next)!=0) return -1;
if (m->exports==0)
return 0;
if (m->exports->init_f) {
LM_DBG("initializing module %s\n", m->exports->name);
if (m->exports->init_f()!=0) {
LM_ERR("failed to initialize"
" module %s\n", m->exports->name);
return -1;
}
}
/* no init function -- proceed further */
#ifdef STATISTICS
if (m->exports->stats) {
LM_DBG("registering stats for %s\n", m->exports->name);
if (register_module_stats(m->exports->name,m->exports->stats)!=0) {
LM_ERR("failed to registering "
"statistics for module %s\n", m->exports->name);
return -1;
}
}
#endif
/* register MI functions */
if (m->exports->mi_cmds) {
LM_DBG("register MI for %s\n", m->exports->name);
if (register_mi_mod(m->exports->name,m->exports->mi_cmds)!=0) {
LM_ERR("failed to register MI functions for module %s\n",
m->exports->name);
}
}
/* proceed with success */
return 0;
} else {
/* end of list */
return 0;
}
}
int init_black_lists(void)
{
bl_ctx_idx = context_register_int(CONTEXT_GLOBAL, NULL);
if (bl_ctx_idx < 0)
return -1;
/* register timer routine */
if (register_timer("blcore-expire", delete_expired_routine, 0, 1,
TIMER_FLAG_SKIP_ON_DELAY) < 0) {
LM_ERR("failed to register timer\n");
return -1;
}
/* register MI commands */
if (register_mi_mod("blacklists", mi_bl_cmds) < 0) {
LM_ERR("unable to register MI cmds\n");
return -1;
}
return 0;
}
int init_mi_core(void)
{
int i;
if (register_mi_mod( "core", mi_core_cmds)<0) {
LM_ERR("unable to register core MI cmds\n");
return -1;
}
/* FIXME - init should't be done here
* do MI commands init with all exported MI commands from modules
*/
for (i=0;mi_core_cmds[i].name;i++)
{
if (mi_core_cmds[i].init_f && mi_core_cmds[i].init_f() != 0)
{
LM_ERR("failed to init command %s\n",mi_core_cmds[i].name);
}
}
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;
}
static int mod_init(void)
{
/* Register RPC commands */
if (rpc_register_array(rpc_cmds)!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if (!hash_file) {
LM_INFO("no hash_file given, disable hash functionality\n");
} else {
if (MD5File(config_hash, hash_file) != 0) {
LM_ERR("could not hash the config file");
return -1;
}
LM_DBG("config file hash is %.*s", MD5_LEN, config_hash);
}
if (initial_prob > 100) {
LM_ERR("invalid probability <%d>\n", initial_prob);
return -1;
}
LM_DBG("initial probability %d percent\n", initial_prob);
probability=(int *) shm_malloc(sizeof(int));
if (!probability) {
LM_ERR("no shmem available\n");
return -1;
}
*probability = initial_prob;
gflags=(unsigned int *) shm_malloc(sizeof(unsigned int));
if (!gflags) {
LM_ERR(" no shmem available\n");
return -1;
}
*gflags=initial_gflags;
gflags_lock = lock_alloc();
if (gflags_lock==0) {
LM_ERR("cannot allocate gflgas lock\n");
return -1;
}
if (lock_init(gflags_lock)==NULL) {
LM_ERR("cannot initiate gflags lock\n");
lock_dealloc(gflags_lock);
return -1;
}
if(_cfg_lock_size>0 && _cfg_lock_size<=10)
{
_cfg_lock_size = 1<<_cfg_lock_size;
_cfg_lock_set = lock_set_alloc(_cfg_lock_size);
if(_cfg_lock_set==NULL || lock_set_init(_cfg_lock_set)==NULL)
{
LM_ERR("cannot initiate lock set\n");
return -1;
}
}
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0) {
LM_ERR("failed to register MI commands\n");
return -1;
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1) {
LM_ERR("can't load tm functions. TM module probably not loaded\n");
return -1;
}
/* load peer list - the list containing the module callbacks for dmq */
peer_list = init_peer_list();
if(peer_list==NULL) {
LM_ERR("cannot initialize peer list\n");
return -1;
}
/* load the dmq node list - the list containing the dmq servers */
node_list = init_dmq_node_list();
if(node_list==NULL) {
LM_ERR("cannot initialize node list\n");
return -1;
}
if (rpc_register_array(rpc_methods)!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
/* register worker processes - add one because of the ping process */
register_procs(num_workers);
/* check server_address and notification_address are not empty and correct */
if(parse_uri(dmq_server_address.s, dmq_server_address.len, &dmq_server_uri) < 0) {
LM_ERR("server address invalid\n");
return -1;
}
if(parse_uri(dmq_notification_address.s, dmq_notification_address.len, &dmq_notification_uri) < 0) {
LM_ERR("notification address invalid\n");
return -1;
}
/* create socket string out of the server_uri */
if(make_socket_str_from_uri(&dmq_server_uri, &dmq_server_socket) < 0) {
LM_ERR("failed to create socket out of server_uri\n");
return -1;
}
if (lookup_local_socket(&dmq_server_socket) == NULL) {
LM_ERR("server_uri is not a socket the proxy is listening on\n");
return -1;
}
/* allocate workers array */
workers = shm_malloc(num_workers * sizeof(*workers));
if(workers == NULL) {
LM_ERR("error in shm_malloc\n");
return -1;
}
dmq_init_callback_done = shm_malloc(sizeof(int));
if (!dmq_init_callback_done) {
LM_ERR("no more shm\n");
return -1;
}
*dmq_init_callback_done = 0;
/**
* add the dmq notification peer.
* the dmq is a peer itself so that it can receive node notifications
*/
if(add_notification_peer()<0) {
LM_ERR("cannot add notification peer\n");
return -1;
}
startup_time = (int) time(NULL);
/**
* add the ping timer
* it pings the servers once in a while so that we know which failed
*/
if(ping_interval < MIN_PING_INTERVAL) {
ping_interval = MIN_PING_INTERVAL;
}
if(register_timer(ping_servers, 0, ping_interval)<0) {
LM_ERR("cannot register timer callback\n");
return -1;
}
return 0;
}
/* initialize ratelimit module */
static int mod_init(void)
{
if(rpc_register_array(rpc_methods)!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(pl_hash_size<=0)
{
LM_ERR("invalid hash size parameter: %d\n", pl_hash_size);
return -1;
}
if(pl_init_htable(1<<pl_hash_size)<0)
{
LM_ERR("could not allocate pipes htable\n");
return -1;
}
if(pl_init_db()<0)
{
LM_ERR("could not load pipes description\n");
return -1;
}
/* register timer to reset counters */
if ((pl_timer = timer_alloc()) == NULL) {
LM_ERR("could not allocate timer\n");
return -1;
}
timer_init(pl_timer, pl_timer_handle, 0, F_TIMER_FAST);
timer_add(pl_timer, MS_TO_TICKS(1000)); /* Start it after 1000ms */
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
network_load_value = shm_malloc(sizeof(int));
if (network_load_value==NULL) {
LM_ERR("oom for network_load_value\n");
return -1;
}
load_value = shm_malloc(sizeof(double));
if (load_value==NULL) {
LM_ERR("oom for load_value\n");
return -1;
}
load_source = shm_malloc(sizeof(int));
if (load_source==NULL) {
LM_ERR("oom for load_source\n");
return -1;
}
pid_kp = shm_malloc(sizeof(double));
if (pid_kp==NULL) {
LM_ERR("oom for pid_kp\n");
return -1;
}
pid_ki = shm_malloc(sizeof(double));
if (pid_ki==NULL) {
LM_ERR("oom for pid_ki\n");
return -1;
}
pid_kd = shm_malloc(sizeof(double));
if (pid_kd==NULL) {
LM_ERR("oom for pid_kd\n");
return -1;
}
_pl_pid_setpoint = shm_malloc(sizeof(double));
if (_pl_pid_setpoint==NULL) {
LM_ERR("oom for pid_setpoint\n");
return -1;
}
drop_rate = shm_malloc(sizeof(int));
if (drop_rate==NULL) {
LM_ERR("oom for drop_rate\n");
return -1;
}
*network_load_value = 0;
*load_value = 0.0;
*load_source = load_source_mp;
*pid_kp = 0.0;
*pid_ki = -25.0;
*pid_kd = 0.0;
*_pl_pid_setpoint = 0.01 * (double)_pl_cfg_setpoint;
*drop_rate = 0;
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
LM_DBG("...\n");
if (register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(min_expires< 0)
min_expires= 0;
if(default_expires< 600)
default_expires= 3600;
/* load TM API */
if(load_tm_api(&tmb)==-1)
{
LM_ERR("can't load tm functions\n");
return -1;
}
db_url.len = db_url.s ? strlen(db_url.s) : 0;
LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.s);
db_table.len = db_table.s ? strlen(db_table.s) : 0;
/* 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 (dbmode != PUA_DB_ONLY)
{
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 (dbmode != PUA_DB_DEFAULT && dbmode != PUA_DB_ONLY)
{
dbmode = PUA_DB_DEFAULT;
LM_ERR( "Invalid dbmode-using default mode\n" );
}
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;
}
if(check_remote_contact<0 || check_remote_contact>1)
{
LM_ERR("bad value for check_remote_contact\n");
return -1;
}
startup_time = (int) time(NULL);
if (update_period > 0) /* probably should check > 5 here!! -croc */
register_timer(hashT_clean, 0, update_period- 5);
if (dbmode != PUA_DB_ONLY)
{
if (update_period > 0)
register_timer(db_update, 0, update_period);
}
if(pua_db)
pua_dbf.close(pua_db);
pua_db = NULL;
outbound_proxy.len = outbound_proxy.s ? strlen(outbound_proxy.s) : 0;
return 0;
}
/*! \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;
}
/**
* init module function
*/
static int mod_init(void)
{
bind_presence_t bind_presence;
presence_api_t pres;
if(passive_mode==1)
return 0;
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n",ZSW(db_url.s),db_url.len, db_url.s);
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
bind_presence= (bind_presence_t)find_export("bind_presence", 1,0);
if (!bind_presence)
{
LM_ERR("Can't bind presence\n");
return -1;
}
if (bind_presence(&pres) < 0)
{
LM_ERR("Can't bind to presence module\n");
return -1;
}
pres_get_sphere= pres.get_sphere;
pres_add_event= pres.add_event;
pres_update_watchers= pres.update_watchers_status;
pres_contains_event= pres.contains_event;
pres_get_presentity= pres.get_presentity;
pres_free_presentity= pres.free_presentity;
if (pres_add_event == NULL || pres_update_watchers== NULL)
{
LM_ERR("Can't import add_event\n");
return -1;
}
if(xml_add_events()< 0)
{
LM_ERR("adding xml events\n");
return -1;
}
if(force_active== 0)
{
/* binding to mysql module */
if (db_bind_mod(&db_url, &pxml_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pxml_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
pxml_db = pxml_dbf.init(&db_url);
if (!pxml_db)
{
LM_ERR("while connecting to database\n");
return -1;
}
if(db_check_table_version(&pxml_dbf, pxml_db, &xcap_table, S_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
if(!integrated_xcap_server )
{
xcap_api_t xcap_api;
bind_xcap_t bind_xcap;
/* bind xcap */
bind_xcap= (bind_xcap_t)find_export("bind_xcap", 1, 0);
if (!bind_xcap)
{
LM_ERR("Can't bind xcap_client\n");
return -1;
}
if (bind_xcap(&xcap_api) < 0)
{
LM_ERR("Can't bind xcap_api\n");
return -1;
}
xcap_GetNewDoc= xcap_api.getNewDoc;
if(xcap_GetNewDoc== NULL)
{
LM_ERR("can't import get_elem from xcap_client module\n");
return -1;
}
if(xcap_api.register_xcb(PRES_RULES, xcap_doc_updated)< 0)
{
LM_ERR("registering xcap callback function\n");
return -1;
}
}
}
if(shm_copy_xcap_list()< 0)
{
LM_ERR("copying xcap server list in share memory\n");
return -1;
}
if(pxml_db)
pxml_dbf.close(pxml_db);
pxml_db = NULL;
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
pv_spec_t avp_spec;
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(ds_init_rpc()<0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
if (dst_avp_param.s)
dst_avp_param.len = strlen(dst_avp_param.s);
if (grp_avp_param.s)
grp_avp_param.len = strlen(grp_avp_param.s);
if (cnt_avp_param.s)
cnt_avp_param.len = strlen(cnt_avp_param.s);
if (dstid_avp_param.s)
dstid_avp_param.len = strlen(dstid_avp_param.s);
if (attrs_avp_param.s)
attrs_avp_param.len = strlen(attrs_avp_param.s);
if (hash_pvar_param.s)
hash_pvar_param.len = strlen(hash_pvar_param.s);
if (ds_setid_pvname.s)
ds_setid_pvname.len = strlen(ds_setid_pvname.s);
if (ds_attrs_pvname.s)
ds_attrs_pvname.len = strlen(ds_attrs_pvname.s);
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);
if (ds_outbound_proxy.s) ds_outbound_proxy.len = strlen(ds_outbound_proxy.s);
if(cfg_declare("dispatcher", dispatcher_cfg_def,
&default_dispatcher_cfg, cfg_sizeof(dispatcher),
&dispatcher_cfg)){
LM_ERR("Fail to declare the configuration\n");
return -1;
}
/* Initialize the counter */
ds_ping_reply_codes = (int**)shm_malloc(sizeof(unsigned int*));
*ds_ping_reply_codes = 0;
ds_ping_reply_codes_cnt = (int*)shm_malloc(sizeof(int));
*ds_ping_reply_codes_cnt = 0;
if(ds_ping_reply_codes_str.s) {
ds_ping_reply_codes_str.len = strlen(ds_ping_reply_codes_str.s);
cfg_get(dispatcher, dispatcher_cfg, ds_ping_reply_codes_str)
= ds_ping_reply_codes_str;
if(ds_parse_reply_codes()< 0)
{
return -1;
}
}
/* Copy Threshhold to Config */
cfg_get(dispatcher, dispatcher_cfg, probing_threshhold)
= probing_threshhold;
if(init_data()!= 0)
return -1;
if(ds_db_url.s)
{
ds_db_url.len = strlen(ds_db_url.s);
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_flags_col.len = strlen(ds_dest_flags_col.s);
ds_dest_priority_col.len = strlen(ds_dest_priority_col.s);
ds_dest_attrs_col.len = strlen(ds_dest_attrs_col.s);
if(init_ds_db()!= 0)
{
LM_ERR("could not initiate a connect to the database\n");
return -1;
}
} else {
if(ds_load_list(dslistfile)!=0) {
LM_ERR("no dispatching list loaded from file\n");
return -1;
} else {
LM_DBG("loaded dispatching list\n");
}
}
if (dst_avp_param.s && dst_avp_param.len > 0)
{
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;
}
} else {
dst_avp_name.n = 0;
dst_avp_type = 0;
}
if (grp_avp_param.s && grp_avp_param.len > 0)
{
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;
}
} else {
grp_avp_name.n = 0;
grp_avp_type = 0;
}
if (cnt_avp_param.s && cnt_avp_param.len > 0)
{
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;
}
} else {
cnt_avp_name.n = 0;
cnt_avp_type = 0;
}
if (dstid_avp_param.s && dstid_avp_param.len > 0)
{
if (pv_parse_spec(&dstid_avp_param, &avp_spec)==0
|| avp_spec.type!=PVT_AVP)
{
LM_ERR("malformed or non AVP %.*s AVP definition\n",
dstid_avp_param.len, dstid_avp_param.s);
return -1;
}
if(pv_get_avp_name(0, &(avp_spec.pvp), &dstid_avp_name,
&dstid_avp_type)!=0)
{
LM_ERR("[%.*s]- invalid AVP definition\n", dstid_avp_param.len,
dstid_avp_param.s);
return -1;
}
} else {
dstid_avp_name.n = 0;
dstid_avp_type = 0;
}
if (attrs_avp_param.s && attrs_avp_param.len > 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.n = 0;
attrs_avp_type = 0;
}
if (hash_pvar_param.s && *hash_pvar_param.s) {
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!=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;
}
}
if(ds_attrs_pvname.s!=0)
{
if(pv_parse_spec(&ds_attrs_pvname, &ds_attrs_pv)==NULL
|| !pv_is_w(&ds_attrs_pv))
{
LM_ERR("[%s]- invalid attrs_pvname\n", ds_attrs_pvname.s);
return -1;
}
}
if (dstid_avp_param.s && dstid_avp_param.len > 0)
{
if(ds_hash_size>0)
{
if(ds_hash_load_init(1<<ds_hash_size, ds_hash_expire,
ds_hash_initexpire)<0)
return -1;
register_timer(ds_ht_timer, NULL, ds_hash_check_interval);
} else {
LM_ERR("call load dispatching DSTID_AVP set but no size"
" for hash table\n");
return -1;
}
}
/* Only, if the Probing-Timer is enabled the TM-API needs to be loaded: */
if (ds_ping_interval > 0)
{
/*****************************************************
* TM-Bindings
*****************************************************/
if (load_tm_api( &tmb ) == -1)
{
LM_ERR("could not load the TM-functions - disable DS ping\n");
return -1;
}
/*****************************************************
* Register the PING-Timer
*****************************************************/
register_timer(ds_check_timer, NULL, ds_ping_interval);
}
return 0;
}
static int mod_init(void)
{
unsigned int n;
if(dlg_ka_interval!=0 && dlg_ka_interval<30) {
LM_ERR("ka interval too low (%d), has to be at least 30\n",
dlg_ka_interval);
return -1;
}
dlg_event_rt[DLG_EVENTRT_START] = route_lookup(&event_rt, "dialog:start");
dlg_event_rt[DLG_EVENTRT_END] = route_lookup(&event_rt, "dialog:end");
dlg_event_rt[DLG_EVENTRT_FAILED] = route_lookup(&event_rt, "dialog:failed");
#ifdef STATISTICS
/* register statistics */
if (register_module_stats( exports.name, mod_stats)!=0 ) {
LM_ERR("failed to register %s statistics\n", exports.name);
return -1;
}
#endif
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if (rpc_register_array(rpc_methods)!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(faked_msg_init()<0)
return -1;
if(dlg_bridge_init_hdrs()<0)
return -1;
/* param checkings */
if (dlg_flag==-1) {
LM_ERR("no dlg flag set!!\n");
return -1;
} else if (dlg_flag>MAX_FLAG) {
LM_ERR("invalid dlg flag %d!!\n",dlg_flag);
return -1;
}
if (rr_param==0 || rr_param[0]==0) {
LM_ERR("empty rr_param!!\n");
return -1;
} else if (strlen(rr_param)>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 (ruri_pvar_param.s==NULL || ruri_pvar_param.len<=0) {
LM_ERR("invalid r-uri PV string\n");
return -1;
}
if(pv_parse_format(&ruri_pvar_param, &ruri_param_model) < 0
|| ruri_param_model==NULL) {
LM_ERR("malformed r-uri PV string: %s\n", ruri_pvar_param.s);
return -1;
}
if (initial_cbs_inscript != 0 && initial_cbs_inscript != 1) {
LM_ERR("invalid parameter for running initial callbacks in-script"
" (must be either 0 or 1)\n");
return -1;
}
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 (detect_spirals != 0 && detect_spirals != 1) {
LM_ERR("invalid value %d for detect_spirals param!!\n",detect_spirals);
return -1;
}
if (dlg_timeout_noreset != 0 && dlg_timeout_noreset != 1) {
LM_ERR("invalid value %d for timeout_noreset param!!\n",
dlg_timeout_noreset);
return -1;
}
/* if statistics are disabled, prevent their registration to core */
if (dlg_enable_stats==0)
exports.stats = 0;
/* 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 ) <0 ) {
LM_ERR("cannot register RR callback\n");
return -1;
}
if (register_script_cb( profile_cleanup, POST_SCRIPT_CB|REQUEST_CB,0)<0) {
LM_ERR("cannot register script callback");
return -1;
}
if (register_script_cb(dlg_cfg_cb,
PRE_SCRIPT_CB|REQUEST_CB,0)<0)
{
LM_ERR("cannot register pre-script ctx callback\n");
return -1;
}
if (register_script_cb(dlg_cfg_cb,
POST_SCRIPT_CB|REQUEST_CB,0)<0)
{
LM_ERR("cannot register post-script ctx callback\n");
return -1;
}
if (register_script_cb( spiral_detect_reset, POST_SCRIPT_CB|REQUEST_CB,0)<0) {
LM_ERR("cannot register req pre-script spiral detection reset callback\n");
return -1;
}
if(dlg_timer_procs<=0) {
if ( register_timer( dlg_timer_routine, 0, 1)<0 ) {
LM_ERR("failed to register timer \n");
return -1;
}
} else {
register_sync_timers(1);
}
/* init handlers */
init_dlg_handlers( rr_param, dlg_flag,
timeout_spec.s?&timeout_avp:0, default_timeout, seq_match_mode);
/* init timer */
if (init_dlg_timer(dlg_ontimeout)!=0) {
LM_ERR("cannot init timer list\n");
return -1;
}
/* sanitize dlg_hash_zie */
if (dlg_hash_size < 1){
LM_WARN("hash_size is smaller "
"then 1 -> rounding from %d to 1\n",
dlg_hash_size);
dlg_hash_size = 1;
}
/* initialized the hash table */
for( n=0 ; n<(8*sizeof(n)) ; n++) {
if (dlg_hash_size==(1<<n))
break;
if (n && 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);
}
}
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 */
dlg_db_mode = dlg_db_mode_param;
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,db_fetch_rows)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
run_load_callbacks();
}
destroy_dlg_callbacks( DLGCB_LOADED );
/* timer process to send keep alive requests */
if(dlg_ka_timer>0 && dlg_ka_interval>0)
register_sync_timers(1);
/* timer process to clean old unconfirmed dialogs */
register_sync_timers(1);
return 0;
}
/*
* mod_init
* Called by kamailio at init time
*/
static int mod_init(void) {
int argc = 1;
char *argt[] = { MOD_NAME, NULL };
char **argv;
struct timeval t1;
struct timeval t2;
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(ap_init_rpc()<0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
if (!filename) {
LM_ERR("insufficient module parameters. Module not loaded.\n");
return -1;
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
_ap_reset_cycles = shm_malloc(sizeof(int));
if(_ap_reset_cycles == NULL) {
LM_ERR("no more shared memory\n");
return -1;
}
*_ap_reset_cycles = _ap_reset_cycles_init;
argv = argt;
PERL_SYS_INIT3(&argc, &argv, &environ);
gettimeofday(&t1, NULL);
my_perl = parser_init();
gettimeofday(&t2, NULL);
if (my_perl==NULL)
goto error;
LM_INFO("perl interpreter has been initialized (%d.%06d => %d.%06d)\n",
(int)t1.tv_sec, (int)t1.tv_usec,
(int)t2.tv_sec, (int)t2.tv_usec);
#ifdef PERL_EXIT_DESTRUCT_END
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
#else
PL_exit_flags |= PERL_EXIT_EXPECTED;
#endif
return 0;
error:
if(_ap_reset_cycles!=NULL)
shm_free(_ap_reset_cycles);
_ap_reset_cycles = NULL;
return -1;
}
static int mod_init(void)
{
LM_DBG("initializing\n");
if (register_mi_mod(exports.name, mi_cmds) != 0) {
LM_ERR("failed to register MI commands\n");
return -1;
}
if (domain_init_rpc() != 0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if (domain_reg_myself !=0 ) {
if (register_check_self_func(domain_check_self) <0 ) {
LM_ERR("failed to register check self function\n");
return -1;
}
}
/* Bind database */
if (domain_db_bind(&db_url)) {
LM_DBG("Usign db_url [%.*s]\n", db_url.len, db_url.s);
LM_ERR("no database module found. Have you configure thed \"db_url\" modparam properly?\n");
return -1;
}
/* Check table versions */
if (domain_db_init(&db_url) < 0) {
LM_ERR("unable to open database connection\n");
return -1;
}
if (domain_db_ver(&domain_table, DOMAIN_TABLE_VERSION) < 0) {
LM_ERR("error during check of domain table version\n");
domain_db_close();
goto error;
}
if (domain_db_ver(&domain_attrs_table, DOMAIN_ATTRS_TABLE_VERSION) < 0) {
LM_ERR("error during check of domain_attrs table version\n");
domain_db_close();
goto error;
}
domain_db_close();
/* Initializing hash tables and hash table variable */
hash_table = (struct domain_list ***)shm_malloc
(sizeof(struct domain_list *));
hash_table_1 = (struct domain_list **)shm_malloc
(sizeof(struct domain_list *) * (DOM_HASH_SIZE + 1));
hash_table_2 = (struct domain_list **)shm_malloc
(sizeof(struct domain_list *) * (DOM_HASH_SIZE + 1));
if ((hash_table == 0) || (hash_table_1 == 0) || (hash_table_2 == 0)) {
LM_ERR("no memory for hash table\n");
goto error;
}
memset(hash_table_1, 0, sizeof(struct domain_list *) *
(DOM_HASH_SIZE + 1));
memset(hash_table_2, 0, sizeof(struct domain_list *) *
(DOM_HASH_SIZE + 1));
*hash_table = hash_table_1;
/* Allocate and initialize locks */
reload_lock = lock_alloc();
if (reload_lock == NULL) {
LM_ERR("cannot allocate reload_lock\n");
goto error;
}
if (lock_init(reload_lock) == NULL) {
LM_ERR("cannot init reload_lock\n");
goto error;
}
/* First reload */
lock_get(reload_lock);
if (reload_tables() == -1) {
lock_release(reload_lock);
LM_CRIT("domain reload failed\n");
goto error;
}
lock_release(reload_lock);
return 0;
error:
destroy();
return -1;
}
int init_black_lists(void)
{
struct bl_head *old_blst_heads;
struct bl_rule *head;
struct bl_rule *tail;
struct bl_rule *it, *it1;
unsigned int old_used_heads;
unsigned int i;
if (!no_shm) {
LM_CRIT("called twice\n");
return -1;
}
no_shm = 0;
old_blst_heads = blst_heads;
blst_heads = (struct bl_head*)shm_malloc(max_heads*sizeof(struct bl_head));
if (blst_heads==NULL) {
LM_ERR("no more shm memory!\n");
return -1;
}
memset( blst_heads, 0, max_heads * sizeof(struct bl_head));
old_used_heads = used_heads;
used_heads = 0;
bl_default_marker = 0;
/*for lists already created, init locks and move them into shm */
for( i=0 ; i<old_used_heads ; i++ ) {
/* duplicate in shm */
it = old_blst_heads[i].first;
head = tail = 0;
for( it1=it ; it ; it=it1 ) {
if (add_rule_to_list( &head, &tail, &it->ip_net,
&it->body, it->port, it->proto, it->flags)!=0) {
LM_ERR("failed to clone rule!\n");
return -1;
}
it1 = it->next;
pkg_free(it);
}
if (create_bl_head( old_blst_heads[i].owner, old_blst_heads[i].flags,
head, tail, &old_blst_heads[i].name )==NULL ) {
LM_ERR("failed to clone head!\n");
return -1;
}
pkg_free(old_blst_heads[i].name.s);
}
pkg_free(old_blst_heads);
/* register timer routine */
if (register_timer( "blcore-expire", delete_expired_routine, 0, 1)<0) {
LM_ERR("failed to register timer\n");
return -1;
}
/* register MI commands */
if (register_mi_mod( "blacklists", mi_bl_cmds)<0) {
LM_ERR("unable to register MI cmds\n");
return -1;
}
return 0;
}
