/*
* Initialize parameters containing the ID of
* AVPs with variable timers
*/
int init_avp_params(char *fr_timer_param, char *fr_inv_timer_param)
{
if (fr_timer_param && *fr_timer_param) {
fr_timer_str.s = fr_timer_param;
fr_timer_str.len = strlen(fr_timer_str.s);
if (parse_avp_spec( &fr_timer_str, &fr_timer_avp_type,
&fr_timer_avp, &fr_timer_index)<0) {
LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_timer "
"AVP specs \"%s\"\n", fr_timer_param);
return -1;
}
}
if (fr_inv_timer_param && *fr_inv_timer_param) {
fr_inv_timer_str.s = fr_inv_timer_param;
fr_inv_timer_str.len = strlen(fr_inv_timer_str.s);
if (parse_avp_spec( &fr_inv_timer_str, &fr_inv_timer_avp_type,
&fr_inv_timer_avp, &fr_inv_timer_index)<0) {
LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_inv_timer "
"AVP specs \"%s\"\n", fr_inv_timer_param);
return -1;
}
}
return 0;
}
int get_avp_id(str *name)
{
int id;
if (parse_avp_spec(name, &id)) {
LM_ERR("unable to get id\n");
return -1;
}
return id;
}
int init_serialization(void)
{
str alias = { SERIAL_AVP_ALIAS, sizeof(SERIAL_AVP_ALIAS)-1 };
if (parse_avp_spec(&alias, &serial_avp)) {
LM_ERR("cannot parse avp spec\n");
return -1;
}
return 0;
}
/*
* Parses avps used by this module
* return 0 success, -1 failure
*/
int ospParseAvps(void)
{
if (parse_avp_spec(&OSP_INBOUND_NAME, &_osp_inbound_avpid)) {
LM_ERR("cannot get INBOUND AVP id\n");
return -1;
}
if (parse_avp_spec(&OSP_ORIGDEST_NAME, &_osp_origdest_avpid)) {
LM_ERR("cannot get ORIGDEST AVP id\n");
return -1;
}
if (parse_avp_spec(&OSP_TERMDEST_NAME, &_osp_termdest_avpid)) {
LM_ERR("cannot get TERMDEST AVP id\n");
return -1;
}
if (parse_avp_spec(&OSP_CALLING_NAME, &_osp_calling_avpid)) {
LM_ERR("cannot get CALLING AVP id\n");
return -1;
}
return 0;
}
int t_set_reason(struct sip_msg *msg, str *val)
{
str avp_name = str_init("_reason_avp_internal");
int_str reason;
if (_reason_avp_id==0) {
if (parse_avp_spec( &avp_name, &_reason_avp_id) ) {
LM_ERR("failed to init the internal AVP\n");
return -1;
}
}
reason.s = *val;
if (add_avp( AVP_VAL_STR, _reason_avp_id, reason)!=0) {
LM_ERR("failed to add the internal reason AVP\n");
return -1;
}
return 1;
}
/**
* types: cdr, missed
* case insesitive
*
*/
static inline
unsigned long long do_acc_flags_parser(str* token)
{
str_trim_spaces_lr(*token);
if (token->len == do_acc_cdr_s.len &&
!strncasecmp(token->s, do_acc_cdr_s.s, token->len)) {
if (!is_cdr_enabled) {
if (parse_avp_spec( &acc_created_avp_name, &acc_created_avp_id) < 0) {
LM_ERR("failed to register AVP name <%s>\n", acc_created_avp_name.s);
return -1;
}
if (load_dlg_api(&dlg_api)!=0)
LM_DBG("failed to find dialog API - is dialog module loaded?\n");
if (!dlg_api.get_dlg) {
LM_WARN("error loading dialog module - cdrs cannot be generated\n");
return 0;
}
if (dlg_api.get_dlg && dlg_api.register_dlgcb(NULL,
DLGCB_LOADED,acc_loaded_callback, NULL, NULL) < 0)
LM_ERR("cannot register callback for dialog loaded - accounting "
"for ongoing calls will be lost after restart\n");
is_cdr_enabled=1;
}
return DO_ACC_CDR;
} else if (token->len == do_acc_missed_s.len &&
!strncasecmp(token->s, do_acc_missed_s.s, token->len)) {
/* load dialog module if these are used */
return DO_ACC_MISSED;
} else if (token->len == do_acc_failed_s.len &&
!strncasecmp(token->s, do_acc_failed_s.s, token->len)) {
return DO_ACC_FAILED;
} else {
return -1;
}
}
static struct usr_avp *pack_evi_params_as_avp_list(evi_params_t *params)
{
struct usr_avp *avp, *head=NULL;
evi_param_t *e_param;
int_str val;
int avp_id;
/* take all the EVI parameters and convert them into AVPs */
for( e_param=params->first ; e_param ; e_param=e_param->next ) {
/* get an AVP name matching the param name */
if (parse_avp_spec( &e_param->name, &avp_id)<0) {
LM_ERR("cannot get AVP ID for name <%.*s>, skipping..\n",
e_param->name.len, e_param->name.s);
continue;
}
/* create a new AVP */
if (e_param->flags&EVI_STR_VAL) {
val.s = e_param->val.s;
avp = new_avp( AVP_VAL_STR, avp_id, val);
} else if (e_param->flags&EVI_INT_VAL) {
val.n = e_param->val.n;
avp = new_avp( 0, avp_id, val);
} else {
LM_BUG("EVI param no STR, nor INT, ignoring...\n");
continue;
}
if (avp==NULL) {
LM_ERR("cannot get create new AVP name <%.*s>, skipping..\n",
e_param->name.len, e_param->name.s);
continue;
}
/* link the AVP */
avp->next = head;
head = avp;
}
return head;
}
/*
* Initialize parameters containing the ID of
* AVPs with various timers
*/
int init_avp_params(char *fr_timer_param, char *fr_inv_timer_param)
{
pv_spec_t avp_spec;
unsigned short avp_type;
if (fr_timer_param && *fr_timer_param) {
fr_timer_str.s = fr_timer_param;
fr_timer_str.len = strlen(fr_timer_str.s);
LM_WARN("using AVP for TM fr_timer is deprecated,"
" use t_set_fr(...) instead\n");
if(fr_timer_str.s[0]==PV_MARKER) {
if (pv_parse_spec(&fr_timer_str, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n",
fr_timer_param);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &fr_timer_avp, &avp_type)!=0)
{
LM_ERR("[%s]- invalid AVP definition\n", fr_timer_param);
return -1;
}
fr_timer_avp_type = avp_type;
} else {
if (parse_avp_spec( &fr_timer_str, &fr_timer_avp_type,
&fr_timer_avp, &fr_timer_index)<0) {
LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_timer "
"AVP specs \"%s\"\n", fr_timer_param);
return -1;
}
/* ser flavour uses the To track of AVPs */
fr_timer_avp_type |= AVP_TRACK_TO;
}
}
if (fr_inv_timer_param && *fr_inv_timer_param) {
fr_inv_timer_str.s = fr_inv_timer_param;
fr_inv_timer_str.len = strlen(fr_inv_timer_str.s);
LM_WARN("using AVP for TM fr_inv_timer is deprecated,"
" use t_set_fr(...) instead\n");
if(fr_inv_timer_str.s[0]==PV_MARKER) {
if (pv_parse_spec(&fr_inv_timer_str, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n",
fr_inv_timer_param);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &fr_inv_timer_avp,
&avp_type)!=0)
{
LM_ERR("[%s]- invalid AVP definition\n", fr_inv_timer_param);
return -1;
}
fr_inv_timer_avp_type = avp_type;
} else {
if (parse_avp_spec( &fr_inv_timer_str, &fr_inv_timer_avp_type,
&fr_inv_timer_avp, &fr_inv_timer_index)<0) {
LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_inv_timer "
"AVP specs \"%s\"\n", fr_inv_timer_param);
return -1;
}
/* ser flavour uses the To track of AVPs */
fr_inv_timer_avp_type |= AVP_TRACK_TO;
}
}
return 0;
}
static int mod_init(void)
{
LM_INFO("Load-Balancer module - initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
/* Load dialog API */
if (load_dlg_api(&lb_dlg_binds) != 0) {
LM_ERR("Can't load dialog hooks\n");
return -1;
}
if (fetch_freeswitch_stats) {
if (load_fs_api(&fs_api) == -1) {
LM_ERR("failed to load the FS API!\n");
return -1;
}
}
/* data pointer in shm */
curr_data = (struct lb_data**)shm_malloc( sizeof(struct lb_data*) );
if (curr_data==0) {
LM_CRIT("failed to get shm mem for data ptr\n");
return -1;
}
*curr_data = 0;
/* create & init lock */
if ((ref_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
return -1;
}
if (init_lb_bls()) {
LM_ERR("BL INIT failed\n");
return -1;
}
/* init and open DB connection */
if (init_lb_db(&db_url, table_name)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
/* load data */
if ( lb_reload_data()!=0 ) {
LM_CRIT("failed to load load-balancing data\n");
return -1;
}
/* close DB connection */
lb_close_db();
/* arm a function for probing */
if (lb_prob_interval) {
/* load TM API */
if (load_tm_api(&lb_tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* probing method */
lb_probe_method.len = strlen(lb_probe_method.s);
lb_probe_from.len = strlen(lb_probe_from.s);
if (lb_probe_replies.s)
lb_probe_replies.len = strlen(lb_probe_replies.s);
/* register pinger function */
if (register_timer( "lb-pinger", lb_prob_handler , NULL,
lb_prob_interval, TIMER_FLAG_DELAY_ON_DELAY)<0) {
LM_ERR("failed to register probing handler\n");
return -1;
}
/* Register the max load recalculation timer */
if (fetch_freeswitch_stats &&
register_timer("lb-update-max-load", lb_update_max_loads, NULL,
fs_api.stats_update_interval, TIMER_FLAG_SKIP_ON_DELAY)<0) {
LM_ERR("failed to register timer for max load recalc!\n");
return -1;
}
if (lb_probe_replies.s) {
lb_probe_replies.len = strlen(lb_probe_replies.s);
if(parse_reply_codes( &lb_probe_replies, &probing_reply_codes,
&probing_codes_no )< 0) {
LM_ERR("Bad format for options_reply_code parameter"
" - Need a code list separated by commas\n");
return -1;
}
}
}
/* parse avps */
if (parse_avp_spec(&group_avp_name_s, &group_avp_name)) {
LM_ERR("cannot parse group avp\n");
return -1;
}
if (parse_avp_spec(&flags_avp_name_s, &flags_avp_name)) {
LM_ERR("cannot parse flags avp\n");
return -1;
}
if (parse_avp_spec(&mask_avp_name_s, &mask_avp_name)) {
LM_ERR("cannot parse mask avp\n");
return -1;
}
if (parse_avp_spec(&id_avp_name_s, &id_avp_name)) {
LM_ERR("cannot parse id avp\n");
return -1;
}
if (parse_avp_spec(&res_avp_name_s, &res_avp_name)) {
LM_ERR("cannot parse resources avp\n");
return -1;
}
if (lb_init_event() < 0) {
LM_ERR("cannot init event\n");
return -1;
}
if (lb_repl_cluster < 0) {
LM_ERR("Invalid replication_cluster, must be 0 or "
"a positive cluster id\n");
return -1;
}
if (lb_repl_cluster && load_clusterer_api(&clusterer_api)!=0) {
LM_DBG("failed to find clusterer API - is clusterer module loaded?\n");
return -1;
}
/* register handler for processing load_balancer replication packets to the clusterer module */
if (lb_repl_cluster > 0 &&
clusterer_api.register_capability(&status_repl_cap,
receive_lb_binary_packet, NULL, lb_repl_cluster, 0, NODE_CMP_ANY) < 0) {
LM_ERR("cannot register binary packet callback to clusterer module!\n");
return -1;
}
return 0;
}
static int mod_init(void)
{
LM_INFO("Load-Balancer module - initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
/* Load dialog API */
if (load_dlg_api(&lb_dlg_binds) != 0) {
LM_ERR("Can't load dialog hooks");
return -1;
}
/* data pointer in shm */
curr_data = (struct lb_data**)shm_malloc( sizeof(struct lb_data*) );
if (curr_data==0) {
LM_CRIT("failed to get shm mem for data ptr\n");
return -1;
}
*curr_data = 0;
/* create & init lock */
if ((ref_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
return -1;
}
if (init_lb_bls()) {
LM_ERR("BL INIT failed\n");
return -1;
}
/* init and open DB connection */
if (init_lb_db(&db_url, table_name)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
/* load data */
if ( lb_reload_data()!=0 ) {
LM_CRIT("failed to load load-balancing data\n");
return -1;
}
/* close DB connection */
lb_close_db();
/* arm a function for probing */
if (lb_prob_interval) {
/* load TM API */
if (load_tm_api(&lb_tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* probing method */
lb_probe_method.len = strlen(lb_probe_method.s);
lb_probe_from.len = strlen(lb_probe_from.s);
if (lb_probe_replies.s)
lb_probe_replies.len = strlen(lb_probe_replies.s);
/* register pinger function */
if (register_timer( "lb-pinger", lb_prob_handler , NULL,
lb_prob_interval)<0) {
LM_ERR("failed to register probing handler\n");
return -1;
}
if (lb_probe_replies.s) {
lb_probe_replies.len = strlen(lb_probe_replies.s);
if(parse_reply_codes( &lb_probe_replies, &probing_reply_codes,
&probing_codes_no )< 0) {
LM_ERR("Bad format for options_reply_code parameter"
" - Need a code list separated by commas\n");
return -1;
}
}
}
/* parse avps */
if (parse_avp_spec(&grp_avp_name_s, &grp_avp_name)) {
LM_ERR("cannot parse group avp\n");
return -1;
}
if (parse_avp_spec(&mask_avp_name_s, &mask_avp_name)) {
LM_ERR("cannot parse mask avp\n");
return -1;
}
if (parse_avp_spec(&id_avp_name_s, &id_avp_name)) {
LM_ERR("cannot parse id avp\n");
return -1;
}
return 0;
}
static int mod_init(void)
{
unsigned int timer_sets,set;
unsigned int roundto_init;
LM_INFO("TM - initializing...\n");
/* checking if we have sufficient bitmap capacity for given
maximum number of branches */
if (MAX_BRANCHES+1>31) {
LM_CRIT("Too many max UACs for UAC branch_bm_t bitmap: %d\n",
MAX_BRANCHES );
return -1;
}
fix_flag_name(minor_branch_flag_str, minor_branch_flag);
minor_branch_flag =
get_flag_id_by_name(FLAG_TYPE_BRANCH, minor_branch_flag_str);
if (minor_branch_flag!=-1) {
if (minor_branch_flag > (8*sizeof(int)-1)) {
LM_CRIT("invalid minor branch flag\n");
return -1;
}
minor_branch_flag = 1<<minor_branch_flag;
} else {
minor_branch_flag = 0;
}
/* if statistics are disabled, prevent their registration to core */
if (tm_enable_stats==0)
#ifdef STATIC_TM
tm_exports.stats = 0;
#else
exports.stats = 0;
#endif
if (init_callid() < 0) {
LM_CRIT("Error while initializing Call-ID generator\n");
return -1;
}
/* how many timer sets do we need to create? */
timer_sets = (timer_partitions<=1)?1:timer_partitions ;
/* try first allocating all the structures needed for syncing */
if (lock_initialize( timer_sets )==-1)
return -1;
/* building the hash table*/
if (!init_hash_table( timer_sets )) {
LM_ERR("initializing hash_table failed\n");
return -1;
}
/* init static hidden values */
init_t();
if (!tm_init_timers( timer_sets ) ) {
LM_ERR("timer init failed\n");
return -1;
}
/* the ROUNDTO macro taken from the locking interface */
#ifdef ROUNDTO
roundto_init = ROUNDTO;
#else
roundto_init = sizeof(void *);
#endif
while (roundto_init != 1) {
tm_timer_shift++;
roundto_init >>= 1;
}
LM_DBG("timer set shift is %d\n", tm_timer_shift);
/* register the timer functions */
for ( set=0 ; set<timer_sets ; set++ ) {
if (register_timer( "tm-timer", timer_routine,
(void*)(long)set, 1, TIMER_FLAG_DELAY_ON_DELAY) < 0 ) {
LM_ERR("failed to register timer for set %d\n",set);
return -1;
}
if (register_utimer( "tm-utimer", utimer_routine,
(void*)(long)set, 100*1000, TIMER_FLAG_DELAY_ON_DELAY)<0) {
LM_ERR("failed to register utimer for set %d\n",set);
return -1;
}
}
if (uac_init()==-1) {
LM_ERR("uac_init failed\n");
return -1;
}
if (init_tmcb_lists()!=1) {
LM_CRIT("failed to init tmcb lists\n");
return -1;
}
tm_init_tags();
init_twrite_lines();
if (init_twrite_sock() < 0) {
LM_ERR("failed to create socket\n");
return -1;
}
/* register post-script clean-up function */
if (register_script_cb( do_t_cleanup, POST_SCRIPT_CB|REQ_TYPE_CB, 0)<0 ) {
LM_ERR("failed to register POST request callback\n");
return -1;
}
if (register_script_cb( script_init, PRE_SCRIPT_CB|REQ_TYPE_CB , 0)<0 ) {
LM_ERR("failed to register PRE request callback\n");
return -1;
}
if(register_pv_context("request", tm_pv_context_request)< 0) {
LM_ERR("Failed to register pv contexts\n");
return -1;
}
if(register_pv_context("reply", tm_pv_context_reply)< 0) {
LM_ERR("Failed to register pv contexts\n");
return -1;
}
if ( parse_avp_spec( &uac_ctx_avp, &uac_ctx_avp_id)<0 ) {
LM_ERR("failed to register AVP name <%s>\n",uac_ctx_avp.s);
return -1;
}
if ( register_async_script_handlers( t_handle_async, t_resume_async )<0 ) {
LM_ERR("failed to register async handler to core \n");
return -1;
}
return 0;
}
static int cpl_init(void)
{
bind_usrloc_t bind_usrloc;
load_tm_f load_tm;
struct stat stat_t;
char *ptr;
int val;
str foo;
LOG(L_INFO,"CPL - initializing\n");
/* check the module params */
if (DB_URL==0) {
LOG(L_CRIT,"ERROR:cpl_init: mandatory parameter \"cpl_db\" "
"found empty\n");
goto error;
}
if (DB_TABLE==0) {
LOG(L_CRIT,"ERROR:cpl_init: mandatory parameter \"cpl_table\" "
"found empty\n");
goto error;
}
if (cpl_env.proxy_recurse>MAX_PROXY_RECURSE) {
LOG(L_CRIT,"ERROR:cpl_init: value of proxy_recurse param (%d) exceeds "
"the maximum safety value (%d)\n",
cpl_env.proxy_recurse,MAX_PROXY_RECURSE);
goto error;
}
/* fix the timer_avp name */
if (timer_avp) {
foo.s = timer_avp;
foo.len = strlen(foo.s);
if (parse_avp_spec(&foo,&cpl_env.timer_avp_type,&cpl_env.timer_avp,0)<0){
LOG(L_CRIT,"ERROR:cpl_init: invalid timer AVP specs \"%s\"\n",
timer_avp);
goto error;
}
if (cpl_env.timer_avp_type&AVP_NAME_STR && cpl_env.timer_avp.s.s==foo.s) {
cpl_env.timer_avp.s = foo;
}
}
if (dtd_file==0) {
LOG(L_CRIT,"ERROR:cpl_init: mandatory parameter \"cpl_dtd_file\" "
"found empty\n");
goto error;
} else {
/* check if the dtd file exists */
if (stat( dtd_file, &stat_t)==-1) {
LOG(L_ERR,"ERROR:cpl_init: checking file \"%s\" status failed;"
" stat returned %s\n",dtd_file,strerror(errno));
goto error;
}
if ( !S_ISREG( stat_t.st_mode ) ) {
LOG(L_ERR,"ERROR:cpl_init: dir \"%s\" is not a regular file!\n",
dtd_file);
goto error;
}
if (access( dtd_file, R_OK )==-1) {
LOG(L_ERR,"ERROR:cpl_init: checking file \"%s\" for permissions "
"failed; access returned %s\n",dtd_file,strerror(errno));
goto error;
}
}
if (cpl_env.log_dir==0) {
LOG(L_INFO,"INFO:cpl_init: log_dir param found void -> logging "
" disabled!\n");
} else {
if ( strlen(cpl_env.log_dir)>MAX_LOG_DIR_SIZE ) {
LOG(L_ERR,"ERROR:cpl_init: dir \"%s\" has a too long name :-(!\n",
cpl_env.log_dir);
goto error;
}
/* check if the dir exists */
if (stat( cpl_env.log_dir, &stat_t)==-1) {
LOG(L_ERR,"ERROR:cpl_init: checking dir \"%s\" status failed;"
" stat returned %s\n",cpl_env.log_dir,strerror(errno));
goto error;
}
if ( !S_ISDIR( stat_t.st_mode ) ) {
LOG(L_ERR,"ERROR:cpl_init: dir \"%s\" is not a directory!\n",
cpl_env.log_dir);
goto error;
}
if (access( cpl_env.log_dir, R_OK|W_OK )==-1) {
LOG(L_ERR,"ERROR:cpl_init: checking dir \"%s\" for permissions "
"failed; access returned %s\n",
cpl_env.log_dir, strerror(errno));
goto error;
}
}
/* import the TM auto-loading function */
if ( !(load_tm=(load_tm_f)find_export("load_tm", NO_SCRIPT, 0))) {
LOG(L_ERR, "ERROR:cpl_c:cpl_init: cannot import load_tm\n");
goto error;
}
/* let the auto-loading function load all TM stuff */
if (load_tm( &(cpl_fct.tmb) )==-1)
goto error;
/* bind the SL API */
if (sl_load_api(&cpl_fct.slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* bind to usrloc module if requested */
if (lookup_domain) {
/* import all usrloc functions */
bind_usrloc = (bind_usrloc_t)find_export("ul_bind_usrloc", 1, 0);
if (!bind_usrloc) {
LOG(L_ERR, "ERROR:cpl_c:cpl_init: Can't bind usrloc\n");
goto error;
}
if (bind_usrloc( &(cpl_fct.ulb) ) < 0) {
LOG(L_ERR, "ERROR:cpl_c:cpl_init: importing usrloc failed\n");
goto error;
}
/* convert lookup_domain from char* to udomain_t* pointer */
if (cpl_fct.ulb.register_udomain( lookup_domain, &cpl_env.lu_domain)
< 0) {
LOG(L_ERR, "ERROR:cpl_c:cpl_init: Error while registering domain "
"<%s>\n",lookup_domain);
goto error;
}
} else {
LOG(L_NOTICE,"NOTICE:cpl_init: no lookup_domain given -> disable "
" lookup node\n");
}
/* build a pipe for sending commands to aux process */
if ( pipe( cpl_env.cmd_pipe )==-1 ) {
LOG(L_CRIT,"ERROR:cpl_init: cannot create command pipe: %s!\n",
strerror(errno) );
goto error;
}
/* set the writing non blocking */
if ( (val=fcntl(cpl_env.cmd_pipe[1], F_GETFL, 0))<0 ) {
LOG(L_ERR,"ERROR:cpl_init: getting flags from pipe[1] failed: fcntl "
"said %s!\n",strerror(errno));
goto error;
}
if ( fcntl(cpl_env.cmd_pipe[1], F_SETFL, val|O_NONBLOCK) ) {
LOG(L_ERR,"ERROR:cpl_init: setting flags to pipe[1] failed: fcntl "
"said %s!\n",strerror(errno));
goto error;
}
/* init the CPL parser */
if (init_CPL_parser( dtd_file )!=1 ) {
LOG(L_ERR,"ERROR:cpl_init: init_CPL_parser failed!\n");
goto error;
}
/* make a copy of the original TZ env. variable */
ptr = getenv("TZ");
cpl_env.orig_tz.len = 3/*"TZ="*/ + (ptr?(strlen(ptr)+1):0);
if ( (cpl_env.orig_tz.s=shm_malloc( cpl_env.orig_tz.len ))==0 ) {
LOG(L_ERR,"ERROR:cpl_init: no more shm mem. for saving TZ!\n");
goto error;
}
memcpy(cpl_env.orig_tz.s,"TZ=",3);
if (ptr)
strcpy(cpl_env.orig_tz.s+3,ptr);
/* convert realm_prefix from string null terminated to str */
if (cpl_env.realm_prefix.s) {
/* convert the realm_prefix to lower cases */
strlower( &cpl_env.realm_prefix );
}
/* Register a child process that will keep updating
* its local configuration */
cfg_register_child(1);
return 0;
error:
return -1;
}
static int mod_init(void){
str s;
int n;
LM_INFO("initializing TLS protocol\n");
if (tls_db_enabled != 0 && tls_db_enabled != 1) {
tls_db_enabled = 1;
}
if (tls_db_enabled) {
/* create & init lock */
if ((dom_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
return -1;
}
init_db_url(tls_db_url, 0 /*cannot be null*/);
tls_db_table.len = strlen(tls_db_table.s);
if (tls_db_table.len == 0) {
LM_ERR("db url not specified\n");
return -1;
}
id_col.len = strlen(id_col.s);
address_col.len = strlen(address_col.s);
type_col.len = strlen(type_col.s);
method_col.len = strlen(method_col.s);
verify_cert_col.len = strlen(verify_cert_col.s);
require_cert_col.len = strlen(require_cert_col.s);
certificate_col.len = strlen(certificate_col.s);
pk_col.len = strlen(pk_col.s);
crl_check_col.len = strlen(crl_check_col.s);
calist_col.len = strlen(calist_col.s);
cadir_col.len = strlen(cadir_col.s);
cplist_col.len = strlen(cplist_col.s);
dhparams_col.len = strlen(dhparams_col.s);
eccurve_col.len = strlen(eccurve_col.s);
if (db_bind_mod(&tls_db_url, &dr_dbf)) {
LM_CRIT("cannot bind to database module! "
"Did you forget to load a database module ?\n");
return -1;
}
/* init DB connection */
if ((db_hdl = dr_dbf.init(&tls_db_url)) == 0) {
LM_CRIT("cannot initialize database connection\n");
return -1;
}
if (dr_dbf.use_table(db_hdl, &tls_db_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", tls_db_table.len, tls_db_table.s);
return -1;
}
}
if (tls_domain_avp) {
s.s = tls_domain_avp;
s.len = strlen(s.s);
if (parse_avp_spec( &s, &tls_client_domain_avp)) {
LM_ERR("cannot parse tls_client_avp");
return -1;
}
}
/*
* this has to be called before any function calling CRYPTO_malloc,
* CRYPTO_malloc will set allow_customize in openssl to 0
*/
if (!CRYPTO_set_mem_functions(os_malloc, os_realloc, os_free)) {
LM_ERR("unable to set the memory allocation functions\n");
LM_ERR("NOTE: check if you have openssl 1.0.1e-fips, as this "
"version is know to be broken; if so, you need to upgrade or "
"downgrade to a differen openssl version !!\n");
return -1;
}
#if !defined(OPENSSL_NO_COMP)
STACK_OF(SSL_COMP)* comp_methods;
/* disabling compression */
LM_WARN("disabling compression due ZLIB problems\n");
comp_methods = SSL_COMP_get_compression_methods();
if (comp_methods==0) {
LM_INFO("openssl compression already disabled\n");
} else {
sk_SSL_COMP_zero(comp_methods);
}
#endif
if (tls_init_multithread() < 0) {
LM_ERR("failed to init multi-threading support\n");
return -1;
}
SSL_library_init();
SSL_load_error_strings();
init_ssl_methods();
n = check_for_krb();
if (n==-1) {
LM_ERR("kerberos check failed\n");
return -1;
}
if ( ( n ^
#ifndef OPENSSL_NO_KRB5
1
#else
0
#endif
)!=0 ) {
LM_ERR("compiled agaist an openssl with %s"
"kerberos, but run with one with %skerberos\n",
(n==1)?"":"no ",(n!=1)?"no ":"");
return -1;
}
/*
* finish setting up the tls default domains
*/
tls_default_client_domain.type = TLS_DOMAIN_DEF|TLS_DOMAIN_CLI ;
tls_default_client_domain.addr.af = AF_INET;
tls_default_server_domain.type = TLS_DOMAIN_DEF|TLS_DOMAIN_SRV;
tls_default_server_domain.addr.af = AF_INET;
/*
* now initialize tls default domains
*/
if ( (n=init_tls_domains(&tls_default_server_domain)) ) {
return n;
}
if ( (n=init_tls_domains(&tls_default_client_domain)) ) {
return n;
}
/*
* now initialize tls virtual domains
*/
if (tls_db_enabled && load_info(&dr_dbf, db_hdl, &tls_db_table, &tls_server_domains,
&tls_client_domains)){
return -1;
}
if ( (n=init_tls_domains(tls_server_domains)) ) {
return n;
}
if ( (n=init_tls_domains(tls_client_domains)) ) {
return n;
}
/*
* we are all set
*/
return 0;
}
/* tw_append syntax:
* tw_append = name:element[;element]
* element = [title=]value
* value = avp[avp_spec] | hdr[hdr_name] | msg[body] */
int parse_tw_append( modparam_t type, void* val)
{
struct hdr_field hdr;
struct hdr_avp *last;
struct hdr_avp *ha;
struct tw_append *app;
int_str avp_name;
char *s;
char bar;
str foo;
int n;
int index;
if (val==0 || ((char*)val)[0]==0)
return 0;
s = (char*)val;
/* start parsing - first the name */
while( *s && isspace((int)*s) ) s++;
if ( !*s || *s==':')
goto parse_error;
foo.s = s;
while ( *s && *s!=':' && !isspace((int)*s) ) s++;
if ( !*s || foo.s==s )
goto parse_error;
foo.len = s - foo.s;
/* parse separator */
while( *s && isspace((int)*s) ) s++;
if ( !*s || *s!=':')
goto parse_error;
s++;
while( *s && isspace((int)*s) ) s++;
if ( !*s )
goto parse_error;
/* check for name duplication */
for(app=tw_appends;app;app=app->next)
if (app->name.len==foo.len && !strncasecmp(app->name.s,foo.s,foo.len)){
LOG(L_ERR,"ERROR:tm:parse_tw_append: duplicated tw_append name "
"<%.*s>\n",foo.len,foo.s);
goto error;
}
/* new tw_append structure */
app = (struct tw_append*)pkg_malloc( sizeof(struct tw_append) );
if (app==0) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: no more pkg memory\n");
goto error;
}
app->name.s = (char*)pkg_malloc( foo.len+1 );
if (app->name.s==0) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: no more pkg memory\n");
goto error;
}
memcpy( app->name.s, foo.s, foo.len);
app->name.len = foo.len;
app->name.s[app->name.len] = 0;
last = app->elems = 0;
app->next = tw_appends;
tw_appends = app;
/* parse the elements */
while (*s) {
/* parse element title or element type */
foo.s = s;
while( *s && *s!='[' && *s!='=' && *s!=';' && !isspace((int)*s) ) s++;
if ( !*s || foo.s==s)
goto parse_error;
foo.len = s - foo.s;
/* new hdr_avp structure */
ha = (struct hdr_avp*)pkg_malloc( sizeof(struct hdr_avp) );
if (ha==0) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: no more pkg memory\n");
goto error;
}
memset( ha, 0, sizeof(struct hdr_avp));
if (*s!='[') {
/* foo must by title or some error -> parse separator */
while( *s && isspace((int)*s) ) s++;
if ( !*s || *s!='=')
goto parse_error;
s++;
while( *s && isspace((int)*s) ) s++;
if ( !*s )
goto parse_error;
/* set the title */
ha->title.s = (char*)pkg_malloc( foo.len+1 );
if (ha->title.s==0) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: no more pkg memory\n");
goto error;
}
memcpy( ha->title.s, foo.s, foo.len);
ha->title.len = foo.len;
ha->title.s[ha->title.len] = 0;
/* parse the type now */
foo.s = s;
while( *s && *s!='[' && *s!=']' && *s!=';' && !isspace((int)*s) )
s++;
if ( *s!='[' || foo.s==s)
goto parse_error;
foo.len = s - foo.s;
}
/* foo containes the elemet type */
if ( foo.len==ELEM_TYPE_AVP_LEN &&
!strncasecmp( foo.s, ELEM_TYPE_AVP, foo.len) ) {
ha->type = ELEM_IS_AVP;
} else if ( foo.len==ELEM_TYPE_HDR_LEN &&
!strncasecmp( foo.s, ELEM_TYPE_HDR, foo.len) ) {
ha->type = ELEM_IS_HDR;
} else if ( foo.len==ELEM_TYPE_MSG_LEN &&
!strncasecmp( foo.s, ELEM_TYPE_MSG, foo.len) ) {
ha->type = ELEM_IS_MSG;
} else {
LOG(L_ERR,"ERROR:tm:parse_tw_append: unknown type <%.*s>\n",
foo.len, foo.s);
goto error;
}
/* parse the element name */
s++;
foo.s = s;
while( *s && *s!=']' && *s!=';' && !isspace((int)*s) ) s++;
if ( *s!=']' || foo.s==s )
goto parse_error;
foo.len = s - foo.s;
s++;
/* process and optimize the element name */
if (ha->type==ELEM_IS_AVP) {
/* element is AVP */
if ( parse_avp_spec( &foo, &n, &avp_name, &index)!=0 ) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: bad alias spec "
"<%.*s>\n",foo.len, foo.s);
goto error;
}
if (n&AVP_NAME_STR) {
/* string name */
ha->sval.s = (char*)pkg_malloc(avp_name.s.len+1);
if (ha->sval.s==0) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: no more pkg mem\n");
goto error;
}
memcpy( ha->sval.s, avp_name.s.s, avp_name.s.len);
ha->sval.len = avp_name.s.len;
ha->sval.s[ha->sval.len] = 0;
if (ha->title.s==0)
ha->title = ha->sval;
} else {
/* ID name - if title is missing, convert the ID to
* string and us it a title */
ha->ival = avp_name.n;
if (ha->title.s==0) {
foo.s=int2str((unsigned long)ha->ival, &foo.len);
ha->title.s = (char*)pkg_malloc( n+1 );
if (ha->title.s==0) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: no more pkg "
"memory\n");
goto error;
}
memcpy( ha->title.s, foo.s, foo.len);
ha->title.len = foo.len;
ha->title.s[ha->title.len] = 0;
}
}
} else if (ha->type==ELEM_IS_HDR) {
/* element is HDR - try to get it's coded type if defined */
bar = foo.s[foo.len];
foo.s[foo.len] = ':';
/* parse header name */
if (parse_hname2( foo.s, foo.s+foo.len+1, &hdr)==0) {
LOG(L_ERR,"BUG:tm_parse_tw_append: parse header failed\n");
goto error;
}
foo.s[foo.len] = bar;
ha->ival = hdr.type;
if (hdr.type==HDR_OTHER_T || ha->title.s==0) {
/* duplicate hdr name */
ha->sval.s = (char*)pkg_malloc(foo.len+1);
if (ha->sval.s==0) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: no more pkg mem\n");
goto error;
}
memcpy( ha->sval.s, foo.s, foo.len);
ha->sval.len = foo.len;
ha->sval.s[ha->sval.len] = 0;
if (ha->title.s==0)
ha->title = ha->sval;
}
} else {
/* element is MSG */
if ( !(foo.len==ELEM_VAL_BODY_LEN &&
!strncasecmp(ELEM_VAL_BODY,foo.s,foo.len)) ) {
LOG(L_ERR,"ERROR:tm:parse_tw_append: unsupported value <%.*s>"
" for msg type\n",foo.len,foo.s);
goto error;
}
app->add_body = 1;
pkg_free( ha );
ha = 0;
}
/* parse the element separator, if present */
while( *s && isspace((int)*s) ) s++;
if ( *s && *s!=';')
goto parse_error;
if (*s==';') {
s++;
while( *s && isspace((int)*s) ) s++;
if (!*s)
goto parse_error;
}
/* link the element to tw_append structure */
if (ha) {
if (last==0) {
last = app->elems = ha;
} else {
last->next = ha;
last = ha;
}
}
} /* end while */
print_tw_append( app );
/* free the old string */
pkg_free(val);
return 0;
parse_error:
LOG(L_ERR,"ERROR:tm:parse_tw_append: parse error in <%s> around "
"position %ld\n", (char*)val, (long)(s-(char*)val));
error:
return -1;
}
static int ul_contact_event_to_msg(struct sip_msg *req)
{
static enum ul_attrs { UL_URI, UL_RECEIVED, UL_PATH, UL_QVAL,
UL_SOCKET, UL_BFLAGS, UL_ATTR, UL_MAX } ul_attr;
/* keep the names of the AVPs aligned with the contact-related events
* from USRLOC module !!!! */
static str ul_names[UL_MAX]= {str_init("uri"),str_init("received"),
str_init("path"),str_init("qval"),
str_init("socket"),str_init("bflags"),
str_init("attr") };
static int avp_ids[UL_MAX] = { -1, -1, -1, -1, -1, -1, -1};
int_str vals[UL_MAX];
int proto, port;
str host;
str path_dst;
if (avp_ids[0]==-1) {
/* init the avp IDs mapping us on the UL event */
for( ul_attr=0 ; ul_attr<UL_MAX ; ul_attr++ ){
if (parse_avp_spec( &ul_names[ul_attr], &avp_ids[ul_attr])<0) {
LM_ERR("failed to init UL AVP %d/%s\n",
ul_attr,ul_names[ul_attr].s);
avp_ids[0] = -1;
return -1;
}
}
}
/* fetch the AVP values one by one */
for( ul_attr=0 ; ul_attr<UL_MAX ; ul_attr++ ) {
if (search_first_avp(0, avp_ids[ul_attr], &vals[ul_attr], NULL)==NULL){
LM_ERR("cannot find AVP(%d) for event attr %d/%s\n",
avp_ids[ul_attr], ul_attr, ul_names[ul_attr].s);
return -1;
}
}
/* OK, we have the values, lets inject them into the SIP msg */
LM_DBG("injecting new branch: uri=<%.*s>, received=<%.*s>,"
"path=<%.*s>, qval=%d, socket=<%.*s>, bflags=%X, attr=<%.*s>\n",
vals[UL_URI].s.len, vals[UL_URI].s.s,
vals[UL_RECEIVED].s.len, vals[UL_RECEIVED].s.s,
vals[UL_PATH].s.len, vals[UL_PATH].s.s,
vals[UL_QVAL].n,
vals[UL_SOCKET].s.len, vals[UL_SOCKET].s.s,
vals[UL_BFLAGS].n,
vals[UL_ATTR].s.len, vals[UL_ATTR].s.s);
/* contact URI goes as RURI */
if (set_ruri( req, &vals[UL_URI].s)<0) {
LM_ERR("failed to set new RURI\n");
return -1;
}
/* contact PATH goes as path */
if (vals[UL_PATH].s.len) {
if (get_path_dst_uri(&vals[UL_PATH].s, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
return -1;
}
if (set_dst_uri( req, &path_dst) < 0) {
LM_ERR("failed to set dst_uri of Path\n");
return -1;
}
if (set_path_vector( req, &vals[UL_PATH].s)<0) {
LM_ERR("failed to set PATH\n");
return -1;
}
} else
/* contact RECEIVED goes as DURI */
if (vals[UL_RECEIVED].s.len) {
if (set_dst_uri( req, &vals[UL_RECEIVED].s)<0) {
LM_ERR("failed to set DST URI\n");
return -1;
}
}
/* contact Qval goes as RURI Qval */
set_ruri_q( req, vals[UL_QVAL].n);
/* contact BFLAGS goes as RURI bflags */
setb0flags( req, vals[UL_BFLAGS].n);
/* socket info */
if (vals[UL_SOCKET].s.len) {
if ( parse_phostport( vals[UL_SOCKET].s.s, vals[UL_SOCKET].s.len,
&host.s, &host.len, &port, &proto) < 0) {
LM_ERR("failed to parse socket from Event attr <%.*s>\n",
vals[UL_SOCKET].s.len, vals[UL_SOCKET].s.s);
} else {
req->force_send_socket = grep_sock_info( &host,
(unsigned short)port, (unsigned short)proto);
}
}
return 0;
}
static int mod_init(void)
{
int ver;
LM_INFO("initializing...\n");
init_db_url( db_url , 0 /*cannot be null*/);
domainpolicy_table.len = strlen(domainpolicy_table.s);
domainpolicy_col_rule.len = strlen(domainpolicy_col_rule.s);
domainpolicy_col_type.len = strlen(domainpolicy_col_type.s);
domainpolicy_col_att.len = strlen(domainpolicy_col_att.s);
domainpolicy_col_val.len = strlen(domainpolicy_col_val.s);
LM_INFO("check for DB module\n");
/* Check if database module has been loaded */
if (domainpolicy_db_bind(&db_url)<0) {
LM_ERR("no database module loaded!"
" Please make sure that a DB module is loaded first\n");
return -1;
}
LM_INFO("update length of module variables\n");
/* Update length of module variables */
port_override_avp.len = strlen(port_override_avp.s);
transport_override_avp.len = strlen(transport_override_avp.s);
domain_prefix_avp.len = strlen(domain_prefix_avp.s);
domain_suffix_avp.len = strlen(domain_suffix_avp.s);
domain_replacement_avp.len = strlen(domain_replacement_avp.s);
send_socket_avp.len = strlen(send_socket_avp.s);
/* Check table version */
ver = domainpolicy_db_ver(&db_url, &domainpolicy_table);
if (ver < 0) {
LM_ERR("failed to query table version\n");
return -1;
} else if (ver < DOMAINPOLICY_TABLE_VERSION) {
LM_ERR("invalid table version of domainpolicy table\n");
return -1;
}
/* Assign AVP parameter names */
LM_INFO("AVP\n");
if (parse_avp_spec(&port_override_avp, &port_override_name) < 0) {
LM_ERR("invalid port_override_avp!\n");
return -1;
}
if (parse_avp_spec(&transport_override_avp, &transport_override_name) < 0) {
LM_ERR("invalid transport_override_avp!\n");
return -1;
}
if (parse_avp_spec(&domain_prefix_avp, &domain_prefix_name) < 0) {
LM_ERR("invalid domain_prefix_avp!\n");
return -1;
}
if (parse_avp_spec(&domain_suffix_avp, &domain_suffix_name) < 0) {
LM_ERR("invalid domain_suffix_avp!\n");
return -1;
}
if (parse_avp_spec(&domain_replacement_avp, &domain_replacement_name) < 0) {
LM_ERR("invalid domain_replacement_avp!\n");
return -1;
}
if (parse_avp_spec(&send_socket_avp, &send_socket_name) < 0) {
LM_ERR("invalid send_socket_avp!\n");
return -1;
}
return 0;
}
static int mod_init(void)
{
str s;
int n;
LM_INFO("initializing TLS protocol\n");
if (tls_domain_avp) {
s.s = tls_domain_avp;
s.len = strlen(s.s);
if (parse_avp_spec( &s, &tls_client_domain_avp)) {
LM_ERR("cannot parse tls_client_avp");
return -1;
}
}
/*
* this has to be called before any function calling CRYPTO_malloc,
* CRYPTO_malloc will set allow_customize in openssl to 0
*/
if (!CRYPTO_set_mem_functions(os_malloc, os_realloc, os_free)) {
LM_ERR("unable to set the memory allocation functions\n");
return -1;
}
#if !defined(OPENSSL_NO_COMP)
STACK_OF(SSL_COMP)* comp_methods;
/* disabling compression */
LM_WARN("disabling compression due ZLIB problems\n");
comp_methods = SSL_COMP_get_compression_methods();
if (comp_methods==0) {
LM_INFO("openssl compression already disabled\n");
} else {
sk_SSL_COMP_zero(comp_methods);
}
#endif
if (tls_init_multithread() < 0) {
LM_ERR("failed to init multi-threading support\n");
return -1;
}
SSL_library_init();
SSL_load_error_strings();
init_ssl_methods();
n = check_for_krb();
if (n==-1) {
LM_ERR("kerberos check failed\n");
return -1;
}
if ( ( n ^
#ifndef OPENSSL_NO_KRB5
1
#else
0
#endif
)!=0 ) {
LM_ERR("compiled agaist an openssl with %s"
"kerberos, but run with one with %skerberos\n",
(n==1)?"":"no ",(n!=1)?"no ":"");
return -1;
}
/*
* finish setting up the tls default domains
*/
tls_default_client_domain.type = TLS_DOMAIN_DEF|TLS_DOMAIN_CLI ;
tls_default_client_domain.addr.af = AF_INET;
tls_default_server_domain.type = TLS_DOMAIN_DEF|TLS_DOMAIN_SRV;
tls_default_server_domain.addr.af = AF_INET;
/*
* now initialize tls default domains
*/
if ( (n=init_tls_domains(&tls_default_server_domain)) ) {
return n;
}
if ( (n=init_tls_domains(&tls_default_client_domain)) ) {
return n;
}
/*
* now initialize tls virtual domains
*/
if ( (n=init_tls_domains(tls_server_domains)) ) {
return n;
}
if ( (n=init_tls_domains(tls_client_domains)) ) {
return n;
}
/*
* we are all set
*/
return 0;
}
