/**
* Get the S-CSCF capabilities from the database and fill the S-CSCF set.
* @param cap - array of scscf_capabilities to fill with capabilities
* @returns 1 on success, 0 on error
*/
int icscf_db_get_capabilities(scscf_capabilities *cap[],int cap_cnt)
{
// db_key_t keys_cmp[] = {"icscf"};
db_key_t keys_ret[] = {"id_s_cscf","capability"};
db_key_t key_ord = "id_s_cscf";
db_res_t * res = 0 ;
int i,j;
int ccnt=0;
int cnt;
if (!icscf_db_check_init(hdl_capabilities))
goto error;
DBG("DBG:"M_NAME":icscf_db_get_capabilities: fetching list of Capabilities for I-CSCF\n");
if (dbf.query(hdl_capabilities, 0, 0, 0, keys_ret, 0, 2, key_ord, & res) < 0) {
LOG(L_ERR, "ERR:"M_NAME":icscf_db_get_capabilities: db_query failed\n");
goto error;
}
if (res->n == 0) {
DBG("DBG:"M_NAME":icscf_db_get_capabilities: No Capabilites found... not critical...\n");
return 1;
}
else {
for(i=0;i<cap_cnt;i++){
cnt = 0;
for(j=0;j<res->n;j++)
if (res->rows[j].values[0].val.int_val == (*cap)[i].id_s_cscf)
cnt++;
(*cap)[i].capabilities = shm_malloc(sizeof(int)*cnt);
if (!(*cap)[i].capabilities) {
LOG(L_ERR,"ERR:"M_NAME":icscf_db_get_capabilities: Error allocating %d bytes\n",
sizeof(int)*cnt);
(*cap)[i].cnt=0;
goto error;
}
cnt=0;
for(j=0;j<res->n;j++)
if (res->rows[j].values[0].val.int_val == (*cap)[i].id_s_cscf) {
(*cap)[i].capabilities[cnt++]=res->rows[j].values[1].val.int_val;
ccnt++;
}
(*cap)[i].cnt=cnt;
}
}
LOG(L_INFO, "INF:"M_NAME":icscf_db_get_capabilities: Loaded %d capabilities for %d S-CSCFs (%d invalid entries in db)\n",
ccnt,cap_cnt,res->n-ccnt);
dbf.free_result( hdl_capabilities, res);
return 1;
error:
if (res)
dbf.free_result( hdl_capabilities, res);
return 0;
}
/**
* Get the S-CSCF names from the database and create the S-CSCF set.
* @param cap - array of scscf_capabilities to fill with the db contents for the S-CSCF names
* @returns 1 on success, 0 on error
*/
int icscf_db_get_scscf(scscf_capabilities *cap[])
{
db_key_t keys_ret[] = {"id","s_cscf_uri"};
db_key_t key_ord = "id";
db_res_t * res = 0 ;
int i;
*cap = 0;
if (!icscf_db_check_init(hdl_scscf))
goto error;
DBG("DBG:"M_NAME":icscf_db_get_scscf: fetching S-CSCFs \n");
if (dbf.query(hdl_scscf, 0, 0, 0, keys_ret, 0, 2, key_ord, & res) < 0) {
LOG(L_ERR, "ERR:"M_NAME":icscf_db_get_scscf: db_query failed\n");
goto error;
}
if (res->n == 0) {
LOG(L_ERR,"ERR:"M_NAME":icscf_db_get_scscf: no S-CSCFs found\n");
goto error;
}
else {
*cap = shm_malloc(sizeof(scscf_capabilities)*res->n);
if (!(*cap)) {
LOG(L_ERR,"ERR:"M_NAME":icscf_db_get_scscf: Error allocating %d bytes\n",
sizeof(scscf_capabilities)*res->n);
goto error;
}
memset((*cap),0,sizeof(scscf_capabilities)*res->n);
for(i=0;i<res->n;i++){
(*cap)[i].id_s_cscf = res->rows[i].values[0].val.int_val;
(*cap)[i].scscf_name.len = strlen(res->rows[i].values[1].val.string_val);
(*cap)[i].scscf_name.s = shm_malloc((*cap)[i].scscf_name.len);
if (!(*cap)[i].scscf_name.s){
LOG(L_ERR,"ERR:"M_NAME":icscf_db_get_scscf: Error allocating %d bytes\n",
(*cap)[i].scscf_name.len);
(*cap)[i].scscf_name.len=0;
goto error;
}
memcpy((*cap)[i].scscf_name.s,res->rows[i].values[1].val.string_val,
(*cap)[i].scscf_name.len);
}
}
dbf.free_result( hdl_scscf, res);
// return the size of scscf set
return i;
error:
if (res)
dbf.free_result( hdl_scscf, res);
return 0;
}
/*
* 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;
}
/*
* 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;
}
}
/*
* 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);
}
}
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;
}
/**
* 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;
}
/**
* Rebuild d-tree using database entries
* \return negative on failure, positive on success, indicating the number of d-tree entries
*/
int db_reload_source(const str *table, struct dt_node_t *root)
{
db_key_t columns[2] = { &prefix_col, &whitelist_col };
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, NULL, NULL, NULL, columns, 0, 2, NULL, &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;
}
/*
* Reload trusted table to new hash table and when done, make new hash table
* current one.
*/
int reload_trusted_table(void)
{
db_key_t cols[6];
db1_res_t* res = NULL;
db_row_t* row;
db_val_t* val;
struct trusted_list **new_hash_table;
struct trusted_list **old_hash_table;
int i;
int priority;
char *pattern, *ruri_pattern, *tag;
if (hash_table == 0) {
LM_ERR("in-memory hash table not initialized\n");
return -1;
}
if (db_handle == 0) {
LM_ERR("no connection to database\n");
return -1;
}
cols[0] = &source_col;
cols[1] = &proto_col;
cols[2] = &from_col;
cols[3] = &ruri_col;
cols[4] = &tag_col;
cols[5] = &priority_col;
if (perm_dbf.use_table(db_handle, &trusted_table) < 0) {
LM_ERR("failed to use trusted table\n");
return -1;
}
if (perm_dbf.query(db_handle, NULL, 0, NULL, cols, 0, 6, 0, &res) < 0) {
LM_ERR("failed to query database\n");
return -1;
}
/* Choose new hash table and free its old contents */
if (*hash_table == hash_table_1) {
new_hash_table = hash_table_2;
} else {
new_hash_table = hash_table_1;
}
empty_hash_table(new_hash_table);
row = RES_ROWS(res);
LM_DBG("number of rows in trusted table: %d\n", RES_ROW_N(res));
for (i = 0; i < RES_ROW_N(res); i++) {
val = ROW_VALUES(row + i);
if ((ROW_N(row + i) == 6) &&
((VAL_TYPE(val) == DB1_STRING) || (VAL_TYPE(val) == DB1_STR) ) &&
!VAL_NULL(val) &&
((VAL_TYPE(val + 1) == DB1_STRING) || (VAL_TYPE(val + 1) == DB1_STR))
&& !VAL_NULL(val + 1) &&
(VAL_NULL(val + 2) ||
(((VAL_TYPE(val + 2) == DB1_STRING) || (VAL_TYPE(val + 2) == DB1_STR)) &&
!VAL_NULL(val + 2))) && (VAL_NULL(val + 3) ||
(((VAL_TYPE(val + 3) == DB1_STRING) || (VAL_TYPE(val + 3) == DB1_STR) )&&
!VAL_NULL(val + 3))) && (VAL_NULL(val + 4) ||
(((VAL_TYPE(val + 4) == DB1_STRING) || (VAL_TYPE(val + 4) == DB1_STR) )&&
!VAL_NULL(val + 4)))) {
if (VAL_NULL(val + 2)) {
pattern = 0;
} else {
pattern = (char *)VAL_STRING(val + 2);
}
if (VAL_NULL(val + 3)) {
ruri_pattern = 0;
} else {
ruri_pattern = (char *)VAL_STRING(val + 3);
}
if (VAL_NULL(val + 4)) {
tag = 0;
} else {
tag = (char *)VAL_STRING(val + 4);
}
if (VAL_NULL(val + 5)) {
priority = 0;
} else {
priority = (int)VAL_INT(val + 5);
}
if (hash_table_insert(new_hash_table,
(char *)VAL_STRING(val),
(char *)VAL_STRING(val + 1),
pattern, ruri_pattern, tag, priority) == -1) {
LM_ERR("hash table problem\n");
perm_dbf.free_result(db_handle, res);
empty_hash_table(new_hash_table);
return -1;
}
LM_DBG("tuple <%s, %s, %s, %s, %s> inserted into trusted hash "
"table\n", VAL_STRING(val), VAL_STRING(val + 1),
pattern, ruri_pattern, tag);
} else {
LM_ERR("database problem\n");
perm_dbf.free_result(db_handle, res);
empty_hash_table(new_hash_table);
return -1;
}
}
perm_dbf.free_result(db_handle, res);
old_hash_table = *hash_table;
*hash_table = new_hash_table;
empty_hash_table(old_hash_table);
LM_DBG("trusted table reloaded successfully.\n");
return 1;
}
static void db_update(unsigned int ticks,void *param)
{
ua_pres_t* p= NULL;
db_key_t q_cols[20], result_cols[1];
db1_res_t *res= NULL;
db_key_t db_cols[5];
db_val_t q_vals[20], db_vals[5];
db_op_t db_ops[1] ;
int n_query_cols= 0, n_query_update= 0;
int n_update_cols= 0;
int i;
int puri_col,pid_col,expires_col,flag_col,etag_col,tuple_col,event_col;
int watcher_col,callid_col,totag_col,fromtag_col,record_route_col,cseq_col;
int no_lock= 0, contact_col, desired_expires_col, extra_headers_col;
int remote_contact_col, version_col;
if (dbmode==PUA_DB_ONLY) return;
if(ticks== 0 && param == NULL)
no_lock= 1;
/* cols and values used for insert */
q_cols[puri_col= n_query_cols] = &str_pres_uri_col;
q_vals[puri_col].type = DB1_STR;
q_vals[puri_col].nul = 0;
n_query_cols++;
q_cols[pid_col= n_query_cols] = &str_pres_id_col;
q_vals[pid_col].type = DB1_STR;
q_vals[pid_col].nul = 0;
n_query_cols++;
q_cols[flag_col= n_query_cols] = &str_flag_col;
q_vals[flag_col].type = DB1_INT;
q_vals[flag_col].nul = 0;
n_query_cols++;
q_cols[event_col= n_query_cols] = &str_event_col;
q_vals[event_col].type = DB1_INT;
q_vals[event_col].nul = 0;
n_query_cols++;
q_cols[watcher_col= n_query_cols] = &str_watcher_uri_col;
q_vals[watcher_col].type = DB1_STR;
q_vals[watcher_col].nul = 0;
n_query_cols++;
q_cols[callid_col= n_query_cols] = &str_call_id_col;
q_vals[callid_col].type = DB1_STR;
q_vals[callid_col].nul = 0;
n_query_cols++;
q_cols[totag_col= n_query_cols] = &str_to_tag_col;
q_vals[totag_col].type = DB1_STR;
q_vals[totag_col].nul = 0;
n_query_cols++;
q_cols[fromtag_col= n_query_cols] = &str_from_tag_col;
q_vals[fromtag_col].type = DB1_STR;
q_vals[fromtag_col].nul = 0;
n_query_cols++;
q_cols[etag_col= n_query_cols] = &str_etag_col;
q_vals[etag_col].type = DB1_STR;
q_vals[etag_col].nul = 0;
n_query_cols++;
q_cols[tuple_col= n_query_cols] = &str_tuple_id_col;
q_vals[tuple_col].type = DB1_STR;
q_vals[tuple_col].nul = 0;
n_query_cols++;
q_cols[cseq_col= n_query_cols]= &str_cseq_col;
q_vals[cseq_col].type = DB1_INT;
q_vals[cseq_col].nul = 0;
n_query_cols++;
q_cols[expires_col= n_query_cols] = &str_expires_col;
q_vals[expires_col].type = DB1_INT;
q_vals[expires_col].nul = 0;
n_query_cols++;
q_cols[desired_expires_col= n_query_cols] = &str_desired_expires_col;
q_vals[desired_expires_col].type = DB1_INT;
q_vals[desired_expires_col].nul = 0;
n_query_cols++;
q_cols[record_route_col= n_query_cols] = &str_record_route_col;
q_vals[record_route_col].type = DB1_STR;
q_vals[record_route_col].nul = 0;
n_query_cols++;
q_cols[contact_col= n_query_cols] = &str_contact_col;
q_vals[contact_col].type = DB1_STR;
q_vals[contact_col].nul = 0;
n_query_cols++;
q_cols[remote_contact_col= n_query_cols] = &str_remote_contact_col;
q_vals[remote_contact_col].type = DB1_STR;
q_vals[remote_contact_col].nul = 0;
n_query_cols++;
q_cols[version_col= n_query_cols] = &str_version_col;
q_vals[version_col].type = DB1_INT;
q_vals[version_col].nul = 0;
n_query_cols++;
/* must keep this the last column to be inserted */
q_cols[extra_headers_col= n_query_cols] = &str_extra_headers_col;
q_vals[extra_headers_col].type = DB1_STR;
q_vals[extra_headers_col].nul = 0;
n_query_cols++;
/* cols and values used for update */
db_cols[0]= &str_expires_col;
db_vals[0].type = DB1_INT;
db_vals[0].nul = 0;
db_cols[1]= &str_cseq_col;
db_vals[1].type = DB1_INT;
db_vals[1].nul = 0;
db_cols[2]= &str_etag_col;
db_vals[2].type = DB1_STR;
db_vals[2].nul = 0;
db_cols[3]= &str_desired_expires_col;
db_vals[3].type = DB1_INT;
db_vals[3].nul = 0;
db_cols[4]= &str_version_col;
db_vals[4].type = DB1_INT;
db_vals[4].nul = 0;
result_cols[0]= &str_expires_col;
if(pua_db== NULL)
{
LM_ERR("null database connection\n");
return;
}
if(pua_dbf.use_table(pua_db, &db_table)< 0)
{
LM_ERR("in use table\n");
return ;
}
for(i=0; i<HASH_SIZE; i++)
{
if(!no_lock)
lock_get(&HashT->p_records[i].lock);
p = HashT->p_records[i].entity->next;
while(p)
{
if(p->expires - (int)time(NULL)< 0)
{
p= p->next;
continue;
}
switch(p->db_flag)
{
case NO_UPDATEDB_FLAG:
{
LM_DBG("NO_UPDATEDB_FLAG\n");
break;
}
case UPDATEDB_FLAG:
{
LM_DBG("UPDATEDB_FLAG\n");
n_update_cols= 0;
n_query_update= 0;
q_vals[puri_col].val.str_val = *(p->pres_uri);
n_query_update++;
q_vals[pid_col].val.str_val = p->id;
n_query_update++;
q_vals[flag_col].val.int_val = p->flag;
n_query_update++;
q_vals[event_col].val.int_val = p->event;
n_query_update++;
if(p->watcher_uri)
{
q_vals[watcher_col].val.str_val = *(p->watcher_uri);
n_query_update++;
q_vals[callid_col].val.str_val = p->call_id;
n_query_update++;
q_vals[totag_col].val.str_val = p->to_tag;
n_query_update++;
q_vals[fromtag_col].val.str_val = p->from_tag;
n_query_update++;
}
db_vals[0].val.int_val= p->expires;
n_update_cols++;
db_vals[1].val.int_val= p->cseq ;
n_update_cols++;
db_vals[2].val.str_val= p->etag ;
n_update_cols++;
db_vals[3].val.int_val= p->desired_expires;
n_update_cols++;
db_vals[4].val.int_val= p->version;
n_update_cols++;
LM_DBG("Updating:n_query_update= %d\tn_update_cols= %d\n",
n_query_update, n_update_cols);
if(pua_dbf.query(pua_db, q_cols, 0, q_vals,
result_cols, n_query_update, 1, 0, &res)< 0)
{
LM_ERR("while querying db table pua\n");
if(!no_lock)
lock_release(&HashT->p_records[i].lock);
if(res)
pua_dbf.free_result(pua_db, res);
return ;
}
if(res && res->n> 0)
{
if(pua_dbf.update(pua_db, q_cols, 0, q_vals, db_cols,
db_vals, n_query_update, n_update_cols)<0)
{
LM_ERR("while updating in database\n");
if(!no_lock)
lock_release(&HashT->p_records[i].lock);
pua_dbf.free_result(pua_db, res);
res= NULL;
return ;
}
pua_dbf.free_result(pua_db, res);
res= NULL;
}
else
{
if(res)
{
pua_dbf.free_result(pua_db, res);
res= NULL;
}
LM_DBG("UPDATEDB_FLAG and no record found\n");
// p->db_flag= INSERTDB_FLAG;
}
break;
}
case INSERTDB_FLAG:
{
LM_DBG("INSERTDB_FLAG\n");
q_vals[puri_col].val.str_val = *(p->pres_uri);
q_vals[pid_col].val.str_val = p->id;
q_vals[flag_col].val.int_val = p->flag;
q_vals[callid_col].val.str_val = p->call_id;
q_vals[fromtag_col].val.str_val = p->from_tag;
q_vals[cseq_col].val.int_val= p->cseq;
q_vals[expires_col].val.int_val = p->expires;
q_vals[desired_expires_col].val.int_val = p->desired_expires;
q_vals[event_col].val.int_val = p->event;
q_vals[version_col].val.int_val = p->version;
if((p->watcher_uri))
q_vals[watcher_col].val.str_val = *(p->watcher_uri);
else
{
q_vals[watcher_col].val.str_val.s = "";
q_vals[watcher_col].val.str_val.len = 0;
}
if(p->tuple_id.s == NULL)
{
q_vals[tuple_col].val.str_val.s="";
q_vals[tuple_col].val.str_val.len=0;
}
else
q_vals[tuple_col].val.str_val = p->tuple_id;
if(p->etag.s == NULL)
{
q_vals[etag_col].val.str_val.s="";
q_vals[etag_col].val.str_val.len=0;
}
else
q_vals[etag_col].val.str_val = p->etag;
if (p->to_tag.s == NULL)
{
q_vals[totag_col].val.str_val.s="";
q_vals[totag_col].val.str_val.len=0;
}
else
q_vals[totag_col].val.str_val = p->to_tag;
if(p->record_route.s== NULL)
{
q_vals[record_route_col].val.str_val.s= "";
q_vals[record_route_col].val.str_val.len = 0;
}
else
q_vals[record_route_col].val.str_val = p->record_route;
if(p->contact.s == NULL)
{
q_vals[contact_col].val.str_val.s = "";
q_vals[contact_col].val.str_val.len = 0;
}
else
q_vals[contact_col].val.str_val = p->contact;
if(p->remote_contact.s)
{
q_vals[remote_contact_col].val.str_val = p->remote_contact;
LM_DBG("p->remote_contact = %.*s\n", p->remote_contact.len, p->remote_contact.s);
}
else
{
q_vals[remote_contact_col].val.str_val.s = "";
q_vals[remote_contact_col].val.str_val.len = 0;
}
if(p->extra_headers)
q_vals[extra_headers_col].val.str_val = *(p->extra_headers);
else
{
q_vals[extra_headers_col].val.str_val.s = "";
q_vals[extra_headers_col].val.str_val.len = 0;
}
if(pua_dbf.insert(pua_db, q_cols, q_vals,n_query_cols )<0)
{
LM_ERR("while inserting in db table pua\n");
if(!no_lock)
lock_release(&HashT->p_records[i].lock);
return ;
}
break;
}
}
p->db_flag= NO_UPDATEDB_FLAG;
p= p->next;
}
if(!no_lock)
lock_release(&HashT->p_records[i].lock);
}
db_vals[0].val.int_val= (int)time(NULL)- 10;
db_ops[0]= OP_LT;
if(pua_dbf.delete(pua_db, db_cols, db_ops, db_vals, 1) < 0)
{
LM_ERR("while deleting from db table pua\n");
}
return ;
}
static int db_restore(void)
{
ua_pres_t* p= NULL;
db_key_t result_cols[19];
db1_res_t *res= NULL;
db_row_t *row = NULL;
db_val_t *row_vals= NULL;
str pres_uri, pres_id;
str etag, tuple_id;
str watcher_uri, call_id;
str to_tag, from_tag, remote_contact;
str record_route, contact, extra_headers;
int size= 0, i;
int n_result_cols= 0;
int puri_col,pid_col,expires_col,flag_col,etag_col, desired_expires_col;
int watcher_col,callid_col,totag_col,fromtag_col,cseq_col,remote_contact_col;
int event_col,contact_col,tuple_col,record_route_col, extra_headers_col;
int version_col;
if (dbmode==PUA_DB_ONLY)
{
LM_ERR( "db_restore shouldn't be called in PUA_DB_ONLY mode\n" );
return(-1);
}
result_cols[puri_col=n_result_cols++] = &str_pres_uri_col;
result_cols[pid_col=n_result_cols++] = &str_pres_id_col;
result_cols[expires_col=n_result_cols++]= &str_expires_col;
result_cols[flag_col=n_result_cols++] = &str_flag_col;
result_cols[etag_col=n_result_cols++] = &str_etag_col;
result_cols[tuple_col=n_result_cols++] = &str_tuple_id_col;
result_cols[watcher_col=n_result_cols++]= &str_watcher_uri_col;
result_cols[callid_col=n_result_cols++] = &str_call_id_col;
result_cols[totag_col=n_result_cols++] = &str_to_tag_col;
result_cols[fromtag_col=n_result_cols++]= &str_from_tag_col;
result_cols[cseq_col= n_result_cols++] = &str_cseq_col;
result_cols[event_col= n_result_cols++] = &str_event_col;
result_cols[record_route_col= n_result_cols++] = &str_record_route_col;
result_cols[contact_col= n_result_cols++] = &str_contact_col;
result_cols[remote_contact_col= n_result_cols++] = &str_remote_contact_col;
result_cols[extra_headers_col= n_result_cols++] = &str_extra_headers_col;
result_cols[desired_expires_col= n_result_cols++] = &str_desired_expires_col;
result_cols[version_col= n_result_cols++] = &str_version_col;
if(!pua_db)
{
LM_ERR("null database connection\n");
return -1;
}
if(pua_dbf.use_table(pua_db, &db_table)< 0)
{
LM_ERR("in use table\n");
return -1;
}
if(db_fetch_query(&pua_dbf, pua_fetch_rows, pua_db, 0, 0, 0, result_cols,
0, n_result_cols, 0, &res)< 0)
{
LM_ERR("while querrying table\n");
if(res)
{
pua_dbf.free_result(pua_db, res);
res = NULL;
}
return -1;
}
if(res==NULL)
return -1;
if(res->n<=0)
{
LM_INFO("the query returned no result\n");
pua_dbf.free_result(pua_db, res);
res = NULL;
return 0;
}
do {
LM_DBG("found %d db entries\n", res->n);
for(i =0 ; i< res->n ; i++)
{
row = &res->rows[i];
row_vals = ROW_VALUES(row);
pres_uri.s= (char*)row_vals[puri_col].val.string_val;
pres_uri.len = strlen(pres_uri.s);
LM_DBG("pres_uri= %.*s\n", pres_uri.len, pres_uri.s);
memset(&etag, 0, sizeof(str));
memset(&tuple_id, 0, sizeof(str));
memset(&watcher_uri, 0, sizeof(str));
memset(&call_id, 0, sizeof(str));
memset(&to_tag, 0, sizeof(str));
memset(&from_tag, 0, sizeof(str));
memset(&record_route, 0, sizeof(str));
memset(&pres_id, 0, sizeof(str));
memset(&contact, 0, sizeof(str));
memset(&remote_contact, 0, sizeof(str));
memset(&extra_headers, 0, sizeof(str));
pres_id.s= (char*)row_vals[pid_col].val.string_val;
if(pres_id.s)
pres_id.len = strlen(pres_id.s);
if(row_vals[etag_col].val.string_val)
{
etag.s= (char*)row_vals[etag_col].val.string_val;
etag.len = strlen(etag.s);
tuple_id.s= (char*)row_vals[tuple_col].val.string_val;
tuple_id.len = strlen(tuple_id.s);
}
if(row_vals[watcher_col].val.string_val)
{
watcher_uri.s= (char*)row_vals[watcher_col].val.string_val;
watcher_uri.len = strlen(watcher_uri.s);
call_id.s= (char*)row_vals[callid_col].val.string_val;
call_id.len = strlen(call_id.s);
to_tag.s= (char*)row_vals[totag_col].val.string_val;
to_tag.len = strlen(to_tag.s);
from_tag.s= (char*)row_vals[fromtag_col].val.string_val;
from_tag.len = strlen(from_tag.s);
if(row_vals[record_route_col].val.string_val)
{
record_route.s= (char*)row_vals[record_route_col].val.string_val;
record_route.len= strlen(record_route.s);
}
contact.s= (char*)row_vals[contact_col].val.string_val;
contact.len = strlen(contact.s);
remote_contact.s= (char*)row_vals[remote_contact_col].val.string_val;
remote_contact.len = strlen(remote_contact.s);
}
extra_headers.s= (char*)row_vals[extra_headers_col].val.string_val;
if(extra_headers.s)
extra_headers.len= strlen(extra_headers.s);
else
extra_headers.len= 0;
size= sizeof(ua_pres_t)+ sizeof(str)+ (pres_uri.len+ pres_id.len+
tuple_id.len)* sizeof(char);
if(extra_headers.s)
size+= sizeof(str)+ extra_headers.len* sizeof(char);
if(watcher_uri.s)
size+= sizeof(str)+ (watcher_uri.len+ call_id.len+ to_tag.len+
from_tag.len+ record_route.len+ contact.len)* sizeof(char);
p= (ua_pres_t*)shm_malloc(size);
if(p== NULL)
{
LM_ERR("no more share memmory");
goto error;
}
memset(p, 0, size);
size= sizeof(ua_pres_t);
p->pres_uri= (str*)((char*)p+ size);
size+= sizeof(str);
p->pres_uri->s= (char*)p + size;
memcpy(p->pres_uri->s, pres_uri.s, pres_uri.len);
p->pres_uri->len= pres_uri.len;
size+= pres_uri.len;
if(pres_id.s)
{
p->id.s= (char*)p + size;
memcpy(p->id.s, pres_id.s, pres_id.len);
p->id.len= pres_id.len;
size+= pres_id.len;
}
if(tuple_id.s && tuple_id.len)
{
p->tuple_id.s= (char*)p + size;
memcpy(p->tuple_id.s, tuple_id.s, tuple_id.len);
p->tuple_id.len= tuple_id.len;
size+= tuple_id.len;
}
if(watcher_uri.s && watcher_uri.len)
{
p->watcher_uri= (str*)((char*)p+ size);
size+= sizeof(str);
p->watcher_uri->s= (char*)p+ size;
memcpy(p->watcher_uri->s, watcher_uri.s, watcher_uri.len);
p->watcher_uri->len= watcher_uri.len;
size+= watcher_uri.len;
p->to_tag.s= (char*)p+ size;
memcpy(p->to_tag.s, to_tag.s, to_tag.len);
p->to_tag.len= to_tag.len;
size+= to_tag.len;
p->from_tag.s= (char*)p+ size;
memcpy(p->from_tag.s, from_tag.s, from_tag.len);
p->from_tag.len= from_tag.len;
size+= from_tag.len;
p->call_id.s= (char*)p + size;
memcpy(p->call_id.s, call_id.s, call_id.len);
p->call_id.len= call_id.len;
size+= call_id.len;
if(record_route.s && record_route.len)
{
p->record_route.s= (char*)p + size;
memcpy(p->record_route.s, record_route.s, record_route.len);
p->record_route.len= record_route.len;
size+= record_route.len;
}
p->contact.s= (char*)p + size;
memcpy(p->contact.s, contact.s, contact.len);
p->contact.len= contact.len;
size+= contact.len;
p->cseq= row_vals[cseq_col].val.int_val;
p->remote_contact.s= (char*)shm_malloc(remote_contact.len* sizeof(char));
if(p->remote_contact.s== NULL)
{
LM_ERR("No more shared memory\n");
goto error;
}
memcpy(p->remote_contact.s, remote_contact.s, remote_contact.len);
p->remote_contact.len= remote_contact.len;
p->version= row_vals[version_col].val.int_val;
}
if(extra_headers.s)
{
p->extra_headers= (str*)((char*)p+ size);
size+= sizeof(str);
p->extra_headers->s= (char*)p+ size;
memcpy(p->extra_headers->s, extra_headers.s, extra_headers.len);
p->extra_headers->len= extra_headers.len;
size+= extra_headers.len;
}
LM_DBG("size= %d\n", size);
p->event= row_vals[event_col].val.int_val;
p->expires= row_vals[expires_col].val.int_val;
p->desired_expires= row_vals[desired_expires_col].val.int_val;
p->flag|= row_vals[flag_col].val.int_val;
memset(&p->etag, 0, sizeof(str));
if(etag.s && etag.len)
{
/* alloc separately */
p->etag.s= (char*)shm_malloc(etag.len* sizeof(char));
if(p->etag.s== NULL)
{
LM_ERR("no more share memory\n");
goto error;
}
memcpy(p->etag.s, etag.s, etag.len);
p->etag.len= etag.len;
}
print_ua_pres(p);
insert_htable(p);
}
} while((db_fetch_next(&pua_dbf, pua_fetch_rows, pua_db, &res)==1)
&& (RES_ROW_N(res)>0));
pua_dbf.free_result(pua_db, res);
res = NULL;
if(pua_dbf.delete(pua_db, 0, 0 , 0, 0) < 0)
{
LM_ERR("while deleting information from db\n");
goto error;
}
return 0;
error:
if(res)
pua_dbf.free_result(pua_db, res);
if(p)
shm_free(p);
return -1;
}
/* 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 alias_db_query(struct sip_msg* _msg, str table,
struct sip_uri *puri, unsigned long flags,
set_alias_f set_alias, void *param)
{
str user_s;
db_key_t db_keys[2];
db_val_t db_vals[2];
db_key_t db_cols[2];
db1_res_t* db_res = NULL;
int i;
if (flags&ALIAS_REVERSE_FLAG)
{
/* revert lookup: user->alias */
db_keys[0] = &user_column;
db_keys[1] = &domain_column;
db_cols[0] = &alias_user_column;
db_cols[1] = &alias_domain_column;
} else {
/* normal lookup: alias->user */
db_keys[0] = &alias_user_column;
db_keys[1] = &alias_domain_column;
db_cols[0] = &user_column;
db_cols[1] = &domain_column;
}
db_vals[0].type = DB1_STR;
db_vals[0].nul = 0;
db_vals[0].val.str_val.s = puri->user.s;
db_vals[0].val.str_val.len = puri->user.len;
if ( flags&ALIAS_DOMAIN_FLAG ) {
db_vals[1].type = DB1_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = puri->host.s;
db_vals[1].val.str_val.len = puri->host.len;
if (domain_prefix.s && domain_prefix.len>0
&& domain_prefix.len<puri->host.len
&& strncasecmp(puri->host.s,domain_prefix.s,
domain_prefix.len)==0)
{
db_vals[1].val.str_val.s += domain_prefix.len;
db_vals[1].val.str_val.len -= domain_prefix.len;
}
}
adbf.use_table(db_handle, &table);
if(adbf.query( db_handle, db_keys, NULL, db_vals, db_cols,
(flags&ALIAS_DOMAIN_FLAG)?2:1 /*no keys*/, 2 /*no cols*/,
NULL, &db_res)!=0 || db_res==NULL)
{
LM_ERR("failed to query database\n");
goto err_server;
}
if (RES_ROW_N(db_res)<=0 || RES_ROWS(db_res)[0].values[0].nul != 0)
{
LM_DBG("no alias found for R-URI\n");
goto err_server;
}
memcpy(useruri_buf, "sip:", 4);
for(i=0; i<RES_ROW_N(db_res); i++)
{
user_s.len = 4;
user_s.s = useruri_buf+4;
switch(RES_ROWS(db_res)[i].values[0].type)
{
case DB1_STRING:
strcpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[0].val.string_val);
user_s.len += strlen(user_s.s);
break;
case DB1_STR:
strncpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[0].val.str_val.s,
RES_ROWS(db_res)[i].values[0].val.str_val.len);
user_s.len += RES_ROWS(db_res)[i].values[0].val.str_val.len;
break;
case DB1_BLOB:
strncpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[0].val.blob_val.s,
RES_ROWS(db_res)[i].values[0].val.blob_val.len);
user_s.len += RES_ROWS(db_res)[i].values[0].val.blob_val.len;
break;
default:
LM_ERR("unknown type of DB user column\n");
goto err_server;
}
/* add the @*/
useruri_buf[user_s.len] = '@';
user_s.len++;
/* add the domain */
user_s.s = useruri_buf+user_s.len;
switch(RES_ROWS(db_res)[i].values[1].type)
{
case DB1_STRING:
strcpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[1].val.string_val);
user_s.len += strlen(user_s.s);
break;
case DB1_STR:
strncpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[1].val.str_val.s,
RES_ROWS(db_res)[i].values[1].val.str_val.len);
user_s.len += RES_ROWS(db_res)[i].values[1].val.str_val.len;
useruri_buf[user_s.len] = '\0';
break;
case DB1_BLOB:
strncpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[1].val.blob_val.s,
RES_ROWS(db_res)[i].values[1].val.blob_val.len);
user_s.len += RES_ROWS(db_res)[i].values[1].val.blob_val.len;
useruri_buf[user_s.len] = '\0';
break;
default:
LM_ERR("unknown type of DB user column\n");
goto err_server;
}
user_s.s = useruri_buf;
/* set the URI */
LM_DBG("new URI [%d] is [%.*s]\n", i, user_s.len ,user_s.s );
if (set_alias(_msg, &user_s, i, param)!=0) {
LM_ERR("error while setting alias\n");
goto err_server;
}
}
/**
* Free the DB result
*/
if (adbf.free_result(db_handle, db_res) < 0) {
LM_DBG("failed to freeing result of query\n");
}
return 1;
err_server:
if (db_res!=NULL) {
if(adbf.free_result(db_handle, db_res) < 0) {
LM_DBG("failed to freeing result of query\n");
}
}
return -1;
}
static int update_pw_dialogs_dbonlymode(subs_t* subs, subs_t** subs_array)
{
db_key_t query_cols[5], db_cols[3];
db_val_t query_vals[5], db_vals[3];
db_key_t result_cols[24];
int n_query_cols=0, n_result_cols=0, n_update_cols=0;
int event_col, pres_uri_col, watcher_user_col, watcher_domain_col;
int r_pres_uri_col,r_to_user_col,r_to_domain_col;
int r_from_user_col,r_from_domain_col,r_callid_col;
int r_to_tag_col,r_from_tag_col,r_sockinfo_col;
int r_event_id_col,r_local_contact_col,r_contact_col;
int r_record_route_col, r_reason_col;
int r_event_col, r_local_cseq_col, r_remote_cseq_col;
int r_status_col, r_version_col;
int r_expires_col, r_watcher_user_col, r_watcher_domain_col;
db1_res_t *result= NULL;
db_val_t *row_vals;
db_row_t *rows;
int nr_rows, loop;
subs_t s, *cs;
str ev_sname;
if(pa_db == NULL)
{
LM_ERR("null database connection\n");
return(-1);
}
if (pa_dbf.use_table(pa_db, &active_watchers_table) < 0)
{
LM_ERR("use table failed\n");
return(-1);
}
query_cols[event_col=n_query_cols]= &str_event_col;
query_vals[event_col].nul= 0;
query_vals[event_col].type= DB1_STR;
query_vals[event_col].val.str_val= subs->event->name ;
n_query_cols++;
query_cols[pres_uri_col=n_query_cols]= &str_presentity_uri_col;
query_vals[pres_uri_col].nul= 0;
query_vals[pres_uri_col].type= DB1_STR;
query_vals[pres_uri_col].val.str_val= subs->pres_uri;
n_query_cols++;
query_cols[watcher_user_col=n_query_cols]= &str_watcher_username_col;
query_vals[watcher_user_col].nul= 0;
query_vals[watcher_user_col].type= DB1_STR;
query_vals[watcher_user_col].val.str_val= subs->watcher_user;
n_query_cols++;
query_cols[watcher_domain_col=n_query_cols]= &str_watcher_domain_col;
query_vals[watcher_domain_col].nul= 0;
query_vals[watcher_domain_col].type= DB1_STR;
query_vals[watcher_domain_col].val.str_val= subs->watcher_domain;
n_query_cols++;
result_cols[r_to_user_col=n_result_cols++] = &str_to_user_col;
result_cols[r_to_domain_col=n_result_cols++] = &str_to_domain_col;
result_cols[r_from_user_col=n_result_cols++] = &str_from_user_col;
result_cols[r_from_domain_col=n_result_cols++] = &str_from_domain_col;
result_cols[r_watcher_user_col=n_result_cols++] = &str_watcher_username_col;
result_cols[r_watcher_domain_col=n_result_cols++] = &str_watcher_domain_col;
result_cols[r_callid_col=n_result_cols++] = &str_callid_col;
result_cols[r_to_tag_col=n_result_cols++] = &str_to_tag_col;
result_cols[r_from_tag_col=n_result_cols++] = &str_from_tag_col;
result_cols[r_sockinfo_col=n_result_cols++] = &str_socket_info_col;
result_cols[r_event_id_col=n_result_cols++] = &str_event_id_col;
result_cols[r_local_contact_col=n_result_cols++] = &str_local_contact_col;
result_cols[r_record_route_col=n_result_cols++] = &str_record_route_col;
result_cols[r_reason_col=n_result_cols++] = &str_reason_col;
result_cols[r_local_cseq_col=n_result_cols++] = &str_local_cseq_col;
result_cols[r_version_col=n_result_cols++] = &str_version_col;
result_cols[r_expires_col=n_result_cols++] = &str_expires_col;
result_cols[r_event_col=n_result_cols++] = &str_event_col;
result_cols[r_pres_uri_col=n_result_cols++] = &str_presentity_uri_col;
result_cols[r_contact_col=n_result_cols++] = &str_contact_col;
/* these ones are unused for some reason !!! */
result_cols[r_remote_cseq_col=n_result_cols++] = &str_remote_cseq_col;
result_cols[r_status_col=n_result_cols++] = &str_status_col;
/*********************************************/
if(pa_dbf.query(pa_db, query_cols, 0, query_vals, result_cols,
n_query_cols, n_result_cols, 0, &result )< 0)
{
LM_ERR("Can't query db\n");
if(result) pa_dbf.free_result(pa_db, result);
return(-1);
}
if(result == NULL) return(-1);
nr_rows = RES_ROW_N(result);
LM_DBG("found %d matching dialogs\n", nr_rows);
if (nr_rows <= 0)
{
pa_dbf.free_result(pa_db, result);
return 0;
}
rows = RES_ROWS(result);
/* get the results and fill in return data structure */
for (loop=0; loop <nr_rows; loop++)
{
row_vals = ROW_VALUES(&rows[loop]);
memset(&s, 0, sizeof(subs_t));
s.status= subs->status;
s.reason.s= subs->reason.s;
s.reason.len= s.reason.s?strlen(s.reason.s):0; //>>>>>>>>>>
s.pres_uri.s= (char*)row_vals[r_pres_uri_col].val.string_val;
s.pres_uri.len= s.pres_uri.s?strlen(s.pres_uri.s):0;
s.to_user.s= (char*)row_vals[r_to_user_col].val.string_val;
s.to_user.len= s.to_user.s?strlen(s.to_user.s):0;
s.to_domain.s= (char*)row_vals[r_to_domain_col].val.string_val;
s.to_domain.len= s.to_domain.s?strlen(s.to_domain.s):0;
s.from_user.s= (char*)row_vals[r_from_user_col].val.string_val;
s.from_user.len= s.from_user.s?strlen(s.from_user.s):0;
s.from_domain.s= (char*)row_vals[r_from_domain_col].val.string_val;
s.from_domain.len= s.from_domain.s?strlen(s.from_domain.s):0;
s.watcher_user.s= (char*)row_vals[r_watcher_user_col].val.string_val;
s.watcher_user.len= s.watcher_user.s?strlen(s.watcher_user.s):0;
s.watcher_domain.s= (char*)row_vals[r_watcher_domain_col].val.string_val;
s.watcher_domain.len= s.watcher_domain.s?strlen(s.watcher_domain.s):0;
s.event_id.s=(char*)row_vals[r_event_id_col].val.string_val;
s.event_id.len= (s.event_id.s)?strlen(s.event_id.s):0;
s.to_tag.s= (char*)row_vals[r_to_tag_col].val.string_val;
s.to_tag.len= s.to_tag.s?strlen(s.to_tag.s):0;
s.from_tag.s= (char*)row_vals[r_from_tag_col].val.string_val;
s.from_tag.len= s.from_tag.s?strlen(s.from_tag.s):0;
s.callid.s= (char*)row_vals[r_callid_col].val.string_val;
s.callid.len= s.callid.s?strlen(s.callid.s):0;
s.record_route.s= (char*)row_vals[r_record_route_col].val.string_val;
s.record_route.len= (s.record_route.s)?strlen(s.record_route.s):0;
s.contact.s= (char*)row_vals[r_contact_col].val.string_val;
s.contact.len= s.contact.s?strlen(s.contact.s):0;
s.sockinfo_str.s = (char*)row_vals[r_sockinfo_col].val.string_val;
s.sockinfo_str.len = s.sockinfo_str.s?strlen(s.sockinfo_str.s):0;
s.local_contact.s = (char*)row_vals[r_local_contact_col].val.string_val;
s.local_contact.len = s.local_contact.s?strlen(s.local_contact.s):0;
ev_sname.s= (char*)row_vals[r_event_col].val.string_val;
ev_sname.len= ev_sname.s?strlen(ev_sname.s):0;
s.event = contains_event(&ev_sname, NULL);
if(s.event == NULL)
{
LM_ERR("event not found and set to NULL\n");
}
s.local_cseq = row_vals[r_local_cseq_col].val.int_val;
s.expires = row_vals[r_expires_col].val.int_val;
if( s.expires > (int)time(NULL) + expires_offset)
s.expires -= (int)time(NULL);
else
s.expires = 0;
s.version = row_vals[r_version_col].val.int_val;
cs = mem_copy_subs(&s, PKG_MEM_TYPE);
if (cs == NULL)
{
LM_ERR("while copying subs_t structure\n");
/* tidy up and return */
pa_dbf.free_result(pa_db, result);
return(-1);
}
cs->local_cseq++;
cs->next= (*subs_array);
(*subs_array)= cs;
printf_subs(cs);
}
pa_dbf.free_result(pa_db, result);
if (pres_notifier_processes == 0 && subs->status == TERMINATED_STATUS)
{
/* delete the records */
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);
}
/* otherwise we update the records */
db_cols[n_update_cols] = &str_status_col;
db_vals[n_update_cols].type = DB1_INT;
db_vals[n_update_cols].nul = 0;
db_vals[n_update_cols].val.int_val = subs->status;
n_update_cols++;
db_cols[n_update_cols] = &str_reason_col;
db_vals[n_update_cols].type = DB1_STR;
db_vals[n_update_cols].nul = 0;
db_vals[n_update_cols].val.str_val= subs->reason;
n_update_cols++;
db_cols[n_update_cols] = &str_updated_col;
db_vals[n_update_cols].type = DB1_INT;
db_vals[n_update_cols].nul = 0;
if (subs->callid.len == 0 || subs->from_tag.len == 0)
{
db_vals[n_update_cols].val.int_val = (int) ((rand() / (RAND_MAX + 1.0)) *
(pres_waitn_time * pres_notifier_poll_rate
* pres_notifier_processes));
} else {
db_vals[n_update_cols].val.int_val =
core_case_hash(&subs->callid, &subs->from_tag, 0) %
(pres_waitn_time * pres_notifier_poll_rate
* pres_notifier_processes);
}
n_update_cols++;
if(pa_dbf.update(pa_db, query_cols, 0, query_vals,
db_cols,db_vals,n_query_cols,n_update_cols) < 0)
{
LM_ERR("DB update failed\n");
return(-1);
}
return(0);
}
/**
* the initiating function
*/
int add_from_db(void)
{
imc_member_p member = NULL;
int i, j, flag;
db_key_t mq_result_cols[4], mquery_cols[2];
db_key_t rq_result_cols[4];
db_val_t mquery_vals[2];
db1_res_t *r_res= NULL;
db1_res_t *m_res= NULL;
db_row_t *m_row = NULL, *r_row = NULL;
db_val_t *m_row_vals, *r_row_vals = NULL;
str name, domain;
imc_room_p room = NULL;
int er_ret = -1;
rq_result_cols[0] = &imc_col_name;
rq_result_cols[1] = &imc_col_domain;
rq_result_cols[2] = &imc_col_flag;
mq_result_cols[0] = &imc_col_username;
mq_result_cols[1] = &imc_col_domain;
mq_result_cols[2] = &imc_col_flag;
mquery_cols[0] = &imc_col_room;
mquery_vals[0].type = DB1_STR;
mquery_vals[0].nul = 0;
if(imc_dbf.use_table(imc_db, &rooms_table)< 0)
{
LM_ERR("use_table failed\n");
return -1;
}
if(imc_dbf.query(imc_db,0, 0, 0, rq_result_cols,0, 3, 0,&r_res)< 0)
{
LM_ERR("failed to querry table\n");
return -1;
}
if(r_res==NULL || r_res->n<=0)
{
LM_INFO("the query returned no result\n");
if(r_res) imc_dbf.free_result(imc_db, r_res);
r_res = NULL;
return 0;
}
LM_DBG("found %d rooms\n", r_res->n);
for(i =0 ; i< r_res->n ; i++)
{
/*add rooms*/
r_row = &r_res->rows[i];
r_row_vals = ROW_VALUES(r_row);
name.s = r_row_vals[0].val.str_val.s;
name.len = strlen(name.s);
domain.s = r_row_vals[1].val.str_val.s;
domain.len = strlen(domain.s);
flag = r_row_vals[2].val.int_val;
room = imc_add_room(&name, &domain, flag);
if(room == NULL)
{
LM_ERR("failed to add room\n ");
goto error;
}
/* add members */
if(imc_dbf.use_table(imc_db, &members_table)< 0)
{
LM_ERR("use_table failed\n ");
goto error;
}
mquery_vals[0].val.str_val= room->uri;
if(imc_dbf.query(imc_db, mquery_cols, 0, mquery_vals, mq_result_cols,
1, 3, 0, &m_res)< 0)
{
LM_ERR("failed to querry table\n");
goto error;
}
if(m_res==NULL || m_res->n<=0)
{
LM_INFO("the query returned no result\n");
er_ret = 0;
goto error; /* each room must have at least one member*/
}
for(j =0; j< m_res->n; j++)
{
m_row = &m_res->rows[j];
m_row_vals = ROW_VALUES(m_row);
name.s = m_row_vals[0].val.str_val.s;
name.len = strlen(name.s);
domain.s = m_row_vals[1].val.str_val.s;
domain.len = strlen(domain.s);
flag = m_row_vals[2].val.int_val;
LM_DBG("adding memeber: [name]=%.*s [domain]=%.*s"
" in [room]= %.*s\n",name.len, name.s, domain.len,domain.s,
room->uri.len, room->uri.s);
member = imc_add_member(room, &name, &domain, flag);
if(member == NULL)
{
LM_ERR("failed to adding member\n ");
goto error;
}
imc_release_room(room);
}
if(m_res)
{
imc_dbf.free_result(imc_db, m_res);
m_res = NULL;
}
}
if(imc_dbf.use_table(imc_db, &members_table)< 0)
{
LM_ERR("use table failed\n ");
goto error;
}
if(imc_dbf.delete(imc_db, 0, 0 , 0, 0) < 0)
{
LM_ERR("failed to delete information from db\n");
goto error;
}
if(imc_dbf.use_table(imc_db, &rooms_table)< 0)
{
LM_ERR("use table failed\n ");
goto error;
}
if(imc_dbf.delete(imc_db, 0, 0 , 0, 0) < 0)
{
LM_ERR("failed to delete information from db\n");
goto error;
}
if(r_res)
{
imc_dbf.free_result(imc_db, r_res);
r_res = NULL;
}
return 0;
error:
if(r_res)
{
imc_dbf.free_result(imc_db, r_res);
r_res = NULL;
}
if(m_res)
{
imc_dbf.free_result(imc_db, m_res);
m_res = NULL;
}
if(room)
imc_release_room(room);
return er_ret;
}
/*load rules from DB*/
int dp_load_db(void)
{
int i, nr_rows;
db1_res_t * res = 0;
db_val_t * values;
db_row_t * rows;
db_key_t query_cols[DP_TABLE_COL_NO] = {
&dpid_column, &pr_column,
&match_op_column, &match_exp_column, &match_len_column,
&subst_exp_column, &repl_exp_column, &attrs_column };
db_key_t order = &pr_column;
dpl_node_t *rule;
LM_DBG("init\n");
if( (*crt_idx) != (*next_idx)){
LM_WARN("a load command already generated, aborting reload...\n");
return 0;
}
if (dp_dbf.use_table(dp_db_handle, &dp_table_name) < 0){
LM_ERR("error in use_table %.*s\n", dp_table_name.len, dp_table_name.s);
return -1;
}
if (DB_CAPABILITY(dp_dbf, DB_CAP_FETCH)) {
if(dp_dbf.query(dp_db_handle,0,0,0,query_cols, 0,
DP_TABLE_COL_NO, order, 0) < 0){
LM_ERR("failed to query database!\n");
return -1;
}
if(dp_dbf.fetch_result(dp_db_handle, &res, dp_fetch_rows)<0) {
LM_ERR("failed to fetch\n");
if (res)
dp_dbf.free_result(dp_db_handle, res);
return -1;
}
} else {
/*select the whole table and all the columns*/
if(dp_dbf.query(dp_db_handle,0,0,0,query_cols, 0,
DP_TABLE_COL_NO, order, &res) < 0){
LM_ERR("failed to query database\n");
return -1;
}
}
nr_rows = RES_ROW_N(res);
*next_idx = ((*crt_idx) == 0)? 1:0;
destroy_hash(*next_idx);
if(nr_rows == 0){
LM_WARN("no data in the db\n");
goto end;
}
do {
for(i=0; i<RES_ROW_N(res); i++){
rows = RES_ROWS(res);
values = ROW_VALUES(rows+i);
if((rule = build_rule(values)) ==0 )
goto err2;
if(add_rule2hash(rule , *next_idx) != 0)
goto err2;
}
if (DB_CAPABILITY(dp_dbf, DB_CAP_FETCH)) {
if(dp_dbf.fetch_result(dp_db_handle, &res, dp_fetch_rows)<0) {
LM_ERR("failure while fetching!\n");
if (res)
dp_dbf.free_result(dp_db_handle, res);
return -1;
}
} else {
break;
}
} while(RES_ROW_N(res)>0);
end:
/*update data*/
*crt_idx = *next_idx;
list_hash(*crt_idx);
dp_dbf.free_result(dp_db_handle, res);
return 0;
err2:
if(rule) destroy_rule(rule);
destroy_hash(*next_idx);
dp_dbf.free_result(dp_db_handle, res);
*next_idx = *crt_idx;
return -1;
}
/*
* Check if domain is local
*/
int is_domain_local(struct sip_msg *msg, str* _host, char *pvar)
{
pv_spec_t *pv = (pv_spec_t *)pvar;
pv_value_t val;
db_val_t *values;
if (db_mode == 0) {
db_key_t keys[1];
db_val_t vals[1];
db_key_t cols[2];
db_res_t* res = NULL;
keys[0] = &domain_col;
cols[0] = &domain_col;
cols[1] = &domain_attrs_col;
if (domain_dbf.use_table(db_handle, &domain_table) < 0) {
LM_ERR("Error while trying to use domain table\n");
return -3;
}
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, 2, 0, &res) < 0
) {
LM_ERR("Error while querying database\n");
return -3;
}
if (RES_ROW_N(res) == 0) {
LM_DBG("Realm '%.*s' is not local\n",
_host->len, ZSW(_host->s));
domain_dbf.free_result(db_handle, res);
return -1;
} else {
LM_DBG("Realm '%.*s' is local\n",
_host->len, ZSW(_host->s));
if (pvar) {
/* XXX: what shall we do if there are duplicate entries? */
/* we only check the first row - razvanc */
values = ROW_VALUES(RES_ROWS(res));
if (!VAL_NULL(values +1)) {
if (VAL_TYPE(values + 1) == DB_STR) {
val.rs = VAL_STR(values + 1);
} else {
val.rs.s = (char *)VAL_STRING(values + 1);
val.rs.len = strlen(val.rs.s);
}
val.flags = PV_VAL_STR;
if (pv_set_value(msg, pv, 0, &val) != 0)
LM_ERR("Cannot set attributes value\n");
}
}
domain_dbf.free_result(db_handle, res);
return 1;
}
} else {
return hash_table_lookup (msg, _host, pv);
}
}
/**
* Loads the routing data from the database given in global
* variable db_url and stores it in routing tree rd.
*
* @param rd Pointer to the route data tree where the routing data
* shall be loaded into
*
* @return 0 means ok, -1 means an error occured
*
*/
int load_route_data(struct rewrite_data * rd) {
db_res_t * res = NULL;
db_row_t * row = NULL;
int i, ret;
int carrier_count = 0;
struct carrier * carriers = NULL, * tmp = NULL;
static str query_str;
str tmp_carrier;
str tmp_domain;
str tmp_scan_prefix;
str tmp_rewrite_host;
str tmp_rewrite_prefix;
str tmp_rewrite_suffix;
str tmp_host_name;
str tmp_reply_code;
str tmp_next_domain;
str tmp_comment;
int no_rows=10;
if( (strlen("SELECT DISTINCT FROM WHERE = ")
+ db_table.len + columns[COL_DOMAIN]->len
+ columns[COL_CARRIER]->len + 20) > QUERY_LEN) {
LM_ERR("query too long\n");
return -1;
}
if((carrier_count = store_carriers(&carriers)) <= 0){
LM_ERR("error while retrieving carriers\n");
goto errout;
}
if ((rd->carriers = shm_malloc(sizeof(struct carrier_tree *) * carrier_count)) == NULL) {
LM_ERR("out of shared memory\n");
goto errout;
}
memset(rd->carriers, 0, sizeof(struct carrier_tree *) * carrier_count);
rd->tree_num = carrier_count;
tmp = carriers;
for (i=0; i<carrier_count; i++) {
memset(query, 0, QUERY_LEN);
ret = snprintf(query, QUERY_LEN, "SELECT DISTINCT %.*s FROM %.*s WHERE %.*s=%i",
columns[COL_DOMAIN]->len, columns[COL_DOMAIN]->s, db_table.len, db_table.s,
columns[COL_CARRIER]->len, columns[COL_CARRIER]->s, tmp->id);
if (ret < 0) {
LM_ERR("error in snprintf");
goto errout;
}
query_str.s = query;
query_str.len = ret;
if (dbf.raw_query(dbh, &query_str, &res) < 0) {
LM_ERR("Failed to query database.\n");
goto errout;
}
LM_INFO("name %s, id %i, trees: %i\n", tmp->name, tmp->id, RES_ROW_N(res));
tmp_carrier.s=tmp->name;
tmp_carrier.len=strlen(tmp_carrier.s);
if (add_carrier_tree(&tmp_carrier, tmp->id, rd, RES_ROW_N(res)) == NULL) {
LM_ERR("can't add carrier %s\n", tmp->name);
goto errout;
}
dbf.free_result(dbh, res);
res = NULL;
tmp = tmp->next;
}
if (dbf.use_table(dbh, &db_table) < 0) {
LM_ERR("Cannot set database table '%.*s'.\n", db_table.len, db_table.s);
return -1;
}
if (DB_CAPABILITY(dbf, DB_CAP_FETCH)) {
if (dbf.query(dbh, NULL, NULL, NULL, (db_key_t *) columns, 0, COLUMN_NUM, NULL, NULL) < 0) {
LM_ERR("Failed to query database to prepare fetchrow.\n");
return -1;
}
no_rows = estimate_available_rows( 4+64+64+64+4+4+4+64+4+64+64+128,
COLUMN_NUM);
if (no_rows==0) no_rows = 10;
if(dbf.fetch_result(dbh, &res, no_rows) < 0) {
LM_ERR("Fetching rows failed\n");
return -1;
}
} else {
if (dbf.query(dbh, NULL, NULL, NULL, (db_key_t *)columns, 0, COLUMN_NUM, NULL, &res) < 0) {
LM_ERR("Failed to query database.\n");
return -1;
}
}
int n = 0;
do {
LM_DBG("loading, cycle %d", n++);
for (i = 0; i < RES_ROW_N(res); ++i) {
row = &RES_ROWS(res)[i];
tmp_domain.s=(char *)row->values[COL_DOMAIN].val.string_val;
tmp_scan_prefix.s=(char *)row->values[COL_SCAN_PREFIX].val.string_val;
tmp_rewrite_host.s=(char *)row->values[COL_REWRITE_HOST].val.string_val;
tmp_rewrite_prefix.s=(char *)row->values[COL_REWRITE_PREFIX].val.string_val;
tmp_rewrite_suffix.s=(char *)row->values[COL_REWRITE_SUFFIX].val.string_val;
tmp_comment.s=(char *)row->values[COL_COMMENT].val.string_val;
if (tmp_domain.s==NULL) tmp_domain.s="";
if (tmp_scan_prefix.s==NULL) tmp_scan_prefix.s="";
if (tmp_rewrite_host.s==NULL) tmp_rewrite_host.s="";
if (tmp_rewrite_prefix.s==NULL) tmp_rewrite_prefix.s="";
if (tmp_rewrite_suffix.s==NULL) tmp_rewrite_suffix.s="";
if (tmp_comment.s==NULL) tmp_comment.s="";
tmp_domain.len=strlen(tmp_domain.s);
tmp_scan_prefix.len=strlen(tmp_scan_prefix.s);
tmp_rewrite_host.len=strlen(tmp_rewrite_host.s);
tmp_rewrite_prefix.len=strlen(tmp_rewrite_prefix.s);
tmp_rewrite_suffix.len=strlen(tmp_rewrite_suffix.s);
tmp_comment.len=strlen(tmp_comment.s);
if (add_route(rd,
row->values[COL_CARRIER].val.int_val,
&tmp_domain,
&tmp_scan_prefix,
row->values[COL_FLAGS].val.int_val,
row->values[COL_MASK].val.int_val,
0,
row->values[COL_PROB].val.double_val,
&tmp_rewrite_host,
row->values[COL_STRIP].val.int_val,
&tmp_rewrite_prefix,
&tmp_rewrite_suffix,
1,
0,
-1,
NULL,
&tmp_comment) == -1) {
goto errout;
}
}
if (DB_CAPABILITY(dbf, DB_CAP_FETCH)) {
if(dbf.fetch_result(dbh, &res, no_rows) < 0) {
LM_ERR("fetching rows failed\n");
dbf.free_result(dbh, res);
return -1;
}
} else {
break;
}
} while(RES_ROW_N(res) > 0);
dbf.free_result(dbh, res);
res = NULL;
if (dbf.use_table(dbh, &db_failure_table) < 0) {
LM_ERR("cannot set database table '%.*s'.\n",
db_failure_table.len, db_failure_table.s);
return -1;
}
if (dbf.query(dbh, NULL, NULL, NULL, (db_key_t *)failure_columns, 0,
FAILURE_COLUMN_NUM, NULL, &res) < 0) {
LM_ERR("failed to query database.\n");
return -1;
}
for (i = 0; i < RES_ROW_N(res); ++i) {
row = &RES_ROWS(res)[i];
tmp_domain.s=(char *)row->values[FCOL_DOMAIN].val.string_val;
tmp_scan_prefix.s=(char *)row->values[FCOL_SCAN_PREFIX].val.string_val;
tmp_host_name.s=(char *)row->values[FCOL_HOST_NAME].val.string_val;
tmp_reply_code.s=(char *)row->values[FCOL_REPLY_CODE].val.string_val;
tmp_next_domain.s=(char *)row->values[FCOL_NEXT_DOMAIN].val.string_val;
tmp_comment.s=(char *)row->values[FCOL_COMMENT].val.string_val;
if (tmp_domain.s==NULL) tmp_domain.s="";
if (tmp_scan_prefix.s==NULL) tmp_scan_prefix.s="";
if (tmp_host_name.s==NULL) tmp_host_name.s="";
if (tmp_reply_code.s==NULL) tmp_reply_code.s="";
if (tmp_next_domain.s==NULL) tmp_next_domain.s="";
if (tmp_comment.s==NULL) tmp_comment.s="";
tmp_domain.len=strlen(tmp_domain.s);
tmp_scan_prefix.len=strlen(tmp_scan_prefix.s);
tmp_host_name.len=strlen(tmp_host_name.s);
tmp_reply_code.len=strlen(tmp_reply_code.s);
tmp_next_domain.len=strlen(tmp_next_domain.s);
tmp_comment.len=strlen(tmp_comment.s);
if (add_failure_route(rd,
row->values[FCOL_CARRIER].val.int_val,
&tmp_domain,
&tmp_scan_prefix,
&tmp_host_name,
&tmp_reply_code,
row->values[FCOL_FLAGS].val.int_val,
row->values[FCOL_MASK].val.int_val,
&tmp_next_domain,
&tmp_comment) == -1) {
goto errout;
}
}
destroy_carriers(carriers);
dbf.free_result(dbh, res);
return 0;
errout:
destroy_carriers(carriers);
if (res) {
dbf.free_result(dbh, res);
}
return -1;
}
static int load_dialog_info_from_db(int dlg_hash_size)
{
db_res_t * res;
db_val_t * values;
db_row_t * rows;
int i, nr_rows;
struct dlg_cell *dlg;
str callid, from_uri, to_uri, from_tag, to_tag;
str cseq1,cseq2,contact1,contact2,rroute1,rroute2,mangled_fu,mangled_tu;
unsigned int next_id;
int no_rows = 10;
struct socket_info *caller_sock,*callee_sock;
res = 0;
if((nr_rows = select_entire_dialog_table(&res,&no_rows)) < 0)
goto end;
nr_rows = RES_ROW_N(res);
do {
LM_DBG("loading information from database for %i dialogs\n", nr_rows);
rows = RES_ROWS(res);
/* for every row---dialog */
for(i=0; i<nr_rows; i++){
values = ROW_VALUES(rows + i);
if (VAL_NULL(values) || VAL_NULL(values+1)) {
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
h_entry_column.len, h_entry_column.s,
h_id_column.len, h_id_column.s);
continue;
}
if (VAL_NULL(values+7) || VAL_NULL(values+8)) {
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
start_time_column.len, start_time_column.s,
state_column.len, state_column.s);
continue;
}
if ( VAL_INT(values+8) == DLG_STATE_DELETED ) {
LM_DBG("dialog already terminated -> skipping\n");
continue;
}
caller_sock = create_socket_info(values, 16);
callee_sock = create_socket_info(values, 17);
if (caller_sock == NULL || callee_sock == NULL) {
LM_ERR("Dialog in DB doesn't match any listening sockets");
continue;
}
/*restore the dialog info*/
GET_STR_VALUE(callid, values, 2, 1, 0);
GET_STR_VALUE(from_uri, values, 3, 1, 0);
GET_STR_VALUE(from_tag, values, 4, 1, 0);
GET_STR_VALUE(to_uri, values, 5, 1, 0);
if((dlg=build_new_dlg(&callid, &from_uri, &to_uri, &from_tag))==0){
LM_ERR("failed to build new dialog\n");
goto error;
}
if(dlg->h_entry != VAL_INT(values)){
LM_ERR("inconsistent hash data in the dialog database: "
"you may have restarted opensips using a different "
"hash_size: please erase %.*s database and restart\n",
dialog_table_name.len, dialog_table_name.s);
shm_free(dlg);
goto error;
}
/*link the dialog*/
link_dlg(dlg, 0);
dlg->h_id = VAL_INT(values+1);
next_id = d_table->entries[dlg->h_entry].next_id;
d_table->entries[dlg->h_entry].next_id =
(next_id < dlg->h_id) ? (dlg->h_id+1) : next_id;
GET_STR_VALUE(to_tag, values, 6, 1, 1);
dlg->start_ts = VAL_INT(values+7);
dlg->state = VAL_INT(values+8);
if (dlg->state==DLG_STATE_CONFIRMED_NA ||
dlg->state==DLG_STATE_CONFIRMED) {
active_dlgs_cnt++;
} else if (dlg->state==DLG_STATE_EARLY) {
early_dlgs_cnt++;
}
GET_STR_VALUE(cseq1, values, 10 , 1, 1);
GET_STR_VALUE(cseq2, values, 11 , 1, 1);
GET_STR_VALUE(rroute1, values, 12, 0, 0);
GET_STR_VALUE(rroute2, values, 13, 0, 0);
GET_STR_VALUE(contact1, values, 14, 0, 1);
GET_STR_VALUE(contact2, values, 15, 0, 1);
GET_STR_VALUE(mangled_fu, values, 24,0,1);
GET_STR_VALUE(mangled_tu, values, 25,0,1);
/* add the 2 legs */
if ( (dlg_add_leg_info( dlg, &from_tag, &rroute1, &contact1,
&cseq1, caller_sock,0,0)!=0) ||
(dlg_add_leg_info( dlg, &to_tag, &rroute2, &contact2,
&cseq2, callee_sock,&mangled_fu,&mangled_tu)!=0) ) {
LM_ERR("dlg_set_leg_info failed\n");
/* destroy the dialog */
unref_dlg(dlg,1);
continue;
}
dlg->legs_no[DLG_LEG_200OK] = DLG_FIRST_CALLEE_LEG;
/* script variables */
if (!VAL_NULL(values+18))
read_dialog_vars( VAL_STR(values+18).s,
VAL_STR(values+18).len, dlg);
/* profiles */
if (!VAL_NULL(values+19))
read_dialog_profiles( VAL_STR(values+19).s,
strlen(VAL_STR(values+19).s), dlg,0);
/* script flags */
if (!VAL_NULL(values+20)) {
dlg->user_flags = VAL_INT(values+20);
}
/* top hiding */
dlg->flags = VAL_INT(values+23);
if (dlg_db_mode==DB_MODE_SHUTDOWN)
dlg->flags |= DLG_FLAG_NEW;
/* calculcate timeout */
dlg->tl.timeout = (unsigned int)(VAL_INT(values+9)) + get_ticks();
if (dlg->tl.timeout<=(unsigned int)time(0))
dlg->tl.timeout = 0;
else
dlg->tl.timeout -= (unsigned int)time(0);
/* restore the timer values */
if (0 != insert_dlg_timer( &(dlg->tl), (int)dlg->tl.timeout )) {
LM_CRIT("Unable to insert dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
/* destroy the dialog */
unref_dlg(dlg,1);
continue;
}
/* reference the dialog as kept in the timer list */
ref_dlg(dlg,1);
LM_DBG("current dialog timeout is %u\n", dlg->tl.timeout);
dlg->lifetime = 0;
dlg->legs[DLG_CALLER_LEG].last_gen_cseq =
(unsigned int)(VAL_INT(values+21));
dlg->legs[callee_idx(dlg)].last_gen_cseq =
(unsigned int)(VAL_INT(values+22));
if (dlg->flags & DLG_FLAG_PING_CALLER || dlg->flags & DLG_FLAG_PING_CALLEE) {
if (0 != insert_ping_timer(dlg))
LM_CRIT("Unable to insert dlg %p into ping timer\n",dlg);
else {
/* reference dialog as kept in ping timer list */
ref_dlg(dlg,1);
}
}
next_dialog:
;
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(dialog_dbf, DB_CAP_FETCH)) {
if (dialog_dbf.fetch_result( dialog_db_handle, &res,no_rows) < 0) {
LM_ERR("fetching more rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(res);
} else {
nr_rows = 0;
}
}while (nr_rows>0);
end:
dialog_dbf.free_result(dialog_db_handle, res);
return 0;
error:
dialog_dbf.free_result(dialog_db_handle, res);
return -1;
}
int update_watchers_status(str pres_uri, pres_ev_t* ev, str* rules_doc)
{
subs_t subs;
db_key_t query_cols[6], result_cols[5];
db_val_t query_vals[6];
int n_result_cols= 0, n_query_cols = 0;
db1_res_t* result= NULL;
db_row_t *row;
db_val_t *row_vals ;
int i;
str w_user, w_domain, reason= {0, 0};
unsigned int status;
int status_col, w_user_col, w_domain_col, reason_col;
subs_t* subs_array= NULL,* s;
unsigned int hash_code;
int err_ret= -1;
int n= 0;
typedef struct ws
{
int status;
str reason;
str w_user;
str w_domain;
}ws_t;
ws_t* ws_list= NULL;
LM_DBG("start\n");
if(ev->content_type.s== NULL)
{
ev= contains_event(&ev->name, NULL);
if(ev== NULL)
{
LM_ERR("wrong event parameter\n");
return 0;
}
}
memset(&subs, 0, sizeof(subs_t));
subs.pres_uri= pres_uri;
subs.event= ev;
subs.auth_rules_doc= rules_doc;
/* update in watchers_table */
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= pres_uri;
n_query_cols++;
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= ev->name;
n_query_cols++;
result_cols[status_col= n_result_cols++]= &str_status_col;
result_cols[reason_col= n_result_cols++]= &str_reason_col;
result_cols[w_user_col= n_result_cols++]= &str_watcher_username_col;
result_cols[w_domain_col= n_result_cols++]= &str_watcher_domain_col;
if (pa_dbf.use_table(pa_db, &watchers_table) < 0)
{
LM_ERR( "in use_table\n");
goto done;
}
if(pa_dbf.query(pa_db, query_cols, 0, query_vals, result_cols,n_query_cols,
n_result_cols, 0, &result)< 0)
{
LM_ERR( "in sql query\n");
goto done;
}
if(result== NULL)
return 0;
if(result->n<= 0)
{
err_ret= 0;
goto done;
}
LM_DBG("found %d record-uri in watchers_table\n", result->n);
hash_code= core_case_hash(&pres_uri, &ev->name, shtable_size);
subs.db_flag= hash_code;
/*must do a copy as sphere_check requires database queries */
if(sphere_enable)
{
n= result->n;
ws_list= (ws_t*)pkg_malloc(n * sizeof(ws_t));
if(ws_list== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memset(ws_list, 0, n * sizeof(ws_t));
for(i= 0; i< result->n ; i++)
{
row= &result->rows[i];
row_vals = ROW_VALUES(row);
status= row_vals[status_col].val.int_val;
reason.s= (char*)row_vals[reason_col].val.string_val;
reason.len= reason.s?strlen(reason.s):0;
w_user.s= (char*)row_vals[w_user_col].val.string_val;
w_user.len= strlen(w_user.s);
w_domain.s= (char*)row_vals[w_domain_col].val.string_val;
w_domain.len= strlen(w_domain.s);
if(reason.len)
{
ws_list[i].reason.s = (char*)pkg_malloc(reason.len* sizeof(char));
if(ws_list[i].reason.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].reason.s, reason.s, reason.len);
ws_list[i].reason.len= reason.len;
}
else
ws_list[i].reason.s= NULL;
ws_list[i].w_user.s = (char*)pkg_malloc(w_user.len* sizeof(char));
if(ws_list[i].w_user.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].w_user.s, w_user.s, w_user.len);
ws_list[i].w_user.len= w_user.len;
ws_list[i].w_domain.s = (char*)pkg_malloc(w_domain.len* sizeof(char));
if(ws_list[i].w_domain.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].w_domain.s, w_domain.s, w_domain.len);
ws_list[i].w_domain.len= w_domain.len;
ws_list[i].status= status;
}
pa_dbf.free_result(pa_db, result);
result= NULL;
for(i=0; i< n; i++)
{
subs.watcher_user = ws_list[i].w_user;
subs.watcher_domain = ws_list[i].w_domain;
subs.status = ws_list[i].status;
memset(&subs.reason, 0, sizeof(str));
if( pres_update_status(subs, reason, query_cols, query_vals,
n_query_cols, &subs_array)< 0)
{
LM_ERR("failed to update watcher status\n");
goto done;
}
}
for(i=0; i< n; i++)
{
pkg_free(ws_list[i].w_user.s);
pkg_free(ws_list[i].w_domain.s);
if(ws_list[i].reason.s)
pkg_free(ws_list[i].reason.s);
}
ws_list= NULL;
goto send_notify;
}
for(i = 0; i< result->n; i++)
{
row= &result->rows[i];
row_vals = ROW_VALUES(row);
status= row_vals[status_col].val.int_val;
reason.s= (char*)row_vals[reason_col].val.string_val;
reason.len= reason.s?strlen(reason.s):0;
w_user.s= (char*)row_vals[w_user_col].val.string_val;
w_user.len= strlen(w_user.s);
w_domain.s= (char*)row_vals[w_domain_col].val.string_val;
w_domain.len= strlen(w_domain.s);
subs.watcher_user= w_user;
subs.watcher_domain= w_domain;
subs.status= status;
memset(&subs.reason, 0, sizeof(str));
if( pres_update_status(subs,reason, query_cols, query_vals,
n_query_cols, &subs_array)< 0)
{
LM_ERR("failed to update watcher status\n");
goto done;
}
}
pa_dbf.free_result(pa_db, result);
result= NULL;
send_notify:
if (pres_notifier_processes == 0)
{
s= subs_array;
while(s)
{
if(notify(s, NULL, NULL, 0)< 0)
{
LM_ERR( "sending Notify request\n");
goto done;
}
/* delete from database also */
if(s->status== TERMINATED_STATUS)
{
if(pres_db_delete_status(s)<0)
{
LM_ERR("failed to delete terminated "
"dialog from database\n");
goto done;
}
}
s= s->next;
}
}
free_subs_list(subs_array, PKG_MEM_TYPE, 0);
return 0;
done:
if(result)
pa_dbf.free_result(pa_db, result);
free_subs_list(subs_array, PKG_MEM_TYPE, 0);
if(ws_list)
{
for(i= 0; i< n; i++)
{
if(ws_list[i].w_user.s)
pkg_free(ws_list[i].w_user.s);
else
break;
if(ws_list[i].w_domain.s)
pkg_free(ws_list[i].w_domain.s);
if(ws_list[i].reason.s)
pkg_free(ws_list[i].reason.s);
}
}
return err_ret;
}
static int mt_load_db(m_tree_t *pt)
{
db_key_t db_cols[MT_MAX_COLS] = {&tprefix_column, &tvalue_column};
db_key_t key_cols[1];
db_op_t op[1] = {OP_EQ};
db_val_t vals[1];
str tprefix, tvalue;
db1_res_t* db_res = NULL;
int i, ret, c;
m_tree_t new_tree;
m_tree_t *old_tree = NULL;
mt_node_t *bk_head = NULL;
if(pt->ncols>0) {
for(c=0; c<pt->ncols; c++) {
db_cols[c] = &pt->scols[c];
}
} else {
db_cols[0] = &tprefix_column;
db_cols[1] = &tvalue_column;
c = 2;
}
key_cols[0] = &tname_column;
VAL_TYPE(vals) = DB1_STRING;
VAL_NULL(vals) = 0;
VAL_STRING(vals) = pt->tname.s;
if(db_con==NULL)
{
LM_ERR("no db connection\n");
return -1;
}
old_tree = mt_get_tree(&(pt->tname));
if(old_tree==NULL)
{
LM_ERR("tree definition not found [%.*s]\n", pt->tname.len,
pt->tname.s);
return -1;
}
memcpy(&new_tree, old_tree, sizeof(m_tree_t));
new_tree.head = 0;
new_tree.next = 0;
new_tree.nrnodes = 0;
new_tree.nritems = 0;
new_tree.memsize = 0;
new_tree.reload_count++;
new_tree.reload_time = (unsigned int)time(NULL);
if (mt_dbf.use_table(db_con, &old_tree->dbtable) < 0)
{
LM_ERR("failed to use_table\n");
return -1;
}
if (DB_CAPABILITY(mt_dbf, DB_CAP_FETCH)) {
if(mt_dbf.query(db_con, key_cols, op, vals, db_cols, pt->multi,
c, 0, 0) < 0)
{
LM_ERR("Error while querying db\n");
return -1;
}
if(mt_dbf.fetch_result(db_con, &db_res, mt_fetch_rows)<0)
{
LM_ERR("Error while fetching result\n");
goto error;
} else {
if(RES_ROW_N(db_res)==0)
{
goto dbreloaded;
}
}
} else {
if((ret=mt_dbf.query(db_con, key_cols, op, vals, db_cols,
pt->multi, 2, 0, &db_res))!=0
|| RES_ROW_N(db_res)<=0 )
{
if(ret==0)
{
goto dbreloaded;
} else {
goto error;
}
}
}
if(RES_ROW_N(db_res)>0)
{
if(RES_ROWS(db_res)[0].values[0].type != DB1_STRING
|| RES_ROWS(db_res)[0].values[1].type != DB1_STRING)
{
LM_ERR("wrond column types in db table (%d / %d)\n",
RES_ROWS(db_res)[0].values[0].type,
RES_ROWS(db_res)[0].values[1].type);
goto error;
}
}
do {
for(i=0; i<RES_ROW_N(db_res); i++)
{
/* check for NULL values ?!?! */
tprefix.s = (char*)(RES_ROWS(db_res)[i].values[0].val.string_val);
tprefix.len = strlen(ZSW(tprefix.s));
if(c>2) {
if(mt_pack_values(&new_tree, db_res, i, c, &tvalue)<0) {
LM_ERR("Error packing values\n");
goto error;
}
} else {
tvalue.s = (char*)(RES_ROWS(db_res)[i].values[1].val.string_val);
tvalue.len = strlen(ZSW(tvalue.s));
}
if(tprefix.s==NULL || tvalue.s==NULL
|| tprefix.len<=0 || tvalue.len<=0)
{
LM_ERR("Error - bad record in db"
" (prefix: %p/%d - value: %p/%d)\n",
tprefix.s, tprefix.len, tvalue.s, tvalue.len);
continue;
}
if(mt_add_to_tree(&new_tree, &tprefix, &tvalue)<0)
{
LM_ERR("Error adding info to tree\n");
goto error;
}
}
if (DB_CAPABILITY(mt_dbf, DB_CAP_FETCH)) {
if(mt_dbf.fetch_result(db_con, &db_res, mt_fetch_rows)<0) {
LM_ERR("Error while fetching!\n");
if (db_res)
mt_dbf.free_result(db_con, db_res);
goto error;
}
} else {
break;
}
} while(RES_ROW_N(db_res)>0);
dbreloaded:
mt_dbf.free_result(db_con, db_res);
/* block all readers */
lock_get( mt_lock );
mt_reload_flag = 1;
lock_release( mt_lock );
while (mt_tree_refcnt) {
sleep_us(10);
}
bk_head = old_tree->head;
old_tree->head = new_tree.head;
old_tree->nrnodes = new_tree.nrnodes;
old_tree->nritems = new_tree.nritems;
old_tree->memsize = new_tree.memsize;
old_tree->reload_count = new_tree.reload_count;
old_tree->reload_time = new_tree.reload_time;
mt_reload_flag = 0;
/* free old data */
if (bk_head!=NULL)
mt_free_node(bk_head, new_tree.type);
return 0;
error:
mt_dbf.free_result(db_con, db_res);
if (new_tree.head!=NULL)
mt_free_node(new_tree.head, new_tree.type);
return -1;
}
static int mt_load_db_trees()
{
db_key_t db_cols[3] = {&tname_column, &tprefix_column, &tvalue_column};
str tprefix, tvalue, tname;
db1_res_t* db_res = NULL;
int i, ret;
m_tree_t *new_head = NULL;
m_tree_t *new_tree = NULL;
m_tree_t *old_head = NULL;
if(db_con==NULL)
{
LM_ERR("no db connection\n");
return -1;
}
if (mt_dbf.use_table(db_con, &db_table) < 0)
{
LM_ERR("failed to use_table\n");
return -1;
}
if (DB_CAPABILITY(mt_dbf, DB_CAP_FETCH))
{
if(mt_dbf.query(db_con,0,0,0,db_cols,0,3,&tname_column,0) < 0)
{
LM_ERR("Error while querying db\n");
return -1;
}
if(mt_dbf.fetch_result(db_con, &db_res, mt_fetch_rows)<0)
{
LM_ERR("Error while fetching result\n");
if (db_res)
mt_dbf.free_result(db_con, db_res);
goto error;
} else {
if(RES_ROW_N(db_res)==0)
{
return 0;
}
}
} else {
if((ret=mt_dbf.query(db_con, NULL, NULL, NULL, db_cols,
0, 3, &tname_column, &db_res))!=0
|| RES_ROW_N(db_res)<=0 )
{
mt_dbf.free_result(db_con, db_res);
if( ret==0)
{
return 0;
} else {
goto error;
}
}
}
do {
for(i=0; i<RES_ROW_N(db_res); i++)
{
/* check for NULL values ?!?! */
tname.s = (char*)(RES_ROWS(db_res)[i].values[0].val.string_val);
tname.len = strlen(tname.s);
tprefix.s = (char*)(RES_ROWS(db_res)[i].values[1].val.string_val);
tprefix.len = strlen(tprefix.s);
tvalue.s = (char*)(RES_ROWS(db_res)[i].values[2].val.string_val);
tvalue.len = strlen(tvalue.s);
if(tprefix.s==NULL || tvalue.s==NULL || tname.s==NULL ||
tprefix.len<=0 || tvalue.len<=0 || tname.len<=0)
{
LM_ERR("Error - bad values in db\n");
continue;
}
new_tree = mt_add_tree(&new_head, &tname, &db_table, NULL,
_mt_tree_type, 0);
if(new_tree==NULL)
{
LM_ERR("New tree cannot be initialized\n");
goto error;
}
if(mt_add_to_tree(new_tree, &tprefix, &tvalue)<0)
{
LM_ERR("Error adding info to tree\n");
goto error;
}
}
if (DB_CAPABILITY(mt_dbf, DB_CAP_FETCH)) {
if(mt_dbf.fetch_result(db_con, &db_res, mt_fetch_rows)<0) {
LM_ERR("Error while fetching!\n");
if (db_res)
mt_dbf.free_result(db_con, db_res);
goto error;
}
} else {
break;
}
} while(RES_ROW_N(db_res)>0);
mt_dbf.free_result(db_con, db_res);
/* block all readers */
lock_get( mt_lock );
mt_reload_flag = 1;
lock_release( mt_lock );
while (mt_tree_refcnt) {
sleep_us(10);
}
old_head = mt_swap_list_head(new_head);
mt_reload_flag = 0;
/* free old data */
if (old_head!=NULL)
mt_free_tree(old_head);
return 0;
error:
mt_dbf.free_result(db_con, db_res);
if (new_head!=NULL)
mt_free_tree(new_head);
return -1;
}
int alias_db_lookup(struct sip_msg* _msg, str table_s)
{
str user_s;
db_key_t db_keys[2] = {&alias_user_column, &alias_domain_column};
db_val_t db_vals[2];
db_key_t db_cols[] = {&user_column, &domain_column};
db1_res_t* db_res = NULL;
int i;
if (parse_sip_msg_uri(_msg) < 0)
return -1;
db_vals[0].type = DB1_STR;
db_vals[0].nul = 0;
db_vals[0].val.str_val.s = _msg->parsed_uri.user.s;
db_vals[0].val.str_val.len = _msg->parsed_uri.user.len;
if (use_domain)
{
db_vals[1].type = DB1_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = _msg->parsed_uri.host.s;
db_vals[1].val.str_val.len = _msg->parsed_uri.host.len;
if (domain_prefix.s && domain_prefix.len>0
&& domain_prefix.len<_msg->parsed_uri.host.len
&& strncasecmp(_msg->parsed_uri.host.s,domain_prefix.s,
domain_prefix.len)==0)
{
db_vals[1].val.str_val.s += domain_prefix.len;
db_vals[1].val.str_val.len -= domain_prefix.len;
}
}
adbf.use_table(db_handle, &table_s);
if(adbf.query(db_handle, db_keys, NULL, db_vals, db_cols,
(use_domain)?2:1 /*no keys*/, 2 /*no cols*/, NULL, &db_res)!=0)
{
LM_ERR("failed to query database\n");
goto err_server;
}
if (RES_ROW_N(db_res)<=0 || RES_ROWS(db_res)[0].values[0].nul != 0)
{
LM_DBG("no alias found for R-URI\n");
if (db_res!=NULL && adbf.free_result(db_handle, db_res) < 0)
LM_DBG("failed to freeing result of query\n");
return -1;
}
memcpy(useruri_buf, "sip:", 4);
for(i=0; i<RES_ROW_N(db_res); i++)
{
user_s.len = 4;
user_s.s = useruri_buf+4;
switch(RES_ROWS(db_res)[i].values[0].type)
{
case DB1_STRING:
strcpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[0].val.string_val);
user_s.len += strlen(user_s.s);
break;
case DB1_STR:
strncpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[0].val.str_val.s,
RES_ROWS(db_res)[i].values[0].val.str_val.len);
user_s.len += RES_ROWS(db_res)[i].values[0].val.str_val.len;
break;
case DB1_BLOB:
strncpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[0].val.blob_val.s,
RES_ROWS(db_res)[i].values[0].val.blob_val.len);
user_s.len += RES_ROWS(db_res)[i].values[0].val.blob_val.len;
break;
default:
LM_ERR("unknown type of DB user column\n");
if (db_res != NULL && adbf.free_result(db_handle, db_res) < 0)
{
LM_DBG("failed to freeing result of query\n");
}
goto err_server;
}
/* add the @*/
useruri_buf[user_s.len] = '@';
user_s.len++;
/* add the domain */
user_s.s = useruri_buf+user_s.len;
switch(RES_ROWS(db_res)[i].values[1].type)
{
case DB1_STRING:
strcpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[1].val.string_val);
user_s.len += strlen(user_s.s);
break;
case DB1_STR:
strncpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[1].val.str_val.s,
RES_ROWS(db_res)[i].values[1].val.str_val.len);
user_s.len += RES_ROWS(db_res)[i].values[1].val.str_val.len;
useruri_buf[user_s.len] = '\0';
break;
case DB1_BLOB:
strncpy(user_s.s,
(char*)RES_ROWS(db_res)[i].values[1].val.blob_val.s,
RES_ROWS(db_res)[i].values[1].val.blob_val.len);
user_s.len += RES_ROWS(db_res)[i].values[1].val.blob_val.len;
useruri_buf[user_s.len] = '\0';
break;
default:
LM_ERR("unknown type of DB user column\n");
if (db_res != NULL && adbf.free_result(db_handle, db_res) < 0)
{
LM_DBG("failed to freeing result of query\n");
}
goto err_server;
}
/* set the URI */
LM_DBG("new URI [%d] is [%s]\n", i, useruri_buf);
if(i==0)
{
if(rewrite_ruri(_msg, useruri_buf)<0)
{
LM_ERR("cannot replace the R-URI\n");
goto err_server;
}
if(ald_append_branches==0)
break;
} else {
user_s.s = useruri_buf;
if (append_branch(_msg, &user_s, 0, 0, MIN_Q, 0, 0) == -1)
{
LM_ERR("error while appending branches\n");
goto err_server;
}
}
}
/**
* Free the DB result
*/
if (db_res!=NULL && adbf.free_result(db_handle, db_res) < 0)
LM_DBG("failed to freeing result of query\n");
return 1;
err_server:
if (db_res!=NULL && adbf.free_result(db_handle, db_res) < 0)
LM_DBG("failed to freeing result of query\n");
return -1;
}
/*
* Reload domain table to new hash table and when done, make new hash table
* current one.
*/
int reload_domain_table ( void )
{
db_key_t cols[2];
db_res_t* res = NULL;
db_row_t* row;
db_val_t* val;
struct domain_list **new_hash_table;
int i;
str domain, attrs;
cols[0] = &domain_col;
cols[1] = &domain_attrs_col;
if (domain_dbf.use_table(db_handle, &domain_table) < 0) {
LM_ERR("Error while trying to use domain table\n");
return -3;
}
if (domain_dbf.query(db_handle, NULL, 0, NULL, cols, 0, 2, 0, &res) < 0) {
LM_ERR("Error while querying database\n");
return -3;
}
/* Choose new hash table and free its old contents */
if (*hash_table == hash_table_1) {
hash_table_free(hash_table_2);
new_hash_table = hash_table_2;
} else {
hash_table_free(hash_table_1);
new_hash_table = hash_table_1;
}
row = RES_ROWS(res);
LM_DBG("Number of rows in domain table: %d\n", RES_ROW_N(res));
for (i = 0; i < RES_ROW_N(res); i++) {
val = ROW_VALUES(row + i);
if (VAL_TYPE(val) == DB_STRING) {
domain.s = (char *)VAL_STRING(val);
domain.len = strlen(domain.s);
} else if (VAL_TYPE(val) == DB_STR) {
domain = VAL_STR(val);
} else {
LM_ERR("Database problem on domain column\n");
domain_dbf.free_result(db_handle, res);
return -3;
}
if (VAL_NULL(val + 1)) {
/* add a marker to determine whether the attributes exist or not */
attrs.len = 0;
attrs.s = NULL;
} else if (VAL_TYPE(val + 1) == DB_STRING) {
attrs.s = (char *)VAL_STRING(val + 1);
attrs.len = strlen(attrs.s);
} else if (VAL_TYPE(val + 1) == DB_STR) {
attrs = VAL_STR(val + 1);
} else {
LM_ERR("Database problem on attrs column\n");
domain_dbf.free_result(db_handle, res);
return -3;
}
LM_DBG("Value: %s inserted into domain hash table\n",VAL_STRING(val));
if (hash_table_install(new_hash_table, &domain, &attrs)==-1){
LM_ERR("Hash table problem\n");
domain_dbf.free_result(db_handle, res);
return -3;
}
}
domain_dbf.free_result(db_handle, res);
*hash_table = new_hash_table;
return 1;
}
/*
* input: rule straight from the DDDS + avp-stack.
*
* output: adds found rules to the stack and return
* 1 on success
* 0 on failure
*/
static int check_rule(str *rule, char *service, int service_len, struct avp_stack *stack) {
/* for the select */
db_key_t keys[2];
db_val_t vals[2];
db_key_t cols[4];
db1_res_t* res;
db_row_t* row;
db_val_t* val;
int i;
char *type;
int type_len;
LM_INFO("checking for '%.*s'.\n", rule->len, ZSW(rule->s));
if ((service_len != 11) || (strncasecmp("d2p+sip:fed", service, 11) &&
strncasecmp("d2p+sip:std", service, 11) && strncasecmp("d2p+sip:dom", service, 11))) {
LM_ERR("can only cope with d2p+sip:fed, d2p+sip:std,and d2p+sip:dom "
"for now (and not %.*s).\n", service_len, service);
return(0);
}
type = service + 8;
type_len = service_len - 8;
if (domainpolicy_dbf.use_table(db_handle, &domainpolicy_table) < 0) {
LM_ERR("failed to domainpolicy table\n");
return -1;
}
keys[0]=&domainpolicy_col_rule;
keys[1]=&domainpolicy_col_type;
cols[0]=&domainpolicy_col_rule;
cols[1]=&domainpolicy_col_type;
cols[2]=&domainpolicy_col_att;
cols[3]=&domainpolicy_col_val;
VAL_TYPE(&vals[0]) = DB1_STR;
VAL_NULL(&vals[0]) = 0;
VAL_STR(&vals[0]).s = rule->s;
VAL_STR(&vals[0]).len = rule->len;
VAL_TYPE(&vals[1]) = DB1_STR;
VAL_NULL(&vals[1]) = 0;
VAL_STR(&vals[1]).s = type;
VAL_STR(&vals[1]).len = type_len;
/*
* SELECT rule, att, val from domainpolicy where rule = "..."
*/
if (domainpolicy_dbf.query(db_handle, keys, 0, vals, cols, 2, 4, 0, &res) < 0
) {
LM_ERR("querying database\n");
return -1;
}
LM_INFO("querying database OK\n");
if (RES_ROW_N(res) == 0) {
LM_DBG("rule '%.*s' is not know.\n",
rule->len, ZSW(rule->s));
domainpolicy_dbf.free_result(db_handle, res);
return 0;
} else {
LM_DBG("rule '%.*s' is known\n", rule->len, ZSW(rule->s));
row = RES_ROWS(res);
for(i = 0; i < RES_ROW_N(res); i++) {
if (ROW_N(row + i) != 4) {
LM_ERR("unexpected cell count\n");
return(-1);
}
val = ROW_VALUES(row + i);
if ((VAL_TYPE(val) != DB1_STRING) ||
(VAL_TYPE(val+1) != DB1_STRING) ||
(VAL_TYPE(val+2) != DB1_STRING) ||
(VAL_TYPE(val+3) != DB1_STRING)) {
LM_ERR("unexpected cell types\n");
return(-1);
}
if (VAL_NULL(val+2) || VAL_NULL(val+3)) {
LM_INFO("db returned NULL values. Fine with us.\n");
continue;
}
LM_INFO("DB returned %s/%s \n",VAL_STRING(val+2),VAL_STRING(val+3));
if (!stack_push(stack, (char *) VAL_STRING(val+2),
(char *) VAL_STRING(val+3))) {
return(-1);
}
}
domainpolicy_dbf.free_result(db_handle, res);
return 1;
}
}
static int load_sca_info_from_db(void)
{
db_res_t * res = NULL;
db_val_t * values;
db_row_t * rows;
int i, j, nr_rows;
unsigned int valid_record;
unsigned int n_result_cols = 0;
unsigned int shared_line_col, watchers_col;
unsigned int app_shared_entity_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_state_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_info_uri_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_info_appearance_uri_col[MAX_APPEARANCE_INDEX];
unsigned int app_b2bl_key_col[MAX_APPEARANCE_INDEX];
db_key_t q_cols[SCA_TABLE_TOTAL_COL_NO];
str shared_line, watchers_csv;
//str_lst_t *watchers;
//unsigned int size, watcher_size, watchers_no;
//unsigned int size;
unsigned int hash_index;
//char *p;
b2b_sca_record_t *record;
b2b_sca_call_t *call;
unsigned int shared_entity, appearance_index, call_state;
str call_info_uri, call_info_apperance_uri, b2bl_key;
b2bl_cb_ctx_t *cb_params;
if(use_sca_table()) return -1;
q_cols[shared_line_col = n_result_cols++] = &shared_line_column;
q_cols[watchers_col = n_result_cols++] = &watchers_column;
for (i=0; i<MAX_APPEARANCE_INDEX; i++) {
q_cols[app_shared_entity_col[i] = n_result_cols++] = &app_shared_entity_column[i];
q_cols[app_call_state_col[i] = n_result_cols++] = &app_call_state_column[i];
q_cols[app_call_info_uri_col[i] = n_result_cols++] = &app_call_info_uri_column[i];
q_cols[app_call_info_appearance_uri_col[i] = n_result_cols++] =
&app_call_info_appearance_uri_column[i];
q_cols[app_b2bl_key_col[i] = n_result_cols++] = &app_b2bl_key_column[i];
}
/* select the whole tabel and all the columns */
if (DB_CAPABILITY(sca_dbf, DB_CAP_FETCH)) {
if(sca_dbf.query(sca_db_handle, 0, 0, 0, q_cols, 0,
SCA_TABLE_TOTAL_COL_NO, 0, 0) < 0) {
LM_ERR("Error while querying (fetch) database\n");
return -1;
}
if(sca_dbf.fetch_result(sca_db_handle, &res, SCA_FETCH_SIZE)<0){
LM_ERR("fetching rows failed\n");
return -1;
}
} else {
if(sca_dbf.query(sca_db_handle, 0, 0, 0, q_cols, 0,
SCA_TABLE_TOTAL_COL_NO, 0, &res) < 0) {
LM_ERR("Error while querying database\n");
return -1;
}
}
nr_rows = RES_ROW_N(res);
do {
LM_DBG("loading [%i] records from db\n", nr_rows);
rows = RES_ROWS(res);
/* for every row/record */
for(i=0; i<nr_rows; i++){
values = ROW_VALUES(rows + i);
if (VAL_NULL(values+shared_line_col) || VAL_NULL(values+watchers_col)) {
LM_ERR("columns [%.*s] or/and [%.*s] cannot be null -> skipping\n",
shared_line_column.len, shared_line_column.s,
watchers_column.len, watchers_column.s);
continue;
}
shared_line.s = (char*)values[shared_line_col].val.string_val;
shared_line.len = strlen(shared_line.s);
watchers_csv.s = (char*)values[watchers_col].val.string_val;
watchers_csv.len = strlen(watchers_csv.s);
record = restore_record(&shared_line, &watchers_csv);
if (record == NULL)
goto error;
hash_index = core_hash(&shared_line, NULL, b2b_sca_hsize);
j = 0;
while (j < MAX_APPEARANCE_INDEX) {
if( VAL_NULL(values + app_shared_entity_col[j]) ||
VAL_NULL(values + app_call_state_col[j]) ||
VAL_NULL(values + app_call_info_uri_col[j]) ||
VAL_NULL(values + app_call_info_appearance_uri_col[j]) ||
VAL_NULL(values + app_b2bl_key_col[j]) ) {
goto cont;
}
appearance_index = j + 1;
/* 1 - get shared_entity */
shared_entity = values[app_shared_entity_col[j]].val.int_val;
if (shared_entity!=0 && shared_entity!=1) {
LM_ERR("Unexpected shared_entity [%d] "
"for shared_line [%.*s]\n",
shared_entity, shared_line.len, shared_line.s);
goto cont;
}
/* 2 - get call_state */
call_state = values[app_call_state_col[j]].val.int_val;
if (call_state == IDLE_STATE) {
LM_DBG("empty call[%d]\n", appearance_index);
goto cont;
}
if (call_state > MAX_INDEX_STATE) {
LM_ERR("Unexpected call_state [%d] for shared_line [%.*s]\n",
call_state, shared_line.len, shared_line.s);
goto cont;
}
/* 3 - get call_info_uri */
call_info_uri.s =
(char*)values[app_call_info_uri_col[j]].val.string_val;
if (call_info_uri.s)
call_info_uri.len = strlen(call_info_uri.s);
else {
LM_ERR("Missing call_info_uri for shared_line [%.*s][%d]\n",
shared_line.len, shared_line.s, appearance_index);
goto cont;
}
LM_DBG("call_info_uri=[%.*s]\n",
call_info_uri.len, call_info_uri.s);
/* 4 - get call_info_apperance_uri */
call_info_apperance_uri.s =
(char*)
values[app_call_info_appearance_uri_col[j]].val.string_val;
if (call_info_apperance_uri.s)
call_info_apperance_uri.len =
strlen(call_info_apperance_uri.s);
else {
LM_ERR("Missing call_info_apperance_uri for "
"shared_line [%.*s][%d]\n",
shared_line.len, shared_line.s, appearance_index);
goto cont;
}
LM_DBG("call_info_apperance_uri=[%.*s]\n",
call_info_apperance_uri.len, call_info_apperance_uri.s);
/* 5 - get b2bl_key */
b2bl_key.s = (char*)values[app_b2bl_key_col[j]].val.string_val;
if (b2bl_key.s) {
b2bl_key.len = strlen(b2bl_key.s);
if (b2bl_key.len > B2BL_MAX_KEY_LEN) {
LM_ERR("buffer overflow on b2bl_key [%.*s]"
" for shared_line [%.*s][%d]\n",
b2bl_key.len, b2bl_key.s,
shared_line.len, shared_line.s,
appearance_index);
goto cont;
}
LM_DBG("b2bl_key=[%.*s]\n", b2bl_key.len, b2bl_key.s);
} else {
LM_ERR("Missing b2bl_key for shared_line [%.*s][1]\n",
shared_line.len, shared_line.s);
goto cont;
}
/* restore the call */
call = restore_call(record, appearance_index,
shared_entity, call_state,
&call_info_uri, &call_info_apperance_uri);
if (call == NULL) {
goto error;
}
/* update record */
if (0!=b2b_sca_update_call_record_key(call, &b2bl_key)) {
LM_ERR("Unable to update b2bl_key [%.*s]\n",
b2bl_key.len, b2bl_key.s);
shm_free(call);
call = NULL;
record->call[appearance_index-1] = NULL;
goto cont;
}
/* Prepare b2b_logic callback params. */
cb_params = build_cb_params(hash_index,
&shared_line, appearance_index);
if (cb_params == NULL) {
LM_ERR("Unable to build cb_params\n");
goto error;
}
/* re-register callbacks */
if(b2bl_api.register_cb(&b2bl_key, &sca_logic_notify, cb_params,
B2B_RE_INVITE_CB|B2B_CONFIRMED_CB|B2B_DESTROY_CB) != 0){
LM_ERR("Unable register b2b cb\n");
shm_free(call);
call = NULL;
record->call[appearance_index-1] = NULL;
goto cont;
}
cont:
j++;
}
valid_record = j = 0;
while (j < MAX_APPEARANCE_INDEX) {
if (record->call[j]) {
valid_record = 1;
goto check_valid_record;
}
j++;
}
check_valid_record:
if (valid_record) {
b2b_sca_print_record(record);
insert_record(hash_index, record);
} else {
LM_DBG("removing the record from db!\n");
delete_sca_info_from_db(record);
}
LM_DBG("Done\n");
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(sca_dbf, DB_CAP_FETCH)) {
if (sca_dbf.fetch_result(sca_db_handle, &res, SCA_FETCH_SIZE)<0) {
LM_ERR("fetching more rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(res);
} else {
nr_rows = 0;
}
}while (nr_rows>0);
sca_dbf.free_result(sca_db_handle, res);
return 0;
error:
sca_dbf.free_result(sca_db_handle, res);
return -1;
}
void query_xcap_update(unsigned int ticks, void* param)
{
db_key_t query_cols[3], update_cols[3];
db_val_t query_vals[3], update_vals[3];
db_key_t result_cols[7];
int n_result_cols = 0, n_query_cols= 0, n_update_cols= 0;
db_res_t* result= NULL;
int user_col, domain_col, doc_type_col, etag_col, doc_uri_col, port_col;
db_row_t *row ;
db_val_t *row_vals ;
unsigned int port;
char* etag, *path, *new_etag= NULL, *doc= NULL;
int u_doc_col, u_etag_col;
str user, domain, uri;
int i;
/* query the ones I have to handle */
query_cols[n_query_cols] = "source";
query_vals[n_query_cols].type = DB_INT;
query_vals[n_query_cols].nul = 0;
query_vals[n_query_cols].val.int_val= XCAP_CL_MOD;
n_query_cols++;
query_cols[n_query_cols] = "path";
query_vals[n_query_cols].type = DB_STR;
query_vals[n_query_cols].nul = 0;
update_cols[u_doc_col=n_update_cols] = "doc";
update_vals[n_update_cols].type = DB_STRING;
update_vals[n_update_cols].nul = 0;
n_update_cols++;
update_cols[u_etag_col=n_update_cols] = "etag";
update_vals[n_update_cols].type = DB_STRING;
update_vals[n_update_cols].nul = 0;
n_update_cols++;
result_cols[user_col= n_result_cols++] = "username";
result_cols[domain_col=n_result_cols++] = "domain";
result_cols[doc_type_col=n_result_cols++] = "doc_type";
result_cols[etag_col=n_result_cols++] = "etag";
result_cols[doc_uri_col= n_result_cols++] = "doc_uri";
result_cols[port_col= n_result_cols++] = "port";
if (xcap_dbf.use_table(xcap_db, xcap_db_table) < 0)
{
LM_ERR("in use_table-[table]= %s\n", xcap_db_table);
goto error;
}
if(xcap_dbf.query(xcap_db, query_cols, 0, query_vals, result_cols, 1,
n_result_cols, 0, &result)< 0)
{
LM_ERR("in sql query\n");
goto error;
}
if(result== NULL)
{
LM_ERR("in sql query- null result\n");
return;
}
if(result->n<= 0)
{
xcap_dbf.free_result(xcap_db, result);
return;
}
n_query_cols++;
/* ask if updated */
for(i= 0; i< result->n; i++)
{
row = &result->rows[i];
row_vals = ROW_VALUES(row);
path= (char*)row_vals[doc_uri_col].val.string_val;
port= row_vals[port_col].val.int_val;
etag= (char*)row_vals[etag_col].val.string_val;
user.s= (char*)row_vals[user_col].val.string_val;
user.len= strlen(user.s);
domain.s= (char*)row_vals[domain_col].val.string_val;
domain.len= strlen(domain.s);
/* send HTTP request */
doc= send_http_get(path, port, etag, IF_NONE_MATCH, &new_etag);
if(doc== NULL)
{
LM_DBG("document not update\n");
continue;
}
if(new_etag== NULL)
{
LM_ERR("etag not found\n");
pkg_free(doc);
goto error;
}
/* update in xcap db table */
update_vals[u_doc_col].val.string_val= doc;
update_vals[u_etag_col].val.string_val= etag;
if(xcap_dbf.update(xcap_db, query_cols, 0, query_vals, update_cols,
update_vals, n_query_cols, n_update_cols)< 0)
{
LM_ERR("in sql update\n");
pkg_free(doc);
goto error;
}
/* call registered callbacks */
if(uandd_to_uri(user, domain, &uri)< 0)
{
LM_ERR("converting user and domain to uri\n");
pkg_free(doc);
goto error;
}
run_xcap_update_cb(row_vals[doc_type_col].val.int_val, uri, doc);
pkg_free(doc);
}
xcap_dbf.free_result(xcap_db, result);
return;
error:
if(result)
xcap_dbf.free_result(xcap_db, result);
}
/*
* Retrieve did directly from database, without using
* memory cache. Use 0 as the value of first parameter
* if you only want to know whether the entry is in the
* database. The function returns 1 if there is such
* entry, 0 if not, and -1 on error.
* The result is allocated using pkg_malloc and must be
* freed.
*/
static int db_get_did(str* did, str* domain)
{
db_key_t keys[1], cols[2];
db_val_t vals[1], *val;
db_res_t* res;
str t;
keys[0] = domain_col.s;
cols[0] = did_col.s;
cols[1] = flags_col.s;
res = 0;
if (!domain) {
ERR("BUG:Invalid parameter value\n");
goto err;
}
if (db.use_table(con, domain_table.s) < 0) {
ERR("Error while trying to use domain table\n");
goto err;
}
vals[0].type = DB_STR;
vals[0].nul = 0;
vals[0].val.str_val = *domain;
if (db.query(con, keys, 0, vals, cols, 1, 2, 0, &res) < 0) {
ERR("Error while querying database\n");
goto err;
}
if (res->n > 0) {
val = res->rows[0].values;
/* Test flags first, we are only interested in rows
* that are not disabled
*/
if (val[1].nul || (val[1].val.int_val & DB_DISABLED)) {
db.free_result(con, res);
return 0;
}
if (did) {
if (val[0].nul) {
did->len = 0;
did->s = 0;
WARN("Domain '%.*s' has NULL did\n", domain->len, ZSW(domain->s));
} else {
t.s = (char*)val[0].val.string_val;
t.len = strlen(t.s);
did->s = pkg_malloc(t.len);
if (!did->s) {
ERR("No memory left\n");
goto err;
}
memcpy(did->s, t.s, t.len);
did->len = t.len;
}
}
db.free_result(con, res);
return 1;
} else {
db.free_result(con, res);
return 0;
}
err:
if (res) {
db.free_result(con, res);
res = 0;
}
return -1;
}
static int frd_load_data(dr_head_p drp, free_list_t **fl)
{
static const size_t col_count = 16;
db_res_t *res = NULL;
unsigned int no_rows = 0, row_count, i;
db_row_t *rows;
db_val_t *values;
db_key_t query_cols[] = {
&rid_col, &pid_col, &prefix_col, &start_h_col, &end_h_col, &days_col,
&cpm_thresh_warn_col, &cpm_thresh_crit_col, &calldur_thresh_warn_col,
&calldur_thresh_crit_col, &totalc_thresh_warn_col, &totalc_thresh_crit_col,
&concalls_thresh_warn_col, &concalls_thresh_crit_col, &seqcalls_thresh_warn_col,
&seqcalls_thresh_crit_col
};
if (db_handle == NULL) {
LM_ERR("Invalid db handler\n");
return -1;
}
if (dbf.use_table(db_handle, &table_name) != 0) {
LM_ERR("Cannot use table\n");
return -1;
}
if (DB_CAPABILITY(dbf, DB_CAP_FETCH)) {
if (dbf.query(db_handle, 0, 0, 0, query_cols, 0, col_count, 0, 0) != 0) {
LM_ERR("Error while querying db\n");
goto error;
}
/* estimate rows */
no_rows = estimate_available_rows(4 + 64 + 5 + 5 + 64 + 5 * 2 * 4, col_count);
if (no_rows == 0)
no_rows = 10;
if (dbf.fetch_result(db_handle, &res, no_rows) != 0) {
LM_ERR("Error while fetching rows\n");
goto error;
}
} else {
/* No fetching capability */
if (dbf.query(db_handle, 0, 0, 0, query_cols, 0, col_count, 0, &res) != 0) {
LM_ERR("Error while querying db\n");
goto error;
}
}
/* Process the actual data */
unsigned int rid, pid, j;
str prefix, start_time, end_time, days;
free_list_t *fl_it = NULL;
*fl = NULL;
do {
row_count = RES_ROW_N(res);
rows = RES_ROWS(res);
fl_it = pkg_malloc(sizeof(free_list_t));
if (fl_it == NULL) {
LM_ERR ("no more pkg memory");
dbf.free_result(db_handle, res);
return -1;
}
fl_it ->next = *fl;
*fl = fl_it;
fl_it->trec = shm_malloc(sizeof(tmrec_t) * row_count);
if (fl_it->trec == NULL)
goto no_more_shm;
fl_it->thr = shm_malloc(sizeof(frd_thresholds_t) * row_count);
if (fl_it->thr == NULL)
goto no_more_shm;
fl_it->n = row_count;
for (i = 0; i < row_count; ++i) {
values = ROW_VALUES(rows + i);
fl_it->trec[i].byday = NULL;
/* rule id */
if (VAL_NULL(values)) {
LM_ERR("rule id cannot be NULL - skipping rule\n");
continue;
}
rid = VAL_INT(values);
/* profile id */
if (VAL_NULL(values + 1)) {
LM_ERR("profile id cannot be NULL - skipping rule\n");
continue;
}
pid = VAL_INT(values + 1);
get_str_from_dbval(prefix_col.s, values + 2, 1, 1, prefix, null_val);
get_str_from_dbval(start_h_col.s, values + 3, 1, 1, start_time, null_val);
get_str_from_dbval(end_h_col.s, values + 4, 1, 1, end_time, null_val);
get_str_from_dbval(days_col.s, values + 5, 1, 1, days, null_val);
if (create_time_rec(&start_time, &end_time, &days, fl_it->trec + i) != 0)
goto null_val;
/* Now load the thresholds */
for (j = 0; j < 2 * 5; ++j) {
if (VAL_NULL(values + 6 + j))
goto null_val;
memcpy((char*)fl_it->thr + i * sizeof(frd_thresholds_t) +
j * sizeof(unsigned int), &VAL_INT(values + 6 + j),
sizeof(unsigned int));
}
/* Rule OK, time to put it in DR */
if (drb.add_rule(drp, rid, &prefix, pid, 0, fl_it->trec + i,
(void*)(&fl_it->thr[i])) != 0) {
LM_ERR("Cannot add rule in dr <%u>. Skipping...\n", rid);
}
null_val:
continue;
}
if (DB_CAPABILITY(dbf, DB_CAP_FETCH)) {
/* any more rows to fetch ? */
if(dbf.fetch_result(db_handle, &res, no_rows)<0) {
LM_ERR("error while fetching rows\n");
goto error;
}
/* success in fetching more rows - continue the loop */
} else
break;
} while (RES_ROW_N(res) > 0);
dbf.free_result(db_handle, res);
return 0;
no_more_shm:
LM_ERR ("no more shm memory\n");
dbf.free_result(db_handle, res);
error:
return -1;
}
