/**
* child init
*/
static int child_init(int rank)
{
if (imc_dbf.init==0)
{
LM_ERR("database not bound\n");
return -1;
}
imc_db = imc_dbf.init(&db_url);
if (!imc_db)
{
LM_ERR("child %d: Error while connecting database\n", rank);
return -1;
}
else
{
if (imc_dbf.use_table(imc_db, &rooms_table) < 0)
{
LM_ERR("child %d: Error in use_table '%.*s'\n", rank, rooms_table.len, rooms_table.s);
return -1;
}
if (imc_dbf.use_table(imc_db, &members_table) < 0)
{
LM_ERR("child %d: Error in use_table '%.*s'\n", rank, members_table.len, members_table.s);
return -1;
}
LM_DBG("child %d: Database connection opened successfully\n", rank);
}
return 0;
}
/**
* Init the database connection
* @param db_url - URL of the database
* @param db_table_nds - name of the NDS table
* @param db_table_scscf - name of the S-CSCF table
* @param db_table_capabilities - name of the S-CSCF capabilities table
* @returns 0 on success, -1 on error
*/
int icscf_db_init(char* db_url,
char* db_table_nds,
char* db_table_scscf,
char* db_table_capabilities)
{
if (dbf.init==0){
LOG(L_CRIT, "BUG:"M_NAME":icscf_db_init: unbound database module\n");
return -1;
}
/* NDS */
hdl_nds=dbf.init(db_url);
if (hdl_nds==0){
LOG(L_CRIT,"ERR:"M_NAME":icscf_db_init: cannot initialize database "
"connection\n");
goto error;
}
if (dbf.use_table(hdl_nds, db_table_nds)<0) {
LOG(L_CRIT,"ERR:"M_NAME":icscf_db_init: cannot select table \"%s\"\n",db_table_nds);
goto error;
}
/* S_CSCF */
hdl_scscf=dbf.init(db_url);
if (hdl_scscf==0){
LOG(L_CRIT,"ERR:"M_NAME":icscf_db_init: cannot initialize database "
"connection\n");
goto error;
}
if (dbf.use_table(hdl_scscf, db_table_scscf)<0) {
LOG(L_CRIT,"ERR:"M_NAME":icscf_db_init: cannot select table \"%s\"\n",db_table_scscf);
goto error;
}
/* Capabilities */
hdl_capabilities=dbf.init(db_url);
if (hdl_capabilities==0){
LOG(L_CRIT,"ERR:"M_NAME":icscf_db_init: cannot initialize database "
"connection\n");
goto error;
}
if (dbf.use_table(hdl_capabilities, db_table_capabilities)<0) {
LOG(L_CRIT,"ERR:"M_NAME":icscf_db_init: cannot select table \"%s\"\n",db_table_capabilities);
goto error;
}
return 0;
error:
if (hdl_nds){
dbf.close(hdl_nds);
hdl_nds=0;
}
if (hdl_scscf){
dbf.close(hdl_scscf);
hdl_nds=0;
}
if (hdl_capabilities){
dbf.close(hdl_capabilities);
hdl_nds=0;
}
return -1;
}
/*
* Check if uri belongs to a local user
*/
int does_uri_exist(struct sip_msg* _msg, char* _s1, char* _s2)
{
static db_ps_t my_ps = NULL;
db_key_t keys[2];
db_val_t vals[2];
db_key_t cols[1];
db_res_t* res = NULL;
if (parse_sip_msg_uri(_msg) < 0) {
LM_ERR("Error while parsing URI\n");
return ERR_INTERNAL;
}
if (use_uri_table != 0) {
uridb_dbf.use_table(db_handle, &db_table);
keys[0] = &uridb_uriuser_col;
keys[1] = &uridb_domain_col;
cols[0] = &uridb_uriuser_col;
} else {
uridb_dbf.use_table(db_handle, &db_table);
keys[0] = &uridb_user_col;
keys[1] = &uridb_domain_col;
cols[0] = &uridb_user_col;
}
VAL_TYPE(vals) = VAL_TYPE(vals + 1) = DB_STR;
VAL_NULL(vals) = VAL_NULL(vals + 1) = 0;
VAL_STR(vals) = _msg->parsed_uri.user;
VAL_STR(vals + 1) = _msg->parsed_uri.host;
CON_PS_REFERENCE(db_handle) = &my_ps;
if (uridb_dbf.query(db_handle, keys, 0, vals, cols, (use_domain ? 2 : 1),
1, 0, &res) < 0) {
LM_ERR("Error while querying database\n");
return ERR_USERNOTFOUND;
}
if (RES_ROW_N(res) == 0) {
LM_DBG("User in request uri does not exist\n");
uridb_dbf.free_result(db_handle, res);
return ERR_DBEMTPYRES;
} else {
LM_DBG("User in request uri does exist\n");
uridb_dbf.free_result(db_handle, res);
return OK;
}
}
int log_request(struct sip_msg *rq, str* ouri, struct hdr_field *to, char *table, unsigned int code, time_t req_timestamp)
{
int cnt;
if (skip_cancel(rq)) return 1;
cnt = fmt2strar(log_fmt, rq, ouri, to, code, req_timestamp);
if (cnt == 0) {
LOG(L_ERR, "ERROR:acc:log_request: fmt2strar failed\n");
return -1;
}
if (!db_url.len) {
LOG(L_ERR, "ERROR:acc:log_request: can't log -- no db_url set\n");
return -1;
}
if (acc_dbf.use_table(db_handle, table) < 0) {
LOG(L_ERR, "ERROR:acc:log_request:Error in use_table\n");
return -1;
}
if (acc_dbf.insert(db_handle, keys, vals, cnt) < 0) {
LOG(L_ERR, "ERROR:acc:log_request:acc_request: Error while inserting to database\n");
return -1;
}
return 1;
}
int update_db_state(int state) {
db_key_t node_id_key = &id_col;
db_val_t node_id_val;
db_key_t update_key;
db_val_t update_val;
VAL_TYPE(&node_id_val) = DB_INT;
VAL_NULL(&node_id_val) = 0;
VAL_INT(&node_id_val) = current_id;
update_key = &state_col;
CON_OR_RESET(db_hdl);
if (dr_dbf.use_table(db_hdl, &db_table) < 0) {
LM_ERR("cannot select table: \"%.*s\"\n", db_table.len, db_table.s);
return -1;
}
VAL_TYPE(&update_val) = DB_INT;
VAL_NULL(&update_val) = 0;
VAL_INT(&update_val) = state;
if (dr_dbf.update(db_hdl, &node_id_key, 0, &node_id_val, &update_key,
&update_val, 1, 1) < 0)
return -1;
return 0;
}
static int save_siptrace(struct sip_msg *msg,struct usr_avp *avp,
int_str *first_val,db_key_t *keys,db_val_t *vals)
{
if (duplicate_with_hep)
trace_send_hep_duplicate(&db_vals[0].val.blob_val, &db_vals[4].val.str_val,
&db_vals[5].val.str_val, db_vals[6].val.int_val, &db_vals[7].val.str_val,
&db_vals[8].val.str_val, db_vals[9].val.int_val);
else
trace_send_duplicate(db_vals[0].val.blob_val.s,
db_vals[0].val.blob_val.len);
if(trace_to_database_flag!=NULL && *trace_to_database_flag!=0) {
LM_DBG("saving siptrace\n");
db_funcs.use_table(db_con, siptrace_get_table());
if (flag_trace_is_set(msg) && insert_siptrace_flag(msg,keys,vals) < 0)
return -1;
if (avp==NULL)
return 0;
if (insert_siptrace_avp(avp,first_val,keys,vals) < 0)
return -1;
}
return 0;
}
static int mi_child_init(void)
{
if(passive_mode==1)
return 0;
if(force_active== 0)
{
if(pxml_db)
return 0;
pxml_db = pxml_dbf.init(&db_url);
if (pxml_db== NULL)
{
LM_ERR("while connecting database\n");
return -1;
}
if (pxml_dbf.use_table(pxml_db, &xcap_table) < 0)
{
LM_ERR("in use_table SQL operation\n");
return -1;
}
}
LM_DBG("Database connection opened successfully\n");
return 0;
}
static int child_init(int rank)
{
LM_DBG("[%d] pid [%d]\n", rank, getpid());
if(passive_mode==1)
return 0;
if (rank==PROC_INIT || rank==PROC_MAIN || rank==PROC_TCP_MAIN)
return 0; /* do nothing for the main process */
if(force_active== 0)
{
if(pxml_db)
return 0;
pxml_db = pxml_dbf.init(&db_url);
if (pxml_db== NULL)
{
LM_ERR("while connecting database\n");
return -1;
}
if (pxml_dbf.use_table(pxml_db, &xcap_table) < 0)
{
LM_ERR("in use_table SQL operation\n");
return -1;
}
}
LM_DBG("child %d: Database connection opened successfully\n",rank);
return 0;
}
/* initialize child */
static int child_init(int rank)
{
LM_DBG("initializing child %d\n", rank);
if (rank == PROC_TCP_MAIN || rank == PROC_BIN)
return 0;
/* init DB connection */
if ((db_hdl = dr_dbf.init(&clusterer_db_url)) == 0) {
LM_CRIT("cannot initialize database connection\n");
return -1;
}
/* child 1 load the routing info */
if ((rank == 1) && reload_data() != 0) {
LM_CRIT("failed to load routing data\n");
return -1;
}
/* use db_table */
if (dr_dbf.use_table(db_hdl, &db_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", db_table.len, db_table.s);
return -1;
}
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 (pua_dbf.init==0)
{
LM_CRIT("database not bound\n");
return -1;
}
/* In DB only mode do not pool the connections where possible. */
if (dbmode == PUA_DB_ONLY && pua_dbf.init2)
pua_db = pua_dbf.init2(&db_url, DB_POOLING_NONE);
else
pua_db = pua_dbf.init(&db_url);
if (!pua_db)
{
LM_ERR("Child %d: connecting to database failed\n", rank);
return -1;
}
if (pua_dbf.use_table(pua_db, &db_table) < 0)
{
LM_ERR("child %d: Error in use_table pua\n", rank);
return -1;
}
LM_DBG("child %d: Database connection opened successfully\n", rank);
return 0;
}
static int mi_child_init(void)
{
if (pua_dbf.init==0)
{
LM_CRIT("database not bound\n");
return -1;
}
/* In DB only mode do not pool the connections where possible. */
if (dbmode == PUA_DB_ONLY && pua_dbf.init2)
pua_db = pua_dbf.init2(&db_url, DB_POOLING_NONE);
else
pua_db = pua_dbf.init(&db_url);
if (!pua_db)
{
LM_ERR("connecting to database failed\n");
return -1;
}
if (pua_dbf.use_table(pua_db, &db_table) < 0)
{
LM_ERR("Error in use_table pua\n");
return -1;
}
LM_DBG("Database connection opened successfully\n");
return 0;
}
static int use_reg_table(void)
{
if(!reg_db_handle){
LM_ERR("invalid database handle\n");
return -1;
}
reg_dbf.use_table(reg_db_handle, ®_table_name);
return 0;
}
static int use_sca_table(void)
{
if(!sca_db_handle){
LM_ERR("invalid database handle\n");
return -1;
}
sca_dbf.use_table(sca_db_handle, &sca_table_name);
return 0;
}
static int mi_child_init(void)
{
if(library_mode)
return 0;
if (pa_dbf.init==0)
{
LM_CRIT("database not bound\n");
return -1;
}
/* Do not pool the connections where possible when running notifier
processes. */
if (pres_notifier_processes > 0 && pa_dbf.init2)
pa_db = pa_dbf.init2(&db_url, DB_POOLING_NONE);
else
pa_db = pa_dbf.init(&db_url);
if (!pa_db)
{
LM_ERR("connecting database\n");
return -1;
}
if (pa_dbf.use_table(pa_db, &presentity_table) < 0)
{
LM_ERR( "unsuccessful use_table presentity_table\n");
return -1;
}
if (pa_dbf.use_table(pa_db, &active_watchers_table) < 0)
{
LM_ERR( "unsuccessful use_table active_watchers_table\n");
return -1;
}
if (pa_dbf.use_table(pa_db, &watchers_table) < 0)
{
LM_ERR( "unsuccessful use_table watchers_table\n");
return -1;
}
LM_DBG("Database connection opened successfully\n");
return 0;
}
static int use_dialog_table(void)
{
if(!dialog_db_handle){
LM_ERR("invalid database handle\n");
return -1;
}
dialog_dbf.use_table(dialog_db_handle, &dialog_table_name);
return 0;
}
/**
* Builds a d-tree using database entries.
* \return negative on failure, postive on success, indicating the number of d-tree entries
*/
int db_build_userbl_tree(const str *username, const str *domain, const str *table, struct dt_node_t *root, int use_domain)
{
db_key_t columns[2] = { &prefix_col, &whitelist_col };
db_key_t key[2] = { &username_key, &domain_key };
db_val_t val[2];
VAL_TYPE(val) = VAL_TYPE(val + 1) = DB_STR;
VAL_NULL(val) = VAL_NULL(val + 1) = 0;
VAL_STR(val).s = username->s;
VAL_STR(val).len = username->len;
VAL_STR(val + 1).s = domain->s;
VAL_STR(val + 1).len = domain->len;
db_res_t *res;
int i;
int n = 0;
if (dbf.use_table(dbc, table) < 0) {
LM_ERR("cannot use table '%.*s'.\n", table->len, table->s);
return -1;
}
if (dbf.query(dbc, key, 0, val, columns, (!use_domain) ? (1) : (2), 2, 0, &res) < 0) {
LM_ERR("error while executing query.\n");
return -1;
}
dt_clear(root);
if (RES_COL_N(res) > 1) {
for(i = 0; i < RES_ROW_N(res); i++) {
if ((!RES_ROWS(res)[i].values[0].nul) && (!RES_ROWS(res)[i].values[1].nul)) {
if ((RES_ROWS(res)[i].values[0].type == DB_STRING) &&
(RES_ROWS(res)[i].values[1].type == DB_INT)) {
/* LM_DBG("insert into tree prefix %s, whitelist %d",
RES_ROWS(res)[i].values[0].val.string_val,
RES_ROWS(res)[i].values[1].val.int_val); */
dt_insert(root, RES_ROWS(res)[i].values[0].val.string_val,
RES_ROWS(res)[i].values[1].val.int_val);
n++;
}
else {
LM_ERR("got invalid result type from query.\n");
}
}
}
}
dbf.free_result(dbc, res);
return n;
}
/*
* Checks based on given source IP address and protocol, and From URI
* of request if request can be trusted without authentication.
*/
int allow_trusted(struct sip_msg* msg, char *src_ip, int proto)
{
int result;
db1_res_t* res = NULL;
db_key_t keys[1];
db_val_t vals[1];
db_key_t cols[4];
if (db_mode == DISABLE_CACHE) {
db_key_t order = &priority_col;
if (db_handle == 0) {
LM_ERR("no connection to database\n");
return -1;
}
keys[0] = &source_col;
cols[0] = &proto_col;
cols[1] = &from_col;
cols[2] = &ruri_col;
cols[3] = &tag_col;
if (perm_dbf.use_table(db_handle, &trusted_table) < 0) {
LM_ERR("failed to use trusted table\n");
return -1;
}
VAL_TYPE(vals) = DB1_STRING;
VAL_NULL(vals) = 0;
VAL_STRING(vals) = src_ip;
if (perm_dbf.query(db_handle, keys, 0, vals, cols, 1, 4, order,
&res) < 0){
LM_ERR("failed to query database\n");
return -1;
}
if (RES_ROW_N(res) == 0) {
perm_dbf.free_result(db_handle, res);
return -1;
}
result = match_res(msg, proto, res);
perm_dbf.free_result(db_handle, res);
return result;
} else {
return match_hash_table(*hash_table, msg, src_ip, proto);
}
}
int load_user_carrier(str * user, str * domain) {
db_res_t * res;
db_key_t cols[1];
db_key_t keys[2];
db_val_t vals[2];
db_op_t op[2];
int id;
if (!user || (use_domain && !domain)) {
LM_ERR("NULL pointer in parameter\n");
return -1;
}
cols[0] = subscriber_columns[SUBSCRIBER_CARRIER_COL];
keys[0] = subscriber_columns[SUBSCRIBER_USERNAME_COL];
op[0] = OP_EQ;
vals[0].type = DB_STR;
vals[0].nul = 0;
vals[0].val.str_val = *user;
keys[1] = subscriber_columns[SUBSCRIBER_DOMAIN_COL];
op[1] = OP_EQ;
vals[1].type = DB_STR;
vals[1].nul = 0;
vals[1].val.str_val = *domain;
if (dbf.use_table(dbh, &subscriber_table) < 0) {
LM_ERR("can't use table\n");
return -1;
}
if (dbf.query(dbh, keys, op, vals, cols, use_domain ? 2 : 1, 1, NULL, &res) < 0) {
LM_ERR("can't query database\n");
return -1;
}
if (RES_ROW_N(res) == 0) {
dbf.free_result(dbh, res);
return 0;
}
if (VAL_NULL(ROW_VALUES(RES_ROWS(res)))) {
dbf.free_result(dbh, res);
return 0;
}
id = VAL_INT(ROW_VALUES(RES_ROWS(res)));
dbf.free_result(dbh, res);
return id;
}
int acc_db_request( struct sip_msg *rq, struct sip_msg *rpl,
query_list_t **ins_list)
{
static db_ps_t my_ps_ins = NULL;
static db_ps_t my_ps = NULL;
int m;
int n;
int i;
/* formated database columns */
m = core2strar( rq, val_arr );
for(i = 0; i < m; i++)
VAL_STR(db_vals+i) = val_arr[i];
/* time value */
VAL_TIME(db_vals+(m++)) = acc_env.ts;
/* extra columns */
m += extra2strar( db_extra, rq, rpl, val_arr+m, 0);
for( i++; i < m; i++)
VAL_STR(db_vals+i) = val_arr[i];
acc_dbf.use_table(db_handle, &acc_env.text/*table*/);
CON_PS_REFERENCE(db_handle) = ins_list? &my_ps_ins : &my_ps;
/* multi-leg columns */
if ( !leg_info ) {
if (con_set_inslist(&acc_dbf,db_handle,ins_list,db_keys,m) < 0 )
CON_RESET_INSLIST(db_handle);
if (acc_dbf.insert(db_handle, db_keys, db_vals, m) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
} else {
n = legs2strar(leg_info,rq,val_arr+m,1);
do {
for ( i = m; i < m + n; i++)
VAL_STR(db_vals+i)=val_arr[i];
if (con_set_inslist(&acc_dbf,db_handle,ins_list,db_keys,m+n) < 0 )
CON_RESET_INSLIST(db_handle);
if (acc_dbf.insert(db_handle, db_keys, db_vals, m+n) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
}while ( (n = legs2strar(leg_info,rq,val_arr+m,0))!=0 );
}
return 1;
}
void rlsubs_table_update(unsigned int ticks,void *param)
{
int no_lock= 0;
if(ticks== 0 && param == NULL)
no_lock= 1;
if(rls_dbf.use_table(rls_db, rlsubs_table)< 0)
{
LM_ERR("sql use table failed\n");
return;
}
pres_update_db_subs(rls_db, rls_dbf, rls_table, hash_size,
no_lock, handle_expired_record);
}
static int child_init(void)
{
db_con = pdt_dbf.init(&db_url);
if(db_con==NULL)
{
LM_ERR("failed to connect to database\n");
return -1;
}
if (pdt_dbf.use_table(db_con, &db_table) < 0)
{
LM_ERR("use_table failed\n");
return -1;
}
return 0;
}
/* each child get a new connection to the database */
static int child_init(int r)
{
DBG("PDT:child_init #%d / pid <%d>\n", r, getpid());
if(r>0)
{
if(_dhash==NULL)
{
LOG(L_ERR,"PDT:child_init #%d: ERROR no domain hash\n", r);
return -1;
}
lock_get(&_dhash->diff_lock);
_dhash->workers++;
lock_release(&_dhash->diff_lock);
} else {
if(_ptree!=NULL)
{
pdt_free_tree(_ptree);
_ptree = 0;
}
}
if (r==PROC_MAIN || r==PROC_TCP_MAIN)
return 0; /* do nothing for the main or tcp_main processes */
db_con = pdt_dbf.init(db_url);
if(db_con==NULL)
{
LOG(L_ERR,"PDT:child_init #%d: Error while connecting database\n",r);
return -1;
}
if (pdt_dbf.use_table(db_con, db_table) < 0)
{
LOG(L_ERR, "PDT:child_init #%d: Error in use_table\n", r);
return -1;
}
if(sync_time<=0)
sync_time = 300;
sync_time += r%60;
DBG("PDT:child_init #%d: Database connection opened successfully\n",r);
return 0;
}
int pdt_init_db(void)
{
/* db handler initialization */
db_con = pdt_dbf.init(&db_url);
if(db_con==NULL)
{
LM_ERR("failed to connect to database\n");
return -1;
}
if (pdt_dbf.use_table(db_con, &db_table) < 0)
{
LM_ERR("use_table failed\n");
return -1;
}
return 0;
}
static int pres_db_open(void) {
if (!pres_db_url.s || !pres_db_url.len) {
return 0;
}
if (pres_dbh) {
pres_dbf.close(pres_dbh);
}
if ((pres_dbh = pres_dbf.init(&pres_db_url)) == NULL) {
LM_ERR("can't connect to database\n");
return -1;
}
if (pres_dbf.use_table(pres_dbh, &xcap_table) < 0) {
LM_ERR("in use_table: %.*s\n", xcap_table.len, xcap_table.s);
return -1;
}
return 0;
}
int acc_db_request( struct sip_msg *rq)
{
int m;
int n;
int i;
/* formated database columns */
m = core2strar( rq, val_arr, int_arr, type_arr );
for(i=0; i<m; i++)
VAL_STR(db_vals+i) = val_arr[i];
/* time value */
VAL_TIME(db_vals+(m++)) = acc_env.ts;
/* extra columns */
m += extra2strar( db_extra, rq, val_arr+m, int_arr+m, type_arr+m);
for( i++ ; i<m; i++)
VAL_STR(db_vals+i) = val_arr[i];
if (acc_dbf.use_table(db_handle, &acc_env.text/*table*/) < 0) {
LM_ERR("error in use_table\n");
return -1;
}
/* multi-leg columns */
if ( !leg_info ) {
if (acc_dbf.insert(db_handle, db_keys, db_vals, m) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
} else {
n = legs2strar(leg_info,rq,val_arr+m,int_arr+m,type_arr+m,1);
do {
for (i=m; i<m+n; i++)
VAL_STR(db_vals+i)=val_arr[i];
if (acc_dbf.insert(db_handle, db_keys, db_vals, m+n) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
}while ( (n=legs2strar(leg_info,rq,val_arr+m,int_arr+m,
type_arr+m,0))!=0 );
}
return 1;
}
void rlsubs_table_update(unsigned int ticks,void *param)
{
int no_lock= 0;
if (dbmode==RLS_DB_ONLY) { delete_expired_subs_rlsdb(); return; }
if(ticks== 0 && param == NULL)
no_lock= 1;
if(rls_dbf.use_table(rls_db, &rlsubs_table)< 0)
{
LM_ERR("sql use table failed\n");
return;
}
pres_update_db_subs_timer(rls_db, rls_dbf, rls_table, hash_size,
no_lock, handle_expired_record);
}
/*
* Check if domain is local
*/
int is_domain_local(str* _host)
{
if (db_mode == 0) {
db_key_t keys[1];
db_val_t vals[1];
db_key_t cols[1];
db_res_t* res;
keys[0]=domain_col.s;
cols[0]=domain_col.s;
if (domain_dbf.use_table(db_handle, domain_table.s) < 0) {
LOG(L_ERR, "is_local(): Error while trying to use domain table\n");
return -1;
}
VAL_TYPE(vals) = DB_STR;
VAL_NULL(vals) = 0;
VAL_STR(vals).s = _host->s;
VAL_STR(vals).len = _host->len;
if (domain_dbf.query(db_handle, keys, 0, vals, cols, 1, 1, 0, &res) < 0
) {
LOG(L_ERR, "is_local(): Error while querying database\n");
return -1;
}
if (RES_ROW_N(res) == 0) {
DBG("is_local(): Realm '%.*s' is not local\n",
_host->len, ZSW(_host->s));
domain_dbf.free_result(db_handle, res);
return -1;
} else {
DBG("is_local(): Realm '%.*s' is local\n",
_host->len, ZSW(_host->s));
domain_dbf.free_result(db_handle, res);
return 1;
}
} else {
return hash_table_lookup (_host);
}
}
int pres_db_delete_status(subs_t* s)
{
int n_query_cols= 0;
db_key_t query_cols[5];
db_val_t query_vals[5];
if (pa_dbf.use_table(pa_db, &active_watchers_table) < 0)
{
LM_ERR("sql use table failed\n");
return -1;
}
query_cols[n_query_cols]= &str_event_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
query_vals[n_query_cols].val.str_val= s->event->name ;
n_query_cols++;
query_cols[n_query_cols]= &str_presentity_uri_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
query_vals[n_query_cols].val.str_val= s->pres_uri;
n_query_cols++;
query_cols[n_query_cols]= &str_watcher_username_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
query_vals[n_query_cols].val.str_val= s->watcher_user;
n_query_cols++;
query_cols[n_query_cols]= &str_watcher_domain_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
query_vals[n_query_cols].val.str_val= s->watcher_domain;
n_query_cols++;
if(pa_dbf.delete(pa_db, query_cols, 0, query_vals, n_query_cols)< 0)
{
LM_ERR("sql delete failed\n");
return -1;
}
return 0;
}
/**
* delete databse table
*/
int ht_db_delete_records(str *dbtable)
{
if(ht_db_con==NULL)
{
LM_ERR("no db connection\n");
return -1;
}
if (ht_dbf.use_table(ht_db_con, dbtable) < 0)
{
LM_ERR("failed to use_table\n");
return -1;
}
if(ht_dbf.delete(ht_db_con, NULL, NULL, NULL, 0) < 0)
LM_ERR("failed to delete db records in [%.*s]\n",
dbtable->len, dbtable->s);
return 0;
}
static int store_carriers(struct carrier ** start){
db_res_t * res = NULL;
int i;
int count;
struct carrier * nc;
if(!start){
LM_ERR("invalid parameter\n");
return -1;
}
if (dbf.use_table(dbh, &carrier_table) < 0) {
LM_ERR("couldn't use table\n");
return -1;
}
if (dbf.query(dbh, 0, 0, 0, (db_key_t *)carrier_columns, 0, CARRIER_COLUMN_NUM, 0, &res) < 0) {
LM_ERR("couldn't query table\n");
return -1;
}
count = RES_ROW_N(res);
for(i=0; i<RES_ROW_N(res); i++){
if((nc = pkg_malloc(sizeof(struct carrier))) == NULL){
LM_ERR("out of private memory\n");
return -1;
}
nc->id = res->rows[i].values[0].val.int_val;
if((nc->name = pkg_malloc(strlen(res->rows[i].values[1].val.string_val) + 1)) == NULL){
LM_ERR("out of private memory\n");
pkg_free(nc);
goto errout;
}
strcpy(nc->name, res->rows[i].values[1].val.string_val);
nc->next = *start;
*start = nc;
}
dbf.free_result(dbh, res);
return count;
errout:
if(res){
dbf.free_result(dbh, res);
}
return -1;
}
