/**
* init module function
*/
static int mod_init(void)
{
pv_spec_t avp_spec;
str host;
int port, proto;
if(ds_ping_active_init() < 0) {
return -1;
}
if(ds_init_rpc() < 0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
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) {
cfg_get(dispatcher, dispatcher_cfg, ds_ping_reply_codes_str) =
ds_ping_reply_codes_str;
if(ds_parse_reply_codes() < 0) {
return -1;
}
}
/* copy threshholds to config */
cfg_get(dispatcher, dispatcher_cfg, probing_threshold) = probing_threshold;
cfg_get(dispatcher, dispatcher_cfg, inactive_threshold) =
inactive_threshold;
if(ds_default_socket.s && ds_default_socket.len > 0) {
if(parse_phostport(
ds_default_socket.s, &host.s, &host.len, &port, &proto)
!= 0) {
LM_ERR("bad socket <%.*s>\n", ds_default_socket.len,
ds_default_socket.s);
return -1;
}
ds_default_sockinfo =
grep_sock_info(&host, (unsigned short)port, proto);
if(ds_default_sockinfo == 0) {
LM_WARN("non-local socket <%.*s>\n", ds_default_socket.len,
ds_default_socket.s);
return -1;
}
LM_INFO("default dispatcher socket set to <%.*s>\n",
ds_default_socket.len, ds_default_socket.s);
}
if(init_data() != 0)
return -1;
if(ds_db_url.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(sock_avp_param.s && sock_avp_param.len > 0) {
if(pv_parse_spec(&sock_avp_param, &avp_spec) == 0
|| avp_spec.type != PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n",
sock_avp_param.len, sock_avp_param.s);
return -1;
}
if(pv_get_avp_name(0, &(avp_spec.pvp), &sock_avp_name, &sock_avp_type)
!= 0) {
LM_ERR("[%.*s]- invalid AVP definition\n", sock_avp_param.len,
sock_avp_param.s);
return -1;
}
} else {
sock_avp_name.n = 0;
sock_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;
if(ds_timer_mode == 1) {
if(sr_wtimer_add(ds_ht_timer, NULL, ds_hash_check_interval) < 0)
return -1;
} else {
if(register_timer(ds_ht_timer, NULL, ds_hash_check_interval)
< 0)
return -1;
}
} else {
LM_ERR("call load dispatching DSTID_AVP set but no size"
" for hash table (see ds_hash_size parameter)\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
*****************************************************/
if(ds_timer_mode == 1) {
if(sr_wtimer_add(ds_check_timer, NULL, ds_ping_interval) < 0)
return -1;
} else {
if(register_timer(ds_check_timer, NULL, ds_ping_interval) < 0)
return -1;
}
}
return 0;
}
static int mod_init(void)
{
str stmp;
LM_INFO("initializing...\n");
/* load SIGNALING API */
if(load_sig_api(&sigb)< 0){
LM_ERR("can't load signaling functions\n");
return -1;
}
/* If the parameter was not used */
if (sec_param == 0) {
/* Generate secret using random generator */
if (generate_random_secret() < 0) {
LM_ERR("failed to generate random secret\n");
return -3;
}
} else {
/* Otherwise use the parameter's value */
secret.s = sec_param;
secret.len = strlen(secret.s);
}
if ( init_rpid_avp(rpid_avp_param)<0 ) {
LM_ERR("failed to process rpid AVPs\n");
return -4;
}
rpid_prefix.len = strlen(rpid_prefix.s);
rpid_suffix.len = strlen(rpid_suffix.s);
realm_prefix.len = strlen(realm_prefix.s);
if(user_spec_param!=0)
{
stmp.s = user_spec_param; stmp.len = strlen(stmp.s);
if(pv_parse_spec(&stmp, &user_spec)==NULL)
{
LM_ERR("failed to parse username spec\n");
return -5;
}
switch(user_spec.type) {
case PVT_NONE:
case PVT_EMPTY:
case PVT_NULL:
case PVT_MARKER:
case PVT_COLOR:
LM_ERR("invalid username spec\n");
return -6;
default: ;
}
}
if(passwd_spec_param!=0)
{
stmp.s = passwd_spec_param; stmp.len = strlen(stmp.s);
if(pv_parse_spec(&stmp, &passwd_spec)==NULL)
{
LM_ERR("failed to parse password spec\n");
return -7;
}
switch(passwd_spec.type) {
case PVT_NONE:
case PVT_EMPTY:
case PVT_NULL:
case PVT_MARKER:
case PVT_COLOR:
LM_ERR("invalid password spec\n");
return -8;
default: ;
}
}
if(!disable_nonce_check)
{
nonce_lock = (gen_lock_t*)lock_alloc();
if(nonce_lock== NULL)
{
LM_ERR("no more shared memory\n");
return -1;
}
/* initialize lock_nonce */
if(lock_init(nonce_lock)== 0)
{
LM_ERR("failed to init lock\n");
return -9;
}
nonce_buf= (char*)shm_malloc(NBUF_LEN);
if(nonce_buf== NULL)
{
LM_ERR("no more share memory\n");
return -10;
}
memset(nonce_buf, 255, NBUF_LEN);
sec_monit= (int*)shm_malloc((nonce_expire +1)* sizeof(int));
if(sec_monit== NULL)
{
LM_ERR("no more share memory\n");
return -10;
}
memset(sec_monit, -1, (nonce_expire +1)* sizeof(int));
second= (int*)shm_malloc(sizeof(int));
next_index= (int*)shm_malloc(sizeof(int));
if(second== NULL || next_index== NULL)
{
LM_ERR("no more share memory\n");
return -10;
}
*next_index= -1;
}
return 0;
}
/**
* The initialization function, called when the module is loaded by
* the script. This function is called only once.
*
* Bind to the dialog module and setup the callbacks. Also initialize
* the shared memory to store our interninal information in.
*
* @return 0 to continue to load the Kamailio, -1 to stop the loading
* and abort Kamailio.
*/
static int mod_init(void)
{
str s;
/* if statistics are disabled, prevent their registration to core. */
if (sst_enable_stats==0) {
exports.stats = 0;
}
#ifdef STATISTICS
/* register statistics */
if (sst_enable_stats!=0)
{
if (register_module_stats( exports.name, mod_stats)!=0 ) {
LM_ERR("failed to register core statistics\n");
return -1;
}
}
#endif
if (sst_flag == -1) {
LM_ERR("no sst flag set!!\n");
return -1;
}
else if (sst_flag > MAX_FLAG) {
LM_ERR("invalid sst flag %d!!\n", sst_flag);
return -1;
}
if (timeout_spec != NULL) {
LM_DBG("Dialog AVP is %s", timeout_spec);
s.s = timeout_spec; s.len = strlen(s.s);
if (pv_parse_spec(&s, &timeout_avp)==0
&& (timeout_avp.type != PVT_AVP)){
LM_ERR("malformed or non AVP timeout AVP definition in '%s'\n",
timeout_spec);
return -1;
}
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* Init the handlers */
sst_handler_init((timeout_spec?&timeout_avp:0), sst_minSE,
sst_flag, sst_reject);
/* Register the main (static) dialog call back. */
if (load_dlg_api(&dialog_st) != 0) {
LM_ERR("failed to load dialog hooks");
return(-1);
}
/* Load dialog hooks */
dialog_st.register_dlgcb(NULL, DLGCB_CREATED, sst_dialog_created_CB, NULL, NULL);
return 0;
}
static int mod_init(void)
{
str def_str = str_init(DEFAULT_PARTITION);
dp_head_p el = dp_get_head(def_str);
LM_INFO("initializing module...\n");
init_db_url( default_dp_db_url , 0 /*can be null*/);
dpid_column.len = strlen(dpid_column.s);
pr_column.len = strlen(pr_column.s);
match_op_column.len = strlen(match_op_column.s);
match_exp_column.len = strlen(match_exp_column.s);
match_flags_column.len = strlen(match_flags_column.s);
subst_exp_column.len = strlen(subst_exp_column.s);
repl_exp_column.len = strlen(repl_exp_column.s);
attrs_column.len = strlen(attrs_column.s);
timerec_column.len = strlen(timerec_column.s);
disabled_column.len = strlen(disabled_column.s);
if (default_dp_db_url.s) {
default_dp_db_url.len = strlen(default_dp_db_url.s);
if (!el) {
default_dp_partition.len = sizeof(DEFAULT_PARTITION) - 1;
default_dp_partition.s = pkg_malloc(default_dp_partition.len);
if (!default_dp_partition.s) {
LM_ERR("No more pkg memory\n");
return -1;
}
memcpy(default_dp_partition.s, DEFAULT_PARTITION,
default_dp_partition.len);
} else {
default_dp_partition.s = el->partition.s;
default_dp_partition.len = el->partition.len;
}
dp_head_insert( DP_TYPE_URL, default_dp_db_url,
default_dp_partition);
}
if (default_dp_table.s) {
if (!default_dp_partition.s) {
if (!el) {
LM_ERR("DB URL not defined for partition default!\n");
return -1;
} else {
default_dp_partition.s = el->partition.s;
default_dp_partition.len = el->partition.len;
}
}
default_dp_table.len = strlen(default_dp_table.s);
dp_head_insert( DP_TYPE_TABLE, default_dp_table,
default_dp_partition);
}
el = dp_hlist;
for (el = dp_hlist; el ; el = el->next) {
//db_url must be set
if (!el->dp_db_url.s) {
LM_ERR("DB URL is not defined for partition %.*s!\n",
el->partition.len,el->partition.s);
return -1;
}
if (!el->dp_table_name.s) {
el->dp_table_name.len = sizeof(DP_TABLE_NAME) - 1;
el->dp_table_name.s = pkg_malloc(el->dp_table_name.len);
if(!el->dp_table_name.s){
LM_ERR("No more pkg mem\n");
return -1;
}
memcpy(el->dp_table_name.s, DP_TABLE_NAME,
el->dp_table_name.len);
}
}
default_par2 = (dp_param_p)shm_malloc(sizeof(dp_param_t));
if(default_par2 == NULL){
LM_ERR("no shm more memory\n");
return -1;
}
memset(default_par2, 0, sizeof(dp_param_t));
default_param_s.len = strlen(default_param_s.s);
if (pv_parse_spec( &default_param_s, &default_par2->v.sp[0])==NULL) {
LM_ERR("input pv is invalid\n");
return -1;
}
default_param_s.len = strlen(default_param_s.s);
if (pv_parse_spec( &default_param_s, &default_par2->v.sp[1])==NULL) {
LM_ERR("output pv is invalid\n");
return -1;
}
dp_print_list();
if(init_data() != 0) {
LM_ERR("could not initialize data\n");
return -1;
}
return 0;
#undef init_db_url_part
}
/* first param: DPID: type: INT, AVP, SVAR
* second param: SRC/DST type: RURI, RURI_USERNAME, AVP, SVAR
* default value for the second param: $ru.user/$ru.user
*/
static int dp_trans_fixup(void ** param, int param_no){
int dpid;
dp_param_p dp_par= NULL;
char *p, *s = NULL;
str lstr, partition_name;
dp_connection_list_t *list = NULL;
if (param_no < 1 || param_no > 3)
return 0;
p = (char*)*param;
if(!p || (*p == '\0')){
LM_DBG("null param %i\n", param_no);
return E_CFG;
}
dp_par = (dp_param_p)pkg_malloc(sizeof(dp_param_t));
if(dp_par == NULL){
LM_ERR("no more pkg memory\n");
return E_OUT_OF_MEM;
}
memset(dp_par, 0, sizeof(dp_param_t));
switch (param_no) {
case 1:
p = parse_dp_command(p, -1, &partition_name);
if (p == NULL) {
LM_ERR("Invalid dp command\n");
return E_CFG;
}
if (!partition_name.s && !partition_name.len) {
partition_name.s = DEFAULT_PARTITION;
partition_name.len = sizeof(DEFAULT_PARTITION) - 1;
}
if (*partition_name.s != PV_MARKER) {
list = dp_get_connection(&partition_name);
if(!list){
LM_ERR("Partition with name [%.*s] is not defined\n",
partition_name.len, partition_name.s );
return -1;
}
dp_par->type = DP_VAL_STR;
} else {
dp_par->type = DP_VAL_SPEC;
}
if (*p != PV_MARKER) {
lstr.s = p; lstr.len = strlen(p);
if(str2sint(&lstr, &dpid) != 0) {
LM_ERR("bad number <%s>\n",(char *)(*param));
pkg_free(dp_par);
return E_CFG;
}
if(dp_par->type == DP_VAL_SPEC){
/*int dpid and pv partition_name*/
dp_par->type = DP_VAL_INT;
dp_par->v.pv_id.id = dpid;
if( !pv_parse_spec( &partition_name,
&dp_par->v.pv_id.partition))
goto error;
} else {
/*DP_VAL_STR remains DP_VAL_STR
( int dpid and str partition_name)*/
dp_par->v.id = dpid;
}
} else {
if (dp_par->type == DP_VAL_STR) {
/*pv dpid and str partition_name*/
dp_par->type = DP_VAL_STR_SPEC;
} else {
/*DP_VAL_SPEC remains DP_VAL_SPEC
( pv dpid and pv partition_name) */
if( !pv_parse_spec( &partition_name,
&dp_par->v.sp[1]))
goto error;
}
lstr.s = p; lstr.len = strlen(p);
if (pv_parse_spec( &lstr, &dp_par->v.sp[0])==NULL)
goto error;
verify_par_type(dp_par->v.sp[0]);
}
dp_par->hash = list;
break;
case 2:
if( ((s = strchr(p, '/')) == 0) ||( *(s+1)=='\0'))
goto error;
*s = '\0'; s++;
lstr.s = p; lstr.len = strlen(p);
if(pv_parse_spec( &lstr, &dp_par->v.sp[0])==NULL)
goto error;
verify_par_type(dp_par->v.sp[0]);
lstr.s = s; lstr.len = strlen(s);
if (pv_parse_spec( &lstr, &dp_par->v.sp[1] )==NULL)
goto error;
verify_par_type(dp_par->v.sp[1]);
if (dp_par->v.sp[1].setf==NULL) {
LM_ERR("the output PV is read-only!!\n");
return E_CFG;
}
dp_par->type = DP_VAL_SPEC;
break;
case 3:
return fixup_pvar(param);
}
*param = (void *)dp_par;
return 0;
error:
LM_ERR("failed to parse param %i\n", param_no);
return E_INVALID_PARAMS;
}
static int mod_init(void) {
unsigned int n;
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 (timeout_spec.s)
timeout_spec.len = strlen(timeout_spec.s);
dlg_bridge_controller.len = strlen(dlg_bridge_controller.s);
/* 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.s == '\0') {
LM_ERR("invalid r-uri PV string\n");
return -1;
}
ruri_pvar_param.len = strlen(ruri_pvar_param.s);
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;
}
/* update the len of the extra headers */
if (dlg_extra_hdrs.s)
dlg_extra_hdrs.len = strlen(dlg_extra_hdrs.s);
if (seq_match_mode != SEQ_MATCH_NO_ID &&
seq_match_mode != SEQ_MATCH_FALLBACK &&
seq_match_mode != SEQ_MATCH_STRICT_ID) {
LM_ERR("invalid value %d for seq_match_mode param!!\n", seq_match_mode);
return -1;
}
if (detect_spirals != 0 && detect_spirals != 1) {
LM_ERR("invalid value %d for detect_spirals param!!\n", detect_spirals);
return -1;
}
/* 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 regsiter script callback");
return -1;
}
if (register_script_cb(dlg_cfg_cb,
PRE_SCRIPT_CB | REQUEST_CB, 0) < 0) {
LM_ERR("cannot regsiter pre-script ctx callback\n");
return -1;
}
if (register_script_cb(dlg_cfg_cb,
POST_SCRIPT_CB | REQUEST_CB, 0) < 0) {
LM_ERR("cannot regsiter 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 (register_timer(dlg_timer_routine, 0, 1) < 0) {
LM_ERR("failed to register timer \n");
return -1;
}
/*for testing only!!!! setup timer to call print all dlg every 10 seconds!*/
if (register_timer(print_all_dlgs, 0, 10) < 0) {
LM_ERR("failed to register timer \n");
return -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;
}
destroy_dlg_callbacks(DLGCB_LOADED);
return 0;
}
static int mod_init(void) {
pv_spec_t avp_spec;
str s;
bind_usrloc_t bind_usrloc;
qvalue_t dq;
/*build the required strings */
scscf_serviceroute_uri_str.s =
(char*) pkg_malloc(orig_prefix.len + scscf_name_str.len);
if (!scscf_serviceroute_uri_str.s) {
LM_ERR("Unable to allocate memory for service route uri\n");
return -1;
}
memcpy(scscf_serviceroute_uri_str.s, orig_prefix.s, orig_prefix.len);
scscf_serviceroute_uri_str.len = orig_prefix.len;
if (scscf_name_str.len > 4
&& strncasecmp(scscf_name_str.s, "sip:", 4) == 0) {
memcpy(scscf_serviceroute_uri_str.s + scscf_serviceroute_uri_str.len,
scscf_name_str.s + 4, scscf_name_str.len - 4);
scscf_serviceroute_uri_str.len += scscf_name_str.len - 4;
} else {
memcpy(scscf_serviceroute_uri_str.s + scscf_serviceroute_uri_str.len,
scscf_name_str.s, scscf_name_str.len);
scscf_serviceroute_uri_str.len += scscf_name_str.len;
}
/* </build required strings> */
#ifdef STATISTICS
/* register statistics */
if (register_module_stats(exports.name, mod_stats) != 0) {
LM_ERR("failed to register core statistics\n");
return -1;
}
if (!register_stats()) {
LM_ERR("Unable to register 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;
}
/* load the TM API */
if (load_tm_api(&tmb) != 0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* load the CDP API */
if (load_cdp_api(&cdpb) != 0) {
LM_ERR("can't load CDP API\n");
return -1;
}
cdp_avp = load_cdp_avp();
if (!cdp_avp) {
LM_ERR("can't load CDP_AVP 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 (aor_avp_param && *aor_avp_param) {
s.s = aor_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", aor_avp_param);
return -1;
}
if (pv_get_avp_name(0, &avp_spec.pvp, &aor_avp_name, &aor_avp_type)
!= 0) {
LM_ERR("[%s]- invalid AVP definition\n", aor_avp_param);
return -1;
}
} else {
aor_avp_name.n = 0;
aor_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;
}
/*Register for callback of URECORD being deleted - so we can send a SAR*/
if (ul.register_ulcb == NULL) {
LM_ERR("Could not import ul_register_ulcb\n");
return -1;
}
if (ul.register_ulcb(0, 0, UL_IMPU_INSERT, ul_impu_inserted, 0) < 0) {
LM_ERR("can not register callback for insert\n");
return -1;
}
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;
}
/* fix the flags */
sock_flag = (sock_flag != -1) ? (1 << sock_flag) : 0;
tcp_persistent_flag =
(tcp_persistent_flag != -1) ? (1 << tcp_persistent_flag) : 0;
/* init the registrar notifications */
if (!notify_init()) return -1;
/* register the registrar notifications timer */
//Currently we do not use this - we send notifies immediately
//if (register_timer(notification_timer, notification_list, 5) < 0) return -1;
return 0;
}
/**
* callback executed for each cfg action
*/
int dbg_cfg_trace(void *data)
{
struct action *a;
struct sip_msg *msg;
int loop;
int olen;
str pvn;
pv_spec_t pvs;
pv_value_t val;
void **srevp;
str *an;
srevp = (void**)data;
a = (struct action *)srevp[0];
msg = (struct sip_msg *)srevp[1];
if(a==NULL || msg==NULL || _dbg_pid_list==NULL)
return 0;
an = dbg_get_action_name(a);
if(_dbg_pid_list[process_no].set&DBG_CFGTRACE_ON)
{
if(is_printable(_dbg_cfgtrace_level))
{
LOG_(_dbg_cfgtrace_facility, _dbg_cfgtrace_level,
_dbg_cfgtrace_prefix,
" c=[%s] l=%d a=%d n=%.*s\n",
ZSW(a->cfile), a->cline, a->type, an->len, ZSW(an->s)
);
}
}
if(!(_dbg_pid_list[process_no].set&DBG_ABKPOINT_ON))
{
/* no breakpoints to be considered */
return 0;
}
if(_dbg_pid_list[process_no].state==DBG_STATE_INIT)
{
LOG(_dbg_cfgtrace_level,
"breakpoint hit: p=[%u] c=[%s] l=%d a=%d n=%.*s\n",
_dbg_pid_list[process_no].pid,
ZSW(a->cfile), a->cline, a->type, an->len, ZSW(an->s)
);
_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
_dbg_pid_list[process_no].state = DBG_STATE_WAIT;
}
loop = 1;
while(loop)
{
switch(_dbg_pid_list[process_no].in.cmd)
{
case DBG_CMD_NOP:
sleep_us(_dbg_step_usleep);
break;
case DBG_CMD_MOVE:
loop = 0;
_dbg_pid_list[process_no].state=DBG_STATE_INIT;
_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
_dbg_pid_list[process_no].in.pid = 0;
break;
case DBG_CMD_NEXT:
loop = 0;
if(_dbg_pid_list[process_no].state==DBG_STATE_WAIT)
_dbg_pid_list[process_no].state=DBG_STATE_NEXT;
_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
olen = snprintf(_dbg_pid_list[process_no].out.buf,
DBG_CMD_SIZE,
"exec [%s:%d] a=%d n=%.*s",
ZSW(a->cfile), a->cline, a->type, an->len, ZSW(an->s));
if(olen<0)
{
_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
break;
}
_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
break;
case DBG_CMD_PVEVAL:
case DBG_CMD_PVLOG:
loop = _dbg_pid_list[process_no].in.cmd;
_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
pvn.s = _dbg_pid_list[process_no].in.buf;
pvn.len = strlen(pvn.s);
if(pvn.len<=0)
{
LM_ERR("no pv to eval\n");
break;
}
LM_DBG("pv to eval: %s\n", pvn.s);
if(pv_parse_spec(&pvn, &pvs)<0)
{
LM_ERR("unable to parse pv [%s]\n", pvn.s);
break;
}
memset(&val, 0, sizeof(pv_value_t));
if(pv_get_spec_value(msg, &pvs, &val) != 0)
{
LM_ERR("unable to get pv value for [%s]\n", pvn.s);
break;
}
if(val.flags&PV_VAL_NULL)
{
if(loop==DBG_CMD_PVEVAL)
{
olen = snprintf(_dbg_pid_list[process_no].out.buf,
DBG_CMD_SIZE,
"%s : t=null",
pvn.s);
if(olen<0)
{
_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
break;
}
_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
} else {
LOG(_dbg_cfgtrace_level,
"breakpoint eval: %s : t=null\n",
pvn.s
);
}
break;
}
if(val.flags&PV_TYPE_INT)
{
if(loop==DBG_CMD_PVEVAL)
{
olen = snprintf(_dbg_pid_list[process_no].out.buf,
DBG_CMD_SIZE,
"%s : t=int v=%d",
pvn.s, val.ri);
if(olen<0)
{
_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
break;
}
_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
} else {
LOG(_dbg_cfgtrace_level,
"breakpoint eval: %s : t=int v=%d\n",
pvn.s, val.ri
);
}
break;
}
if(loop==DBG_CMD_PVEVAL)
{
olen = snprintf(_dbg_pid_list[process_no].out.buf,
DBG_CMD_SIZE,
"%s : t=str v=%.*s",
pvn.s, val.rs.len, val.rs.s);
if(olen<0)
{
_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
break;
}
_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
} else {
LOG(_dbg_cfgtrace_level,
"breakpoint eval: %s : t=str v=%.*s\n",
pvn.s, val.rs.len, val.rs.s
);
}
break;
case DBG_CMD_SHOW:
_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
_dbg_pid_list[process_no].out.cmd = DBG_CMD_NOP;
olen = snprintf(_dbg_pid_list[process_no].out.buf,
DBG_CMD_SIZE,
"at bkp [%s:%d] a=%d n=%.*s",
a->cfile, a->cline, a->type, an->len, an->s);
if(olen<0)
{
_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
break;
}
_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
break;
default:
/* unknown command?!? - exit loop */
_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
_dbg_pid_list[process_no].state=DBG_STATE_INIT;
loop = 0;
}
}
return 0;
}
static int
mod_init(void)
{
pv_spec_t avp_spec;
// initialize the canonical_uri_avp structure
if (canonical_uri_avp.spec.s==NULL || *(canonical_uri_avp.spec.s)==0) {
LM_ERR("missing/empty canonical_uri_avp parameter. using default.\n");
canonical_uri_avp.spec.s = CANONICAL_URI_AVP_SPEC;
}
canonical_uri_avp.spec.len = strlen(canonical_uri_avp.spec.s);
if (pv_parse_spec(&(canonical_uri_avp.spec), &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_CRIT("invalid AVP specification for canonical_uri_avp: `%s'\n", canonical_uri_avp.spec.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &(canonical_uri_avp.name), &(canonical_uri_avp.type))!=0) {
LM_CRIT("invalid AVP specification for canonical_uri_avp: `%s'\n", canonical_uri_avp.spec.s);
return -1;
}
// initialize the signaling_ip_avp structure
if (signaling_ip_avp.spec.s==NULL || *(signaling_ip_avp.spec.s)==0) {
LM_ERR("missing/empty signaling_ip_avp parameter. using default.\n");
signaling_ip_avp.spec.s = SIGNALING_IP_AVP_SPEC;
}
signaling_ip_avp.spec.len = strlen(signaling_ip_avp.spec.s);
if (pv_parse_spec(&(signaling_ip_avp.spec), &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_CRIT("invalid AVP specification for signaling_ip_avp: `%s'\n", signaling_ip_avp.spec.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &(signaling_ip_avp.name), &(signaling_ip_avp.type))!=0) {
LM_CRIT("invalid AVP specification for signaling_ip_avp: `%s'\n", signaling_ip_avp.spec.s);
return -1;
}
// initialize the call_limit_avp structure
if (call_limit_avp.spec.s==NULL || *(call_limit_avp.spec.s)==0) {
LM_ERR("missing/empty call_limit_avp parameter. using default.\n");
call_limit_avp.spec.s = CALL_LIMIT_AVP_SPEC;
}
call_limit_avp.spec.len = strlen(call_limit_avp.spec.s);
if (pv_parse_spec(&(call_limit_avp.spec), &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_CRIT("invalid AVP specification for call_limit_avp: `%s'\n", call_limit_avp.spec.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &(call_limit_avp.name), &(call_limit_avp.type))!=0) {
LM_CRIT("invalid AVP specification for call_limit_avp: `%s'\n", call_limit_avp.spec.s);
return -1;
}
// initialize the call_token_avp structure
if (call_token_avp.spec.s==NULL || *(call_token_avp.spec.s)==0) {
LM_ERR("missing/empty call_token_avp parameter. using default.\n");
call_token_avp.spec.s = CALL_TOKEN_AVP_SPEC;
}
call_token_avp.spec.len = strlen(call_token_avp.spec.s);
if (pv_parse_spec(&(call_token_avp.spec), &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_CRIT("invalid AVP specification for call_token_avp: `%s'\n", call_token_avp.spec.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &(call_token_avp.name), &(call_token_avp.type))!=0) {
LM_CRIT("invalid AVP specification for call_token_avp: `%s'\n", call_token_avp.spec.s);
return -1;
}
// initialize the diverter_avp structure
if (diverter_avp.spec.s==NULL || *(diverter_avp.spec.s)==0) {
LM_ERR("missing/empty diverter_avp parameter. using default.\n");
diverter_avp.spec.s = DIVERTER_AVP_SPEC;
}
diverter_avp.spec.len = strlen(diverter_avp.spec.s);
if (pv_parse_spec(&(diverter_avp.spec), &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_CRIT("invalid AVP specification for diverter_avp: `%s'\n", diverter_avp.spec.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &(diverter_avp.name), &(diverter_avp.type))!=0) {
LM_CRIT("invalid AVP specification for diverter_avp: `%s'\n", diverter_avp.spec.s);
return -1;
}
// bind to the dialog API
if (load_dlg_api(&dlg_api)!=0) {
LM_CRIT("cannot load the dialog module API\n");
return -1;
}
// register dialog loading callback
if (dlg_api.register_dlgcb(NULL, DLGCB_LOADED, __dialog_loaded, NULL, NULL) != 0) {
LM_CRIT("cannot register callback for dialogs loaded from the database\n");
}
fix_flag_name(prepaid_account_str, prepaid_account_flag);
prepaid_account_flag = get_flag_id_by_name(FLAG_TYPE_MSG, prepaid_account_str);
return 0;
}
static int
mod_init(void)
{
bind_usrloc_t ul_bind_usrloc;
pv_spec_t avp_spec;
// initialize the signaling_ip_avp structure
if (signaling_ip_avp.spec.s==NULL || *(signaling_ip_avp.spec.s)==0) {
LM_WARN("missing/empty signaling_ip_avp parameter. will use default.\n");
signaling_ip_avp.spec.s = SIGNALING_IP_AVP_SPEC;
}
signaling_ip_avp.spec.len = strlen(signaling_ip_avp.spec.s);
if (pv_parse_spec(&(signaling_ip_avp.spec), &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_CRIT("invalid AVP specification for signaling_ip_avp: `%s'\n", signaling_ip_avp.spec.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &(signaling_ip_avp.name), &(signaling_ip_avp.type))!=0) {
LM_CRIT("invalid AVP specification for signaling_ip_avp: `%s'\n", signaling_ip_avp.spec.s);
return -1;
}
// initialize the domain_avp structure
if (domain_avp.spec.s==NULL || *(domain_avp.spec.s)==0) {
LM_WARN("missing/empty domain_avp parameter. will use default.\n");
domain_avp.spec.s = DOMAIN_AVP_SPEC;
}
domain_avp.spec.len = strlen(domain_avp.spec.s);
if (pv_parse_spec(&(domain_avp.spec), &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_CRIT("invalid AVP specification for domain_avp: `%s'\n", domain_avp.spec.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &(domain_avp.name), &(domain_avp.type))!=0) {
LM_CRIT("invalid AVP specification for domain_avp: `%s'\n", domain_avp.spec.s);
return -1;
}
isFromLocal = (CheckLocalPartyProc)find_export("is_from_local", 0, 0);
isDestinationLocal = (CheckLocalPartyProc)find_export("is_uri_host_local", 0, 0);
if (!isFromLocal || !isDestinationLocal) {
LM_CRIT("can't find the is_from_local and/or is_uri_host_local "
"functions. Check if domain.so is loaded\n");
return -1;
}
if (natpingInterval > 0) {
ul_bind_usrloc = (bind_usrloc_t)find_export("ul_bind_usrloc", 1, 0);
if (!ul_bind_usrloc) {
LM_CRIT("can't find the usrloc module. Check if usrloc.so is loaded.\n");
return -1;
}
if (ul_bind_usrloc(&userLocation) < 0) {
LM_CRIT("can't access the usrloc module.\n");
return -1;
}
if (userLocation.nat_flag==0) {
LM_CRIT("bad config - nat ping enabled, but no nat bflag set in "
"the usrloc module\n");
return -1;
}
register_timer(pingClients, NULL, natpingInterval);
}
checkAsymmetricFile(&sipAsymmetrics);
checkAsymmetricFile(&rtpAsymmetrics);
// children won't benefit from this. figure another way
//register_timer(checkAsymmetricFiles, NULL, 5);
return 0;
}
