static int mod_init(void)
{
if(default_siputils_cfg.ring_timeout > 0) {
ring_init_hashtable();
ring_lock = lock_alloc();
assert(ring_lock);
if (lock_init(ring_lock) == 0) {
LM_CRIT("cannot initialize lock.\n");
return -1;
}
if (register_script_cb(ring_filter, PRE_SCRIPT_CB|ONREPLY_CB, 0) != 0) {
LM_ERR("could not insert callback");
return -1;
}
}
/* bind the SL API */
if (sl_load_api(&opt_slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
if ( init_rpid_avp(rpid_avp_param)<0 ) {
LM_ERR("failed to init rpid AVP name\n");
return -1;
}
if(cfg_declare("siputils", siputils_cfg_def, &default_siputils_cfg, cfg_sizeof(siputils), &siputils_cfg)){
LM_ERR("Fail to declare the configuration\n");
return -1;
}
return 0;
}
/*
* initialize module
*/
static int mod_init(void) {
strl* ptr;
LM_DBG("sanity initializing\n");
ksr_sanity_info_init();
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
LM_DBG("parsing proxy requires string:\n");
ptr = parse_str_list(&pr_str);
proxyrequire_list = ptr;
while (ptr != NULL) {
LM_DBG("string: '%.*s', next: %p\n", ptr->string.len,
ptr->string.s, ptr->next);
ptr = ptr->next;
}
return 0;
}
/*
* mod_init
* Called by kamailio at init time
*/
static int mod_init(void) {
int argc = 1;
char *argt[] = { MOD_NAME, NULL };
char **argv;
struct timeval t1;
struct timeval t2;
if(ap_init_rpc()<0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if (!filename) {
LM_ERR("insufficient module parameters. Module not loaded.\n");
return -1;
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
_ap_reset_cycles = shm_malloc(sizeof(int));
if(_ap_reset_cycles == NULL) {
LM_ERR("no more shared memory\n");
return -1;
}
*_ap_reset_cycles = _ap_reset_cycles_init;
argv = argt;
PERL_SYS_INIT3(&argc, &argv, &environ);
gettimeofday(&t1, NULL);
my_perl = parser_init();
gettimeofday(&t2, NULL);
if (my_perl==NULL)
goto error;
LM_INFO("perl interpreter has been initialized (%d.%06d => %d.%06d)\n",
(int)t1.tv_sec, (int)t1.tv_usec,
(int)t2.tv_sec, (int)t2.tv_usec);
#ifdef PERL_EXIT_DESTRUCT_END
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
#else
PL_exit_flags |= PERL_EXIT_EXPECTED;
#endif
return 0;
error:
if(_ap_reset_cycles!=NULL)
shm_free(_ap_reset_cycles);
_ap_reset_cycles = NULL;
return -1;
}
static int mod_init(void)
{
struct nonsip_hook nsh;
int route_no;
route_no=route_get(&event_rt, "xhttp:request");
if (route_no==-1)
{
LM_ERR("failed to find event_route[xhttp:request]\n");
return -1;
}
if (event_rt.rlist[route_no]==0)
{
LM_WARN("event_route[xhttp:request] is empty\n");
}
xhttp_route_no=route_no;
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* register non-sip hooks */
memset(&nsh, 0, sizeof(nsh));
nsh.name = "xhttp";
nsh.destroy = 0;
nsh.on_nonsip_req = xhttp_handler;
if (register_nonsip_msg_hook(&nsh)<0)
{
LM_ERR("Failed to register non sip msg hooks\n");
return -1;
}
if(xhttp_url_match!=NULL)
{
memset(&xhttp_url_match_regexp, 0, sizeof(regex_t));
if (regcomp(&xhttp_url_match_regexp, xhttp_url_match, REG_EXTENDED)!=0) {
LM_ERR("bad match re %s\n", xhttp_url_match);
return E_BAD_RE;
}
}
if(xhttp_url_skip!=NULL)
{
memset(&xhttp_url_skip_regexp, 0, sizeof(regex_t));
if (regcomp(&xhttp_url_skip_regexp, xhttp_url_skip, REG_EXTENDED)!=0) {
LM_ERR("bad skip re %s\n", xhttp_url_skip);
return E_BAD_RE;
}
}
return 0;
}
static int sca_bind_sl(sca_mod *scam, sl_api_t *sl_api)
{
sl_cbelem_t sl_cbe;
assert(scam != NULL);
assert(sl_api != NULL);
if (sl_load_api(sl_api) != 0) {
LM_ERR("Failed to initialize required sl API. Check if the \"sl\" module is loaded.\n");
return (-1);
}
scam->sl_api = sl_api;
sl_cbe.type = SLCB_REPLY_READY;
sl_cbe.cbf = (sl_cbf_f) sca_call_info_sl_reply_cb;
if (scam->sl_api->register_cb(&sl_cbe) < 0) {
LM_ERR("Failed to register sl reply callback\n");
return (-1);
}
return (0);
}
/**
* init module function
*/
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0) {
LM_ERR("failed to register MI commands\n");
return -1;
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1) {
LM_ERR("can't load tm functions. TM module probably not loaded\n");
return -1;
}
/* load peer list - the list containing the module callbacks for dmq */
peer_list = init_peer_list();
if(peer_list==NULL) {
LM_ERR("cannot initialize peer list\n");
return -1;
}
/* load the dmq node list - the list containing the dmq servers */
node_list = init_dmq_node_list();
if(node_list==NULL) {
LM_ERR("cannot initialize node list\n");
return -1;
}
if (rpc_register_array(rpc_methods)!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
/* register worker processes - add one because of the ping process */
register_procs(num_workers);
/* check server_address and notification_address are not empty and correct */
if(parse_uri(dmq_server_address.s, dmq_server_address.len, &dmq_server_uri) < 0) {
LM_ERR("server address invalid\n");
return -1;
}
if(parse_uri(dmq_notification_address.s, dmq_notification_address.len, &dmq_notification_uri) < 0) {
LM_ERR("notification address invalid\n");
return -1;
}
/* create socket string out of the server_uri */
if(make_socket_str_from_uri(&dmq_server_uri, &dmq_server_socket) < 0) {
LM_ERR("failed to create socket out of server_uri\n");
return -1;
}
if (lookup_local_socket(&dmq_server_socket) == NULL) {
LM_ERR("server_uri is not a socket the proxy is listening on\n");
return -1;
}
/* allocate workers array */
workers = shm_malloc(num_workers * sizeof(*workers));
if(workers == NULL) {
LM_ERR("error in shm_malloc\n");
return -1;
}
dmq_init_callback_done = shm_malloc(sizeof(int));
if (!dmq_init_callback_done) {
LM_ERR("no more shm\n");
return -1;
}
*dmq_init_callback_done = 0;
/**
* add the dmq notification peer.
* the dmq is a peer itself so that it can receive node notifications
*/
if(add_notification_peer()<0) {
LM_ERR("cannot add notification peer\n");
return -1;
}
startup_time = (int) time(NULL);
/**
* add the ping timer
* it pings the servers once in a while so that we know which failed
*/
if(ping_interval < MIN_PING_INTERVAL) {
ping_interval = MIN_PING_INTERVAL;
}
if(register_timer(ping_servers, 0, ping_interval)<0) {
LM_ERR("cannot register timer callback\n");
return -1;
}
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
bind_presence_t bind_presence;
presence_api_t pres;
if(passive_mode==1)
return 0;
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n",ZSW(db_url.s),db_url.len, db_url.s);
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
bind_presence= (bind_presence_t)find_export("bind_presence", 1,0);
if (!bind_presence)
{
LM_ERR("Can't bind presence\n");
return -1;
}
if (bind_presence(&pres) < 0)
{
LM_ERR("Can't bind to presence module\n");
return -1;
}
pres_get_sphere= pres.get_sphere;
pres_add_event= pres.add_event;
pres_update_watchers= pres.update_watchers_status;
pres_contains_event= pres.contains_event;
pres_get_presentity= pres.get_presentity;
pres_free_presentity= pres.free_presentity;
if (pres_add_event == NULL || pres_update_watchers== NULL)
{
LM_ERR("Can't import add_event\n");
return -1;
}
if(xml_add_events()< 0)
{
LM_ERR("adding xml events\n");
return -1;
}
if(force_active== 0)
{
/* binding to mysql module */
if (db_bind_mod(&db_url, &pxml_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pxml_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
pxml_db = pxml_dbf.init(&db_url);
if (!pxml_db)
{
LM_ERR("while connecting to database\n");
return -1;
}
if(db_check_table_version(&pxml_dbf, pxml_db, &xcap_table, S_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
if(!integrated_xcap_server )
{
xcap_api_t xcap_api;
bind_xcap_t bind_xcap;
/* bind xcap */
bind_xcap= (bind_xcap_t)find_export("bind_xcap", 1, 0);
if (!bind_xcap)
{
LM_ERR("Can't bind xcap_client\n");
return -1;
}
if (bind_xcap(&xcap_api) < 0)
{
LM_ERR("Can't bind xcap_api\n");
return -1;
}
xcap_GetNewDoc= xcap_api.getNewDoc;
if(xcap_GetNewDoc== NULL)
{
LM_ERR("can't import get_elem from xcap_client module\n");
return -1;
}
if(xcap_api.register_xcb(PRES_RULES, xcap_doc_updated)< 0)
{
LM_ERR("registering xcap callback function\n");
return -1;
}
}
}
if(shm_copy_xcap_list()< 0)
{
LM_ERR("copying xcap server list in share memory\n");
return -1;
}
if(pxml_db)
pxml_dbf.close(pxml_db);
pxml_db = NULL;
return 0;
}
/* initialize ratelimit module */
static int mod_init(void)
{
if(rpc_register_array(rpc_methods)!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(pl_hash_size<=0)
{
LM_ERR("invalid hash size parameter: %d\n", pl_hash_size);
return -1;
}
if(pl_init_htable(1<<pl_hash_size)<0)
{
LM_ERR("could not allocate pipes htable\n");
return -1;
}
if(pl_init_db()<0)
{
LM_ERR("could not load pipes description\n");
return -1;
}
/* register timer to reset counters */
if ((pl_timer = timer_alloc()) == NULL) {
LM_ERR("could not allocate timer\n");
return -1;
}
timer_init(pl_timer, pl_timer_handle, 0, F_TIMER_FAST);
timer_add(pl_timer, MS_TO_TICKS(1000)); /* Start it after 1000ms */
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
network_load_value = shm_malloc(sizeof(int));
if (network_load_value==NULL) {
LM_ERR("oom for network_load_value\n");
return -1;
}
load_value = shm_malloc(sizeof(double));
if (load_value==NULL) {
LM_ERR("oom for load_value\n");
return -1;
}
load_source = shm_malloc(sizeof(int));
if (load_source==NULL) {
LM_ERR("oom for load_source\n");
return -1;
}
pid_kp = shm_malloc(sizeof(double));
if (pid_kp==NULL) {
LM_ERR("oom for pid_kp\n");
return -1;
}
pid_ki = shm_malloc(sizeof(double));
if (pid_ki==NULL) {
LM_ERR("oom for pid_ki\n");
return -1;
}
pid_kd = shm_malloc(sizeof(double));
if (pid_kd==NULL) {
LM_ERR("oom for pid_kd\n");
return -1;
}
_pl_pid_setpoint = shm_malloc(sizeof(double));
if (_pl_pid_setpoint==NULL) {
LM_ERR("oom for pid_setpoint\n");
return -1;
}
drop_rate = shm_malloc(sizeof(int));
if (drop_rate==NULL) {
LM_ERR("oom for drop_rate\n");
return -1;
}
*network_load_value = 0;
*load_value = 0.0;
*load_source = load_source_mp;
*pid_kp = 0.0;
*pid_ki = -25.0;
*pid_kd = 0.0;
*_pl_pid_setpoint = 0.01 * (double)_pl_cfg_setpoint;
*drop_rate = 0;
return 0;
}
static int mod_init(void) {
pv_spec_t avp_spec;
str s;
bind_usrloc_t bind_usrloc;
qvalue_t dq;
callback_singleton = shm_malloc(sizeof (int));
*callback_singleton = 0;
/*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;
}
if (contact_expires_buffer_percentage < 0 || contact_expires_buffer_percentage > 90) {
LM_ERR("contact expires percentage not valid, must be >0 and <=90");
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;
}
pv_tmx_data_init();
/* </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
/*register space for notification processors*/
register_procs(notification_processes);
cfg_register_child(notification_processes);
/* 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;
}
/*! \brief
* Initialize parent
*/
static int mod_init(void) {
bind_usrloc_t bind_usrloc;
bind_pua_t bind_pua;
/*register space for event processor*/
register_procs(1);
if (!fix_parameters()) goto error;
/* bind the SL API */
if (sl_load_api(&slb) != 0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
LM_DBG("Successfully bound to SL module\n");
/* load the TM API */
if (load_tm_api(&tmb) != 0) {
LM_ERR("can't load TM API\n");
return -1;
}
LM_DBG("Successfully bound to TM module\n");
bind_usrloc = (bind_usrloc_t) find_export("ul_bind_ims_usrloc_pcscf", 1, 0);
if (!bind_usrloc) {
LM_ERR("can't bind ims_usrloc_pcscf\n");
return -1;
}
if (bind_usrloc(&ul) < 0) {
return -1;
}
LM_DBG("Successfully bound to PCSCF Usrloc module\n");
if(subscribe_to_reginfo == 1){
/* 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;
}
if (pua.get_subs_list == NULL) {
LM_ERR("Could not import get_subs_list\n");
return -1;
}
LM_DBG("Successfully bound to PUA module\n");
/*init cdb cb event list*/
if (!init_reginfo_event_list()) {
LM_ERR("unable to initialise reginfo_event_list\n");
return -1;
}
LM_DBG("Successfully initialised reginfo_event_list\n");
}
return 0;
error:
return -1;
}
/**
* init module function
*/
static int mod_init(void)
{
bind_presence_t bind_presence;
presence_api_t pres;
bind_pua_t bind_pua;
pua_api_t pua;
bind_libxml_t bind_libxml;
libxml_api_t libxml_api;
bind_xcap_t bind_xcap;
xcap_api_t xcap_api;
char* sep;
LM_DBG("start\n");
if (register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if (dbmode <RLS_DB_DEFAULT || dbmode > RLS_DB_ONLY)
{
LM_ERR( "Invalid dbmode-set to default mode\n" );
dbmode = 0;
}
if(!rls_server_address.s || rls_server_address.len<=0)
{
LM_ERR("server_address parameter not set in configuration file\n");
return -1;
}
if(!rls_integrated_xcap_server && xcap_root== NULL)
{
LM_ERR("xcap_root parameter not set\n");
return -1;
}
/* extract port if any */
if(xcap_root)
{
sep= strchr(xcap_root, ':');
if(sep)
{
char* sep2= NULL;
sep2= strchr(sep+ 1, ':');
if(sep2)
sep= sep2;
str port_str;
port_str.s= sep+ 1;
port_str.len= strlen(xcap_root)- (port_str.s-xcap_root);
if(str2int(&port_str, &xcap_port)< 0)
{
LM_ERR("converting string to int [port]= %.*s\n",
port_str.len, port_str.s);
return -1;
}
if(xcap_port< 0 || xcap_port> 65535)
{
LM_ERR("wrong xcap server port\n");
return -1;
}
*sep= '\0';
}
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1)
{
LM_ERR("can't load tm functions\n");
return -1;
}
bind_presence= (bind_presence_t)find_export("bind_presence", 1,0);
if (!bind_presence)
{
LM_ERR("Can't bind presence\n");
return -1;
}
if (bind_presence(&pres) < 0)
{
LM_ERR("Can't bind presence\n");
return -1;
}
pres_contains_event = pres.contains_event;
pres_search_event = pres.search_event;
pres_get_ev_list = pres.get_event_list;
if (rls_expires_offset < 0 )
{
LM_ERR( "Negative expires_offset, defaulted to zero\n" );
rls_expires_offset = 0;
}
if (dbmode == RLS_DB_ONLY)
{
pres_new_shtable = rls_new_shtable;
pres_destroy_shtable = rls_destroy_shtable;
pres_insert_shtable = rls_insert_shtable;
pres_delete_shtable = rls_delete_shtable;
pres_update_shtable = rls_update_shtable;
pres_search_shtable = rls_search_shtable;
pres_update_db_subs_timer = rls_update_db_subs_timer;
}
else
{
pres_new_shtable = pres.new_shtable;
pres_destroy_shtable = pres.destroy_shtable;
pres_insert_shtable = pres.insert_shtable;
pres_delete_shtable = pres.delete_shtable;
pres_update_shtable = pres.update_shtable;
pres_search_shtable = pres.search_shtable;
pres_update_db_subs_timer = pres.update_db_subs_timer;
}
pres_copy_subs = pres.mem_copy_subs;
pres_extract_sdialog_info= pres.extract_sdialog_info;
if(!pres_contains_event || !pres_get_ev_list || !pres_new_shtable ||
!pres_destroy_shtable || !pres_insert_shtable || !pres_delete_shtable
|| !pres_update_shtable || !pres_search_shtable || !pres_copy_subs
|| !pres_extract_sdialog_info)
{
LM_ERR("importing functions from presence module\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.s);
if(xcap_db_url.len==0)
{
xcap_db_url.s = db_url.s;
xcap_db_url.len = db_url.len;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(xcap_db_url.s), xcap_db_url.len, xcap_db_url.s);
if(rlpres_db_url.len==0)
{
rlpres_db_url.s = db_url.s;
rlpres_db_url.len = db_url.len;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(rlpres_db_url.s), rlpres_db_url.len, rlpres_db_url.s);
/* binding to mysql module */
if (db_bind_mod(&db_url, &rls_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (db_bind_mod(&rlpres_db_url, &rlpres_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (db_bind_mod(&xcap_db_url, &rls_xcap_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(rls_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
if (!DB_CAPABILITY(rlpres_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
if (!DB_CAPABILITY(rls_xcap_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
rls_db = rls_dbf.init(&db_url);
if (!rls_db)
{
LM_ERR("while connecting database\n");
return -1;
}
rlpres_db = rlpres_dbf.init(&rlpres_db_url);
if (!rlpres_db)
{
LM_ERR("while connecting database\n");
return -1;
}
rls_xcap_db = rls_xcap_dbf.init(&xcap_db_url);
if (!rls_xcap_db)
{
LM_ERR("while connecting database\n");
return -1;
}
/* verify table version */
if(db_check_table_version(&rls_dbf, rls_db, &rlsubs_table, W_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
/* verify table version */
if(db_check_table_version(&rlpres_dbf, rlpres_db, &rlpres_table, P_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
/* verify table version */
if(db_check_table_version(&rls_xcap_dbf, rls_xcap_db, &rls_xcap_table, X_TABLE_VERSION) < 0)
{
LM_ERR("error during table version check.\n");
return -1;
}
if (dbmode != RLS_DB_ONLY)
{
if(hash_size<=1)
hash_size= 512;
else
hash_size = 1<<hash_size;
rls_table= pres_new_shtable(hash_size);
if(rls_table== NULL)
{
LM_ERR("while creating new hash table\n");
return -1;
}
if(rls_reload_db_subs!=0)
{
if(rls_restore_db_subs()< 0)
{
LM_ERR("while restoring rl watchers table\n");
return -1;
}
}
}
if(rls_db)
rls_dbf.close(rls_db);
rls_db = NULL;
if(rlpres_db)
rlpres_dbf.close(rlpres_db);
rlpres_db = NULL;
if(rls_xcap_db)
rls_xcap_dbf.close(rls_xcap_db);
rls_xcap_db = NULL;
if(waitn_time<= 0)
waitn_time= 5;
if(rls_notifier_poll_rate<= 0)
rls_notifier_poll_rate= 10;
if(rls_notifier_processes<= 0)
rls_notifier_processes= 1;
/* bind libxml wrapper functions */
if((bind_libxml=(bind_libxml_t)find_export("bind_libxml_api", 1, 0))== NULL)
{
LM_ERR("can't import bind_libxml_api\n");
return -1;
}
if(bind_libxml(&libxml_api)< 0)
{
LM_ERR("can not bind libxml api\n");
return -1;
}
XMLNodeGetAttrContentByName= libxml_api.xmlNodeGetAttrContentByName;
XMLDocGetNodeByName= libxml_api.xmlDocGetNodeByName;
XMLNodeGetNodeByName= libxml_api.xmlNodeGetNodeByName;
XMLNodeGetNodeContentByName= libxml_api.xmlNodeGetNodeContentByName;
if(XMLNodeGetAttrContentByName== NULL || XMLDocGetNodeByName== NULL ||
XMLNodeGetNodeByName== NULL || XMLNodeGetNodeContentByName== NULL)
{
LM_ERR("libxml wrapper functions could not be bound\n");
return -1;
}
/* bind pua */
bind_pua= (bind_pua_t)find_export("bind_pua", 1,0);
if (!bind_pua)
{
LM_ERR("Can't bind pua\n");
return -1;
}
if (bind_pua(&pua) < 0)
{
LM_ERR("mod_init Can't bind pua\n");
return -1;
}
if(pua.send_subscribe == NULL)
{
LM_ERR("Could not import send_subscribe\n");
return -1;
}
pua_send_subscribe= pua.send_subscribe;
if(pua.get_record_id == NULL)
{
LM_ERR("Could not import get_record_id\n");
return -1;
}
pua_get_record_id= pua.get_record_id;
if(pua.get_subs_list == NULL)
{
LM_ERR("Could not import get_subs_list\n");
return -1;
}
pua_get_subs_list= pua.get_subs_list;
if(!rls_integrated_xcap_server)
{
/* bind xcap */
bind_xcap= (bind_xcap_t)find_export("bind_xcap", 1, 0);
if (!bind_xcap)
{
LM_ERR("Can't bind xcap_client\n");
return -1;
}
if (bind_xcap(&xcap_api) < 0)
{
LM_ERR("Can't bind xcap\n");
return -1;
}
xcap_GetNewDoc= xcap_api.getNewDoc;
if(xcap_GetNewDoc== NULL)
{
LM_ERR("Can't import xcap_client functions\n");
return -1;
}
}
if (rlpres_clean_period < 0)
rlpres_clean_period = clean_period;
if (clean_period > 0)
register_timer(rlsubs_table_update, 0, clean_period);
if (rlpres_clean_period > 0)
register_timer(rls_presentity_clean, 0, rlpres_clean_period);
if(dbmode == RLS_DB_ONLY)
{
if ((rls_notifier_id = shm_malloc(sizeof(int) * rls_notifier_processes)) == NULL)
{
LM_ERR("allocating shared memory\n");
return -1;
}
register_basic_timers(rls_notifier_processes);
}
else
register_timer(timer_send_notify, 0, waitn_time);
if ((rls_update_subs_lock = lock_alloc()) == NULL)
{
LM_ERR("Failed to alloc rls_update_subs_lock\n");
return -1;
}
if (lock_init(rls_update_subs_lock) == NULL)
{
LM_ERR("Failed to init rls_updae_subs_lock\n");
return -1;
}
return 0;
}
static int mod_init(void)
{
str attr;
DBG("auth module - initializing\n");
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* If the parameter was not used */
if (sec_param == 0) {
/* Generate secret using random generator */
if (generate_random_secret() < 0) {
LOG(L_ERR, "auth:mod_init: Error while generating random secret\n");
return -3;
}
} else {
/* Otherwise use the parameter's value */
secret1.s = sec_param;
secret1.len = strlen(secret1.s);
if (auth_checks_reg || auth_checks_ind || auth_checks_ood) {
/* divide the secret in half: one half for secret1 and one half for
* secret2 */
secret2.len = secret1.len/2;
secret1.len -= secret2.len;
secret2.s = secret1.s + secret1.len;
if (secret2.len < 16) {
WARN("auth: consider a longer secret when extra auth checks are"
" enabled (the config secret is divided in 2!)\n");
}
}
}
if ((!challenge_attr.s || challenge_attr.len == 0) ||
challenge_attr.s[0] != '$') {
ERR("auth: Invalid value of challenge_attr module parameter\n");
return -1;
}
attr.s = challenge_attr.s + 1;
attr.len = challenge_attr.len - 1;
if (parse_avp_ident(&attr, &challenge_avpid) < 0) {
ERR("auth: Error while parsing value of challenge_attr module"
" parameter\n");
return -1;
}
parse_qop(&auth_qop);
switch(auth_qop.qop_parsed){
case QOP_OTHER:
ERR("auth: Unsupported qop parameter value\n");
return -1;
case QOP_AUTH:
case QOP_AUTHINT:
if (nc_enabled){
#ifndef USE_NC
WARN("auth: nounce count support enabled from config, but"
" disabled at compile time (recompile with -DUSE_NC)\n");
nc_enabled=0;
#else
if (nid_crt==0)
init_nonce_id();
if (init_nonce_count()!=0)
return -1;
#endif
}
#ifdef USE_NC
else{
INFO("auth: qop set, but nonce-count (nc_enabled) support"
" disabled\n");
}
#endif
break;
default:
if (nc_enabled){
WARN("auth: nonce-count support enabled, but qop not set\n");
nc_enabled=0;
}
break;
}
if (otn_enabled){
#ifdef USE_OT_NONCE
if (nid_crt==0) init_nonce_id();
if (init_ot_nonce()!=0)
return -1;
#else
WARN("auth: one-time-nonce support enabled from config, but "
"disabled at compile time (recompile with -DUSE_OT_NONCE)\n");
otn_enabled=0;
#endif /* USE_OT_NONCE */
}
return 0;
}
/*
* init module function
*/
static int mod_init(void)
{
bind_presence_t bind_presence;
load_tm_f load_tm;
bind_pua_t bind_pua;
bind_libxml_t bind_libxml;
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* import the TM auto-loading function */
if((load_tm=(load_tm_f)find_export("load_tm", NO_SCRIPT, 0))==NULL) {
LM_ERR("can't import load_tm\n");
return -1;
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1) {
LM_ERR("can't load tm functions\n");
return -1;
}
bind_presence= (bind_presence_t)find_export("bind_presence", 1,0);
if (!bind_presence) {
LM_ERR("can't bind presence\n");
return -1;
}
if (bind_presence(&pres) < 0) {
LM_ERR("can't bind presence\n");
return -1;
}
if (pres.add_event == NULL) {
LM_ERR("could not import add_event\n");
return -1;
}
bind_pua= (bind_pua_t)find_export("bind_pua", 1,0);
if (!bind_pua) {
LM_ERR("Can't bind pua\n");
return -1;
}
if (bind_pua(&pua) < 0) {
LM_ERR("mod_init Can't bind pua\n");
return -1;
}
/* bind libxml wrapper functions */
if((bind_libxml= (bind_libxml_t)find_export("bind_libxml_api", 1, 0))== NULL) {
LM_ERR("can't import bind_libxml_api\n");
return -1;
}
if(bind_libxml(&libxml_api)< 0) {
LM_ERR("can not bind libxml api\n");
return -1;
}
if(libxml_api.xmlNodeGetNodeByName==NULL) {
LM_ERR("can not bind libxml api\n");
return -1;
}
if(dfks_add_events() < 0) {
LM_ERR("failed to add as-feature-event events\n");
return -1;
}
outbound_proxy.len = outbound_proxy.s ? strlen(outbound_proxy.s) : 0;
return 0;
}
/*! \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 mod_init(void)
{
str attr;
DBG("auth module - initializing\n");
auth_realm_prefix.len = strlen(auth_realm_prefix.s);
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\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("Error while generating random secret\n");
return -3;
}
} else {
/* Otherwise use the parameter's value */
secret1.s = sec_param;
secret1.len = strlen(secret1.s);
if (auth_checks_reg || auth_checks_ind || auth_checks_ood) {
/* divide the secret in half: one half for secret1 and one half for
* secret2 */
secret2.len = secret1.len/2;
secret1.len -= secret2.len;
secret2.s = secret1.s + secret1.len;
if (secret2.len < 16) {
LM_WARN("consider a longer secret when extra auth checks are"
" enabled (the config secret is divided in 2!)\n");
}
}
}
if ((!challenge_attr.s || challenge_attr.len == 0) ||
challenge_attr.s[0] != '$') {
LM_ERR("Invalid value of challenge_attr module parameter\n");
return -1;
}
attr.s = challenge_attr.s + 1;
attr.len = challenge_attr.len - 1;
if (parse_avp_ident(&attr, &challenge_avpid) < 0) {
LM_ERR("Error while parsing value of challenge_attr module"
" parameter\n");
return -1;
}
parse_qop(&auth_qop);
switch(auth_qop.qop_parsed){
case QOP_OTHER:
LM_ERR("Unsupported qop parameter value\n");
return -1;
case QOP_AUTH:
case QOP_AUTHINT:
if (nc_enabled){
#ifndef USE_NC
LM_WARN("nounce count support enabled from config, but"
" disabled at compile time (recompile with -DUSE_NC)\n");
nc_enabled=0;
#else
if (nid_crt==0)
init_nonce_id();
if (init_nonce_count()!=0)
return -1;
#endif
}
#ifdef USE_NC
else{
LM_INFO("qop set, but nonce-count (nc_enabled) support"
" disabled\n");
}
#endif
break;
default:
if (nc_enabled){
LM_WARN("nonce-count support enabled, but qop not set\n");
nc_enabled=0;
}
break;
}
if (otn_enabled){
#ifdef USE_OT_NONCE
if (nid_crt==0) init_nonce_id();
if (init_ot_nonce()!=0)
return -1;
#else
LM_WARN("one-time-nonce support enabled from config, but "
"disabled at compile time (recompile with -DUSE_OT_NONCE)\n");
otn_enabled=0;
#endif /* USE_OT_NONCE */
}
if (auth_algorithm.len == 0 || strcmp(auth_algorithm.s, "MD5") == 0) {
hash_hex_len = HASHHEXLEN;
calc_HA1 = calc_HA1_md5;
calc_response = calc_response_md5;
}
else if (strcmp(auth_algorithm.s, "SHA-256") == 0) {
hash_hex_len = HASHHEXLEN_SHA256;
calc_HA1 = calc_HA1_sha256;
calc_response = calc_response_sha256;
}
else {
LM_ERR("Invalid algorithm provided."
" Possible values are \"\", \"MD5\" or \"SHA-256\"\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 cpl_init(void)
{
bind_usrloc_t bind_usrloc;
struct stat stat_t;
char *ptr;
int val;
pv_spec_t avp_spec;
unsigned short avp_type;
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
db_url.len = strlen(db_url.s);
db_table.len = strlen(db_table.s);
if (timer_avp.s) timer_avp.len = strlen(timer_avp.s);
if (cpl_env.proxy_recurse>MAX_PROXY_RECURSE) {
LM_CRIT("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.s && timer_avp.len > 0) {
if (pv_parse_spec(&timer_avp, &avp_spec)==0
|| avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n", timer_avp.len, timer_avp.s);
return -1;
}
if(pv_get_avp_name(0, &(avp_spec.pvp), &cpl_env.timer_avp,
&avp_type)!=0)
{
LM_ERR("[%.*s]- invalid AVP definition\n", timer_avp.len, timer_avp.s);
return -1;
}
cpl_env.timer_avp_type = avp_type;
}
if (dtd_file==0) {
LM_CRIT("mandatory parameter \"cpl_dtd_file\" found empty\n");
goto error;
} else {
/* check if the dtd file exists */
if (stat( dtd_file, &stat_t)==-1) {
LM_ERR("checking file \"%s\" status failed; stat returned %s\n",
dtd_file,strerror(errno));
goto error;
}
if ( !S_ISREG( stat_t.st_mode ) ) {
LM_ERR("dir \"%s\" is not a regular file!\n", dtd_file);
goto error;
}
if (access( dtd_file, R_OK )==-1) {
LM_ERR("checking file \"%s\" for permissions "
"failed; access returned %s\n",dtd_file,strerror(errno));
goto error;
}
}
if (cpl_env.log_dir==0) {
LM_INFO("log_dir param found empty -> logging disabled!\n");
} else {
if ( strlen(cpl_env.log_dir)>MAX_LOG_DIR_SIZE ) {
LM_ERR("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) {
LM_ERR("checking dir \"%s\" status failed;"
" stat returned %s\n",cpl_env.log_dir,strerror(errno));
goto error;
}
if ( !S_ISDIR( stat_t.st_mode ) ) {
LM_ERR("dir \"%s\" is not a directory!\n", cpl_env.log_dir);
goto error;
}
if (access( cpl_env.log_dir, R_OK|W_OK )==-1) {
LM_ERR("checking dir \"%s\" for permissions failed; access "
"returned %s\n", cpl_env.log_dir, strerror(errno));
goto error;
}
}
/* bind to the mysql module */
if (cpl_db_bind(&db_url, &db_table)<0) goto error;
/* load TM API */
if (load_tm_api(&cpl_fct.tmb)!=0) {
LM_ERR("can't load TM API\n");
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) {
LM_ERR("can't bind usrloc\n");
goto error;
}
if (bind_usrloc( &(cpl_fct.ulb) ) < 0) {
LM_ERR("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) {
LM_ERR("failed to register domain <%s>\n",lookup_domain);
goto error;
}
} else {
LM_NOTICE("no lookup_domain given -> disable lookup node\n");
}
/* build a pipe for sending commands to aux process */
if ( pipe( cpl_env.cmd_pipe )==-1 ) {
LM_CRIT("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 ) {
LM_ERR("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) ) {
LM_ERR("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 ) {
LM_ERR("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 ) {
LM_ERR("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) {
cpl_env.realm_prefix.len = strlen(cpl_env.realm_prefix.s);
/* convert the realm_prefix to lower cases */
strlower( &cpl_env.realm_prefix );
}
return 0;
error:
return -1;
}
/**
* 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;
}
int mod_init (void)
{
/**********
* o allocate shared mem and init
* o init configuration data
* o init DB
**********/
pmod_data = (mod_data *) shm_malloc (sizeof (mod_data));
if (!pmod_data)
{
LM_ERR ("Unable to allocate shared memory");
return -1;
}
memset (pmod_data, 0, sizeof (mod_data));
if (!init_cfg ())
{ goto initerr; }
if (!init_db ())
{ goto initerr; }
/**********
* o bind to SL/TM/RR modules
* o bind to RTPPROXY functions
**********/
if (sl_load_api (pmod_data->psl))
{
LM_ERR ("Unable to load SL module\n");
goto initerr;
}
if (load_tm_api (pmod_data->ptm))
{
LM_ERR ("Unable to load TM module\n");
goto initerr;
}
if (load_rr_api (pmod_data->prr))
{
LM_ERR ("Unable to load RR module\n");
goto initerr;
}
pmod_data->fn_rtp_answer = find_export ("rtpproxy_answer", 0, 0);
if (!pmod_data->fn_rtp_answer)
{
LM_ERR ("Unable to load rtpproxy_answer\n");
goto initerr;
}
pmod_data->fn_rtp_offer = find_export ("rtpproxy_offer", 0, 0);
if (!pmod_data->fn_rtp_offer)
{
LM_ERR ("Unable to load rtpproxy_offer\n");
goto initerr;
}
pmod_data->fn_rtp_stream_c = find_export ("rtpproxy_stream2uac", 2, 0);
if (!pmod_data->fn_rtp_stream_c)
{
LM_ERR ("Unable to load rtpproxy_stream2uac\n");
goto initerr;
}
pmod_data->fn_rtp_stream_s = find_export ("rtpproxy_stream2uas", 2, 0);
if (!pmod_data->fn_rtp_stream_s)
{
LM_ERR ("Unable to load rtpproxy_stream2uas\n");
goto initerr;
}
pmod_data->fn_rtp_destroy = find_export ("rtpproxy_destroy", 0, 0);
if (!pmod_data->fn_rtp_destroy)
{
LM_ERR ("Unable to load rtpproxy_destroy\n");
goto initerr;
}
/**********
* init MOH and call queue locks
**********/
if (!mohq_lock_init (pmod_data->pmohq_lock))
{ goto initerr; }
if (!mohq_lock_init (pmod_data->pcall_lock))
{ goto initerr; }
return 0;
/**********
* o release shared mem
* o exit with error
**********/
initerr:
if (pmod_data->mohq_cnt)
{ shm_free (pmod_data->pmohq_lst); }
if (pmod_data->pcall_lock->plock)
{ mohq_lock_destroy (pmod_data->pcall_lock); }
shm_free (pmod_data);
pmod_data = NULL;
return -1;
}
static int mod_init(void)
{
if (sl_load_api(&ws_slb) != 0)
{
LM_ERR("binding to SL\n");
goto error;
}
if (sr_event_register_cb(SREV_TCP_WS_FRAME_IN, ws_frame_receive) != 0)
{
LM_ERR("registering WebSocket receive call-back\n");
goto error;
}
if (sr_event_register_cb(SREV_TCP_WS_FRAME_OUT, ws_frame_transmit) != 0)
{
LM_ERR("registering WebSocket transmit call-back\n");
goto error;
}
if (register_module_stats(exports.name, stats) != 0)
{
LM_ERR("registering core statistics\n");
goto error;
}
if (register_mi_mod(exports.name, mi_cmds) != 0)
{
LM_ERR("registering MI commands\n");
goto error;
}
if (wsconn_init() < 0)
{
LM_ERR("initialising WebSocket connections table\n");
goto error;
}
if (ws_ping_application_data.len < 1
|| ws_ping_application_data.len > 125)
{
ws_ping_application_data.s = DEFAULT_PING_APPLICATION_DATA + 8;
ws_ping_application_data.len =
DEFAULT_PING_APPLICATION_DATA_LEN - 8;
}
if (ws_keepalive_mechanism != KEEPALIVE_MECHANISM_NONE)
{
if (ws_keepalive_timeout < 1 || ws_keepalive_timeout > 3600)
ws_keepalive_timeout = DEFAULT_KEEPALIVE_TIMEOUT;
switch(ws_keepalive_mechanism)
{
case KEEPALIVE_MECHANISM_PING:
case KEEPALIVE_MECHANISM_PONG:
break;
default:
ws_keepalive_mechanism = DEFAULT_KEEPALIVE_MECHANISM;
break;
}
if (ws_keepalive_interval < 1 || ws_keepalive_interval > 60)
ws_keepalive_interval = DEFAULT_KEEPALIVE_INTERVAL;
if (ws_keepalive_processes < 1 || ws_keepalive_processes > 16)
ws_keepalive_processes = DEFAULT_KEEPALIVE_PROCESSES;
/* Add extra process/timer for the keepalive process */
register_sync_timers(ws_keepalive_processes);
}
if (ws_sub_protocols & SUB_PROTOCOL_MSRP
&& !sr_event_enabled(SREV_TCP_MSRP_FRAME))
ws_sub_protocols &= ~SUB_PROTOCOL_MSRP;
if ((ws_sub_protocols & SUB_PROTOCOL_ALL) == 0)
{
LM_ERR("no sub-protocols enabled\n");
goto error;
}
if ((ws_sub_protocols | SUB_PROTOCOL_ALL) != SUB_PROTOCOL_ALL)
{
LM_ERR("unrecognised sub-protocols enabled\n");
goto error;
}
if (ws_cors_mode < 0 || ws_cors_mode > 2)
{
LM_ERR("bad value for cors_mode\n");
goto error;
}
if (cfg_declare("websocket", ws_cfg_def, &default_ws_cfg,
cfg_sizeof(websocket), &ws_cfg))
{
LM_ERR("declaring configuration\n");
return -1;
}
cfg_get(websocket, ws_cfg, keepalive_timeout) = ws_keepalive_timeout;
if (!module_loaded("xhttp"))
{
LM_ERR("\"xhttp\" must be loaded to use WebSocket.\n");
return -1;
}
if (((ws_sub_protocols & SUB_PROTOCOL_SIP) == SUB_PROTOCOL_SIP)
&& !module_loaded("nathelper")
&& !module_loaded("outbound"))
{
LM_WARN("neither \"nathelper\" nor \"outbound\" modules are"
" loaded. At least one of these is required for correct"
" routing of SIP over WebSocket.\n");
}
return 0;
error:
wsconn_destroy();
return -1;
}
/**
* init module function
*/
static int mod_init(void)
{
if(pres_uri_match == 1) {
presence_sip_uri_match = sip_uri_case_insensitive_match;
} else {
presence_sip_uri_match = sip_uri_case_sensitive_match;
}
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(presence_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len,db_url.s);
if(db_url.s== NULL)
library_mode= 1;
EvList= init_evlist();
if(!EvList){
LM_ERR("unsuccessful initialize event list\n");
return -1;
}
if(library_mode== 1)
{
LM_DBG("Presence module used for API library purpose only\n");
return 0;
}
if(expires_offset<0)
expires_offset = 0;
if(to_tag_pref==NULL || strlen(to_tag_pref)==0)
to_tag_pref="10";
if(max_expires<= 0)
max_expires = 3600;
if(min_expires < 0)
min_expires = 0;
if(min_expires > max_expires)
min_expires = max_expires;
if(min_expires_action < 1 || min_expires_action > 2) {
LM_ERR("min_expires_action must be 1 = RFC 6665/3261 Reply 423, 2 = force min_expires value\n");
return -1;
}
if(server_address.s== NULL)
LM_DBG("server_address parameter not set in configuration file\n");
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1)
{
LM_ERR("Can't load tm functions. Module TM not loaded?\n");
return -1;
}
if(db_url.s== NULL)
{
LM_ERR("database url not set!\n");
return -1;
}
/* binding to database module */
if (db_bind_mod(&db_url, &pa_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pa_dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by presence module\n");
return -1;
}
pa_db = pa_dbf.init(&db_url);
if (!pa_db)
{
LM_ERR("Connection to database failed\n");
return -1;
}
/*verify table versions */
if((db_check_table_version(&pa_dbf, pa_db, &presentity_table, P_TABLE_VERSION) < 0) ||
(db_check_table_version(&pa_dbf, pa_db, &watchers_table, S_TABLE_VERSION) < 0)) {
LM_ERR("error during table version check\n");
return -1;
}
if(subs_dbmode != NO_DB &&
db_check_table_version(&pa_dbf, pa_db, &active_watchers_table, ACTWATCH_TABLE_VERSION) < 0) {
LM_ERR("wrong table version for %s\n", active_watchers_table.s);
return -1;
}
if(subs_dbmode != DB_ONLY) {
if(shtable_size< 1)
shtable_size= 512;
else
shtable_size= 1<< shtable_size;
subs_htable= new_shtable(shtable_size);
if(subs_htable== NULL)
{
LM_ERR(" initializing subscribe hash table\n");
return -1;
}
if(restore_db_subs()< 0)
{
LM_ERR("restoring subscribe info from database\n");
return -1;
}
}
if(publ_cache_enabled) {
if(phtable_size< 1)
phtable_size= 256;
else
phtable_size= 1<< phtable_size;
pres_htable= new_phtable();
if(pres_htable== NULL)
{
LM_ERR("initializing presentity hash table\n");
return -1;
}
if(pres_htable_restore()< 0)
{
LM_ERR("filling in presentity hash table from database\n");
return -1;
}
}
startup_time = (int) time(NULL);
if(clean_period>0)
{
register_timer(msg_presentity_clean, 0, clean_period);
register_timer(msg_watchers_clean, 0, clean_period);
}
if(db_update_period>0)
register_timer(timer_db_update, 0, db_update_period);
if (pres_waitn_time <= 0)
pres_waitn_time = 5;
if (pres_notifier_poll_rate <= 0)
pres_notifier_poll_rate = 10;
if (pres_notifier_processes < 0 || subs_dbmode != DB_ONLY)
pres_notifier_processes = 0;
if (pres_notifier_processes > 0)
{
if ((pres_notifier_id = shm_malloc(sizeof(int) * pres_notifier_processes)) == NULL)
{
LM_ERR("allocating shared memory\n");
return -1;
}
register_basic_timers(pres_notifier_processes);
}
if (db_table_lock_type != 1)
db_table_lock = DB_LOCKING_NONE;
pa_dbf.close(pa_db);
pa_db = NULL;
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
xcaps_db_url.len = (xcaps_db_url.s) ? strlen(xcaps_db_url.s) : 0;
xcaps_db_table.len = (xcaps_db_table.s) ? strlen(xcaps_db_table.s) : 0;
xcaps_root.len = (xcaps_root.s) ? strlen(xcaps_root.s) : 0;
xcaps_directory_hostname.len
= xcaps_directory_hostname.s
? strlen(xcaps_directory_hostname.s) : 0;
if (xcaps_directory_scheme < -1 || xcaps_directory_scheme > 1)
{
LM_ERR("invalid xcaps_directory_scheme\n");
return -1;
}
if(xcaps_buf.len<=0)
{
LM_ERR("invalid buffer size\n");
return -1;
}
xcaps_buf.s = (char*)pkg_malloc(xcaps_buf.len+1);
if(xcaps_buf.s==NULL)
{
LM_ERR("no pkg\n");
return -1;
}
/* binding to mysql module */
if (db_bind_mod(&xcaps_db_url, &xcaps_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(xcaps_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
xcaps_db = xcaps_dbf.init(&xcaps_db_url);
if (xcaps_db==NULL)
{
LM_ERR("connecting to database\n");
return -1;
}
if(db_check_table_version(&xcaps_dbf, xcaps_db, &xcaps_db_table,
XCAP_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
xcaps_dbf.close(xcaps_db);
xcaps_db = NULL;
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
xcaps_init_time = (int)time(NULL);
return 0;
}
/*! \brief Initialize siptrace module */
static int mod_init(void)
{
pv_spec_t avp_spec;
sl_cbelem_t slcb;
#ifdef STATISTICS
/* register statistics */
if (register_module_stats(exports.name, siptrace_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(siptrace_init_rpc() != 0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
if (trace_flag<0 || trace_flag>(int)MAX_FLAG)
{
LM_ERR("invalid trace flag %d\n", trace_flag);
return -1;
}
trace_flag = 1<<trace_flag;
trace_to_database_flag = (int*)shm_malloc(sizeof(int));
if(trace_to_database_flag==NULL) {
LM_ERR("no more shm memory left\n");
return -1;
}
*trace_to_database_flag = trace_to_database;
if(hep_version != 1 && hep_version != 2) {
LM_ERR("unsupported version of HEP");
return -1;
}
/* Find a database module if needed */
if(trace_to_database_flag!=NULL && *trace_to_database_flag!=0) {
if (db_bind_mod(&db_url, &db_funcs))
{
LM_ERR("unable to bind database module\n");
return -1;
}
if (trace_to_database_flag && !DB_CAPABILITY(db_funcs, DB_CAP_INSERT))
{
LM_ERR("database modules does not provide all functions needed"
" by module\n");
return -1;
}
}
if(hep_version != 1 && hep_version != 2) {
LM_ERR("unsupported version of HEP");
return -1;
}
trace_on_flag = (int*)shm_malloc(sizeof(int));
if(trace_on_flag==NULL) {
LM_ERR("no more shm memory left\n");
return -1;
}
*trace_on_flag = trace_on;
xheaders_write_flag = (int*)shm_malloc(sizeof(int));
xheaders_read_flag = (int*)shm_malloc(sizeof(int));
if (!(xheaders_write_flag && xheaders_read_flag)) {
LM_ERR("no more shm memory left\n");
return -1;
}
*xheaders_write_flag = xheaders_write;
*xheaders_read_flag = xheaders_read;
/* register callbacks to TM */
if (load_tm_api(&tmb)!=0) {
LM_WARN("can't load tm api. Will not install tm callbacks.\n");
} else if(tmb.register_tmcb( 0, 0, TMCB_REQUEST_IN, trace_onreq_in, 0, 0) <=0) {
LM_ERR("can't register trace_onreq_in\n");
return -1;
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_WARN("cannot bind to SL API. Will not install sl callbacks.\n");
} else {
/* register sl callbacks */
memset(&slcb, 0, sizeof(sl_cbelem_t));
slcb.type = SLCB_REPLY_READY;
slcb.cbf = trace_sl_onreply_out;
if (slb.register_cb(&slcb) != 0) {
LM_ERR("can't register for SLCB_REPLY_READY\n");
return -1;
}
if(trace_sl_acks)
{
slcb.type = SLCB_ACK_FILTERED;
slcb.cbf = trace_sl_ack_in;
if (slb.register_cb(&slcb) != 0) {
LM_ERR("can't register for SLCB_ACK_FILTERED\n");
return -1;
}
}
}
if(dup_uri_str.s!=0)
{
dup_uri = (struct sip_uri *)pkg_malloc(sizeof(struct sip_uri));
if(dup_uri==0)
{
LM_ERR("no more pkg memory left\n");
return -1;
}
memset(dup_uri, 0, sizeof(struct sip_uri));
if(parse_uri(dup_uri_str.s, dup_uri_str.len, dup_uri)<0)
{
LM_ERR("bad dup uri\n");
return -1;
}
}
if(force_send_sock_str.s!=0)
{
force_send_sock_str.len = strlen(force_send_sock_str.s);
force_send_sock_uri = (struct sip_uri *)pkg_malloc(sizeof(struct sip_uri));
if(force_send_sock_uri==0)
{
LM_ERR("no more pkg memory left\n");
return -1;
}
memset(force_send_sock_uri, 0, sizeof(struct sip_uri));
if(parse_uri(force_send_sock_str.s, force_send_sock_str.len, force_send_sock_uri)<0)
{
LM_ERR("bad dup uri\n");
return -1;
}
}
if(traced_user_avp_str.s && traced_user_avp_str.len > 0)
{
if (pv_parse_spec(&traced_user_avp_str, &avp_spec)==0
|| avp_spec.type!=PVT_AVP)
{
LM_ERR("malformed or non AVP %.*s AVP definition\n",
traced_user_avp_str.len, traced_user_avp_str.s);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &traced_user_avp,
&traced_user_avp_type)!=0)
{
LM_ERR("[%.*s] - invalid AVP definition\n",
traced_user_avp_str.len, traced_user_avp_str.s);
return -1;
}
} else {
traced_user_avp.n = 0;
traced_user_avp_type = 0;
}
if(trace_table_avp_str.s && trace_table_avp_str.len > 0)
{
if (pv_parse_spec(&trace_table_avp_str, &avp_spec)==0
|| avp_spec.type!=PVT_AVP)
{
LM_ERR("malformed or non AVP %.*s AVP definition\n",
trace_table_avp_str.len, trace_table_avp_str.s);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &trace_table_avp,
&trace_table_avp_type)!=0)
{
LM_ERR("[%.*s] - invalid AVP definition\n",
trace_table_avp_str.len, trace_table_avp_str.s);
return -1;
}
} else {
trace_table_avp.n = 0;
trace_table_avp_type = 0;
}
return 0;
}