/*
* Convert the char* parameters
*/
static int auth_fixup(void** param, int param_no)
{
db1_con_t* dbh = NULL;
str name;
if(strlen((char*)*param)<=0) {
LM_ERR("empty parameter %d not allowed\n", param_no);
return -1;
}
if (param_no == 1 || param_no == 3) {
return fixup_var_str_12(param, 1);
} else if (param_no == 2) {
name.s = (char*)*param;
name.len = strlen(name.s);
dbh = auth_dbf.init(&db_url);
if (!dbh) {
LM_ERR("unable to open database connection\n");
return -1;
}
if(version_table_check!=0
&& db_check_table_version(&auth_dbf, dbh, &name,
TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
auth_dbf.close(dbh);
return -1;
}
auth_dbf.close(dbh);
}
return 0;
}
int init_db_data(dp_connection_list_p dp_connection)
{
if (dp_connection->partition.s == 0) {
LM_ERR("invalid partition name\n");
return -1;
}
if (dp_connect_db(dp_connection) !=0)
return -1;
if (db_check_table_version(&dp_connection->dp_dbf,
*dp_connection->dp_db_handle, &dp_connection->table_name,
DP_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
goto error;
}
if(dp_load_db(dp_connection) != 0){
LM_ERR("failed to load database data\n");
goto error;
}
return 0;
error:
dp_disconnect_db(dp_connection);
return -1;
}
int test_db(dp_connection_list_p dp_connection){
if (dp_connection->partition.s == 0) {
LM_ERR("invalid partition name\n");
return -1;
}
if (db_bind_mod(&dp_connection->db_url, &dp_connection->dp_dbf) < 0){
LM_ERR("unable to bind to a database driver\n");
return -1;
}
if (dp_connect_db(dp_connection) !=0)
return -1;
if (db_check_table_version(&dp_connection->dp_dbf,
*dp_connection->dp_db_handle, &dp_connection->table_name,
DP_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
goto error;
}
dp_disconnect_db(dp_connection);
return 0;
error:
dp_disconnect_db(dp_connection);
return -1;
}
int init_db_data(void)
{
if(!dp_table_name.s || dp_table_name.len<=0){
LM_ERR("invalid database table name\n");
return -1;
}
/* Find a database module */
if (db_bind_mod(&dp_db_url, &dp_dbf) < 0){
LM_ERR("unable to bind to a database driver\n");
return -1;
}
if(dp_connect_db() !=0)
return -1;
if(db_check_table_version(&dp_dbf, dp_db_handle, &dp_table_name,
DP_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
goto error;
}
if(dp_load_db() != 0){
LM_ERR("failed to load database data\n");
goto error;
}
dp_disconnect_db();
return 0;
error:
dp_disconnect_db();
return -1;
}
int init_sca_db(const str *db_url, int dlg_hash_size)
{
/* Find a database module */
if (db_bind_mod(db_url, &sca_dbf) < 0) {
LM_ERR("Unable to bind to a database driver\n");
return -1;
}
if (connect_sca_db(db_url)!=0){
LM_ERR("unable to connect to the database\n");
return -1;
}
if(db_check_table_version(&sca_dbf, sca_db_handle, &sca_table_name, SCA_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
if(load_sca_info_from_db() !=0){
LM_ERR("unable to load the sca data\n");
return -1;
}
sca_dbf.close(sca_db_handle);
sca_db_handle = NULL;
return 0;
}
int domain_db_ver(str* name, int version)
{
if (db_handle==0){
LM_ERR("null database handler\n");
return -1;
}
return db_check_table_version(&domain_dbf, db_handle, name, version);
}
/*!
* \brief Registers a new domain with usrloc
*
* Registers a new domain with usrloc. If the domain exists,
* a pointer to existing structure will be returned, otherwise
* a new domain will be created
* \param _n domain name
* \param _d new created domain
* \return 0 on success, -1 on failure
*/
int register_udomain(const char* _n, udomain_t** _d)
{
dlist_t* d;
str s;
db1_con_t* con;
s.s = (char*)_n;
s.len = strlen(_n);
if (find_dlist(&s, &d) == 0) {
*_d = d->d;
return 0;
}
if (new_dlist(&s, &d) < 0) {
LM_ERR("failed to create new domain\n");
return -1;
}
/* Test tables from database if we are gonna
* to use database
*/
if (db_mode != NO_DB) {
con = ul_dbf.init(&db_url);
if (!con) {
LM_ERR("failed to open database connection\n");
goto err;
}
if(ul_version_table != 0
&& db_check_table_version(&ul_dbf, con, &s, UL_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
goto err;
}
/* test if DB really exists */
if (testdb_udomain(con, d->d) < 0) {
LM_ERR("testing domain '%.*s' failed\n", s.len, ZSW(s.s));
goto err;
}
ul_dbf.close(con);
}
d->next = root;
root = d;
*_d = d->d;
return 0;
err:
if (con) ul_dbf.close(con);
free_udomain(d->d);
shm_free(d->name.s);
shm_free(d);
return -1;
}
/**
* Initialises the db API
*
* @return 0 means ok, -1 means an error occured.
*/
int db_init(void) {
if (!db_url.s) {
LM_ERR("You have to set the db_url module parameter.\n");
return -1;
}
if (db_bind_mod(&db_url, &dbf) < 0) {
LM_ERR("Can't bind database module.\n");
return -1;
}
if((dbh = dbf.init(&db_url)) == NULL){
LM_ERR("Can't connect to database.\n");
return -1;
}
if ( (db_check_table_version(&dbf, dbh, &db_table, ROUTE_TABLE_VER) < 0) ||
(db_check_table_version(&dbf, dbh, &carrier_table, CARRIER_TABLE_VER) < 0) ||
(db_check_table_version(&dbf, dbh, &db_failure_table, FAILURE_TABLE_VER) < 0) ) {
LM_ERR("Error during table version check.\n");
return -1;
}
return 0;
}
int push_check_db(PushServer* apns, const char* push_db, const char* push_table)
{
str db_url = {0, 0};
str table = {0, 0};
if (apns == NULL)
{
return 0;
}
if (push_db == NULL)
{
return 0;
}
db_url.s = (char*)push_db;
db_url.len = strlen(db_url.s);
table.s = (char*)push_table;
table.len = strlen(push_table);
if ((apns->dbf.init == 0) && (db_bind_mod(&db_url, &apns->dbf)))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(apns->dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by push module\n");
return -1;
}
/* should be done prior init in each child...*/
apns->db = apns->dbf.init(&db_url);
if (!apns->db)
{
LM_ERR("Connection to database failed\n");
return -1;
}
if (db_check_table_version(&apns->dbf, apns->db, &table, PUSH_TABLE_VERSION) < 0)
{
LM_ERR("wrong table version for %s\n", table.s);
return -1;
}
apns->dbf.close(apns->db);
apns->db = NULL;
return 1;
}
int db_init(const str *url, const str *table)
{
dbc = dbf.init(url);
if (!dbc) {
LM_ERR("child can't connect to database.\n");
return -1;
}
if(db_check_table_version(&dbf, dbc, table, 2) < 0) {
LM_ERR("during table version check.\n");
return -1;
}
return 0;
}
/*!
* Initialises the DB API, check the table version and closes the connection.
* This should be called from the mod_init function.
*
* \return 0 means ok, -1 means an error occured.
*/
int userblacklist_db_init(void) {
if (!userblacklist_db_url.s || !userblacklist_db_url.len) {
LM_ERR("you have to set the db_url module parameter.\n");
return -1;
}
if (db_bind_mod(&userblacklist_db_url, &userblacklist_dbf) < 0) {
LM_ERR("can't bind database module.\n");
return -1;
}
if ((userblacklist_dbh = userblacklist_dbf.init(&userblacklist_db_url)) == NULL) {
LM_ERR("can't connect to database.\n");
return -1;
}
if (
(db_check_table_version(&userblacklist_dbf, userblacklist_dbh, &userblacklist_table, userblacklist_version) < 0) ||
(db_check_table_version(&userblacklist_dbf, userblacklist_dbh, &globalblacklist_table, globalblacklist_version) < 0)
) {
LM_ERR("during table version check.\n");
userblacklist_db_close();
return -1;
}
userblacklist_db_close();
return 0;
}
static int
sca_bind_srdb1( sca_mod *scam, db_func_t *db_api )
{
db1_con_t *db_con = NULL;
int rc = -1;
if ( db_bind_mod( scam->cfg->db_url, db_api ) != 0 ) {
LM_ERR( "Failed to initialize required DB API" );
goto done;
}
scam->db_api = db_api;
if ( !DB_CAPABILITY( (*db_api), DB_CAP_ALL )) {
LM_ERR( "Selected database %.*s lacks required capabilities",
STR_FMT( scam->cfg->db_url ));
goto done;
}
/* ensure database exists and table schemas are correct */
db_con = db_api->init( scam->cfg->db_url );
if ( db_con == NULL ) {
LM_ERR( "sca_bind_srdb1: failed to connect to DB %.*s",
STR_FMT( scam->cfg->db_url ));
goto done;
}
if ( db_check_table_version( db_api, db_con,
scam->cfg->subs_table, SCA_DB_SUBSCRIPTIONS_TABLE_VERSION ) < 0 ) {
LM_ERR( "Version check of %.*s table in DB %.*s failed",
STR_FMT( scam->cfg->subs_table ), STR_FMT( scam->cfg->db_url ));
LM_ERR( "%.*s table version %d required",
STR_FMT( scam->cfg->subs_table ),
SCA_DB_SUBSCRIPTIONS_TABLE_VERSION );
goto done;
}
/* DB and tables are OK, close DB handle. reopen in each child. */
rc = 0;
done:
if ( db_con != NULL ) {
db_api->close( db_con );
db_con = NULL;
}
return( rc );
}
/**
* init module function
*/
static int mod_init(void)
{
if(xcap_client_init_rpc()<0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
/* binding to mysql module */
if (db_bind_mod(&xcap_db_url, &xcap_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(xcap_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions"
" needed by the module\n");
return -1;
}
xcap_db = xcap_dbf.init(&xcap_db_url);
if (!xcap_db)
{
LM_ERR("while connecting to database\n");
return -1;
}
if(db_check_table_version(&xcap_dbf, xcap_db, &xcap_db_table,
XCAP_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
xcap_dbf.close(xcap_db);
xcap_db = NULL;
curl_global_init(CURL_GLOBAL_ALL);
if(periodical_query)
{
register_timer(query_xcap_update, 0, query_period);
}
return 0;
}
int init_dlg_db(const str *db_url, int dlg_hash_size , int db_update_period)
{
/* Find a database module */
if (db_bind_mod(db_url, &dialog_dbf) < 0){
LM_ERR("Unable to bind to a database driver\n");
return -1;
}
if (dlg_connect_db(db_url)!=0){
LM_ERR("unable to connect to the database\n");
return -1;
}
if(db_check_table_version(&dialog_dbf, dialog_db_handle,
&dialog_table_name, DLG_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
if( (dlg_db_mode==DB_MODE_DELAYED) &&
(register_timer( dialog_update_db, 0, db_update_period)<0 )) {
LM_ERR("failed to register update db\n");
return -1;
}
if( (load_dialog_info_from_db(dlg_hash_size) ) !=0 ){
LM_ERR("unable to load the dialog data\n");
return -1;
}
if (dlg_db_mode==DB_MODE_SHUTDOWN && remove_all_dialogs_from_db()!=0) {
LM_WARN("failed to properly remove all the dialogs form DB\n");
}
dialog_dbf.close(dialog_db_handle);
dialog_db_handle = 0;
return 0;
}
static int child_init(int rank)
{
if (rank==PROC_INIT || rank==PROC_MAIN || rank==PROC_TCP_MAIN)
return 0; /* do nothing for the main process */
if(trace_to_database_flag!=NULL && *trace_to_database_flag!=0) {
db_con = db_funcs.init(&db_url);
if (!db_con)
{
LM_ERR("unable to connect to database. Please check configuration.\n");
return -1;
}
if (db_check_table_version(&db_funcs, db_con, &siptrace_table,
SIP_TRACE_TABLE_VERSION) < 0) {
LM_ERR("error during table version check\n");
db_funcs.close(db_con);
return -1;
}
}
return 0;
}
static int pres_db_init(void) {
if (!pres_db_url.s || !pres_db_url.len) {
LM_INFO("xcap_auth_status function is disabled\n");
return 0;
}
if (db_bind_mod(&pres_db_url, &pres_dbf) < 0) {
LM_ERR("can't bind database module\n");
return -1;
}
if ((pres_dbh = pres_dbf.init(&pres_db_url)) == NULL) {
LM_ERR("can't connect to database\n");
return -1;
}
if (db_check_table_version(&pres_dbf, pres_dbh, &xcap_table,
XCAP_TABLE_VERSION) < 0) {
LM_ERR("during table version check\n");
pres_db_close();
return -1;
}
pres_db_close();
return 0;
}
/*!
* \brief Check the database table version
* \param db_url database URL
* \return -1 on failure, 0 on success
*/
int domainpolicy_db_ver(const str* db_url)
{
db1_con_t* dbh;
if (domainpolicy_dbf.init==0){
LM_CRIT("unbound database\n");
return -1;
}
dbh=domainpolicy_dbf.init(db_url);
if (dbh==0){
LM_CRIT("null database handler\n");
return -1;
}
if (db_check_table_version(&domainpolicy_dbf, dbh, &domainpolicy_table, DOMAINPOLICY_TABLE_VERSION) < 0) {
DB_TABLE_VERSION_ERROR(domainpolicy_table);
domainpolicy_dbf.close(dbh);
dbh=0;
return -1;
}
domainpolicy_dbf.close(dbh);
dbh=0;
return 0;
}
/*!
* Initialises the DB API, check the table version and closes the connection.
* This should be called from the mod_init function.
*
* \return 0 means ok, -1 means an error occured.
*/
int matrix_db_init(void) {
if (!matrix_db_url.s || !matrix_db_url.len) {
LM_ERR("you have to set the db_url module parameter.\n");
return -1;
}
if (db_bind_mod(&matrix_db_url, &matrix_dbf) < 0) {
LM_ERR("can't bind database module.\n");
return -1;
}
if ((matrix_dbh = matrix_dbf.init(&matrix_db_url)) == NULL) {
LM_ERR("can't connect to database.\n");
return -1;
}
if (
(db_check_table_version(&matrix_dbf, matrix_dbh, &matrix_table, matrix_version) < 0)
) {
LM_ERR("during table version check.\n");
matrix_db_close();
return -1;
}
matrix_db_close();
return 0;
}
/*
* Open database connections if necessary
*/
int init_child_trusted(int rank)
{
if ((rank <= 0) && (rank != PROC_RPC) && (rank != PROC_UNIXSOCK))
return 0;
if (!db_url.s) {
return 0;
}
db_handle = perm_dbf.init(&db_url);
if (!db_handle) {
LM_ERR("unable to connect database\n");
return -1;
}
if (db_check_table_version(&perm_dbf, db_handle, &trusted_table,
TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
perm_dbf.close(db_handle);
return -1;
}
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
LM_DBG("...\n");
if (register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(min_expires< 0)
min_expires= 0;
if(default_expires< 600)
default_expires= 3600;
/* load TM API */
if(load_tm_api(&tmb)==-1)
{
LM_ERR("can't load tm functions\n");
return -1;
}
db_url.len = db_url.s ? strlen(db_url.s) : 0;
LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.s);
db_table.len = db_table.s ? strlen(db_table.s) : 0;
/* binding to database module */
if (db_bind_mod(&db_url, &pua_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pua_dbf, DB_CAP_ALL)) {
LM_ERR("Database module does not implement all functions needed"
" by the module\n");
return -1;
}
pua_db = pua_dbf.init(&db_url);
if (!pua_db)
{
LM_ERR("while connecting database\n");
return -1;
}
/* verify table version */
if(db_check_table_version(&pua_dbf, pua_db, &db_table, PUA_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
if (dbmode != PUA_DB_ONLY)
{
if(HASH_SIZE<=1)
HASH_SIZE= 512;
else
HASH_SIZE = 1<<HASH_SIZE;
HashT= new_htable();
if(HashT== NULL)
{
LM_ERR("while creating new hash table\n");
return -1;
}
if(db_restore()< 0)
{
LM_ERR("while restoring hash_table\n");
return -1;
}
}
if (dbmode != PUA_DB_DEFAULT && dbmode != PUA_DB_ONLY)
{
dbmode = PUA_DB_DEFAULT;
LM_ERR( "Invalid dbmode-using default mode\n" );
}
if(update_period<0)
{
LM_ERR("wrong clean_period\n");
return -1;
}
if ( init_puacb_list() < 0)
{
LM_ERR("callbacks initialization failed\n");
return -1;
}
pua_evlist= init_pua_evlist();
if(pua_evlist==0)
{
LM_ERR("when initializing pua_evlist\n");
return -1;
}
if(pua_add_events()< 0)
{
LM_ERR("while adding events\n");
return -1;
}
if(check_remote_contact<0 || check_remote_contact>1)
{
LM_ERR("bad value for check_remote_contact\n");
return -1;
}
startup_time = (int) time(NULL);
if (update_period > 0) /* probably should check > 5 here!! -croc */
register_timer(hashT_clean, 0, update_period- 5);
if (dbmode != PUA_DB_ONLY)
{
if (update_period > 0)
register_timer(db_update, 0, update_period);
}
if(pua_db)
pua_dbf.close(pua_db);
pua_db = NULL;
outbound_proxy.len = outbound_proxy.s ? strlen(outbound_proxy.s) : 0;
return 0;
}
/* loads data from the db */
table_entry_t* load_info(db_func_t *dr_dbf, db_con_t* db_hdl, str *db_table)
{
int int_vals[7];
char *str_vals[2];
int no_of_results;
int i, n;
int no_rows = 5;
int db_cols = 10;
unsigned long last_attempt;
static db_key_t clusterer_machine_id_key = &machine_id_col;
static db_val_t clusterer_machine_id_value = {
.type = DB_INT,
.nul = 0,
};
VAL_INT(&clusterer_machine_id_value) = server_id;
/* the columns from the db table */
db_key_t columns[10];
/* result from a db query */
db_res_t* res;
/* a row from the db table */
db_row_t* row;
/* the processed result */
table_entry_t *data;
res = 0;
data = 0;
columns[0] = &cluster_id_col;
columns[1] = &machine_id_col;
columns[2] = &state_col;
columns[3] = &description_col;
columns[4] = &url_col;
columns[5] = &id_col;
columns[6] = &last_attempt_col;
columns[7] = &failed_attempts_col;
columns[8] = &no_tries_col;
columns[9] = &duration_col;
CON_OR_RESET(db_hdl);
/* checking if the table version is up to date*/
if (db_check_table_version(dr_dbf, db_hdl, db_table, 1/*version*/) != 0)
goto error;
/* read data */
if (dr_dbf->use_table(db_hdl, db_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", db_table->len, db_table->s);
goto error;
}
LM_DBG("DB query - retrieve the clusters list"
"in which the specified server runs\n");
/* first we see in which clusters the specified server runs*/
if (dr_dbf->query(db_hdl, &clusterer_machine_id_key, &op_eq,
&clusterer_machine_id_value, columns, 1, 1, 0, &res) < 0) {
LM_ERR("DB query failed - cannot retrieve the clusters list in which"
" the specified server runs\n");
goto error;
}
LM_DBG("%d rows found in %.*s\n",
RES_ROW_N(res), db_table->len, db_table->s);
if (RES_ROW_N(res) == 0) {
LM_WARN("No machines found in cluster %d\n", server_id);
return 0;
}
clusterer_cluster_id_key = pkg_realloc(clusterer_cluster_id_key,
RES_ROW_N(res) * sizeof(db_key_t));
if (!clusterer_cluster_id_key) {
LM_ERR("no more pkg memory\n");
goto error;
}
for (i = 0; i < RES_ROW_N(res); i++)
clusterer_cluster_id_key[i] = &cluster_id_col;
clusterer_cluster_id_value = pkg_realloc(clusterer_cluster_id_value,
RES_ROW_N(res) * sizeof(db_val_t));
if (!clusterer_cluster_id_value) {
LM_ERR("no more pkg memory\n");
goto error;
}
for (i = 0; i < RES_ROW_N(res); i++) {
VAL_TYPE(clusterer_cluster_id_value + i) = DB_INT;
VAL_NULL(clusterer_cluster_id_value + i) = 0;
}
for (i = 0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
check_val(cluster_id_col, ROW_VALUES(row), DB_INT, 1, 0);
VAL_INT(clusterer_cluster_id_value + i) = VAL_INT(ROW_VALUES(row));
}
no_of_results = RES_ROW_N(res);
dr_dbf->free_result(db_hdl, res);
res = 0;
LM_DBG("DB query - retrieve valid connections\n");
/* fetch is the best strategy */
CON_USE_OR_OP(db_hdl);
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if (dr_dbf->query(db_hdl, clusterer_cluster_id_key, 0,
clusterer_cluster_id_value, columns, no_of_results, db_cols, 0, 0) < 0) {
LM_ERR("DB query failed - retrieve valid connections \n");
goto error;
}
no_rows = estimate_available_rows(4 + 4 + 4 + 64 + 4 + 45 + 4 + 8 + 4 + 4, db_cols);
if (no_rows == 0) no_rows = 5;
if (dr_dbf->fetch_result(db_hdl, &res, no_rows) < 0) {
LM_ERR("Error fetching rows\n");
goto error;
}
} else {
if (dr_dbf->query(db_hdl, clusterer_cluster_id_key, 0,
clusterer_cluster_id_value, columns, no_of_results, db_cols, 0, &res) < 0) {
LM_ERR("DB query failed - retrieve valid connections\n");
goto error;
}
}
LM_DBG("%d rows found in %.*s\n",
RES_ROW_N(res), db_table->len, db_table->s);
n = 0;
do {
for (i = 0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
/* CLUSTER ID column */
check_val(cluster_id_col, ROW_VALUES(row), DB_INT, 1, 0);
int_vals[INT_VALS_CLUSTER_ID_COL] = VAL_INT(ROW_VALUES(row));
/* MACHINE ID column */
check_val(machine_id_col, ROW_VALUES(row) + 1, DB_INT, 1, 0);
int_vals[INT_VALS_MACHINE_ID_COL] = VAL_INT(ROW_VALUES(row) + 1);
/* STATE column */
check_val(state_col, ROW_VALUES(row) + 2, DB_INT, 1, 0);
int_vals[INT_VALS_STATE_COL] = VAL_INT(ROW_VALUES(row) + 2);
/* DESCRIPTION column */
check_val(description_col, ROW_VALUES(row) + 3, DB_STRING, 0, 0);
str_vals[STR_VALS_DESCRIPTION_COL] = (char*) VAL_STRING(ROW_VALUES(row) + 3);
/* URL column */
check_val(url_col, ROW_VALUES(row) + 4, DB_STRING, 1, 1);
str_vals[STR_VALS_URL_COL] = (char*) VAL_STRING(ROW_VALUES(row) + 4);
/* CLUSTERER_ID column */
check_val(id_col, ROW_VALUES(row) + 5, DB_INT, 1, 0);
int_vals[INT_VALS_CLUSTERER_ID_COL] = VAL_INT(ROW_VALUES(row) + 5);
/* LAST_ATTEMPT column */
check_val(last_attempt_col, ROW_VALUES(row) + 6, DB_BIGINT, 1, 0);
last_attempt = VAL_BIGINT(ROW_VALUES(row) + 6);
/* FAILED_ATTEMPTS column */
check_val(failed_attempts_col, ROW_VALUES(row) + 7, DB_INT, 1, 0);
int_vals[INT_VALS_FAILED_ATTEMPTS_COL] = VAL_INT(ROW_VALUES(row) + 7);
/* NO_TRIES column */
check_val(no_tries_col, ROW_VALUES(row) + 8, DB_INT, 1, 0);
int_vals[INT_VALS_NO_TRIES_COL] = VAL_INT(ROW_VALUES(row) + 8);
/* DURATION column */
check_val(duration_col, ROW_VALUES(row) + 9, DB_INT, 1, 0);
int_vals[INT_VALS_DURATION_COL] = VAL_INT(ROW_VALUES(row) + 9);
/* store data */
if (add_info(&data, int_vals, last_attempt, str_vals) < 0) {
LM_DBG("error while adding info to shm\n");
goto error;
}
LM_DBG("machine id %d\n", int_vals[0]);
LM_DBG("cluster id %d\n", int_vals[1]);
LM_DBG("state %d\n", int_vals[2]);
LM_DBG("clusterer_id %d\n", int_vals[3]);
LM_DBG("description %s\n", str_vals[0]);
LM_DBG("url %s\n", str_vals[1]);
n++;
}
if (n == 1)
LM_WARN("The server is the only one in the cluster\n");
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if (dr_dbf->fetch_result(db_hdl, &res, no_rows) < 0) {
LM_ERR("fetching rows (1)\n");
goto error;
}
} else {
break;
}
} while (RES_ROW_N(res) > 0);
LM_DBG("%d records found in %.*s\n",
n, db_table->len, db_table->s);
dr_dbf->free_result(db_hdl, res);
res = 0;
return data;
error:
if (res)
dr_dbf->free_result(db_hdl, res);
if (data)
free_data(data);
data = NULL;
return 0;
}
/* deallocates data */
void free_data(table_entry_t *data)
{
table_entry_t *tmp_entry;
table_entry_info_t *info;
table_entry_info_t *tmp_info;
table_entry_value_t *value;
table_entry_value_t *tmp_value;
struct module_timestamp *timestamp;
struct module_timestamp *tmp_timestamp;
while (data != NULL) {
tmp_entry = data;
data = data->next;
info = tmp_entry->info;
while (info != NULL) {
value = info->value;
while (value != NULL) {
if (value->path.s)
shm_free(value->path.s);
if (value->description.s)
shm_free(value->description.s);
timestamp = value->in_timestamps;
while (timestamp != NULL) {
tmp_timestamp = timestamp;
timestamp = timestamp->next;
shm_free(tmp_timestamp);
}
tmp_value = value;
value = value->next;
shm_free(tmp_value);
}
tmp_info = info;
info = info->next;
shm_free(tmp_info);
}
shm_free(tmp_entry);
}
}
static int mod_init(void)
{
str proto_url;
int checkver=-1;
db_func_t db_funcs;
db_con_t *db_conn = NULL;
LM_DBG("initializing\n");
init_db_url( db_url , 1 /*can be null*/);
if (db_url.s) {
if (db_url.len == 0) {
if (use_uri_table != 0) {
LM_ERR("configuration error - no database URL, "
"but use_uri_table is set!\n");
return -1;
}
return 0;
}
if (db_table.s == NULL) {
/* no table set -> use defaults */
if (use_uri_table != 0){
db_table.s = URI_TABLE;
}
else {
db_table.s = SUBSCRIBER_TABLE;
}
}
db_table.len = strlen(db_table.s);
uridb_user_col.len = strlen(uridb_user_col.s);
uridb_domain_col.len = strlen(uridb_domain_col.s);
uridb_uriuser_col.len = strlen(uridb_uriuser_col.s);
if ( db_bind_mod(&db_url, &db_funcs) != 0 ) {
LM_ERR("No database module found\n");
return -1;
}
db_conn = db_funcs.init(&db_url);
if( db_conn == NULL ) {
LM_ERR("Could not connect to database\n");
return -1;
}
checkver = db_check_table_version( &db_funcs, db_conn, &db_table,
use_uri_table?URI_TABLE_VERSION:SUBSCRIBER_TABLE_VERSION );
/** If checkver == -1, table validation failed */
if( checkver == -1 ) {
LM_ERR("Invalid table version.\n");
db_funcs.close(db_conn);
return -1;
}
db_funcs.close(db_conn);
/* done with checkings - init the working connection */
if (uridb_db_bind(&db_url)!=0) {
LM_ERR("Failed to bind to a DB module\n");
return -1;
}
}
if (aaa_proto_url) {
memset(attrs, 0, sizeof(attrs));
memset(vals, 0, sizeof(vals));
attrs[A_SERVICE_TYPE].name = "Service-Type";
attrs[A_USER_NAME].name = "User-Name";
if (use_sip_uri_host)
attrs[A_SIP_URI_HOST].name = "SIP-URI-Host";
attrs[A_SIP_AVP].name = "SIP-AVP";
attrs[A_ACCT_SESSION_ID].name = "Acct-Session-Id";
vals[V_CALL_CHECK].name = "Call-Check";
proto_url.s = aaa_proto_url;
proto_url.len = strlen(aaa_proto_url);
if(aaa_prot_bind(&proto_url, &proto)) {
LM_ERR("aaa protocol bind failure\n");
return -1;
}
conn = proto.init_prot(&proto_url);
if (!conn) {
LM_ERR("aaa protocol initialization failure\n");
return -2;
}
INIT_AV(proto, conn, attrs, A_MAX, vals, V_MAX, "uri", -3, -4);
if (service_type != -1)
vals[V_CALL_CHECK].value = service_type;
}
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;
}
static int mod_init(void)
{
pv_spec_t avp_spec;
int i;
init_db_url( db_url , 0 /*cannot be null*/);
siptrace_table.len = strlen(siptrace_table.s);
date_column.len = strlen(date_column.s);
callid_column.len = strlen(callid_column.s);
traced_user_column.len = strlen(traced_user_column.s);
msg_column.len = strlen(msg_column.s);
method_column.len = strlen(method_column.s);
status_column.len = strlen(status_column.s);
fromproto_column.len = strlen(fromproto_column.s);
fromip_column.len = strlen(fromip_column.s);
fromport_column.len = strlen(fromport_column.s);
toproto_column.len = strlen(toproto_column.s);
toip_column.len = strlen(toip_column.s);
toport_column.len = strlen(toport_column.s);
fromtag_column.len = strlen(fromtag_column.s);
direction_column.len = strlen(direction_column.s);
if (traced_user_avp_str.s)
traced_user_avp_str.len = strlen(traced_user_avp_str.s);
if (trace_table_avp_str.s)
trace_table_avp_str.len = strlen(trace_table_avp_str.s);
if (dup_uri_str.s)
dup_uri_str.len = strlen(dup_uri_str.s);
if (trace_local_ip.s)
parse_trace_local_ip();
LM_INFO("initializing...\n");
fix_flag_name(trace_flag_str, trace_flag);
trace_flag = get_flag_id_by_name(FLAG_TYPE_MSG, trace_flag_str);
if (flag_idx2mask(&trace_flag)<0)
return -1;
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(trace_to_database_flag!=NULL && *trace_to_database_flag!=0) {
/* Find a database module */
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 ((db_con = db_funcs.init(&db_url)) == 0) {
LM_CRIT("Cannot connect to DB\n");
return -1;
}
if(db_check_table_version(&db_funcs, db_con,
&siptrace_table, SIPTRACE_TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
return -1;
}
db_funcs.close(db_con);
db_con = 0;
}
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;
/* register callbacks to TM */
if (load_tm_api(&tmb)!=0)
{
LM_ERR("can't load tm api\n");
return -1;
}
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;
}
/* register sl callback */
register_slcb_f = (register_slcb_t)find_export("register_slcb", 0, 0);
if(register_slcb_f==NULL)
{
LM_ERR("can't load sl api\n");
return -1;
}
if(register_slcb_f(SLCB_REPLY_OUT,trace_sl_onreply_out, NULL)!=0)
{
LM_ERR("can't register trace_sl_onreply_out\n");
return -1;
}
if(register_fwdcb(trace_msg_out_w)!=0)
{
LM_ERR("can't register trace_sl_ack_out\n");
return -1;
}
if(enable_ack_trace&®ister_slcb_f(SLCB_ACK_IN,trace_sl_ack_in,NULL)!=0)
{
LM_ERR("can't register trace_sl_ack_in\n");
return -1;
}
if(dup_uri_str.s!=0) {
dup_uri_str.len = strlen(dup_uri_str.s);
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(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 = -1;
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 = -1;
trace_table_avp_type = 0;
}
if (duplicate_with_hep) {
load_hep = (load_hep_f)find_export("load_hep", 1, 0);
if (!load_hep) {
LM_ERR("Can't bind proto hep!\n");
return -1;
}
if (load_hep(&hep_api)) {
LM_ERR("can't bind proto hep\n");
return -1;
}
}
/* init the DB keys for future queries */
db_keys[0] = &msg_column;
db_keys[1] = &callid_column;
db_keys[2] = &method_column;
db_keys[3] = &status_column;
db_keys[4] = &fromproto_column;
db_keys[5] = &fromip_column;
db_keys[6] = &fromport_column;
db_keys[7] = &toproto_column;
db_keys[8] = &toip_column;
db_keys[9] = &toport_column;
db_keys[10] = &date_column;
db_keys[11] = &direction_column;
db_keys[12] = &fromtag_column;
db_keys[13] = &traced_user_column;
/* init DB values info which is constant ( type, null ) */
db_vals[0].type = DB_BLOB;
db_vals[1].type = DB_STR;
db_vals[2].type = DB_STR;
db_vals[3].type = DB_STR;
db_vals[4].type = DB_STR;
db_vals[5].type = DB_STR;
db_vals[6].type = DB_INT;
db_vals[7].type = DB_STR;
db_vals[8].type = DB_STR;
db_vals[9].type = DB_INT;
db_vals[10].type = DB_DATETIME;
db_vals[11].type = DB_STRING;
db_vals[12].type = DB_STR;
db_vals[13].type = DB_STR;
/* no field can be null */
for (i=0;i<NR_KEYS;i++)
db_vals[i].nul = 0;
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;
}
/** Module initialize function */
static int mod_init(void)
{
/* inspect the parameters */
if(server_hsize< 1 || server_hsize> 20 ||
client_hsize< 1 || client_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;
}
server_hsize = 1<<server_hsize;
client_hsize = 1<<client_hsize;
if(b2b_key_prefix.s)
{
b2b_key_prefix.len = strlen(b2b_key_prefix.s);
if(b2b_key_prefix.len > B2B_MAX_PREFIX_LEN)
{
LM_ERR("b2b_key_prefix [%s] too long. Maximum size %d\n",
b2b_key_prefix.s, B2B_MAX_PREFIX_LEN);
return -1;
}
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1)
{
LM_ERR("can't load tm functions\n");
return -1;
}
/* load the UAC_AUTH API - FIXME it should be loaded only
* if authentication is required */
if(load_uac_auth_api(&uac_auth_api)<0)
{
LM_INFO("authentication functionality disabled:"
" load uac_auth first to enable it\n");
uac_auth_loaded = 0;
}
else
{
uac_auth_loaded = 1;
}
/* initialize the hash tables; they will be allocated in shared memory
* to be accesible by all processes */
if(init_b2b_htables()< 0)
{
LM_ERR("Failed to initialize b2b table\n");
return -1;
}
memset(&b2be_dbf, 0, sizeof(db_func_t));
if(b2be_db_mode && db_url.s)
{
db_url.len = strlen(db_url.s);
b2be_dbtable.len = strlen(b2be_dbtable.s);
/* binding to database module */
if (db_bind_mod(&db_url, &b2be_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(b2be_dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by b2b_entities module\n");
return -1;
}
b2be_db = b2be_dbf.init(&db_url);
if(!b2be_db)
{
LM_ERR("connecting to database failed\n");
return -1;
}
/*verify table versions */
if(db_check_table_version(&b2be_dbf, b2be_db, &b2be_dbtable, TABLE_VERSION) < 0)
{
LM_ERR("error during table version check\n");
return -1;
}
b2be_initialize();
/* reload data */
if(b2b_entities_restore() < 0)
{
LM_ERR("Failed to restore data from database\n");
return -1;
}
if(b2be_db)
b2be_dbf.close(b2be_db);
b2be_db = NULL;
}
else
b2be_db_mode = 0;
if(register_script_cb( b2b_prescript_f, PRE_SCRIPT_CB|REQ_TYPE_CB, 0 ) < 0)
{
LM_ERR("Failed to register prescript function\n");
return -1;
}
if (script_req_route)
{
req_routeid = get_script_route_ID_by_name( script_req_route, rlist, RT_NO);
if (req_routeid < 1)
{
LM_ERR("route <%s> does not exist\n",script_req_route);
return -1;
}
}
if (script_reply_route)
{
reply_routeid = get_script_route_ID_by_name( script_reply_route, rlist, RT_NO);
if (reply_routeid < 1)
{
LM_ERR("route <%s> does not exist\n",script_reply_route);
return -1;
}
}
if(b2b_update_period < 0)
{
LM_ERR("Wrong parameter - b2b_update_period [%d]\n", b2b_update_period);
return -1;
}
if(b2be_db_mode == WRITE_BACK)
register_timer("b2be-dbupdate", b2be_db_timer_update, 0,
b2b_update_period);
//register_timer("b2b2-clean", b2be_clean, 0, b2b_update_period);
return 0;
}
/**
* 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;
}
/*
* Initialize data structures
*/
int init_trusted(void)
{
/* Check if hash table needs to be loaded from trusted table */
if (!db_url.s) {
LM_INFO("db_url parameter of permissions module not set, "
"disabling allow_trusted\n");
return 0;
} else {
if (db_bind_mod(&db_url, &perm_dbf) < 0) {
LM_ERR("load a database support module\n");
return -1;
}
if (!DB_CAPABILITY(perm_dbf, DB_CAP_QUERY)) {
LM_ERR("database module does not implement 'query' function\n");
return -1;
}
}
hash_table_1 = hash_table_2 = 0;
hash_table = 0;
if (db_mode == ENABLE_CACHE) {
db_handle = perm_dbf.init(&db_url);
if (!db_handle) {
LM_ERR("unable to connect database\n");
return -1;
}
if(db_check_table_version(&perm_dbf, db_handle, &trusted_table, TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
perm_dbf.close(db_handle);
return -1;
}
hash_table_1 = new_hash_table();
if (!hash_table_1) return -1;
hash_table_2 = new_hash_table();
if (!hash_table_2) goto error;
hash_table = (struct trusted_list ***)shm_malloc
(sizeof(struct trusted_list **));
if (!hash_table) goto error;
*hash_table = hash_table_1;
if (reload_trusted_table() == -1) {
LM_CRIT("reload of trusted table failed\n");
goto error;
}
perm_dbf.close(db_handle);
db_handle = 0;
}
return 0;
error:
if (hash_table_1) {
free_hash_table(hash_table_1);
hash_table_1 = 0;
}
if (hash_table_2) {
free_hash_table(hash_table_2);
hash_table_2 = 0;
}
if (hash_table) {
shm_free(hash_table);
hash_table = 0;
}
perm_dbf.close(db_handle);
db_handle = 0;
return -1;
}
static int mod_init(void)
{
LM_DBG("group module - initializing\n");
/* check for a database module */
if (db_url.s) {
db_url.len = strlen(db_url.s);
table.len = strlen(table.s);
user_column.len = strlen(user_column.s);
domain_column.len = strlen(domain_column.s);
group_column.len = strlen(group_column.s);
re_table.len = (re_table.s && re_table.s[0])?strlen(re_table.s):0;
re_exp_column.len = strlen(re_exp_column.s);
re_gid_column.len = strlen(re_gid_column.s);
if (group_db_bind(&db_url)) {
LM_ERR("unable to bind database module\n");
return -1;
}
if (group_db_init(&db_url) < 0 ){
LM_ERR("unable to open database connection\n");
return -1;
}
/* check version for group table */
if (db_check_table_version(&group_dbf, group_dbh, &table, TABLE_VERSION) < 0) {
LM_ERR("error during group table version check.\n");
return -1;
}
if (re_table.len) {
/* check version for group re_group table */
if (db_check_table_version(&group_dbf, group_dbh, &re_table, RE_TABLE_VERSION) < 0) {
LM_ERR("error during re_group table version check.\n");
return -1;
}
if (load_re( &re_table )!=0 ) {
LM_ERR("failed to load <%s> table\n", re_table.s);
return -1;
}
}
group_db_close();
LM_DBG("group database loaded\n");
}
/* check for an aaa module */
if (aaa_proto_url.s) {
aaa_proto_url.len = strlen(aaa_proto_url.s);
memset(attrs, 0, sizeof(attrs));
memset(vals, 0, sizeof(vals));
attrs[A_SERVICE_TYPE].name = "Service-Type";
attrs[A_USER_NAME].name = "User-Name";
attrs[A_SIP_GROUP].name = "Sip-Group";
attrs[A_ACCT_SESSION_ID].name = "Acct-Session-Id";
vals[V_GROUP_CHECK].name = "Group-Check";
if (aaa_prot_bind(&aaa_proto_url, &proto)) {
LM_ERR("unable to bind aaa protocol module\n");
return -1;
}
if (!(conn = proto.init_prot(&aaa_proto_url))) {
LM_ERR("unable to initialize aaa protocol module\n");
return -1;
}
INIT_AV(proto, conn, attrs, A_MAX, vals, V_MAX, "group", -3, -4);
LM_DBG("aaa protocol module loaded\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;
}
