/** 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;
}
static int mod_init(void)
{
LM_INFO("initializing...\n");
int rr_api_loaded=0;
if ( is_script_func_used("uac_auth", -1) ) {
/* load the UAC_AUTH API as uac_auth() is invoked from script */
if(load_uac_auth_api(&uac_auth_api)<0){
LM_ERR("can't load UAC_AUTH API, needed for uac_auth()\n");
goto error;
}
}
/* load the TM API - FIXME it should be loaded only
* if NO_RESTORE and AUTH */
if (load_tm_api(&uac_tmb)!=0) {
LM_ERR("can't load TM API\n");
goto error;
}
if (restore_mode_str && *restore_mode_str) {
if (strcasecmp(restore_mode_str,"none")==0) {
restore_mode = UAC_NO_RESTORE;
} else if (strcasecmp(restore_mode_str,"manual")==0) {
restore_mode = UAC_MANUAL_RESTORE;
} else if (strcasecmp(restore_mode_str,"auto")==0) {
restore_mode = UAC_AUTO_RESTORE;
} else {
LM_ERR("unsupported value '%s' for restore_mode\n",
restore_mode_str);
goto error;
}
}
if ( is_script_func_used("uac_replace_from", -1) ||
is_script_func_used("uac_replace_to", -1) ) {
/* replace TO/FROM stuff is used, get prepared */
rr_from_param.len = strlen(rr_from_param.s);
rr_to_param.len = strlen(rr_to_param.s);
if ( (rr_from_param.len==0 || rr_to_param.len==0) &&
restore_mode!=UAC_NO_RESTORE) {
LM_ERR("rr_store_param cannot be empty if FROM is restoreable\n");
goto error;
}
uac_passwd.len = strlen(uac_passwd.s);
if (restore_mode!=UAC_NO_RESTORE) {
/* load the RR API */
if (load_rr_api(&uac_rrb)!=0) {
LM_ERR("can't load RR API\n");
goto error;
}
rr_api_loaded=1;
if (restore_mode==UAC_AUTO_RESTORE) {
/* we need the append_fromtag on in RR */
if (!force_dialog && !uac_rrb.append_fromtag) {
LM_ERR("'append_fromtag' RR param is not enabled!"
" - required by AUTO restore mode\n");
goto error;
}
/* trying to load dialog module */
memset(&dlg_api, 0, sizeof(struct dlg_binds));
if (load_dlg_api(&dlg_api)!=0) {
if (force_dialog) {
LM_ERR("cannot force dialog. dialog module not loaded\n");
goto error;
}
LM_DBG("failed to find dialog API - is dialog module loaded?\n");
} else {
if ( (parse_store_bavp(&store_to_bavp, &to_bavp_spec) ||
parse_store_bavp(&store_from_bavp, &from_bavp_spec))) {
LM_ERR("cannot set correct store parameters\n");
goto error;
}
/* install calback to catch all loaded dialogs */
if ( dlg_api.register_dlgcb( NULL, DLGCB_LOADED,
dlg_restore_callback, NULL, NULL) != 0 ) {
LM_ERR("failed to install dialog restore callback\n");
goto error;
}
}
/* get all requests doing loose route */
if (uac_rrb.register_rrcb( rr_checker, 0, 2)!=0) {
LM_ERR("failed to install RR callback\n");
goto error;
}
}
}
/* init from replacer */
init_from_replacer();
}
if (is_script_func_used("uac_auth", -1)) {
if (!rr_api_loaded) {
if (load_rr_api(&uac_rrb)!=0) {
LM_ERR("can't load RR API\n");
goto error;
}
}
if (!uac_rrb.append_fromtag) {
LM_ERR("'append_fromtag' RR param is not enabled!"
" - required by uac_auth() restore mode\n");
goto error;
}
if (uac_rrb.register_rrcb( rr_uac_auth_checker, 0, 2)!=0) {
LM_ERR("failed to install RR callback\n");
goto error;
}
}
return 0;
error:
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_INFO("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);
b2be_dbtable.len = strlen(b2be_dbtable.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-dbupdate", b2be_db_timer_update, 0,
b2b_update_period);
//register_timer("b2b2-clean", b2be_clean, 0, b2b_update_period);
return 0;
}
/** Module init function */
static int mod_init(void)
{
uac_reg_map_t *_uac_param, *uac_param = uac_params;
char *p = NULL;
int len = 0;
str now = {NULL, 0};
LM_DBG("start\n");
regfree(&uac_params_regex);
if(load_uac_auth_api(&uac_auth_api)<0){
LM_ERR("Failed to load uac_auth api\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;
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1) {
LM_ERR("can't load tm functions\n");
return -1;
}
p = int2str((unsigned long)(time(0)), &len);
if (p && len>0) {
now.s = (char *)pkg_malloc(len);
if(now.s) {
memcpy(now.s, p, len);
now.len = len;
} else {
LM_ERR("oom\n");
return -1;
}
}
while(uac_param) {
LM_DBG("let's register [%.*s] on [%.*s] from hash table [%d]\n",
uac_param->to_uri.len, uac_param->to_uri.s,
uac_param->registrar_uri.len, uac_param->registrar_uri.s,
uac_param->hash_code);
if(add_record(uac_param, &now)<0) {
LM_ERR("can't load registrant\n");
if (now.s) {pkg_free(now.s);}
return -1;
}
_uac_param = uac_param;
uac_param = uac_param->next;
pkg_free(_uac_param);
}
uac_params = NULL;
if (now.s) {pkg_free(now.s);}
register_timer(timer_check, 0, timer_interval/reg_hsize);
return 0;
}
