static void tcpops_tcp_closed_run_route(struct tcp_connection *con)
{
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
LM_DBG("tcp_closed_run_route event_route[tcp:closed]\n");
rt = route_get(&event_rt, "tcp:closed");
if (rt < 0 || event_rt.rlist[rt] == NULL)
{
LM_DBG("route does not exist");
return;
}
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
fmsg->rcv = con->rcv;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
}
/**
* init module function
*/
static int mod_init(void)
{
stm_timer_t *it;
if(_stm_list==NULL)
return 0;
/* init faked sip msg */
if(faked_msg_init()<0)
{
LM_ERR("failed to init timer local sip msg\n");
return -1;
}
/* register timers */
it = _stm_list;
while(it)
{
if(it->mode==0)
{
if(register_timer(stm_timer_exec, (void*)it, it->interval)<0)
{
LM_ERR("failed to register timer function\n");
return -1;
}
} else {
register_basic_timers(1);
}
it = it->next;
}
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
evrexec_task_t *it;
if(rpc_register_array(evr_rpc_methods)!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(_evrexec_list==NULL)
return 0;
/* init faked sip msg */
if(faked_msg_init()<0) {
LM_ERR("failed to init evrexec local sip msg\n");
return -1;
}
/* register additional processes */
it = _evrexec_list;
while(it) {
register_procs(it->workers);
it = it->next;
}
return 0;
}
static int fire_init_event(int rank)
{
struct sip_msg *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
LM_DBG("rank is (%d)\n", rank);
if (rank!=PROC_INIT)
return 0;
rt = route_get(&event_rt, "kazoo:mod-init");
if(rt>=0 && event_rt.rlist[rt]!=NULL) {
LM_DBG("executing event_route[kazoo:mod-init] (%d)\n", rt);
if(faked_msg_init()<0)
return -1;
fmsg = faked_msg_next();
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, &ctx);
if(ctx.run_flags&DROP_R_F)
{
LM_ERR("exit due to 'drop' in event route\n");
return -1;
}
set_route_type(rtb);
}
return 0;
}
int nsq_consumer_fire_event(char *routename)
{
struct sip_msg *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
LM_DBG("searching event_route[%s]\n", routename);
rt = route_get(&event_rt, routename);
if (rt < 0 || event_rt.rlist[rt] == NULL) {
LM_DBG("route %s does not exist\n", routename);
return -2;
}
LM_DBG("executing event_route[%s] (%d)\n", routename, rt);
if (faked_msg_init()<0) {
return -2;
}
fmsg = faked_msg_next();
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(rtb);
return 0;
}
void ht_expired_run_event_route(char *route)
{
int rt, backup_rt;
sip_msg_t *fmsg;
if (route == NULL)
{
LM_ERR("bad route\n");
}
LM_DBG("ht_expired_run_event_route event_route[%s]\n", route);
rt = route_get(&event_rt, route);
if (rt < 0 || event_rt.rlist[rt] == NULL)
{
LM_DBG("route does not exist");
return;
}
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
fmsg->parsed_orig_ruri_ok = 0;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
}
void ht_expired_run_event_route(int routeid)
{
int backup_rt;
sip_msg_t *fmsg;
if (routeid < 0 || event_rt.rlist[routeid] == NULL)
{
LM_DBG("route does not exist\n");
return;
}
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
fmsg->parsed_orig_ruri_ok = 0;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
run_top_route(event_rt.rlist[routeid], fmsg, 0);
set_route_type(backup_rt);
}
static void wsconn_run_route(ws_connection_t *wsc)
{
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
LM_DBG("wsconn_run_route event_route[websocket:closed]\n");
rt = route_get(&event_rt, "websocket:closed");
if (rt < 0 || event_rt.rlist[rt] == NULL)
{
LM_DBG("route does not exist");
return;
}
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
wsc->rcv.proto_reserved1 = wsc->id;
fmsg->rcv = wsc->rcv;
backup_rt = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
}
void ht_handle_expired_record(ht_t *ht, ht_cell_t *cell)
{
int backup_rt;
sip_msg_t *fmsg;
sr_kemi_eng_t *keng = NULL;
if(ht_event_callback.s==NULL || ht_event_callback.len<=0) {
if (ht->evex_index < 0 || event_rt.rlist[ht->evex_index] == NULL) {
LM_DBG("route does not exist\n");
return;
}
} else {
keng = sr_kemi_eng_get();
if(keng==NULL) {
LM_DBG("event callback (%s) set, but no cfg engine\n",
ht_event_callback.s);
return;
}
}
LM_DBG("running event_route[htable:expired:%.*s]\n",
ht->name.len, ht->name.s);
if (faked_msg_init() < 0) {
LM_ERR("faked_msg_init() failed\n");
return;
}
ht_expired_cell = cell;
fmsg = faked_msg_next();
fmsg->parsed_orig_ruri_ok = 0;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
if(ht->evex_index >= 0) {
run_top_route(event_rt.rlist[ht->evex_index], fmsg, 0);
} else {
if(keng!=NULL) {
if(keng->froute(fmsg, EVENT_ROUTE,
&ht_event_callback, &ht->evex_name)<0) {
LM_ERR("error running event route kemi callback\n");
}
}
}
set_route_type(backup_rt);
ht_expired_cell = NULL;
}
static void wsconn_run_route(ws_connection_t *wsc)
{
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
sr_kemi_eng_t *keng = NULL;
str evrtname = str_init("websocket:closed");
LM_DBG("wsconn_run_route event_route[websocket:closed]\n");
rt = route_lookup(&event_rt, evrtname.s);
if (rt < 0 || event_rt.rlist[rt] == NULL)
{
if(ws_event_callback.len<=0 || ws_event_callback.s==NULL) {
LM_DBG("event route does not exist");
return;
}
keng = sr_kemi_eng_get();
if(keng==NULL) {
LM_DBG("event route callback engine does not exist");
return;
} else {
rt = -1;
}
}
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
wsc->rcv.proto_reserved1 = wsc->id;
fmsg->rcv = wsc->rcv;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
init_run_actions_ctx(&ctx);
if(rt<0) {
/* kemi script event route callback */
if(keng && keng->froute(fmsg, EVENT_ROUTE,
&ws_event_callback, &evrtname)<0) {
LM_ERR("error running event route kemi callback\n");
}
} else {
/* native cfg event route */
run_top_route(event_rt.rlist[rt], fmsg, 0);
}
set_route_type(backup_rt);
}
static int child_init(int rank)
{
struct sip_msg *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
int i;
LM_DBG("rank is (%d)\n", rank);
if(rank==PROC_MAIN) {
if(ht_timer_procs>0) {
for(i=0; i<ht_timer_procs; i++) {
if(fork_sync_timer(PROC_TIMER, "HTable Timer", 1 /*socks flag*/,
ht_timer, (void*)(long)i, ht_timer_interval)<0) {
LM_ERR("failed to start timer routine as process\n");
return -1; /* error */
}
}
}
}
if (rank!=PROC_INIT)
return 0;
rt = route_get(&event_rt, "htable:mod-init");
if(rt>=0 && event_rt.rlist[rt]!=NULL) {
LM_DBG("executing event_route[htable:mod-init] (%d)\n", rt);
if(faked_msg_init()<0)
return -1;
fmsg = faked_msg_next();
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, &ctx);
if(ctx.run_flags&DROP_R_F)
{
LM_ERR("exit due to 'drop' in event route\n");
return -1;
}
set_route_type(rtb);
}
return 0;
}
str *pv_get_mq_name(sip_msg_t *msg, str *in)
{
str *queue;
if (in->s[0] != '$')
queue = in;
else
{
pv_spec_t *pvs;
pv_value_t pvv;
if (pv_locate_name(in) != in->len)
{
LM_ERR("invalid pv [%.*s]\n", in->len, in->s);
return NULL;
}
if ((pvs = pv_cache_get(in)) == NULL)
{
LM_ERR("failed to get pv spec for [%.*s]\n", in->len, in->s);
return NULL;
}
memset(&pvv, 0, sizeof(pv_value_t));
if (msg==NULL && faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return NULL;
}
if (pv_get_spec_value((msg)?msg:faked_msg_next(), pvs, &pvv) != 0)
{
LM_ERR("failed to get pv value for [%.*s]\n", in->len, in->s);
return NULL;
}
queue = &pvv.rs;
}
return queue;
}
/**
* init module function
*/
static int mod_init(void)
{
char *p;
/* init faked sip msg */
if(faked_msg_init()<0) {
LM_ERR("failed to init faked sip message\n");
return -1;
}
if(load_tm_api( &tmb ) < 0) {
LM_INFO("cannot load the TM module functions - async relay disabled\n");
memset(&tmb, 0, sizeof(tm_api_t));
}
if(_evapi_bind_param!=NULL) {
p = strchr(_evapi_bind_param, ':');
if(p!=NULL) {
*p++ = '\0';
_evapi_bind_port = (short)atoi(p);
if (_evapi_bind_port <= 0) {
LM_ERR("invalid port: %d\n", _evapi_bind_port);
return -1;
}
}
_evapi_bind_addr = _evapi_bind_param;
}
/* add space for one extra process */
register_procs(1 + _evapi_workers);
/* add child to update local config framework structures */
cfg_register_child(1 + _evapi_workers);
evapi_init_environment(_evapi_netstring_format_param);
return 0;
}
static void tcpops_tcp_closed_run_route(tcp_closed_event_info_t *tev)
{
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
rt = tcp_closed_routes[tev->reason];
if (rt == -1) return;
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
fmsg->rcv = tev->con->rcv;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
}
/**
* init module function
*/
static int mod_init(void)
{
unsigned int n;
LM_INFO("Initializing Http Async module\n");
#ifdef STATISTICS
/* register statistics */
if (register_module_stats( exports.name, mod_stats)!=0 ) {
LM_ERR("failed to register core statistics\n");
return -1;
}
#endif
/* sanitize hash_size */
if (hash_size < 1){
LM_WARN("hash_size is smaller "
"than 1 -> rounding from %d to 1\n",
hash_size);
hash_size = 1;
}
/* check that the hash table size is a power of 2 */
for( n=0 ; n<(8*sizeof(n)) ; n++) {
if (hash_size==(1<<n))
break;
if (n && hash_size<(1<<n)) {
LM_WARN("hash_size is not a power "
"of 2 as it should be -> rounding from %d to %d (n=%d)\n",
hash_size, 1<<(n-1), n);
hash_size = 1<<(n-1);
break;
}
}
/* check 'workers' param */
if (num_workers < 1) {
LM_ERR("the 'workers' parameter must be >= 1\n");
return -1;
}
tls_verify_host = tls_verify_host?1:0;
tls_verify_peer = tls_verify_peer?1:0;
/* init http parameters list */
init_query_params(&ah_params);
if (strncmp("shm", memory_manager, 3) == 0) {
curl_memory_manager = 0;
} else if (strncmp("sys", memory_manager, 3) == 0) {
curl_memory_manager = 1;
} else {
LM_ERR("invalid memory_manager parameter: '%s'\n", memory_manager);
return -1;
}
if (strncmp("shm", memory_manager, 3) == 0) {
curl_memory_manager = 0;
} else if (strncmp("sys", memory_manager, 3) == 0) {
curl_memory_manager = 1;
} else {
LM_ERR("invalid memory_manager parameter: '%s'\n", memory_manager);
return -1;
}
/* init faked sip msg */
if(faked_msg_init()<0) {
LM_ERR("failed to init faked sip msg\n");
return -1;
}
if(load_tm_api( &tmb ) < 0) {
LM_INFO("cannot load the TM-functions - async relay disabled\n");
memset(&tmb, 0, sizeof(tm_api_t));
}
/* allocate workers array */
workers = shm_malloc(num_workers * sizeof(*workers));
if(workers == NULL) {
LM_ERR("error in shm_malloc\n");
return -1;
}
memset(workers, 0, num_workers * sizeof(*workers));
register_procs(num_workers);
/* add child to update local config framework structures */
cfg_register_child(num_workers);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
sip_uri_t puri;
char buri[MAX_URI_SIZE];
_th_eventrt_outgoing = route_lookup(&event_rt, _th_eventrt_name.s);
if(_th_eventrt_outgoing<0
|| event_rt.rlist[_th_eventrt_outgoing]==NULL) {
_th_eventrt_outgoing = -1;
}
if(faked_msg_init()<0) {
LM_ERR("failed to init fmsg\n");
return -1;
}
if(th_sanity_checks!=0)
{
if(sanity_load_api(&scb)<0)
{
LM_ERR("cannot bind to sanity module\n");
goto error;
}
}
if(th_ip.len<=0)
{
LM_ERR("mask IP parameter is invalid\n");
goto error;
}
if(th_ip.len + 32 >= MAX_URI_SIZE) {
LM_ERR("mask address is too long\n");
goto error;
}
memcpy(buri, "sip:", 4);
memcpy(buri+4, th_ip.s, th_ip.len);
buri[th_ip.len+8] = '\0';
if(parse_uri(buri, th_ip.len+4, &puri)<0) {
LM_ERR("mask uri is invalid\n");
goto error;
}
if(check_self(&puri.host, puri.port_no, 0)==1)
{
th_mask_addr_myself = 1;
LM_INFO("mask address matches myself [%.*s]\n",
th_ip.len, th_ip.s);
}
/* 'SIP/2.0/UDP ' + ip + ';' + param + '=' + prefix (+ '\0') */
th_via_prefix.len = 12 + th_ip.len + 1 + th_vparam_name.len + 1
+ th_vparam_prefix.len;
th_via_prefix.s = (char*)pkg_malloc(th_via_prefix.len+1);
if(th_via_prefix.s==NULL)
{
LM_ERR("via prefix parameter is invalid\n");
goto error;
}
/* 'sip:' + ip + ';' + param + '=' + prefix (+ '\0') */
th_uri_prefix.len = 4 + th_ip.len + 1 + th_uparam_name.len + 1
+ th_uparam_prefix.len;
th_uri_prefix.s = (char*)pkg_malloc(th_uri_prefix.len+1);
if(th_uri_prefix.s==NULL)
{
LM_ERR("uri prefix parameter is invalid\n");
goto error;
}
/* build via prefix */
memcpy(th_via_prefix.s, "SIP/2.0/UDP ", 12);
memcpy(th_via_prefix.s+12, th_ip.s, th_ip.len);
th_via_prefix.s[12+th_ip.len] = ';';
memcpy(th_via_prefix.s+12+th_ip.len+1, th_vparam_name.s,
th_vparam_name.len);
th_via_prefix.s[12+th_ip.len+1+th_vparam_name.len] = '=';
memcpy(th_via_prefix.s+12+th_ip.len+1+th_vparam_name.len+1,
th_vparam_prefix.s, th_vparam_prefix.len);
th_via_prefix.s[th_via_prefix.len] = '\0';
LM_DBG("VIA prefix: [%s]\n", th_via_prefix.s);
/* build uri prefix */
memcpy(th_uri_prefix.s, "sip:", 4);
memcpy(th_uri_prefix.s+4, th_ip.s, th_ip.len);
th_uri_prefix.s[4+th_ip.len] = ';';
memcpy(th_uri_prefix.s+4+th_ip.len+1, th_uparam_name.s, th_uparam_name.len);
th_uri_prefix.s[4+th_ip.len+1+th_uparam_name.len] = '=';
memcpy(th_uri_prefix.s+4+th_ip.len+1+th_uparam_name.len+1,
th_uparam_prefix.s, th_uparam_prefix.len);
th_uri_prefix.s[th_uri_prefix.len] = '\0';
LM_DBG("URI prefix: [%s]\n", th_uri_prefix.s);
th_mask_init();
sr_event_register_cb(SREV_NET_DATA_IN, th_msg_received);
sr_event_register_cb(SREV_NET_DATA_OUT, th_msg_sent);
#ifdef USE_TCP
tcp_set_clone_rcvbuf(1);
#endif
return 0;
error:
return -1;
}
static int child_init(int rank)
{
struct sip_msg *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
int i;
sr_kemi_eng_t *keng = NULL;
str evname = str_init("htable:mod-init");
LM_DBG("rank is (%d)\n", rank);
if(rank==PROC_MAIN) {
if(ht_timer_procs>0) {
for(i=0; i<ht_timer_procs; i++) {
if(fork_sync_timer(PROC_TIMER, "HTable Timer", 1 /*socks flag*/,
ht_timer, (void*)(long)i, ht_timer_interval)<0) {
LM_ERR("failed to start timer routine as process\n");
return -1; /* error */
}
}
}
}
if (rank!=PROC_INIT)
return 0;
rt = -1;
if(ht_event_callback.s==NULL || ht_event_callback.len<=0) {
rt = route_lookup(&event_rt, evname.s);
if(rt<0 || event_rt.rlist[rt]==NULL) {
rt = -1;
}
} else {
keng = sr_kemi_eng_get();
if(keng==NULL) {
LM_DBG("event callback (%s) set, but no cfg engine\n",
ht_event_callback.s);
goto done;
}
}
if(rt>=0 || ht_event_callback.len>0) {
LM_DBG("executing event_route[%s] (%d)\n", evname.s, rt);
if(faked_msg_init()<0)
return -1;
fmsg = faked_msg_next();
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
if(rt>=0) {
run_top_route(event_rt.rlist[rt], fmsg, &ctx);
} else {
if(keng!=NULL) {
if(keng->froute(fmsg, EVENT_ROUTE,
&ht_event_callback, &evname)<0) {
LM_ERR("error running event route kemi callback\n");
return -1;
}
}
}
set_route_type(rtb);
if(ctx.run_flags&DROP_R_F) {
LM_ERR("exit due to 'drop' in event route\n");
return -1;
}
}
done:
return 0;
}
static int mod_init(void)
{
unsigned int n;
if(dlg_ka_interval!=0 && dlg_ka_interval<30) {
LM_ERR("ka interval too low (%d), has to be at least 30\n",
dlg_ka_interval);
return -1;
}
dlg_event_rt[DLG_EVENTRT_START] = route_lookup(&event_rt, "dialog:start");
dlg_event_rt[DLG_EVENTRT_END] = route_lookup(&event_rt, "dialog:end");
dlg_event_rt[DLG_EVENTRT_FAILED] = route_lookup(&event_rt, "dialog:failed");
#ifdef STATISTICS
/* register statistics */
if (register_module_stats( exports.name, mod_stats)!=0 ) {
LM_ERR("failed to register %s statistics\n", exports.name);
return -1;
}
#endif
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if (rpc_register_array(rpc_methods)!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(faked_msg_init()<0)
return -1;
if(dlg_bridge_init_hdrs()<0)
return -1;
/* param checkings */
if (dlg_flag==-1) {
LM_ERR("no dlg flag set!!\n");
return -1;
} else if (dlg_flag>MAX_FLAG) {
LM_ERR("invalid dlg flag %d!!\n",dlg_flag);
return -1;
}
if (rr_param==0 || rr_param[0]==0) {
LM_ERR("empty rr_param!!\n");
return -1;
} else if (strlen(rr_param)>MAX_DLG_RR_PARAM_NAME) {
LM_ERR("rr_param too long (max=%d)!!\n", MAX_DLG_RR_PARAM_NAME);
return -1;
}
if (timeout_spec.s) {
if ( pv_parse_spec(&timeout_spec, &timeout_avp)==0
&& (timeout_avp.type!=PVT_AVP)){
LM_ERR("malformed or non AVP timeout "
"AVP definition in '%.*s'\n", timeout_spec.len,timeout_spec.s);
return -1;
}
}
if (default_timeout<=0) {
LM_ERR("0 default_timeout not accepted!!\n");
return -1;
}
if (ruri_pvar_param.s==NULL || ruri_pvar_param.len<=0) {
LM_ERR("invalid r-uri PV string\n");
return -1;
}
if(pv_parse_format(&ruri_pvar_param, &ruri_param_model) < 0
|| ruri_param_model==NULL) {
LM_ERR("malformed r-uri PV string: %s\n", ruri_pvar_param.s);
return -1;
}
if (initial_cbs_inscript != 0 && initial_cbs_inscript != 1) {
LM_ERR("invalid parameter for running initial callbacks in-script"
" (must be either 0 or 1)\n");
return -1;
}
if (seq_match_mode!=SEQ_MATCH_NO_ID &&
seq_match_mode!=SEQ_MATCH_FALLBACK &&
seq_match_mode!=SEQ_MATCH_STRICT_ID ) {
LM_ERR("invalid value %d for seq_match_mode param!!\n",seq_match_mode);
return -1;
}
if (detect_spirals != 0 && detect_spirals != 1) {
LM_ERR("invalid value %d for detect_spirals param!!\n",detect_spirals);
return -1;
}
if (dlg_timeout_noreset != 0 && dlg_timeout_noreset != 1) {
LM_ERR("invalid value %d for timeout_noreset param!!\n",
dlg_timeout_noreset);
return -1;
}
/* if statistics are disabled, prevent their registration to core */
if (dlg_enable_stats==0)
exports.stats = 0;
/* create profile hashes */
if (add_profile_definitions( profiles_nv_s, 0)!=0 ) {
LM_ERR("failed to add profiles without value\n");
return -1;
}
if (add_profile_definitions( profiles_wv_s, 1)!=0 ) {
LM_ERR("failed to add profiles with value\n");
return -1;
}
/* load the TM API */
if (load_tm_api(&d_tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* load RR API also */
if (load_rr_api(&d_rrb)!=0) {
LM_ERR("can't load RR API\n");
return -1;
}
/* register callbacks*/
/* listen for all incoming requests */
if ( d_tmb.register_tmcb( 0, 0, TMCB_REQUEST_IN, dlg_onreq, 0, 0 ) <=0 ) {
LM_ERR("cannot register TMCB_REQUEST_IN callback\n");
return -1;
}
/* listen for all routed requests */
if ( d_rrb.register_rrcb( dlg_onroute, 0 ) <0 ) {
LM_ERR("cannot register RR callback\n");
return -1;
}
if (register_script_cb( profile_cleanup, POST_SCRIPT_CB|REQUEST_CB,0)<0) {
LM_ERR("cannot register script callback");
return -1;
}
if (register_script_cb(dlg_cfg_cb,
PRE_SCRIPT_CB|REQUEST_CB,0)<0)
{
LM_ERR("cannot register pre-script ctx callback\n");
return -1;
}
if (register_script_cb(dlg_cfg_cb,
POST_SCRIPT_CB|REQUEST_CB,0)<0)
{
LM_ERR("cannot register post-script ctx callback\n");
return -1;
}
if (register_script_cb( spiral_detect_reset, POST_SCRIPT_CB|REQUEST_CB,0)<0) {
LM_ERR("cannot register req pre-script spiral detection reset callback\n");
return -1;
}
if(dlg_timer_procs<=0) {
if ( register_timer( dlg_timer_routine, 0, 1)<0 ) {
LM_ERR("failed to register timer \n");
return -1;
}
} else {
register_sync_timers(1);
}
/* init handlers */
init_dlg_handlers( rr_param, dlg_flag,
timeout_spec.s?&timeout_avp:0, default_timeout, seq_match_mode);
/* init timer */
if (init_dlg_timer(dlg_ontimeout)!=0) {
LM_ERR("cannot init timer list\n");
return -1;
}
/* sanitize dlg_hash_zie */
if (dlg_hash_size < 1){
LM_WARN("hash_size is smaller "
"then 1 -> rounding from %d to 1\n",
dlg_hash_size);
dlg_hash_size = 1;
}
/* initialized the hash table */
for( n=0 ; n<(8*sizeof(n)) ; n++) {
if (dlg_hash_size==(1<<n))
break;
if (n && dlg_hash_size<(1<<n)) {
LM_WARN("hash_size is not a power "
"of 2 as it should be -> rounding from %d to %d\n",
dlg_hash_size, 1<<(n-1));
dlg_hash_size = 1<<(n-1);
}
}
if ( init_dlg_table(dlg_hash_size)<0 ) {
LM_ERR("failed to create hash table\n");
return -1;
}
/* if a database should be used to store the dialogs' information */
dlg_db_mode = dlg_db_mode_param;
if (dlg_db_mode==DB_MODE_NONE) {
db_url.s = 0; db_url.len = 0;
} else {
if (dlg_db_mode!=DB_MODE_REALTIME &&
dlg_db_mode!=DB_MODE_DELAYED && dlg_db_mode!=DB_MODE_SHUTDOWN ) {
LM_ERR("unsupported db_mode %d\n", dlg_db_mode);
return -1;
}
if ( !db_url.s || db_url.len==0 ) {
LM_ERR("db_url not configured for db_mode %d\n", dlg_db_mode);
return -1;
}
if (init_dlg_db(&db_url, dlg_hash_size, db_update_period,db_fetch_rows)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
run_load_callbacks();
}
destroy_dlg_callbacks( DLGCB_LOADED );
/* timer process to send keep alive requests */
if(dlg_ka_timer>0 && dlg_ka_interval>0)
register_sync_timers(1);
/* timer process to clean old unconfirmed dialogs */
register_sync_timers(1);
return 0;
}
static int mod_init(void) {
unsigned int n;
if (register_mi_mod(exports.name, mi_cmds) != 0) {
LM_ERR("failed to register MI commands\n");
return -1;
}
if (rpc_register_array(rpc_methods) != 0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if (dialog_ng_stats_init() != 0) {
LM_ERR("Failed to register dialog_ng counters\n");
return -1;
}
if (faked_msg_init() < 0)
return -1;
if (timeout_spec.s)
timeout_spec.len = strlen(timeout_spec.s);
dlg_bridge_controller.len = strlen(dlg_bridge_controller.s);
/* param checkings */
if (dlg_flag == -1) {
LM_ERR("no dlg flag set!!\n");
return -1;
} else if (dlg_flag > MAX_FLAG) {
LM_ERR("invalid dlg flag %d!!\n", dlg_flag);
return -1;
}
if (rr_param == 0 || rr_param[0] == 0) {
LM_ERR("empty rr_param!!\n");
return -1;
} else if (strlen(rr_param) > MAX_DLG_RR_PARAM_NAME) {
LM_ERR("rr_param too long (max=%d)!!\n", MAX_DLG_RR_PARAM_NAME);
return -1;
}
if (timeout_spec.s) {
if (pv_parse_spec(&timeout_spec, &timeout_avp) == 0
&& (timeout_avp.type != PVT_AVP)) {
LM_ERR("malformed or non AVP timeout "
"AVP definition in '%.*s'\n", timeout_spec.len, timeout_spec.s);
return -1;
}
}
if (default_timeout <= 0) {
LM_ERR("0 default_timeout not accepted!!\n");
return -1;
}
if (ruri_pvar_param.s == NULL || *ruri_pvar_param.s == '\0') {
LM_ERR("invalid r-uri PV string\n");
return -1;
}
ruri_pvar_param.len = strlen(ruri_pvar_param.s);
if (pv_parse_format(&ruri_pvar_param, &ruri_param_model) < 0
|| ruri_param_model == NULL) {
LM_ERR("malformed r-uri PV string: %s\n", ruri_pvar_param.s);
return -1;
}
/* update the len of the extra headers */
if (dlg_extra_hdrs.s)
dlg_extra_hdrs.len = strlen(dlg_extra_hdrs.s);
if (seq_match_mode != SEQ_MATCH_NO_ID &&
seq_match_mode != SEQ_MATCH_FALLBACK &&
seq_match_mode != SEQ_MATCH_STRICT_ID) {
LM_ERR("invalid value %d for seq_match_mode param!!\n", seq_match_mode);
return -1;
}
if (detect_spirals != 0 && detect_spirals != 1) {
LM_ERR("invalid value %d for detect_spirals param!!\n", detect_spirals);
return -1;
}
/* create profile hashes */
if (add_profile_definitions(profiles_nv_s, 0) != 0) {
LM_ERR("failed to add profiles without value\n");
return -1;
}
if (add_profile_definitions(profiles_wv_s, 1) != 0) {
LM_ERR("failed to add profiles with value\n");
return -1;
}
/* load the TM API */
if (load_tm_api(&d_tmb) != 0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* load RR API also */
if (load_rr_api(&d_rrb) != 0) {
LM_ERR("can't load RR API\n");
return -1;
}
/* register callbacks*/
/* listen for all incoming requests */
if (d_tmb.register_tmcb(0, 0, TMCB_REQUEST_IN, dlg_onreq, 0, 0) <= 0) {
LM_ERR("cannot register TMCB_REQUEST_IN callback\n");
return -1;
}
/* listen for all routed requests */
if (d_rrb.register_rrcb(dlg_onroute, 0) < 0) {
LM_ERR("cannot register RR callback\n");
return -1;
}
if (register_script_cb(profile_cleanup, POST_SCRIPT_CB | REQUEST_CB, 0) < 0) {
LM_ERR("cannot regsiter script callback");
return -1;
}
if (register_script_cb(dlg_cfg_cb,
PRE_SCRIPT_CB | REQUEST_CB, 0) < 0) {
LM_ERR("cannot regsiter pre-script ctx callback\n");
return -1;
}
if (register_script_cb(dlg_cfg_cb,
POST_SCRIPT_CB | REQUEST_CB, 0) < 0) {
LM_ERR("cannot regsiter post-script ctx callback\n");
return -1;
}
if (register_script_cb(spiral_detect_reset, POST_SCRIPT_CB | REQUEST_CB, 0) < 0) {
LM_ERR("cannot register req pre-script spiral detection reset callback\n");
return -1;
}
if (register_timer(dlg_timer_routine, 0, 1) < 0) {
LM_ERR("failed to register timer \n");
return -1;
}
/*for testing only!!!! setup timer to call print all dlg every 10 seconds!*/
if (register_timer(print_all_dlgs, 0, 10) < 0) {
LM_ERR("failed to register timer \n");
return -1;
}
/* init handlers */
init_dlg_handlers(rr_param, dlg_flag,
timeout_spec.s ? &timeout_avp : 0, default_timeout, seq_match_mode);
/* init timer */
if (init_dlg_timer(dlg_ontimeout) != 0) {
LM_ERR("cannot init timer list\n");
return -1;
}
/* sanitize dlg_hash_zie */
if (dlg_hash_size < 1) {
LM_WARN("hash_size is smaller "
"then 1 -> rounding from %d to 1\n",
dlg_hash_size);
dlg_hash_size = 1;
}
/* initialized the hash table */
for (n = 0; n < (8 * sizeof (n)); n++) {
if (dlg_hash_size == (1 << n))
break;
if (n && dlg_hash_size < (1 << n)) {
LM_WARN("hash_size is not a power "
"of 2 as it should be -> rounding from %d to %d\n",
dlg_hash_size, 1 << (n - 1));
dlg_hash_size = 1 << (n - 1);
}
}
if (init_dlg_table(dlg_hash_size) < 0) {
LM_ERR("failed to create hash table\n");
return -1;
}
/* if a database should be used to store the dialogs' information */
dlg_db_mode = dlg_db_mode_param;
if (dlg_db_mode==DB_MODE_NONE) {
db_url.s = 0; db_url.len = 0;
} else {
if (dlg_db_mode!=DB_MODE_REALTIME &&
dlg_db_mode!=DB_MODE_DELAYED && dlg_db_mode!=DB_MODE_SHUTDOWN ) {
LM_ERR("unsupported db_mode %d\n", dlg_db_mode);
return -1;
}
if ( !db_url.s || db_url.len==0 ) {
LM_ERR("db_url not configured for db_mode %d\n", dlg_db_mode);
return -1;
}
if (init_dlg_db(&db_url, dlg_hash_size, db_update_period, db_fetch_rows)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
run_load_callbacks();
}
destroy_dlg_callbacks(DLGCB_LOADED);
return 0;
}
void reg_ul_expired_contact(ucontact_t* ptr, int type, void* param)
{
str profile = {"exp", 3};
regpv_profile_t *rpp;
ucontact_t* c0;
int backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
int olen;
int ilen;
char *p;
if(reg_expire_event_rt<0)
return;
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
rpp = regpv_get_profile(&profile);
if(rpp==0)
{
LM_ERR("error getting profile structure\n");
return;
}
/* check and free if profile already set */
if(rpp->flags)
regpv_free_profile(rpp);
/* copy aor and ul domain */
rpp->aor.s = (char*)pkg_malloc(ptr->aor->len*sizeof(char));
if(rpp->aor.s==NULL)
{
LM_ERR("no more pkg\n");
return;
}
memcpy(rpp->aor.s, ptr->aor->s, ptr->aor->len);
rpp->aor.len = ptr->aor->len;
rpp->domain = *ptr->domain;
rpp->flags = 1;
/* copy contact */
ilen = sizeof(ucontact_t);
olen = (ptr->c.len + ptr->received.len + ptr->path.len
+ ptr->callid.len + ptr->user_agent.len + ptr->ruid.len
+ ptr->instance.len)*sizeof(char) + ilen;
c0 = (ucontact_t*)pkg_malloc(olen);
if(c0==NULL)
{
LM_ERR("no more pkg\n");
goto error;
}
memcpy(c0, ptr, ilen);
c0->domain = NULL;
c0->aor = NULL;
c0->next = NULL;
c0->prev = NULL;
c0->c.s = (char*)c0 + ilen;
memcpy(c0->c.s, ptr->c.s, ptr->c.len);
c0->c.len = ptr->c.len;
p = c0->c.s + c0->c.len;
if(ptr->received.s!=NULL)
{
c0->received.s = p;
memcpy(c0->received.s, ptr->received.s, ptr->received.len);
c0->received.len = ptr->received.len;
p += c0->received.len;
}
if(ptr->path.s!=NULL)
{
c0->path.s = p;
memcpy(c0->path.s, ptr->path.s, ptr->path.len);
c0->path.len = ptr->path.len;
p += c0->path.len;
}
c0->callid.s = p;
memcpy(c0->callid.s, ptr->callid.s, ptr->callid.len);
c0->callid.len = ptr->callid.len;
p += c0->callid.len;
if(ptr->user_agent.s!=NULL)
{
c0->user_agent.s = p;
memcpy(c0->user_agent.s, ptr->user_agent.s, ptr->user_agent.len);
c0->user_agent.len = ptr->user_agent.len;
p += c0->user_agent.len;
}
if(ptr->ruid.s!=NULL)
{
c0->ruid.s = p;
memcpy(c0->ruid.s, ptr->ruid.s, ptr->ruid.len);
c0->ruid.len = ptr->ruid.len;
p += c0->ruid.len;
}
if(ptr->instance.s!=NULL)
{
c0->instance.s = p;
memcpy(c0->instance.s, ptr->instance.s, ptr->instance.len);
c0->instance.len = ptr->instance.len;
p += c0->instance.len;
}
rpp->contacts = c0;
rpp->nrc = 1;
LM_DBG("saved contact for <%.*s> in [%.*s]\n",
ptr->aor->len, ptr->aor->s, rpp->pname.len, rpp->pname.s);
fmsg = faked_msg_next();
backup_rt = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[reg_expire_event_rt], fmsg, 0);
set_route_type(backup_rt);
return;
error:
regpv_free_profile(rpp);
return;
}
