/**
* init module function
*/
static int mod_init(void)
{
LM_DBG("initializing siprec module ...\n");
if (srs_init() < 0) {
LM_ERR("cannot initialize srs structures!\n");
return -1;
}
if (src_init() < 0) {
LM_ERR("cannot initialize src structures!\n");
return -1;
}
if (load_dlg_api(&srec_dlg) != 0) {
LM_ERR("dialog module not loaded! Cannot use siprec module\n");
return -1;
}
if (load_tm_api(&srec_tm) != 0) {
LM_ERR("tm module not loaded! Cannot use siprec module\n");
return -1;
}
if (load_b2b_api(&srec_b2b) != 0) {
LM_ERR("b2b_entities module not loaded! Cannot use siprec module\n");
return -1;
}
if (load_rtpproxy_api(&srec_rtp) != 0) {
LM_ERR("rtpproxy module not loaded! Cannot use siprec module\n");
return -1;
}
if (srec_dlg.register_dlgcb(NULL, DLGCB_LOADED, srec_loaded_callback,
NULL, NULL) < 0)
LM_WARN("cannot register callback for loaded dialogs - will not be "
"able to terminate siprec sessions after a restart!\n");
return 0;
}
/** Module init function */
static int mod_init(void)
{
char* p = NULL;
char* flags = NULL;
int regexp_flags = 0;
int i = 0, j;
pv_spec_t avp_spec;
LM_DBG("start\n");
/* load b2b_entities api */
if(load_b2b_api(&b2b_api)< 0)
{
LM_ERR("Failed to load b2b api\n");
return -1;
}
if(b2bl_hsize< 1 || b2bl_hsize> 20)
{
LM_ERR("Wrong hash size. Needs to be greater than 1"
" and smaller than 20. Be aware that you should set the log 2"
" value of the real size\n");
return -1;
}
b2bl_hsize = 1<<b2bl_hsize;
if(server_address.s == NULL)
{
if(extern_scenarios)
{
LM_ERR("'server_address' parameter not set. This parameter is"
" compulsory if you want to use extern scenarios. It must"
" be set to the IP address of the machine\n");
return -1;
}
}
else
server_address.len = strlen(server_address.s);
if(init_b2bl_htable() < 0)
{
LM_ERR("Failed to initialize b2b logic hash table\n");
return -1;
}
if(b2b_clean_period < 0)
{
LM_ERR("Wrong parameter - b2b_clean_period [%d]\n", b2b_clean_period);
return -1;
}
if(b2b_update_period < 0)
{
LM_ERR("Wrong parameter - b2b_update_period [%d]\n", b2b_update_period);
return -1;
}
if(b2bl_db_mode && db_url.s)
{
db_url.len = strlen(db_url.s);
b2bl_dbtable.len = strlen(b2bl_dbtable.s);
/* binding to database module */
if (db_bind_mod(&db_url, &b2bl_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(b2bl_dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by b2b_entities module\n");
return -1;
}
b2bl_db = b2bl_dbf.init(&db_url);
if(!b2bl_db)
{
LM_ERR("connecting to database failed\n");
return -1;
}
/*verify table versions */
if(db_check_table_version(&b2bl_dbf, b2bl_db, &b2bl_dbtable, TABLE_VERSION) < 0)
{
LM_ERR("error during table version check\n");
return -1;
}
b2bl_db_init();
/* reload data */
if(b2b_logic_restore() < 0)
{
LM_ERR("Failed to restore data from database\n");
return -1;
}
if(b2bl_db)
b2bl_dbf.close(b2bl_db);
b2bl_db = NULL;
}
else
b2bl_db_mode = 0;
if (b2bl_key_avp_param.s)
b2bl_key_avp_param.len = strlen(b2bl_key_avp_param.s);
if (b2bl_key_avp_param.s && b2bl_key_avp_param.len > 0)
{
if (pv_parse_spec(&b2bl_key_avp_param, &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n",
b2bl_key_avp_param.len, b2bl_key_avp_param.s);
return -1;
}
if (pv_get_avp_name(0, &(avp_spec.pvp), &b2bl_key_avp_name, &b2bl_key_avp_type)!=0){
LM_ERR("[%.*s]- invalid AVP definition\n", b2bl_key_avp_param.len,
b2bl_key_avp_param.s);
return -1;
}
} else {
b2bl_key_avp_name = -1;
b2bl_key_avp_type = 0;
}
if(b2bl_from_spec_param.s)
{
b2bl_from_spec_param.len = strlen(b2bl_from_spec_param.s);
if(pv_parse_spec(&b2bl_from_spec_param, &b2bl_from_spec)==NULL)
{
LM_ERR("failed to parse b2bl_from spec\n");
return E_CFG;
}
switch(b2bl_from_spec.type) {
case PVT_NONE:
case PVT_EMPTY:
case PVT_NULL:
case PVT_MARKER:
case PVT_COLOR:
LM_ERR("invalid b2bl_from spec\n");
return -1;
default: ;
}
}
/* parse extra headers */
if(custom_headers.s)
custom_headers.len = strlen(custom_headers.s);
memset(custom_headers_lst, 0, HDR_LST_LEN*sizeof(str));
custom_headers_lst[i].s = custom_headers.s;
if(custom_headers.s)
{
p = strchr(custom_headers.s, ';');
while(p)
{
custom_headers_lst[i].len = p - custom_headers_lst[i].s;
/* check if this is among the default headers */
for(j = 0; j< HDR_DEFAULT_LEN; j++)
{
if(custom_headers_lst[i].len == default_headers[j].len &&
strncmp(custom_headers_lst[i].s, default_headers[j].s,
default_headers[j].len)== 0)
goto next_hdr;
}
/* check if defined twice */
for(j = 0; j< i; j++)
{
if(custom_headers_lst[i].len == custom_headers_lst[j].len &&
strncmp(custom_headers_lst[i].s, custom_headers_lst[j].s,
custom_headers_lst[j].len)== 0)
goto next_hdr;
}
i++;
if(i == HDR_LST_LEN)
{
LM_ERR("Too many extra headers defined."
" The maximum value is %d\n.", HDR_LST_LEN);
return -1;
}
next_hdr:
p++;
if(p-custom_headers.s >= custom_headers.len)
break;
custom_headers_lst[i].s = p;
p = strchr(p, ';');
}
}
if(p == NULL)
{
custom_headers_lst[i].len = custom_headers.s + custom_headers.len
- custom_headers_lst[i].s;
if(custom_headers_lst[i].len == 0)
i--;
}
custom_headers_lst_len = i +1;
if(custom_headers_regexp.s)
{
custom_headers_regexp.len = strlen(custom_headers_regexp.s);
if ((custom_headers_re=pkg_malloc(sizeof(regex_t)))==0) {
LM_ERR("no more pkg memory\n");
return -1;
}
if (*custom_headers_regexp.s == '/')
{
flags = (char *)memchr(custom_headers_regexp.s+1, '/',
custom_headers_regexp.len-1);
if (flags)
{
custom_headers_regexp.s++;
custom_headers_regexp.len = flags - custom_headers_regexp.s;
custom_headers_regexp.s[custom_headers_regexp.len] = '\0';
flags++;
while(*flags != '\0')
{
switch (*flags) {
case 'i':
regexp_flags |= REG_ICASE;
break;
case 'e':
regexp_flags |= REG_EXTENDED;
break;
default:
LM_ERR("Unknown option '%c'\n", *flags);
}
flags++;
}
} else {
LM_ERR("Second '/' missing from regexp\n");
return -1;
}
}
if (regcomp(custom_headers_re, custom_headers_regexp.s,
regexp_flags) != 0) {
pkg_free(custom_headers_re);
LM_ERR("bad regexp '%.*s'\n",
custom_headers_regexp.len, custom_headers_regexp.s);
return -1;
}
}
if(init_callid_hdr.s)
init_callid_hdr.len = strlen(init_callid_hdr.s);
register_timer("b2bl-clean", b2bl_clean, 0, b2b_clean_period,
TIMER_FLAG_DELAY_ON_DELAY);
if(b2bl_db_mode == WRITE_BACK)
register_timer("b2bl-dbupdate", b2bl_db_timer_update, 0,
b2b_update_period, TIMER_FLAG_SKIP_ON_DELAY);
return 0;
}
