static int child_init(int rank)
{
LM_DBG("rank is (%d)\n", rank);
if(sruid_init(&_kex_sruid, '-', NULL, 0)<0)
return -1;
if (rank==PROC_INIT)
return pkg_proc_stats_init();
return pkg_proc_stats_myinit(rank);
}
static int child_init(int rank)
{
if(sruid_init(&_reg_sruid, '-', "uloc", SRUID_INC)<0)
return -1;
if (rank==1) {
/* init stats */
//TODO if parameters are modified via cfg framework do i change them?
update_stat( max_expires_stat, default_registrar_cfg.max_expires );
update_stat( max_contacts_stat, default_registrar_cfg.max_contacts );
update_stat( default_expire_stat, default_registrar_cfg.default_expires );
}
return 0;
}
static int child_init(int rank)
{
if(sruid_init(&_tps_sruid, '-', "tpsh", SRUID_INC)<0)
return -1;
if (rank==PROC_INIT || rank==PROC_MAIN || rank==PROC_TCP_MAIN)
return 0; /* do nothing for the main process */
_tps_db_handle = _tpsdbf.init(&_tps_db_url);
if (!_tps_db_handle) {
LM_ERR("unable to connect database\n");
return -1;
}
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(sruid_init(&_kex_sruid, '-', NULL, 0)<0)
return -1;
if(init_mi_core()<0)
return -1;
#ifdef STATISTICS
if(register_core_stats()<0)
return -1;
if(register_mi_stats()<0)
return -1;
#endif
register_pkg_proc_stats();
pkg_proc_stats_init_rpc();
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
if(sruid_init(&_kex_sruid, '-', NULL, 0)<0)
return -1;
if(init_mi_core()<0)
return -1;
#ifdef STATISTICS
if(register_core_stats()<0)
return -1;
if(register_mi_stats()<0)
return -1;
#endif
register_pkg_proc_stats();
pkg_proc_stats_init_rpc();
/* per module memmory debugging RPC command */
mod_stats_init_rpc();
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
/* Find a database module */
if (db_bind_mod(&_tps_db_url, &_tpsdbf)) {
LM_ERR("unable to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(_tpsdbf, DB_CAP_ALL)) {
LM_CRIT("database modules does not "
"provide all functions needed\n");
return -1;
}
if(_tps_sanity_checks!=0) {
if(sanity_load_api(&scb)<0) {
LM_ERR("cannot bind to sanity module\n");
goto error;
}
}
if(tps_storage_lock_set_init()<0) {
LM_ERR("failed to initialize locks set\n");
return -1;
}
if(sruid_init(&_tps_sruid, '-', "tpsh", SRUID_INC)<0)
return -1;
sr_event_register_cb(SREV_NET_DATA_IN, tps_msg_received);
sr_event_register_cb(SREV_NET_DATA_OUT, tps_msg_sent);
#ifdef USE_TCP
tcp_set_clone_rcvbuf(1);
#endif
if(sr_wtimer_add(tps_storage_clean, NULL, _tps_clean_interval)<0)
return -1;
return 0;
error:
return -1;
}
static int mi_child_init(void)
{
static int done = 0;
if (done)
return 0;
if (db_mode != NO_DB) {
ul_dbh = ul_dbf.init(&db_url);
if (!ul_dbh) {
LM_ERR("failed to connect to database\n");
return -1;
}
}
if(sruid_init(&_ul_sruid, '-', "ulcx", SRUID_INC)<0)
return -1;
done = 1;
return 0;
}
/*!
* \brief Creates a new dialog profile
* \see add_profile_definitions
* \param name profile name
* \param size profile size
* \param has_value set to 0 for a profile without value, otherwise it has a value
* \return pointer to the created dialog on success, NULL otherwise
*/
static struct dlg_profile_table* new_dlg_profile( str *name, unsigned int size,
unsigned int has_value)
{
struct dlg_profile_table *profile;
struct dlg_profile_table *ptmp;
unsigned int len;
unsigned int i;
if ( name->s==NULL || name->len==0 || size==0 ) {
LM_ERR("invalid parameters\n");
return NULL;
}
for( len=0,i=0 ; i<8*sizeof(size) ; i++ ) {
if ( size & (1<<i) ) len++;
}
if (len!=1) {
LM_ERR(" size %u is not power of 2!\n", size);
return NULL;
}
profile = search_dlg_profile(name);
if (profile!=NULL) {
LM_ERR("duplicate dialog profile registered <%.*s>\n",
name->len, name->s);
return NULL;
}
len = sizeof(struct dlg_profile_table) +
size*sizeof(struct dlg_profile_entry) +
name->len + 1;
profile = (struct dlg_profile_table *)shm_malloc(len);
if (profile==NULL) {
LM_ERR("no more shm mem\n");
return NULL;
}
memset( profile , 0 , len);
profile->size = size;
profile->has_value = (has_value==0)?0:1;
/* init lock */
if (lock_init( &profile->lock )==NULL) {
LM_ERR("failed to init lock\n");
shm_free(profile);
return NULL;
}
/* set inner pointers */
profile->entries = (struct dlg_profile_entry*)(profile + 1);
profile->name.s = ((char*)profile->entries) +
size*sizeof(struct dlg_profile_entry);
/* copy the name of the profile */
memcpy( profile->name.s, name->s, name->len );
profile->name.len = name->len;
profile->name.s[profile->name.len] = 0;
/* link profile */
for( ptmp=profiles ; ptmp && ptmp->next; ptmp=ptmp->next );
if (ptmp==NULL) {
profiles = profile;
sruid_init(&_dlg_profile_sruid, '-', "dlgp", SRUID_INC);
} else {
ptmp->next = profile;
}
return profile;
}
int msrp_sruid_init(void)
{
return sruid_init(&_msrp_sruid, '-', "msrp", SRUID_INC);
}
/*! \brief
* Initialize parent
*/
static int mod_init(void)
{
pv_spec_t avp_spec;
str s;
bind_usrloc_t bind_usrloc;
qvalue_t dq;
if(sruid_init(&_reg_sruid, '-', "uloc", SRUID_INC)<0)
return -1;
#ifdef STATISTICS
/* register statistics */
if (register_module_stats( exports.name, mod_stats)!=0 ) {
LM_ERR("failed to register core statistics\n");
return -1;
}
#endif
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
if(cfg_declare("registrar", registrar_cfg_def, &default_registrar_cfg, cfg_sizeof(registrar), ®istrar_cfg)){
LM_ERR("Fail to declare the configuration\n");
return -1;
}
if (rcv_avp_param && *rcv_avp_param) {
s.s = rcv_avp_param; s.len = strlen(s.s);
if (pv_parse_spec(&s, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n", rcv_avp_param);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &rcv_avp_name, &rcv_avp_type)!=0)
{
LM_ERR("[%s]- invalid AVP definition\n", rcv_avp_param);
return -1;
}
} else {
rcv_avp_name.n = 0;
rcv_avp_type = 0;
}
if (reg_callid_avp_param && *reg_callid_avp_param) {
s.s = reg_callid_avp_param; s.len = strlen(s.s);
if (pv_parse_spec(&s, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n", reg_callid_avp_param);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, ®_callid_avp_name, ®_callid_avp_type)!=0)
{
LM_ERR("[%s]- invalid AVP definition\n", reg_callid_avp_param);
return -1;
}
} else {
reg_callid_avp_name.n = 0;
reg_callid_avp_type = 0;
}
bind_usrloc = (bind_usrloc_t)find_export("ul_bind_usrloc", 1, 0);
if (!bind_usrloc) {
LM_ERR("can't bind usrloc\n");
return -1;
}
/* Normalize default_q parameter */
dq = cfg_get(registrar, registrar_cfg, default_q);
if ( dq!= Q_UNSPECIFIED) {
if (dq > MAX_Q) {
LM_DBG("default_q = %d, lowering to MAX_Q: %d\n", dq, MAX_Q);
dq = MAX_Q;
} else if (dq < MIN_Q) {
LM_DBG("default_q = %d, raising to MIN_Q: %d\n", dq, MIN_Q);
dq = MIN_Q;
}
}
cfg_get(registrar, registrar_cfg, default_q) = dq;
if (bind_usrloc(&ul) < 0) {
return -1;
}
if(ul.register_ulcb != NULL)
{
reg_expire_event_rt = route_lookup(&event_rt, "usrloc:contact-expired");
if (reg_expire_event_rt>=0 && event_rt.rlist[reg_expire_event_rt]==0)
reg_expire_event_rt=-1; /* disable */
if (reg_expire_event_rt>=0) {
set_child_rpc_sip_mode();
if(ul.register_ulcb(UL_CONTACT_EXPIRE, reg_ul_expired_contact, 0)< 0)
{
LM_ERR("can not register callback for expired contacts\n");
return -1;
}
}
}
/*
* Import use_domain parameter from usrloc
*/
reg_use_domain = ul.use_domain;
if (sock_hdr_name.s) {
if (sock_hdr_name.len==0 || sock_flag==-1) {
LM_WARN("empty sock_hdr_name or sock_flag no set -> reseting\n");
sock_hdr_name.len = 0;
sock_flag = -1;
}
} else if (sock_flag!=-1) {
LM_WARN("sock_flag defined but no sock_hdr_name -> reseting flag\n");
sock_flag = -1;
}
if (reg_outbound_mode < 0 || reg_outbound_mode > 2) {
LM_ERR("outbound_mode modparam must be 0 (not supported), 1 (supported), or 2 (supported and required)\n");
return -1;
}
if (reg_regid_mode < 0 || reg_regid_mode > 1) {
LM_ERR("regid_mode modparam must be 0 (use with outbound), 1 (use always)\n");
return -1;
}
if (reg_flow_timer < 0 || reg_flow_timer > REG_FLOW_TIMER_MAX
|| (reg_flow_timer > 0 && reg_outbound_mode == REG_OUTBOUND_NONE)) {
LM_ERR("bad value for flow_timer\n");
return -1;
}
/* fix the flags */
sock_flag = (sock_flag!=-1)?(1<<sock_flag):0;
tcp_persistent_flag = (tcp_persistent_flag!=-1)?(1<<tcp_persistent_flag):0;
return 0;
}
static int child_init(int _rank)
{
dlist_t* ptr;
int i;
if(sruid_init(&_ul_sruid, '-', "ulcx", SRUID_INC)<0)
return -1;
if(_rank==PROC_MAIN && ul_timer_procs>0)
{
for(i=0; i<ul_timer_procs; i++)
{
if(fork_sync_timer(PROC_TIMER, "USRLOC Timer", 1 /*socks flag*/,
ul_local_timer, (void*)(long)i, timer_interval /*sec*/)<0) {
LM_ERR("failed to start timer routine as process\n");
return -1; /* error */
}
}
}
/* connecting to DB ? */
switch (db_mode) {
case NO_DB:
return 0;
case DB_ONLY:
case WRITE_THROUGH:
/* connect to db only from SIP workers, TIMER and MAIN processes */
if (_rank<=0 && _rank!=PROC_TIMER && _rank!=PROC_MAIN)
return 0;
break;
case WRITE_BACK:
/* connect to db only from TIMER (for flush), from MAIN (for
* final flush() and from child 1 for preload */
if (_rank!=PROC_TIMER && _rank!=PROC_MAIN && _rank!=PROC_SIPINIT)
return 0;
break;
case DB_READONLY:
/* connect to db only from child 1 for preload */
if(_rank!=PROC_SIPINIT)
return 0;
break;
}
ul_dbh = ul_dbf.init(&db_url); /* Get a database connection per child */
if (!ul_dbh) {
LM_ERR("child(%d): failed to connect to database\n", _rank);
return -1;
}
/* _rank==PROC_SIPINIT is used even when fork is disabled */
if (_rank==PROC_SIPINIT && db_mode!=DB_ONLY) {
/* if cache is used, populate domains from DB */
for( ptr=root ; ptr ; ptr=ptr->next) {
if (preload_udomain(ul_dbh, ptr->d) < 0) {
LM_ERR("child(%d): failed to preload domain '%.*s'\n",
_rank, ptr->name.len, ZSW(ptr->name.s));
return -1;
}
uldb_preload_attrs(ptr->d);
}
}
return 0;
}
/*! \brief
* Module initialization function
*/
static int mod_init(void)
{
int i;
udomain_t* d;
if(sruid_init(&_ul_sruid, '-', "ulcx", SRUID_INC)<0)
return -1;
#ifdef STATISTICS
/* register statistics */
if (register_module_stats( exports.name, mod_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 (rpc_register_array(ul_rpc)!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
/* Compute the lengths of string parameters */
ruid_col.len = strlen(ruid_col.s);
user_col.len = strlen(user_col.s);
domain_col.len = strlen(domain_col.s);
contact_col.len = strlen(contact_col.s);
expires_col.len = strlen(expires_col.s);
q_col.len = strlen(q_col.s);
callid_col.len = strlen(callid_col.s);
cseq_col.len = strlen(cseq_col.s);
flags_col.len = strlen(flags_col.s);
cflags_col.len = strlen(cflags_col.s);
user_agent_col.len = strlen(user_agent_col.s);
received_col.len = strlen(received_col.s);
path_col.len = strlen(path_col.s);
sock_col.len = strlen(sock_col.s);
methods_col.len = strlen(methods_col.s);
instance_col.len = strlen(instance_col.s);
reg_id_col.len = strlen(reg_id_col.s);
last_mod_col.len = strlen(last_mod_col.s);
db_url.len = strlen(db_url.s);
if(ul_xavp_contact_name.s!=NULL)
ul_xavp_contact_name.len = strlen(ul_xavp_contact_name.s);
if(ul_hash_size<=1)
ul_hash_size = 512;
else
ul_hash_size = 1<<ul_hash_size;
ul_locks_no = ul_hash_size;
/* check matching mode */
switch (matching_mode) {
case CONTACT_ONLY:
case CONTACT_CALLID:
case CONTACT_PATH:
break;
default:
LM_ERR("invalid matching mode %d\n", matching_mode);
}
if(ul_init_locks()!=0)
{
LM_ERR("locks array initialization failed\n");
return -1;
}
/* Register cache timer */
if(ul_timer_procs<=0)
{
if (timer_interval > 0)
register_timer(ul_core_timer, 0, timer_interval);
}
else
register_sync_timers(ul_timer_procs);
/* init the callbacks list */
if ( init_ulcb_list() < 0) {
LM_ERR("usrloc/callbacks initialization failed\n");
return -1;
}
/* Shall we use database ? */
if (db_mode != NO_DB) { /* Yes */
if (db_bind_mod(&db_url, &ul_dbf) < 0) { /* Find database module */
LM_ERR("failed to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(ul_dbf, DB_CAP_ALL)) {
LM_ERR("database module does not implement all functions"
" needed by the module\n");
return -1;
}
if(ul_fetch_rows<=0) {
LM_ERR("invalid fetch_rows number '%d'\n", ul_fetch_rows);
return -1;
}
}
if (nat_bflag==(unsigned int)-1) {
nat_bflag = 0;
} else if ( nat_bflag>=8*sizeof(nat_bflag) ) {
LM_ERR("bflag index (%d) too big!\n", nat_bflag);
return -1;
} else {
nat_bflag = 1<<nat_bflag;
}
for(i=0; i<ul_preload_index; i++) {
if(register_udomain((const char*)ul_preload_list[i], &d)<0) {
LM_ERR("cannot register preloaded table %s\n", ul_preload_list[i]);
return -1;
}
}
if (handle_lost_tcp && db_mode == DB_ONLY)
LM_WARN("handle_lost_tcp option makes nothing in DB_ONLY mode\n");
init_flag = 1;
return 0;
}
static int child_init(int rank)
{
if(sruid_init(&_redirect_sruid, '-', "rdir", SRUID_INC)<0)
return -1;
return 0;
}
static int redirect_init(void)
{
regex_t *filter;
void *p;
cmd_function fct;
/* load the TM API */
if (load_tm_api(&rd_tmb)!=0) {
LM_ERR("failed to load TM API\n");
goto error;
}
p = (void*)acc_db_table;
/* fixup table name */
if(fixup_var_pve_str_12(&p, 1)<0) {
LM_ERR("failed to fixup acc db table\n");
goto error;
}
acc_db_table = p;
/* init filter */
init_filters();
/* what's the default rule? */
if (def_filter_s) {
if ( !strcasecmp(def_filter_s,ACCEPT_RULE_STR) ) {
set_default_rule( ACCEPT_RULE );
} else if ( !strcasecmp(def_filter_s,DENY_RULE_STR) ) {
set_default_rule( DENY_RULE );
} else {
LM_ERR("unknown default filter <%s>\n",def_filter_s);
}
}
/* if accept filter specify, compile it */
if (regexp_compile(accept_filter_s, &filter)<0) {
LM_ERR("failed to init accept filter\n");
goto error;
}
add_default_filter( ACCEPT_FILTER, filter);
/* if deny filter specify, compile it */
if (regexp_compile(deny_filter_s, &filter)<0) {
LM_ERR("failed to init deny filter\n");
goto error;
}
add_default_filter( DENY_FILTER, filter);
if(sruid_init(&_redirect_sruid, '-', "rdir", SRUID_INC)<0)
return -1;
if(rd_acc_fct == 0) {
/* import the acc stuff */
if(acc_fct_s != 0 && acc_fct_s[0] == '\0') {
fct = find_export(acc_fct_s, 2, REQUEST_ROUTE);
if(fct == 0)
fct = find_export(acc_fct_s, 1, REQUEST_ROUTE);
if(fct == 0) {
LM_ERR("cannot import %s function; is acc loaded and"
" configured\n", acc_fct_s);
return E_UNSPEC;
}
rd_acc_fct = fct;
}
}
return 0;
error:
return -1;
}
/**
* init module function
*/
static int mod_init(void)
{
bind_pua_t bind_pua;
bind_usrloc_t bind_usrloc;
if (publish_reginfo == 1) {
/* Verify the default domain: */
if(default_domain.s == NULL ) {
LM_ERR("default domain parameter not set\n");
return -1;
}
default_domain.len= strlen(default_domain.s);
}
if(server_address.s== NULL) {
LM_ERR("server_address parameter not set\n");
return -1;
}
server_address.len= strlen(server_address.s);
if(outbound_proxy.s == NULL)
LM_DBG("No outbound proxy set\n");
else
outbound_proxy.len= strlen(outbound_proxy.s);
/* Bind to 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("Can't bind pua\n");
return -1;
}
/* Check for Publish/Subscribe methods */
if(pua.send_publish == NULL) {
LM_ERR("Could not import send_publish\n");
return -1;
}
if(pua.send_subscribe == NULL) {
LM_ERR("Could not import send_subscribe\n");
return -1;
}
/* Bind to URSLOC: */
bind_usrloc = (bind_usrloc_t)find_export("ul_bind_usrloc", 1, 0);
if (!bind_usrloc) {
LM_ERR("Can't bind usrloc\n");
return -1;
}
if (bind_usrloc(&ul) < 0) {
LM_ERR("Can't bind usrloc\n");
return -1;
}
if (publish_reginfo == 1) {
if(ul.register_ulcb == NULL) {
LM_ERR("Could not import ul_register_ulcb\n");
return -1;
}
if(ul.register_ulcb(UL_CONTACT_INSERT, reginfo_usrloc_cb , 0)< 0) {
LM_ERR("can not register callback for insert\n");
return -1;
}
if(ul.register_ulcb(UL_CONTACT_EXPIRE, reginfo_usrloc_cb, 0)< 0) {
LM_ERR("can not register callback for expire\n");
return -1;
}
if(ul.register_ulcb(UL_CONTACT_UPDATE, reginfo_usrloc_cb, 0)< 0) {
LM_ERR("can not register callback for update\n");
return -1;
}
if(ul.register_ulcb(UL_CONTACT_DELETE, reginfo_usrloc_cb, 0)< 0) {
LM_ERR("can not register callback for delete\n");
return -1;
}
}
if(sruid_init(&_reginfo_sruid, (char)'-', "regi", SRUID_INC)<0)
return -1;
return 0;
}