/**
* init module function
*/
static int mod_init(void)
{
m_tree_t *pt = NULL;
if(mtree_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(pv_parse_spec(&value_param, &pv_value)<00
|| !(pv_is_w(&pv_value)))
{
LM_ERR("cannot parse value pv or is read only\n");
return -1;
}
if (pv_parse_spec(&values_param, &pv_values) <0
|| pv_values.type != PVT_AVP) {
LM_ERR("cannot parse values avp\n");
return -1;
}
if(pv_parse_spec(&dstid_param, &pv_dstid)<0
|| pv_dstid.type!=PVT_AVP)
{
LM_ERR("cannot parse dstid avp\n");
return -1;
}
if(pv_parse_spec(&weight_param, &pv_weight)<0
|| pv_weight.type!=PVT_AVP)
{
LM_ERR("cannot parse dstid avp\n");
return -1;
}
if(pv_parse_spec(&count_param, &pv_count)<0
|| !(pv_is_w(&pv_weight)))
{
LM_ERR("cannot parse count pv or is read-only\n");
return -1;
}
if(mt_fetch_rows<=0)
mt_fetch_rows = 1000;
if(mt_char_list.len<=0)
{
LM_ERR("invalid prefix char list\n");
return -1;
}
LM_DBG("mt_char_list=%s \n", mt_char_list.s);
mt_char_table_init();
/* binding to mysql module */
if(db_bind_mod(&db_url, &mt_dbf))
{
LM_ERR("database module not found\n");
return -1;
}
if (!DB_CAPABILITY(mt_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 = mt_dbf.init(&db_url);
if(db_con==NULL)
{
LM_ERR("failed to connect to the database\n");
return -1;
}
LM_DBG("database connection opened successfully\n");
if ( (mt_lock=lock_alloc())==0) {
LM_CRIT("failed to alloc lock\n");
goto error1;
}
if (lock_init(mt_lock)==0 ) {
LM_CRIT("failed to init lock\n");
goto error1;
}
if(mt_defined_trees())
{
LM_DBG("static trees defined\n");
pt = mt_get_first_tree();
while(pt!=NULL)
{
LM_DBG("loading from tree <%.*s>\n",
pt->tname.len, pt->tname.s);
/* loading all information from database */
if(mt_load_db(pt)!=0)
{
LM_ERR("cannot load info from database\n");
goto error1;
}
pt = pt->next;
}
/* reset db_table value */
db_table.s = "";
db_table.len = 0;
} else {
if(db_table.len<=0)
{
LM_ERR("no trees table defined\n");
goto error1;
}
if(mt_init_list_head()<0)
{
LM_ERR("unable to init trees list head\n");
goto error1;
}
/* loading all information from database */
if(mt_load_db_trees()!=0)
{
LM_ERR("cannot load trees from database\n");
goto error1;
}
}
mt_dbf.close(db_con);
db_con = 0;
#if 0
mt_print_tree(mt_get_first_tree());
#endif
/* success code */
return 0;
error1:
if (mt_lock)
{
lock_destroy( mt_lock );
lock_dealloc( mt_lock );
mt_lock = 0;
}
mt_destroy_trees();
if(db_con!=NULL)
mt_dbf.close(db_con);
db_con = 0;
return -1;
}
/**
* 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;
}
static void destroy(void)
{
if (db_handle)
db_funcs.close(db_handle);
}
/*
* Initialize data structures
*/
int init_addresses(void)
{
if (!db_url.s) {
LM_INFO("db_url parameter of permissions module not set, "
"disabling allow_address\n");
return 0;
} else {
if (db_bind_mod(&db_url, &perm_dbf) < 0) {
LM_ERR("load a database support module\n");
return -1;
}
if (!DB_CAPABILITY(perm_dbf, DB_CAP_QUERY)) {
LM_ERR("database module does not implement 'query' function\n");
return -1;
}
}
addr_hash_table_1 = addr_hash_table_2 = 0;
addr_hash_table = 0;
db_handle = perm_dbf.init(&db_url);
if (!db_handle) {
LM_ERR("unable to connect database\n");
return -1;
}
if(db_check_table_version(&perm_dbf, db_handle, &address_table, TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
perm_dbf.close(db_handle);
return -1;
}
addr_hash_table_1 = new_addr_hash_table();
if (!addr_hash_table_1) return -1;
addr_hash_table_2 = new_addr_hash_table();
if (!addr_hash_table_2) goto error;
addr_hash_table = (struct addr_list ***)shm_malloc
(sizeof(struct addr_list **));
if (!addr_hash_table) {
LM_ERR("no more shm memory for addr_hash_table\n");
goto error;
}
*addr_hash_table = addr_hash_table_1;
subnet_table_1 = new_subnet_table();
if (!subnet_table_1) goto error;
subnet_table_2 = new_subnet_table();
if (!subnet_table_2) goto error;
subnet_table = (struct subnet **)shm_malloc(sizeof(struct subnet *));
if (!subnet_table) {
LM_ERR("no more shm memory for subnet_table\n");
goto error;
}
*subnet_table = subnet_table_1;
domain_list_table_1 = new_domain_name_table();
if (!domain_list_table_1) goto error;
domain_list_table_2 = new_domain_name_table();
if (!domain_list_table_2) goto error;
domain_list_table = (struct domain_name_list ***)shm_malloc(sizeof(struct domain_name_list **));
if (!domain_list_table) {
LM_ERR("no more shm memory for domain name table\n");
goto error;
}
*domain_list_table = domain_list_table_1;
if (reload_address_table() == -1) {
LM_CRIT("reload of address table failed\n");
goto error;
}
perm_dbf.close(db_handle);
db_handle = 0;
return 0;
error:
if (addr_hash_table_1) {
free_addr_hash_table(addr_hash_table_1);
addr_hash_table_1 = 0;
}
if (addr_hash_table_2) {
free_addr_hash_table(addr_hash_table_2);
addr_hash_table_2 = 0;
}
if (addr_hash_table) {
shm_free(addr_hash_table);
addr_hash_table = 0;
}
if (subnet_table_1) {
free_subnet_table(subnet_table_1);
subnet_table_1 = 0;
}
if (subnet_table_2) {
free_subnet_table(subnet_table_2);
subnet_table_2 = 0;
}
if (subnet_table) {
shm_free(subnet_table);
subnet_table = 0;
}
if (domain_list_table_1) {
free_domain_name_table(domain_list_table_1);
domain_list_table_1 = 0;
}
if (domain_list_table_2) {
free_domain_name_table(domain_list_table_2);
domain_list_table_2 = 0;
}
if (domain_list_table) {
shm_free(domain_list_table);
domain_list_table = 0;
}
perm_dbf.close(db_handle);
db_handle = 0;
return -1;
}
/** Module init function */
static int mod_init(void)
{
char* p = NULL;
char* flags = NULL;
int regexp_flags = 0;
int i = 0, j;
pv_spec_t avp_spec;
LM_DBG("start\n");
/* load b2b_entities api */
if(load_b2b_api(&b2b_api)< 0)
{
LM_ERR("Failed to load b2b api\n");
return -1;
}
if(b2bl_hsize< 1 || b2bl_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;
}
b2bl_hsize = 1<<b2bl_hsize;
if(server_address.s == NULL)
{
if(extern_scenarios)
{
LM_ERR("'server_address' parameter not set. This parameter is"
" compulsory if you want to use extern scenarios. It must"
" be set to the IP address of the machine\n");
return -1;
}
}
else
server_address.len = strlen(server_address.s);
if(init_b2bl_htable() < 0)
{
LM_ERR("Failed to initialize b2b logic hash table\n");
return -1;
}
if(b2bl_db_mode && db_url.s)
{
db_url.len = strlen(db_url.s);
b2bl_dbtable.len = strlen(b2bl_dbtable.s);
/* binding to database module */
if (db_bind_mod(&db_url, &b2bl_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(b2bl_dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by b2b_entities module\n");
return -1;
}
b2bl_db = b2bl_dbf.init(&db_url);
if(!b2bl_db)
{
LM_ERR("connecting to database failed\n");
return -1;
}
/*verify table versions */
if(db_check_table_version(&b2bl_dbf, b2bl_db, &b2bl_dbtable, TABLE_VERSION) < 0)
{
LM_ERR("error during table version check\n");
return -1;
}
b2bl_db_init();
/* reload data */
if(b2b_logic_restore() < 0)
{
LM_ERR("Failed to restore data from database\n");
return -1;
}
if(b2bl_db)
b2bl_dbf.close(b2bl_db);
b2bl_db = NULL;
}
else
b2bl_db_mode = 0;
if (b2bl_key_avp_param.s)
b2bl_key_avp_param.len = strlen(b2bl_key_avp_param.s);
if (b2bl_key_avp_param.s && b2bl_key_avp_param.len > 0)
{
if (pv_parse_spec(&b2bl_key_avp_param, &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n",
b2bl_key_avp_param.len, b2bl_key_avp_param.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &b2bl_key_avp_name, &b2bl_key_avp_type)!=0){
LM_ERR("[%.*s]- invalid AVP definition\n", b2bl_key_avp_param.len,
b2bl_key_avp_param.s);
return -1;
}
} else {
b2bl_key_avp_name = -1;
b2bl_key_avp_type = 0;
}
if(b2bl_from_spec_param.s)
{
b2bl_from_spec_param.len = strlen(b2bl_from_spec_param.s);
if(pv_parse_spec(&b2bl_from_spec_param, &b2bl_from_spec)==NULL)
{
LM_ERR("failed to parse b2bl_from spec\n");
return E_CFG;
}
switch(b2bl_from_spec.type) {
case PVT_NONE:
case PVT_EMPTY:
case PVT_NULL:
case PVT_MARKER:
case PVT_COLOR:
LM_ERR("invalid b2bl_from spec\n");
return -1;
default: ;
}
}
/* parse extra headers */
if(custom_headers.s)
custom_headers.len = strlen(custom_headers.s);
memset(custom_headers_lst, 0, HDR_LST_LEN*sizeof(str));
custom_headers_lst[i].s = custom_headers.s;
if(custom_headers.s)
{
p = strchr(custom_headers.s, ';');
while(p)
{
custom_headers_lst[i].len = p - custom_headers_lst[i].s;
/* check if this is among the default headers */
for(j = 0; j< HDR_DEFAULT_LEN; j++)
{
if(custom_headers_lst[i].len == default_headers[j].len &&
strncmp(custom_headers_lst[i].s, default_headers[j].s,
default_headers[j].len)== 0)
goto next_hdr;
}
/* check if defined twice */
for(j = 0; j< i; j++)
{
if(custom_headers_lst[i].len == custom_headers_lst[j].len &&
strncmp(custom_headers_lst[i].s, custom_headers_lst[j].s,
custom_headers_lst[j].len)== 0)
goto next_hdr;
}
i++;
if(i == HDR_LST_LEN)
{
LM_ERR("Too many extra headers defined."
" The maximum value is %d\n.", HDR_LST_LEN);
return -1;
}
next_hdr:
p++;
if(p-custom_headers.s >= custom_headers.len)
break;
custom_headers_lst[i].s = p;
p = strchr(p, ';');
}
}
if(p == NULL)
{
custom_headers_lst[i].len = custom_headers.s + custom_headers.len
- custom_headers_lst[i].s;
if(custom_headers_lst[i].len == 0)
i--;
}
custom_headers_lst_len = i +1;
if(custom_headers_regexp.s)
{
custom_headers_regexp.len = strlen(custom_headers_regexp.s);
if ((custom_headers_re=pkg_malloc(sizeof(regex_t)))==0) {
LM_ERR("no more pkg memory\n");
return -1;
}
if (*custom_headers_regexp.s == '/')
{
flags = (char *)memchr(custom_headers_regexp.s+1, '/',
custom_headers_regexp.len-1);
if (flags)
{
custom_headers_regexp.s++;
custom_headers_regexp.len = flags - custom_headers_regexp.s;
custom_headers_regexp.s[custom_headers_regexp.len] = '\0';
flags++;
while(*flags != '\0')
{
switch (*flags) {
case 'i':
regexp_flags |= REG_ICASE;
break;
case 'e':
regexp_flags |= REG_EXTENDED;
break;
default:
LM_ERR("Unknown option '%c'\n", *flags);
}
flags++;
}
} else {
LM_ERR("Second '/' missing from regexp\n");
return -1;
}
}
if (regcomp(custom_headers_re, custom_headers_regexp.s,
regexp_flags) != 0) {
pkg_free(custom_headers_re);
LM_ERR("bad regexp '%.*s'\n",
custom_headers_regexp.len, custom_headers_regexp.s);
return -1;
}
}
if(init_callid_hdr.s)
init_callid_hdr.len = strlen(init_callid_hdr.s);
register_timer("b2bl-clean", b2bl_clean, 0, b2b_clean_period,
TIMER_FLAG_DELAY_ON_DELAY);
if(b2bl_db_mode == WRITE_BACK)
register_timer("b2bl-dbupdate", b2bl_db_timer_update, 0,
b2b_update_period, TIMER_FLAG_SKIP_ON_DELAY);
return 0;
}
static void destroy(void)
{
curl_global_cleanup();
if(xcap_db != NULL)
xcap_dbf.close(xcap_db);
}
/**
* init module function
*/
static int mod_init(void)
{
DBG("PDT: initializing...\n");
if(hs_two_pow<0)
{
LOG(L_ERR, "PDT:mod_init: hash_size_two_pow must be"
" positive and less than %d\n", MAX_HSIZE_TWO_POW);
return -1;
}
prefix.len = strlen(prefix.s);
/* binding to mysql module */
if(bind_dbmod(db_url, &pdt_dbf))
{
LOG(L_ERR, "PDT:mod_init: Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pdt_dbf, DB_CAP_ALL))
{
LOG(L_ERR, "PDT: mod_init: 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)
{
LOG(L_ERR,
"PDT: mod_init: Error while connecting to database\n");
return -1;
}
if (pdt_dbf.use_table(db_con, db_table) < 0)
{
LOG(L_ERR, "PDT: mod_init: Error in use_table\n");
goto error1;
}
DBG("PDT: mod_init: Database connection opened successfully\n");
/* init the hash and tree in share memory */
if( (_dhash = pdt_init_hash(hs_two_pow)) == NULL)
{
LOG(L_ERR, "PDT:mod_init: domain hash could not be allocated\n");
goto error1;
}
if( (_ptree = pdt_init_tree()) == NULL)
{
LOG(L_ERR, "PDT:mod_init: prefix tree could not be allocated\n");
goto error2;
}
/* loading all information from database */
if(pdt_load_db()!=0)
{
LOG(L_ERR, "PDT:mod_init: cannot load info from database\n");
goto error3;
}
pdt_dbf.close(db_con);
db_con = 0;
pdt_print_tree(_ptree);
DBG("PDT:mod_init: -------------------\n");
pdt_print_hash(_dhash);
last_sync = time(NULL);
register_timer(pdt_clean_cache, 0, clean_time);
/* success code */
return 0;
error3:
if(_ptree!=NULL)
{
pdt_free_tree(_ptree);
_ptree = 0;
}
error2:
if(_dhash!=NULL)
{
pdt_free_hash(_dhash);
_dhash = 0;
}
error1:
if(db_con!=NULL)
{
pdt_dbf.close(db_con);
db_con = 0;
}
return -1;
}
static int mod_init(void)
{
LM_INFO("initializing ...\n");
if(imc_hash_size <= 0)
{
LM_ERR("invalid hash size\n");
return -1;
}
imc_hash_size = 1 << imc_hash_size;
if(imc_htable_init() < 0)
{
LM_ERR("initializing hash table\n");
return -1;
}
imc_cmd_start_str.len = strlen(imc_cmd_start_str.s);
if(outbound_proxy.s)
outbound_proxy.len = strlen(outbound_proxy.s);
rooms_table.len = strlen(rooms_table.s);
members_table.len = strlen(members_table.s);
/* binding to mysql module */
init_db_url( db_url , 0 /*cannot be null*/);
LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.s);
if (db_bind_mod(&db_url, &imc_dbf))
{
LM_DBG("database module not found\n");
return -1;
}
imc_db = imc_dbf.init(&db_url);
if (!imc_db)
{
LM_ERR("failed to connect to the database\n");
return -1;
}
/* read the informations stored in db */
if(add_from_db() <0)
{
LM_ERR("failed to get information from db\n");
return -1;
}
/* load TM API */
if (load_tm_api(&tmb)!=0) {
LM_ERR("unable to load tm api\n");
return -1;
}
imc_cmd_start_char = imc_cmd_start_str.s[0];
if(imc_db)
imc_dbf.close(imc_db);
imc_db = NULL;
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if (xcaps_directory_scheme < -1 || xcaps_directory_scheme > 1)
{
LM_ERR("invalid xcaps_directory_scheme\n");
return -1;
}
if(xcaps_buf.len<=0)
{
LM_ERR("invalid buffer size\n");
return -1;
}
xcaps_buf.s = (char*)pkg_malloc(xcaps_buf.len+1);
if(xcaps_buf.s==NULL)
{
LM_ERR("no pkg\n");
return -1;
}
/* binding to mysql module */
if (db_bind_mod(&xcaps_db_url, &xcaps_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(xcaps_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
xcaps_db = xcaps_dbf.init(&xcaps_db_url);
if (xcaps_db==NULL)
{
LM_ERR("connecting to database\n");
return -1;
}
if(db_check_table_version(&xcaps_dbf, xcaps_db, &xcaps_db_table,
XCAP_TABLE_VERSION) < 0) {
DB_TABLE_VERSION_ERROR(xcaps_db_table);
xcaps_dbf.close(xcaps_db);
xcaps_db = NULL;
return -1;
}
xcaps_dbf.close(xcaps_db);
xcaps_db = NULL;
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
xcaps_init_time = (int)time(NULL);
return 0;
}
static void destroy(void)
{
if(xcaps_db != NULL)
xcaps_dbf.close(xcaps_db);
}
/**
* init module function
*/
static int mod_init(void)
{
bind_presence_t bind_presence;
presence_api_t pres;
bind_xcap_t bind_xcap;
xcap_api_t xcap_api;
/* load XCAP API */
bind_xcap = (bind_xcap_t)find_export("bind_xcap", 1, 0);
if (!bind_xcap)
{
LM_ERR("Can't bind xcap\n");
return -1;
}
if (bind_xcap(&xcap_api) < 0)
{
LM_ERR("Can't bind xcap\n");
return -1;
}
integrated_xcap_server = xcap_api.integrated_server;
db_url = xcap_api.db_url;
xcap_table = xcap_api.xcap_table;
normalizeSipUri = xcap_api.normalize_sip_uri;
xcapParseUri = xcap_api.parse_xcap_uri;
xcapDbGetDoc = xcap_api.get_xcap_doc;
if(force_active==0)
{
if ( verify_db() < 0 )
return -1;
}
/* load SL API */
if(load_sig_api(&xml_sigb)==-1)
{
LM_ERR("can't load signaling functions\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 module pua\n");
return -1;
}
pres_get_sphere= pres.get_sphere;
pres_add_event= pres.add_event;
pres_update_watchers= pres.update_watchers_status;
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(pres_rules_auid.s)
{
pres_rules_auid.len = strlen(pres_rules_auid.s);
if (pres_rules_auid.len == IETF_PRES_RULES_AUID_LEN &&
strncmp(pres_rules_auid.s, IETF_PRES_RULES_AUID, IETF_PRES_RULES_AUID_LEN) == 0)
{
LM_INFO("using IETF mode for pres-rules\n");
pres_rules_doc_id = PRES_RULES;
}
if (pres_rules_auid.len == OMA_PRES_RULES_AUID_LEN &&
strncmp(pres_rules_auid.s, OMA_PRES_RULES_AUID, OMA_PRES_RULES_AUID_LEN) == 0)
{
LM_INFO("using OMA mode for pres-rules\n");
pres_rules_doc_id = OMA_PRES_RULES;
}
else
{
LM_ERR("unrecognized AUID for pres-rules: %.*s\n", pres_rules_auid.len, pres_rules_auid.s);
return -1;
}
}
if(force_active== 0 && !integrated_xcap_server )
{
xcap_client_api_t xcap_client_api;
bind_xcap_client_t bind_xcap_client;
/* bind xcap */
bind_xcap_client = (bind_xcap_client_t)find_export("bind_xcap_client", 1, 0);
if (!bind_xcap_client)
{
LM_ERR("Can't bind xcap_client\n");
return -1;
}
if (bind_xcap_client(&xcap_client_api) < 0)
{
LM_ERR("Can't bind xcap_client_api\n");
return -1;
}
xcap_GetNewDoc= xcap_client_api.getNewDoc;
if(xcap_GetNewDoc== NULL)
{
LM_ERR("can't import getNewDoc from xcap_client module\n");
return -1;
}
if(xcap_client_api.register_xcb(pres_rules_doc_id, xcap_doc_updated) < 0)
{
LM_ERR("registering xcap callback function\n");
return -1;
}
if(pres_rules_filename.s)
pres_rules_filename.len = strlen(pres_rules_filename.s);
}
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;
}
static void pres_db_close(void) {
if (pres_dbh) {
pres_dbf.close(pres_dbh);
pres_dbh = NULL;
}
}
/**
* init module function
*/
static int mod_init(void)
{
if(pres_uri_match == 1) {
presence_sip_uri_match = sip_uri_case_insensitive_match;
} else {
presence_sip_uri_match = sip_uri_case_sensitive_match;
}
if(presence_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len,db_url.s);
if(db_url.s== NULL)
library_mode= 1;
EvList= init_evlist();
if(!EvList){
LM_ERR("unsuccessful initialize event list\n");
return -1;
}
if(library_mode== 1)
{
LM_DBG("Presence module used for API library purpose only\n");
return 0;
}
if(expires_offset<0)
expires_offset = 0;
if(to_tag_pref==NULL || strlen(to_tag_pref)==0)
to_tag_pref="10";
if(max_expires == 0)
max_expires = 3600;
if(min_expires > max_expires)
min_expires = max_expires;
if(min_expires_action < 1 || min_expires_action > 2) {
LM_ERR("min_expires_action must be 1 = RFC 6665/3261 Reply 423, 2 = force min_expires value\n");
return -1;
}
if(server_address.s== NULL)
LM_DBG("server_address parameter not set in configuration file\n");
/* 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. Module TM not loaded?\n");
return -1;
}
if(db_url.s== NULL)
{
LM_ERR("database url not set!\n");
return -1;
}
/* binding to database module */
if (db_bind_mod(&db_url, &pa_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pa_dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by presence module\n");
return -1;
}
pa_db = pa_dbf.init(&db_url);
if (!pa_db)
{
LM_ERR("Connection to database failed\n");
return -1;
}
/*verify table versions */
if((db_check_table_version(&pa_dbf, pa_db, &presentity_table, P_TABLE_VERSION) < 0) ||
(db_check_table_version(&pa_dbf, pa_db, &watchers_table, S_TABLE_VERSION) < 0)) {
LM_ERR("error during table version check\n");
return -1;
}
if(subs_dbmode != NO_DB &&
db_check_table_version(&pa_dbf, pa_db, &active_watchers_table, ACTWATCH_TABLE_VERSION) < 0) {
LM_ERR("wrong table version for %s\n", active_watchers_table.s);
return -1;
}
if(subs_dbmode != DB_ONLY) {
if(shtable_size< 1)
shtable_size= 512;
else
shtable_size= 1<< shtable_size;
subs_htable= new_shtable(shtable_size);
if(subs_htable== NULL)
{
LM_ERR(" initializing subscribe hash table\n");
return -1;
}
if(restore_db_subs()< 0)
{
LM_ERR("restoring subscribe info from database\n");
return -1;
}
}
if(publ_cache_enabled) {
if(phtable_size< 1)
phtable_size= 256;
else
phtable_size= 1<< phtable_size;
pres_htable= new_phtable();
if(pres_htable== NULL)
{
LM_ERR("initializing presentity hash table\n");
return -1;
}
if(pres_htable_restore()< 0)
{
LM_ERR("filling in presentity hash table from database\n");
return -1;
}
}
startup_time = (int) time(NULL);
if(clean_period>0)
{
register_timer(msg_presentity_clean, 0, clean_period);
register_timer(msg_watchers_clean, 0, clean_period);
}
if(db_update_period>0)
register_timer(timer_db_update, 0, db_update_period);
if (pres_waitn_time <= 0)
pres_waitn_time = 5;
if (pres_notifier_poll_rate <= 0)
pres_notifier_poll_rate = 10;
if (pres_notifier_processes < 0 || subs_dbmode != DB_ONLY)
pres_notifier_processes = 0;
if (pres_notifier_processes > 0)
{
if ((pres_notifier_id = shm_malloc(sizeof(int) * pres_notifier_processes)) == NULL)
{
LM_ERR("allocating shared memory\n");
return -1;
}
register_basic_timers(pres_notifier_processes);
}
if (pres_force_delete > 0)
pres_force_delete = 1;
if (pres_log_facility_str) {
int tmp = str2facility(pres_log_facility_str);
if (tmp != -1) {
pres_local_log_facility = tmp;
}
else {
LM_ERR("invalid log facility configured\n");
return -1;
}
}
else {
pres_local_log_facility = cfg_get(core, core_cfg, log_facility);
}
if (db_table_lock_type != 1)
db_table_lock = DB_LOCKING_NONE;
pa_dbf.close(pa_db);
pa_db = NULL;
goto_on_notify_reply=route_lookup(&event_rt, "presence:notify-reply");
if (goto_on_notify_reply>=0 && event_rt.rlist[goto_on_notify_reply]==0)
goto_on_notify_reply=-1; /* disable */
return 0;
}
static void mod_destroy(void)
{
if (db_handle && acc_dbf.close) acc_dbf.close(db_handle);
}
/* close a db connection */
void acc_db_close(void)
{
if (db_handle && acc_dbf.close)
acc_dbf.close(db_handle);
}
/**
* init module function
*/
static int mod_init(void)
{
LM_DBG("...\n");
if(min_expires< 0)
min_expires= 0;
if(default_expires< 600)
default_expires= 3600;
if(pua_rpc_init()<0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
/* load TM API */
if(load_tm_api(&tmb)==-1)
{
LM_ERR("can't load tm functions\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.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 (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 > 5)
register_timer(hashT_clean, 0, update_period- 5);
else if (update_period != 0)
{
LM_ERR("update_period must be 0 or > 5\n");
return -1;
}
if (dbmode != PUA_DB_ONLY)
{
if (update_period > 0)
register_timer(db_update, 0, update_period);
}
if (db_table_lock_write != 1)
db_table_lock = DB_LOCKING_NONE;
if(pua_db)
pua_dbf.close(pua_db);
pua_db = NULL;
return 0;
}
/**
* 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;
}
/** Module initialize function */
static int mod_init(void)
{
/* inspect the parameters */
if(server_hsize< 1 || server_hsize> 20 ||
client_hsize< 1 || client_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;
}
server_hsize = 1<<server_hsize;
client_hsize = 1<<client_hsize;
if(b2b_key_prefix.s)
{
b2b_key_prefix.len = strlen(b2b_key_prefix.s);
if(b2b_key_prefix.len > B2B_MAX_PREFIX_LEN)
{
LM_ERR("b2b_key_prefix [%s] too long. Maximum size %d\n",
b2b_key_prefix.s, B2B_MAX_PREFIX_LEN);
return -1;
}
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1)
{
LM_ERR("can't load tm functions\n");
return -1;
}
/* load the UAC_AUTH API - FIXME it should be loaded only
* if authentication is required */
if(load_uac_auth_api(&uac_auth_api)<0)
{
LM_DBG("authentication functionality disabled:"
" load uac_auth first to enable it\n");
uac_auth_loaded = 0;
}
else
{
uac_auth_loaded = 1;
}
/* initialize the hash tables; they will be allocated in shared memory
* to be accesible by all processes */
if(init_b2b_htables()< 0)
{
LM_ERR("Failed to initialize b2b table\n");
return -1;
}
memset(&b2be_dbf, 0, sizeof(db_func_t));
if(b2be_db_mode && db_url.s)
{
db_url.len = strlen(db_url.s);
/* binding to database module */
if (db_bind_mod(&db_url, &b2be_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(b2be_dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by b2b_entities module\n");
return -1;
}
b2be_db = b2be_dbf.init(&db_url);
if(!b2be_db)
{
LM_ERR("connecting to database failed\n");
return -1;
}
/*verify table versions */
if(db_check_table_version(&b2be_dbf, b2be_db, &b2be_dbtable, TABLE_VERSION) < 0)
{
LM_ERR("error during table version check\n");
return -1;
}
b2be_initialize();
/* reload data */
if(b2b_entities_restore() < 0)
{
LM_ERR("Failed to restore data from database\n");
return -1;
}
if(b2be_db)
b2be_dbf.close(b2be_db);
b2be_db = NULL;
}
else
b2be_db_mode = 0;
if(register_script_cb( b2b_prescript_f, PRE_SCRIPT_CB|REQ_TYPE_CB, 0 ) < 0)
{
LM_ERR("Failed to register prescript function\n");
return -1;
}
if (script_req_route)
{
req_routeid = get_script_route_ID_by_name( script_req_route, rlist, RT_NO);
if (req_routeid < 1)
{
LM_ERR("route <%s> does not exist\n",script_req_route);
return -1;
}
}
if (script_reply_route)
{
reply_routeid = get_script_route_ID_by_name( script_reply_route, rlist, RT_NO);
if (reply_routeid < 1)
{
LM_ERR("route <%s> does not exist\n",script_reply_route);
return -1;
}
}
if(b2b_update_period < 0)
{
LM_ERR("Wrong parameter - b2b_update_period [%d]\n", b2b_update_period);
return -1;
}
if(b2be_db_mode == WRITE_BACK)
register_timer(b2be_db_timer_update, 0, b2b_update_period);
//register_timer(b2be_clean, 0, b2b_update_period);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
bind_presence_t bind_presence;
presence_api_t pres;
bind_pua_t bind_pua;
pua_api_t pua;
bind_libxml_t bind_libxml;
libxml_api_t libxml_api;
bind_xcap_t bind_xcap;
xcap_api_t xcap_api;
char* sep;
LM_DBG("start\n");
if (register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if (dbmode <RLS_DB_DEFAULT || dbmode > RLS_DB_ONLY)
{
LM_ERR( "Invalid dbmode-set to default mode\n" );
dbmode = 0;
}
if(!rls_server_address.s || rls_server_address.len<=0)
{
LM_ERR("server_address parameter not set in configuration file\n");
return -1;
}
if(!rls_integrated_xcap_server && xcap_root== NULL)
{
LM_ERR("xcap_root parameter not set\n");
return -1;
}
/* extract port if any */
if(xcap_root)
{
sep= strchr(xcap_root, ':');
if(sep)
{
char* sep2= NULL;
sep2= strchr(sep+ 1, ':');
if(sep2)
sep= sep2;
str port_str;
port_str.s= sep+ 1;
port_str.len= strlen(xcap_root)- (port_str.s-xcap_root);
if(str2int(&port_str, &xcap_port)< 0)
{
LM_ERR("converting string to int [port]= %.*s\n",
port_str.len, port_str.s);
return -1;
}
if(xcap_port< 0 || xcap_port> 65535)
{
LM_ERR("wrong xcap server port\n");
return -1;
}
*sep= '\0';
}
}
/* 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\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 presence\n");
return -1;
}
pres_contains_event = pres.contains_event;
pres_search_event = pres.search_event;
pres_get_ev_list = pres.get_event_list;
if (rls_expires_offset < 0 )
{
LM_ERR( "Negative expires_offset, defaulted to zero\n" );
rls_expires_offset = 0;
}
if (dbmode == RLS_DB_ONLY)
{
pres_new_shtable = rls_new_shtable;
pres_destroy_shtable = rls_destroy_shtable;
pres_insert_shtable = rls_insert_shtable;
pres_delete_shtable = rls_delete_shtable;
pres_update_shtable = rls_update_shtable;
pres_search_shtable = rls_search_shtable;
pres_update_db_subs_timer = rls_update_db_subs_timer;
}
else
{
pres_new_shtable = pres.new_shtable;
pres_destroy_shtable = pres.destroy_shtable;
pres_insert_shtable = pres.insert_shtable;
pres_delete_shtable = pres.delete_shtable;
pres_update_shtable = pres.update_shtable;
pres_search_shtable = pres.search_shtable;
pres_update_db_subs_timer = pres.update_db_subs_timer;
}
pres_copy_subs = pres.mem_copy_subs;
pres_extract_sdialog_info= pres.extract_sdialog_info;
if(!pres_contains_event || !pres_get_ev_list || !pres_new_shtable ||
!pres_destroy_shtable || !pres_insert_shtable || !pres_delete_shtable
|| !pres_update_shtable || !pres_search_shtable || !pres_copy_subs
|| !pres_extract_sdialog_info)
{
LM_ERR("importing functions from presence module\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.s);
if(xcap_db_url.len==0)
{
xcap_db_url.s = db_url.s;
xcap_db_url.len = db_url.len;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(xcap_db_url.s), xcap_db_url.len, xcap_db_url.s);
if(rlpres_db_url.len==0)
{
rlpres_db_url.s = db_url.s;
rlpres_db_url.len = db_url.len;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(rlpres_db_url.s), rlpres_db_url.len, rlpres_db_url.s);
/* binding to mysql module */
if (db_bind_mod(&db_url, &rls_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (db_bind_mod(&rlpres_db_url, &rlpres_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (db_bind_mod(&xcap_db_url, &rls_xcap_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(rls_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
if (!DB_CAPABILITY(rlpres_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
if (!DB_CAPABILITY(rls_xcap_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
rls_db = rls_dbf.init(&db_url);
if (!rls_db)
{
LM_ERR("while connecting database\n");
return -1;
}
rlpres_db = rlpres_dbf.init(&rlpres_db_url);
if (!rlpres_db)
{
LM_ERR("while connecting database\n");
return -1;
}
rls_xcap_db = rls_xcap_dbf.init(&xcap_db_url);
if (!rls_xcap_db)
{
LM_ERR("while connecting database\n");
return -1;
}
/* verify table version */
if(db_check_table_version(&rls_dbf, rls_db, &rlsubs_table, W_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
/* verify table version */
if(db_check_table_version(&rlpres_dbf, rlpres_db, &rlpres_table, P_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
/* verify table version */
if(db_check_table_version(&rls_xcap_dbf, rls_xcap_db, &rls_xcap_table, X_TABLE_VERSION) < 0)
{
LM_ERR("error during table version check.\n");
return -1;
}
if (dbmode != RLS_DB_ONLY)
{
if(hash_size<=1)
hash_size= 512;
else
hash_size = 1<<hash_size;
rls_table= pres_new_shtable(hash_size);
if(rls_table== NULL)
{
LM_ERR("while creating new hash table\n");
return -1;
}
if(rls_reload_db_subs!=0)
{
if(rls_restore_db_subs()< 0)
{
LM_ERR("while restoring rl watchers table\n");
return -1;
}
}
}
if(rls_db)
rls_dbf.close(rls_db);
rls_db = NULL;
if(rlpres_db)
rlpres_dbf.close(rlpres_db);
rlpres_db = NULL;
if(rls_xcap_db)
rls_xcap_dbf.close(rls_xcap_db);
rls_xcap_db = NULL;
if(waitn_time<= 0)
waitn_time= 5;
if(rls_notifier_poll_rate<= 0)
rls_notifier_poll_rate= 10;
if(rls_notifier_processes<= 0)
rls_notifier_processes= 1;
/* bind libxml wrapper functions */
if((bind_libxml=(bind_libxml_t)find_export("bind_libxml_api", 1, 0))== NULL)
{
LM_ERR("can't import bind_libxml_api\n");
return -1;
}
if(bind_libxml(&libxml_api)< 0)
{
LM_ERR("can not bind libxml api\n");
return -1;
}
XMLNodeGetAttrContentByName= libxml_api.xmlNodeGetAttrContentByName;
XMLDocGetNodeByName= libxml_api.xmlDocGetNodeByName;
XMLNodeGetNodeByName= libxml_api.xmlNodeGetNodeByName;
XMLNodeGetNodeContentByName= libxml_api.xmlNodeGetNodeContentByName;
if(XMLNodeGetAttrContentByName== NULL || XMLDocGetNodeByName== NULL ||
XMLNodeGetNodeByName== NULL || XMLNodeGetNodeContentByName== NULL)
{
LM_ERR("libxml wrapper functions could not be bound\n");
return -1;
}
/* bind pua */
bind_pua= (bind_pua_t)find_export("bind_pua", 1,0);
if (!bind_pua)
{
LM_ERR("Can't bind pua\n");
return -1;
}
if (bind_pua(&pua) < 0)
{
LM_ERR("mod_init Can't bind pua\n");
return -1;
}
if(pua.send_subscribe == NULL)
{
LM_ERR("Could not import send_subscribe\n");
return -1;
}
pua_send_subscribe= pua.send_subscribe;
if(pua.get_record_id == NULL)
{
LM_ERR("Could not import get_record_id\n");
return -1;
}
pua_get_record_id= pua.get_record_id;
if(pua.get_subs_list == NULL)
{
LM_ERR("Could not import get_subs_list\n");
return -1;
}
pua_get_subs_list= pua.get_subs_list;
if(!rls_integrated_xcap_server)
{
/* 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\n");
return -1;
}
xcap_GetNewDoc= xcap_api.getNewDoc;
if(xcap_GetNewDoc== NULL)
{
LM_ERR("Can't import xcap_client functions\n");
return -1;
}
}
if (rlpres_clean_period < 0)
rlpres_clean_period = clean_period;
if (clean_period > 0)
register_timer(rlsubs_table_update, 0, clean_period);
if (rlpres_clean_period > 0)
register_timer(rls_presentity_clean, 0, rlpres_clean_period);
if(dbmode == RLS_DB_ONLY)
{
if ((rls_notifier_id = shm_malloc(sizeof(int) * rls_notifier_processes)) == NULL)
{
LM_ERR("allocating shared memory\n");
return -1;
}
register_basic_timers(rls_notifier_processes);
}
else
register_timer(timer_send_notify, 0, waitn_time);
if ((rls_update_subs_lock = lock_alloc()) == NULL)
{
LM_ERR("Failed to alloc rls_update_subs_lock\n");
return -1;
}
if (lock_init(rls_update_subs_lock) == NULL)
{
LM_ERR("Failed to init rls_updae_subs_lock\n");
return -1;
}
return 0;
}
static void mod_destroy(void)
{
int i;
b2b_rule_t* rule_struct = NULL;
b2b_scenario_t* scenario, *next;
if(b2bl_db)
{
if(b2bl_db_mode==WRITE_BACK)
b2b_logic_dump(1);
b2bl_dbf.close(b2bl_db);
}
scenario = extern_scenarios;
while(scenario)
{
next = scenario->next;
xmlFree(scenario->id.s);
xmlFreeDoc(scenario->doc);
pkg_free(scenario);
scenario = next;
}
scenario = script_scenarios;
while(scenario)
{
next = scenario->next;
xmlFreeDoc(scenario->doc);
b2b_rule_t* prev;
for(i = 0; i< B2B_METHODS_NO; i++)
{
rule_struct = scenario->request_rules[i];
while(rule_struct)
{
prev = rule_struct;
rule_struct = rule_struct->next;
pkg_free(prev);
}
}
rule_struct = scenario->reply_rules;
while(rule_struct)
{
prev = rule_struct;
rule_struct = rule_struct->next;
pkg_free(prev);
}
if(scenario->id.s)
xmlFree(scenario->id.s);
if (scenario->body.s)
xmlFree(scenario->body.s);
if (scenario->body_type.s)
xmlFree(scenario->body_type.s);
pkg_free(scenario);
scenario = next;
}
destroy_b2bl_htable();
}
/**
* 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;
}
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);
presentity_table.len = strlen(presentity_table.s);
active_watchers_table.len = strlen(active_watchers_table.s);
watchers_table.len = strlen(watchers_table.s);
if(db_url.s== NULL)
library_mode= 1;
EvList= init_evlist();
if(!EvList){
LM_ERR("unsuccessful initialize event list\n");
return -1;
}
if(library_mode== 1)
{
LM_DBG("Presence module used for API library purpose only\n");
return 0;
}
if(expires_offset<0)
expires_offset = 0;
if(to_tag_pref==NULL || strlen(to_tag_pref)==0)
to_tag_pref="10";
if(max_expires<= 0)
max_expires = 3600;
if(server_address.s== NULL)
LM_DBG("server_address parameter not set in configuration file\n");
if(server_address.s)
server_address.len= strlen(server_address.s);
else
server_address.len= 0;
/* 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. Module TM not loaded?\n");
return -1;
}
if(db_url.s== NULL)
{
LM_ERR("database url not set!\n");
return -1;
}
/* binding to database module */
if (db_bind_mod(&db_url, &pa_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pa_dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by presence module\n");
return -1;
}
pa_db = pa_dbf.init(&db_url);
if (!pa_db)
{
LM_ERR("Connection to database failed\n");
return -1;
}
/*verify table versions */
if((db_check_table_version(&pa_dbf, pa_db, &presentity_table, P_TABLE_VERSION) < 0) ||
(db_check_table_version(&pa_dbf, pa_db, &watchers_table, S_TABLE_VERSION) < 0)) {
LM_ERR("error during table version check\n");
return -1;
}
if(subs_dbmode != NO_DB &&
db_check_table_version(&pa_dbf, pa_db, &active_watchers_table, ACTWATCH_TABLE_VERSION) < 0) {
LM_ERR("wrong table version for %s\n", active_watchers_table.s);
return -1;
}
if(subs_dbmode != DB_ONLY) {
if(shtable_size< 1)
shtable_size= 512;
else
shtable_size= 1<< shtable_size;
subs_htable= new_shtable(shtable_size);
if(subs_htable== NULL)
{
LM_ERR(" initializing subscribe hash table\n");
return -1;
}
if(restore_db_subs()< 0)
{
LM_ERR("restoring subscribe info from database\n");
return -1;
}
}
if(publ_cache_enabled) {
if(phtable_size< 1)
phtable_size= 256;
else
phtable_size= 1<< phtable_size;
pres_htable= new_phtable();
if(pres_htable== NULL)
{
LM_ERR("initializing presentity hash table\n");
return -1;
}
if(pres_htable_restore()< 0)
{
LM_ERR("filling in presentity hash table from database\n");
return -1;
}
}
startup_time = (int) time(NULL);
if(clean_period>0)
{
register_timer(msg_presentity_clean, 0, clean_period);
register_timer(msg_watchers_clean, 0, clean_period);
}
if(db_update_period>0)
register_timer(timer_db_update, 0, db_update_period);
if (pres_waitn_time <= 0)
pres_waitn_time = 5;
if (pres_notifier_poll_rate <= 0)
pres_notifier_poll_rate = 10;
if (pres_notifier_processes < 0 || subs_dbmode != DB_ONLY)
pres_notifier_processes = 0;
if (pres_notifier_processes > 0)
{
if ((pres_notifier_id = shm_malloc(sizeof(int) * pres_notifier_processes)) == NULL)
{
LM_ERR("allocating shared memory\n");
return -1;
}
register_basic_timers(pres_notifier_processes);
}
pa_dbf.close(pa_db);
pa_db = NULL;
return 0;
}
