static int select_entire_dialog_table(db_res_t ** res, int *no_rows)
{
db_key_t query_cols[DIALOG_TABLE_TOTAL_COL_NO] = { &h_entry_column,
&h_id_column, &call_id_column, &from_uri_column,
&from_tag_column, &to_uri_column, &to_tag_column,
&start_time_column, &state_column, &timeout_column,
&from_cseq_column, &to_cseq_column, &from_route_column,
&to_route_column, &from_contact_column, &to_contact_column,
&from_sock_column, &to_sock_column, &vars_column,
&profiles_column, &sflags_column, &from_ping_cseq_column,
&to_ping_cseq_column,&flags_column, &mangled_fu_column,&mangled_tu_column};
if(use_dialog_table() != 0){
return -1;
}
/* select the whole tabel and all the columns */
if (DB_CAPABILITY(dialog_dbf, DB_CAP_FETCH)) {
if(dialog_dbf.query(dialog_db_handle,0,0,0,query_cols, 0,
DIALOG_TABLE_TOTAL_COL_NO, 0, 0) < 0) {
LM_ERR("Error while querying (fetch) database\n");
return -1;
}
*no_rows = estimate_available_rows( 4+4+128+64+32+54+32+4+4+4+16+16
+256+256+64+64+32+32+256+256+4+4+4+4,DIALOG_TABLE_TOTAL_COL_NO );
if (*no_rows==0) *no_rows = 10;
if(dialog_dbf.fetch_result(dialog_db_handle,res,*no_rows)<0){
LM_ERR("fetching rows failed\n");
return -1;
}
} else {
if(dialog_dbf.query(dialog_db_handle,0,0,0,query_cols, 0,
DIALOG_TABLE_TOTAL_COL_NO, 0, res) < 0) {
LM_ERR("Error while querying database\n");
return -1;
}
}
return 0;
}
int b2b_entities_restore(void)
{
db_res_t *result= NULL;
db_row_t *rows = NULL;
db_val_t *row_vals= NULL;
int i;
dlg_leg_t leg, *new_leg;
b2b_dlg_t dlg, *shm_dlg= NULL;
unsigned int hash_index, local_index;
int nr_rows;
str* b2b_key;
str sockinfo_str;
str host;
int port, proto;
b2b_table htable;
int type;
int no_rows = 10;
if(b2be_db == NULL)
{
LM_DBG("NULL database connection\n");
return 0;
}
if(b2be_dbf.use_table(b2be_db, &b2be_dbtable)< 0)
{
LM_ERR("sql use table failed\n");
return -1;
}
if (DB_CAPABILITY(b2be_dbf, DB_CAP_FETCH))
{
if(b2be_dbf.query(b2be_db,0,0,0,qcols, 0,
DB_COLS_NO, 0, 0) < 0)
{
LM_ERR("Error while querying (fetch) database\n");
return -1;
}
no_rows = estimate_available_rows( DB_COLS_NO*128, DB_COLS_NO);
if (no_rows==0) no_rows = 10;
if(b2be_dbf.fetch_result(b2be_db,&result,no_rows)<0)
{
LM_ERR("fetching rows failed\n");
return -1;
}
}
else
{
if (b2be_dbf.query (b2be_db, 0, 0, 0,qcols,0, DB_COLS_NO,
0, &result) < 0)
{
LM_ERR("querying presentity\n");
return -1;
}
}
nr_rows = RES_ROW_N(result);
do {
LM_DBG("loading information from database %i records\n", nr_rows);
rows = RES_ROWS(result);
/* for every row */
for(i=0; i<nr_rows; i++)
{
row_vals = ROW_VALUES(rows +i);
memset(&dlg, 0, sizeof(b2b_dlg_t));
type = row_vals[0].val.int_val;
dlg.tag[1].s = (char*)row_vals[2].val.string_val;
dlg.tag[1].len = dlg.tag[1].s?strlen(dlg.tag[1].s):0;
dlg.callid.s = (char*)row_vals[3].val.string_val;
dlg.callid.len = dlg.callid.s?strlen(dlg.callid.s):0;
if(type == B2B_SERVER)/* extract hash and local index */
{
htable = server_htable;
if(b2b_parse_key(&dlg.tag[1], &hash_index, &local_index) < 0)
{
LM_ERR("Wrong format for b2b key [%.*s]\n", dlg.tag[1].len, dlg.tag[1].s);
goto error;
}
}
else
{
htable = client_htable;
if(b2b_parse_key(&dlg.callid, &hash_index, &local_index) < 0)
{
LM_ERR("Wrong format for b2b key [%.*s]\n", dlg.callid.len, dlg.callid.s);
goto error;
}
}
dlg.id = local_index;
dlg.state = row_vals[13].val.int_val;
dlg.ruri.s = (char*)row_vals[4].val.string_val;
dlg.ruri.len = dlg.ruri.s?strlen(dlg.ruri.s):0;
dlg.from_uri.s = (char*)row_vals[5].val.string_val;
dlg.from_uri.len = strlen(dlg.from_uri.s);
dlg.from_dname.s = (char*)row_vals[6].val.string_val;
dlg.from_dname.len = strlen(dlg.from_dname.s);
dlg.to_uri.s = (char*)row_vals[7].val.string_val;
dlg.to_uri.len = strlen(dlg.to_uri.s);
dlg.to_dname.s = (char*)row_vals[8].val.string_val;
dlg.to_dname.len = dlg.to_dname.s?strlen(dlg.to_dname.s):0;
dlg.tag[0].s = (char*)row_vals[1].val.string_val;
dlg.tag[0].len = dlg.tag[0].s?strlen(dlg.tag[0].s):0;
dlg.cseq[0] = row_vals[14].val.int_val;
dlg.cseq[1] = row_vals[15].val.int_val;
dlg.route_set[0].s = (char*)row_vals[9].val.string_val;
dlg.route_set[0].len = dlg.route_set[0].s?strlen(dlg.route_set[0].s):0;
dlg.route_set[1].s = (char*)row_vals[10].val.string_val;
dlg.route_set[1].len = dlg.route_set[1].s?strlen(dlg.route_set[1].s):0;
dlg.contact[0].s = (char*)row_vals[19].val.string_val;
dlg.contact[0].len = dlg.contact[0].s?strlen(dlg.contact[0].s):0;
dlg.contact[1].s = (char*)row_vals[20].val.string_val;
dlg.contact[1].len = dlg.contact[1].s?strlen(dlg.contact[1].s):0;
dlg.last_method = row_vals[16].val.int_val;
dlg.last_reply_code = row_vals[17].val.int_val;
dlg.last_invite_cseq = row_vals[18].val.int_val;
dlg.param.s = (char*)row_vals[12].val.string_val;
dlg.param.len = strlen(dlg.param.s);
sockinfo_str.s = (char*)row_vals[11].val.string_val;
if(sockinfo_str.s)
{
sockinfo_str.len = strlen(sockinfo_str.s);
if(sockinfo_str.len)
{
if (parse_phostport (sockinfo_str.s, sockinfo_str.len, &host.s,
&host.len, &port, &proto )< 0)
{
LM_ERR("bad format for stored sockinfo string [%.*s]\n",
sockinfo_str.len, sockinfo_str.s);
goto error;
}
dlg.send_sock = grep_sock_info(&host, (unsigned short) port,
(unsigned short) proto);
}
}
dlg.db_flag = NO_UPDATEDB_FLAG;
shm_dlg = b2b_dlg_copy(&dlg);
if(shm_dlg == NULL)
{
LM_ERR("Failed to create new dialog structure\n");
goto error;
}
b2b_key= b2b_htable_insert(htable,shm_dlg,hash_index,type, 1);
if(b2b_key == NULL)
{
LM_ERR("Failed to insert new record\n");
goto error;
}
pkg_free(b2b_key);
memset(&leg, 0, sizeof(dlg_leg_t));
leg.tag.s= (char*)row_vals[21].val.string_val;
if(!leg.tag.s)
continue;
leg.tag.len = strlen(leg.tag.s);
leg.cseq = row_vals[22].val.int_val;
leg.contact.s = (char*)row_vals[23].val.string_val;
leg.contact.len = leg.contact.s?strlen(leg.contact.s):0;
leg.route_set.s = (char*)row_vals[24].val.string_val;
leg.route_set.len = leg.route_set.s?strlen(leg.route_set.s):0;
new_leg = b2b_dup_leg(&leg, SHM_MEM_TYPE);
if(new_leg== NULL)
{
LM_ERR("Failed to construct b2b leg structure\n");
goto error;
}
shm_dlg->legs = new_leg;
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(b2be_dbf, DB_CAP_FETCH)) {
if (b2be_dbf.fetch_result( b2be_db, &result, no_rows) < 0)
{
LM_ERR("fetching more rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(result);
} else {
nr_rows = 0;
}
}while (nr_rows>0);
b2be_dbf.free_result(b2be_db, result);
return 0;
error:
if(result)
b2be_dbf.free_result(b2be_db, result);
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 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;
}
/**
* 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;
}
/*load rules from DB*/
int dp_load_db(dp_connection_list_p dp_conn)
{
int i, nr_rows;
db_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_flags_column,
&subst_exp_column, &repl_exp_column, &attrs_column, &timerec_column };
db_key_t order = &pr_column;
/* disabled condition */
db_key_t cond_cols[1] = { &disabled_column };
db_val_t cond_val[1];
dpl_node_t *rule;
int no_rows = 10;
lock_start_write( dp_conn->ref_lock );
if( dp_conn->crt_index != dp_conn->next_index){
LM_WARN("a load command already generated, aborting reload...\n");
lock_stop_write( dp_conn->ref_lock );
return 0;
}
dp_conn->next_index = dp_conn->crt_index == 0 ? 1 : 0;
lock_stop_write( dp_conn->ref_lock );
if (dp_conn->dp_dbf.use_table(*dp_conn->dp_db_handle, &dp_conn->table_name) < 0){
LM_ERR("error in use_table\n");
goto err1;
}
VAL_TYPE(cond_val) = DB_INT;
VAL_NULL(cond_val) = 0;
VAL_INT(cond_val) = 0;
if (DB_CAPABILITY(dp_conn->dp_dbf, DB_CAP_FETCH)) {
if(dp_conn->dp_dbf.query(*dp_conn->dp_db_handle,cond_cols,
0,cond_val,query_cols,1,
DP_TABLE_COL_NO, order, 0) < 0){
LM_ERR("failed to query database!\n");
goto err1;
}
no_rows = estimate_available_rows( 4+4+4+64+4+64+64+128,
DP_TABLE_COL_NO);
if (no_rows==0) no_rows = 10;
if(dp_conn->dp_dbf.fetch_result(*dp_conn->dp_db_handle,
&res, no_rows)<0) {
LM_ERR("failed to fetch\n");
if (res)
dp_conn->dp_dbf.free_result(*dp_conn->dp_db_handle, res);
goto err1;
}
} else {
/*select the whole table and all the columns*/
if(dp_conn->dp_dbf.query(*dp_conn->dp_db_handle,
cond_cols,0,cond_val,query_cols,1,
DP_TABLE_COL_NO, order, &res) < 0){
LM_ERR("failed to query database\n");
goto err1;
}
}
nr_rows = RES_ROW_N(res);
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)) == NULL) {
LM_WARN(" failed to build rule -> skipping\n");
continue;
}
rule->table_id = i;
if(add_rule2hash(rule , dp_conn, dp_conn->next_index) != 0) {
LM_ERR("add_rule2hash failed\n");
goto err2;
}
}
if (DB_CAPABILITY(dp_conn->dp_dbf, DB_CAP_FETCH)) {
if(dp_conn->dp_dbf.fetch_result(*dp_conn->dp_db_handle,
&res, no_rows)<0) {
LM_ERR("failure while fetching!\n");
if (res)
dp_conn->dp_dbf.free_result(*dp_conn->dp_db_handle, res);
goto err1;
}
} else {
break;
}
} while(RES_ROW_N(res)>0);
end:
/*update data*/
lock_start_write( dp_conn->ref_lock );
destroy_hash(&dp_conn->hash[dp_conn->crt_index]);
dp_conn->crt_index = dp_conn->next_index;
lock_stop_write( dp_conn->ref_lock );
list_hash(dp_conn->hash[dp_conn->crt_index], dp_conn->ref_lock);
dp_conn->dp_dbf.free_result(*dp_conn->dp_db_handle, res);
return 0;
err1:
lock_start_write( dp_conn->ref_lock );
dp_conn->next_index = dp_conn->crt_index;
lock_stop_write( dp_conn->ref_lock );
return -1;
err2:
if(rule) destroy_rule(rule);
destroy_hash(&dp_conn->hash[dp_conn->next_index]);
dp_conn->dp_dbf.free_result(*dp_conn->dp_db_handle, res);
lock_start_write( dp_conn->ref_lock );
dp_conn->next_index = dp_conn->crt_index;
/* if lock defined - release the exclusive writing access */
lock_stop_write( dp_conn->ref_lock );
return -1;
}
/*load rules from DB*/
int dp_load_db(void)
{
int i, nr_rows;
db_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;
int no_rows = 10;
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\n");
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;
}
no_rows = estimate_available_rows( 4+4+4+64+4+64+64+128,
DP_TABLE_COL_NO);
if (no_rows==0) no_rows = 10;
if(dp_dbf.fetch_result(dp_db_handle, &res, no_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);
lock_start_write( ref_lock );
*next_idx = ((*crt_idx) == 0)? 1:0;
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)) == NULL ) {
LM_WARN(" failed to build rule -> skipping\n");
continue;
}
if(add_rule2hash(rule , *next_idx) != 0) {
LM_ERR("add_rule2hash failed\n");
goto err2;
}
}
if (DB_CAPABILITY(dp_dbf, DB_CAP_FETCH)) {
if(dp_dbf.fetch_result(dp_db_handle, &res, no_rows)<0) {
LM_ERR("failure while fetching!\n");
if (res)
dp_dbf.free_result(dp_db_handle, res);
lock_stop_write( ref_lock );
return -1;
}
} else {
break;
}
} while(RES_ROW_N(res)>0);
end:
destroy_hash(*crt_idx);
/*update data*/
*crt_idx = *next_idx;
/* release the exclusive writing access */
lock_stop_write( ref_lock );
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;
/* if lock defined - release the exclusive writing access */
if(ref_lock)
/* release the readers */
lock_stop_write( ref_lock );
return -1;
}
static int db_restore(void)
{
ua_pres_t* p= NULL;
db_key_t result_cols[20];
db_res_t *res= NULL;
db_row_t *row = NULL;
db_val_t *row_vals= NULL;
str pres_uri, pres_id, to_uri;
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,touri_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;
int no_rows = 10;
result_cols[puri_col=n_result_cols++] = &str_pres_uri_col;
result_cols[touri_col=n_result_cols++] = &str_to_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_CAPABILITY(pua_dbf, DB_CAP_FETCH)) {
if(pua_dbf.query(pua_db,0, 0, 0, result_cols,0, n_result_cols, 0,0)< 0)
{
LM_ERR("while querying table\n");
return -1;
}
no_rows = estimate_available_rows( 128+128+8+8+4+32+64+64+128+
128+64+64+16+64, n_result_cols);
if (no_rows==0) no_rows = 10;
if(pua_dbf.fetch_result(pua_db, &res, no_rows)<0)
{
LM_ERR("Error fetching rows\n");
return -1;
}
} else {
if(pua_dbf.query(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;
}
LM_DBG("found %d db entries\n", res->n);
do {
for(i =0 ; i< res->n ; i++)
{
row = &res->rows[i];
row_vals = ROW_VALUES(row);
if(row_vals[expires_col].val.int_val < time(NULL))
continue;
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(&to_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);
to_uri.s= (char*)row_vals[touri_col].val.string_val;
if(to_uri.s == NULL)
to_uri = pres_uri;
else
to_uri.len = strlen(to_uri.s);
LM_DBG("to_uri= %.*s\n", to_uri.len, to_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;
if(remote_contact.s)
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(watcher_uri.s)
size+= sizeof(str)+ to_uri.len + watcher_uri.len+ call_id.len+ to_tag.len+
from_tag.len+ record_route.len+ contact.len;
p= (ua_pres_t*)shm_malloc(size);
if(p== NULL)
{
LM_ERR("no more shared 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)
{
CONT_COPY(p, p->id, pres_id);
}
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;
CONT_COPY(p, p->to_uri, to_uri);
CONT_COPY(p, p->to_tag, to_tag);
CONT_COPY(p, p->from_tag, from_tag);
CONT_COPY(p, p->call_id, call_id);
if(record_route.s && record_route.len)
{
CONT_COPY(p, p->record_route, record_route);
}
CONT_COPY(p, p->contact, contact);
p->cseq= row_vals[cseq_col].val.int_val;
p->remote_contact.s= (char*)shm_malloc(remote_contact.len);
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;
}
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);
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;
}
memset(&p->extra_headers, 0, sizeof(str));
if(extra_headers.s && extra_headers.len)
{
/* alloc separately */
p->extra_headers.s= (char*)shm_malloc(extra_headers.len);
if(p->extra_headers.s== NULL)
{
LM_ERR("no more share memory\n");
goto error;
}
memcpy(p->extra_headers.s, extra_headers.s, extra_headers.len);
p->extra_headers.len= extra_headers.len;
}
print_ua_pres(p);
insert_htable(p);
} /* end for(all rows)*/
if (DB_CAPABILITY(pua_dbf, DB_CAP_FETCH)) {
if(pua_dbf.fetch_result(pua_db, &res, no_rows)<0) {
LM_ERR( "fetching rows (1)\n");
goto error;
}
} else {
break;
}
} while(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)
{
if(p->remote_contact.s) shm_free(p->remote_contact.s);
if(p->extra_headers.s) shm_free(p->extra_headers.s);
if(p->etag.s) shm_free(p->etag.s);
shm_free(p);
}
return -1;
}
rt_data_t* dr_load_routing_info( db_func_t *dr_dbf, db_con_t* db_hdl,
str *drd_table, str *drc_table, str* drr_table, int persistent_state)
{
int int_vals[5];
char * str_vals[6];
str tmp;
db_key_t columns[10];
db_res_t* res;
db_row_t* row;
rt_info_t *ri;
rt_data_t *rdata;
tmrec_t *time_rec;
int i,n;
int no_rows = 10;
int db_cols;
struct socket_info *sock;
str s_sock, host;
int proto, port;
res = 0;
ri = 0;
rdata = 0;
/* init new data structure */
if ( (rdata=build_rt_data())==0 ) {
LM_ERR("failed to build rdata\n");
goto error;
}
if (db_check_table_version(dr_dbf, db_hdl, drd_table, 6/*version*/ )!= 0)
goto error;
/* read the destinations */
if (dr_dbf->use_table( db_hdl, drd_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", drd_table->len,drd_table->s);
goto error;
}
columns[0] = &id_drd_col;
columns[1] = &gwid_drd_col;
columns[2] = &address_drd_col;
columns[3] = &strip_drd_col;
columns[4] = &prefix_drd_col;
columns[5] = &type_drd_col;
columns[6] = &attrs_drd_col;
columns[7] = &probe_drd_col;
columns[8] = &sock_drd_col;
if (persistent_state) {
columns[9] = &state_drd_col;
db_cols = 10;
} else {
db_cols = 9;
}
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if ( dr_dbf->query( db_hdl, 0, 0, 0, columns, 0, db_cols, 0, 0 ) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
no_rows = estimate_available_rows( 4+32+15+4+32+4+128+4+32+4, db_cols);
if (no_rows==0) no_rows = 10;
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, 0, 0, 0, columns, 0, db_cols, 0, &res) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
}
LM_DBG("%d records found in %.*s\n",
RES_ROW_N(res), drd_table->len,drd_table->s);
n = 0;
do {
for(i=0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
/* DB ID column */
check_val( id_drd_col, ROW_VALUES(row), DB_INT, 1, 0);
int_vals[INT_VALS_ID_DRD_COL] = VAL_INT(ROW_VALUES(row));
/* GW ID column */
check_val( gwid_drd_col, ROW_VALUES(row)+1, DB_STRING, 1, 1);
str_vals[STR_VALS_GWID_DRD_COL] = (char*)VAL_STRING(ROW_VALUES(row)+1);
/* ADDRESS column */
check_val( address_drd_col, ROW_VALUES(row)+2, DB_STRING, 1, 1);
str_vals[STR_VALS_ADDRESS_DRD_COL] = (char*)VAL_STRING(ROW_VALUES(row)+2);
/* STRIP column */
check_val( strip_drd_col, ROW_VALUES(row)+3, DB_INT, 1, 0);
int_vals[INT_VALS_STRIP_DRD_COL] = VAL_INT (ROW_VALUES(row)+3);
/* PREFIX column */
check_val( prefix_drd_col, ROW_VALUES(row)+4, DB_STRING, 0, 0);
str_vals[STR_VALS_PREFIX_DRD_COL] = (char*)VAL_STRING(ROW_VALUES(row)+4);
/* TYPE column */
check_val( type_drd_col, ROW_VALUES(row)+5, DB_INT, 1, 0);
int_vals[INT_VALS_TYPE_DRD_COL] = VAL_INT(ROW_VALUES(row)+5);
/* ATTRS column */
check_val( attrs_drd_col, ROW_VALUES(row)+6, DB_STRING, 0, 0);
str_vals[STR_VALS_ATTRS_DRD_COL] = (char*)VAL_STRING(ROW_VALUES(row)+6);
/*PROBE_MODE column */
check_val( probe_drd_col, ROW_VALUES(row)+7, DB_INT, 1, 0);
int_vals[INT_VALS_PROBE_DRD_COL] = VAL_INT(ROW_VALUES(row)+7);
/*SOCKET column */
check_val( sock_drd_col, ROW_VALUES(row)+8, DB_STRING, 0, 0);
if ( !VAL_NULL(ROW_VALUES(row)+8) &&
(s_sock.s=(char*)VAL_STRING(ROW_VALUES(row)+8))[0]!=0 ) {
s_sock.len = strlen(s_sock.s);
if (parse_phostport( s_sock.s, s_sock.len, &host.s, &host.len,
&port, &proto)!=0){
LM_ERR("GW <%s>(%d): socket description <%.*s> "
"is not valid -> ignoring socket\n",
str_vals[STR_VALS_GWID_DRD_COL],
int_vals[INT_VALS_ID_DRD_COL], s_sock.len,s_sock.s);
sock = NULL;
} else {
sock = grep_sock_info( &host, port, proto);
if (sock == NULL) {
LM_ERR("GW <%s>(%d): socket <%.*s> is not local to"
" OpenSIPS (we must listen on it) -> ignoring socket\n",
str_vals[STR_VALS_GWID_DRD_COL],
int_vals[INT_VALS_ID_DRD_COL], s_sock.len,s_sock.s);
}
}
} else {
sock = NULL;
}
/*STATE column */
if (persistent_state) {
check_val( state_drd_col, ROW_VALUES(row)+9, DB_INT, 1, 0);
int_vals[INT_VALS_STATE_DRD_COL] = VAL_INT(ROW_VALUES(row)+9);
} else {
int_vals[INT_VALS_STATE_DRD_COL] = 0; /* by default enabled */
}
/* add the destinaton definition in */
if ( add_dst( rdata, str_vals[STR_VALS_GWID_DRD_COL],
str_vals[STR_VALS_ADDRESS_DRD_COL],
int_vals[INT_VALS_STRIP_DRD_COL],
str_vals[STR_VALS_PREFIX_DRD_COL],
int_vals[INT_VALS_TYPE_DRD_COL],
str_vals[STR_VALS_ATTRS_DRD_COL],
int_vals[INT_VALS_PROBE_DRD_COL],
sock,
int_vals[INT_VALS_STATE_DRD_COL] )<0 ) {
LM_ERR("failed to add destination <%s>(%d) -> skipping\n",
str_vals[STR_VALS_GWID_DRD_COL],int_vals[INT_VALS_ID_DRD_COL]);
continue;
}
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);
dr_dbf->free_result(db_hdl, res);
res = 0;
/* read the carriers, if any */
if (dr_dbf->use_table( db_hdl, drc_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", drc_table->len,drc_table->s);
goto error;
}
columns[0] = &id_drc_col;
columns[1] = &cid_drc_col;
columns[2] = &flags_drc_col;
columns[3] = &gwlist_drc_col;
columns[4] = &attrs_drc_col;
if (persistent_state) {
columns[5] = &state_drc_col;
db_cols = 6;
} else {
db_cols = 5;
}
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if ( dr_dbf->query( db_hdl, 0, 0, 0, columns, 0, db_cols, 0, 0 ) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
no_rows = estimate_available_rows( 4+4+32+64+64, db_cols);
if (no_rows==0) no_rows = 10;
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, 0, 0, 0, columns, 0, db_cols, 0, &res) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
}
if (RES_ROW_N(res) == 0) {
LM_DBG("table \"%.*s\" empty\n", drc_table->len,drc_table->s );
} else {
LM_DBG("%d records found in %.*s\n",
RES_ROW_N(res), drc_table->len,drc_table->s);
do {
for(i=0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
/* ID column */
check_val( id_drc_col, ROW_VALUES(row), DB_INT, 1, 0);
int_vals[INT_VALS_ID_DRC_COL] = VAL_INT(ROW_VALUES(row));
/* CARRIER_ID column */
check_val( cid_drc_col, ROW_VALUES(row)+1, DB_STRING, 1, 1);
str_vals[STR_VALS_CID_DRC_COL] = (char*)VAL_STRING(ROW_VALUES(row)+1);
/* flags column */
check_val( flags_drc_col, ROW_VALUES(row)+2, DB_INT, 1, 0);
int_vals[INT_VALS_FLAGS_DRC_COL] = VAL_INT(ROW_VALUES(row)+2);
/* GWLIST column */
check_val( gwlist_drc_col, ROW_VALUES(row)+3, DB_STRING, 1, 1);
str_vals[STR_VALS_GWLIST_DRC_COL] = (char*)VAL_STRING(ROW_VALUES(row)+3);
/* ATTRS column */
check_val( attrs_drc_col, ROW_VALUES(row)+4, DB_STRING, 0, 0);
str_vals[STR_VALS_ATTRS_DRC_COL] = (char*)VAL_STRING(ROW_VALUES(row)+4);
/* STATE column */
if (persistent_state) {
check_val( state_drc_col, ROW_VALUES(row)+5, DB_INT, 1, 0);
int_vals[INT_VALS_STATE_DRC_COL] = VAL_INT(ROW_VALUES(row)+5);
} else {
int_vals[INT_VALS_STATE_DRC_COL] = 0; /* by default enabled */
}
/* add the new carrier */
if ( add_carrier( str_vals[STR_VALS_CID_DRC_COL],
int_vals[INT_VALS_FLAGS_DRC_COL],
str_vals[STR_VALS_GWLIST_DRC_COL],
str_vals[STR_VALS_ATTRS_DRC_COL],
int_vals[INT_VALS_STATE_DRC_COL], rdata) != 0 ) {
LM_ERR("failed to add carrier db_id %d -> skipping\n",
int_vals[INT_VALS_ID_DRC_COL]);
continue;
}
}
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);
}
dr_dbf->free_result(db_hdl, res);
res = 0;
/* read the routing rules */
if (dr_dbf->use_table( db_hdl, drr_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", drr_table->len, drr_table->s);
goto error;
}
columns[0] = &rule_id_drr_col;
columns[1] = &group_drr_col;
columns[2] = &prefix_drr_col;
columns[3] = &time_drr_col;
columns[4] = &priority_drr_col;
columns[5] = &routeid_drr_col;
columns[6] = &dstlist_drr_col;
columns[7] = &attrs_drr_col;
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if ( dr_dbf->query( db_hdl, 0, 0, 0, columns, 0, 8, 0, 0) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
no_rows = estimate_available_rows( 4+32+32+128+32+64+128, 8/*cols*/);
if (no_rows==0) no_rows = 10;
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, 0, 0, 0, columns, 0, 8, 0, &res) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
}
if (RES_ROW_N(res) == 0) {
LM_WARN("table \"%.*s\" is empty\n", drr_table->len, drr_table->s);
}
LM_DBG("initial %d records found in %.*s\n", RES_ROW_N(res),
drr_table->len, drr_table->s);
n = 0;
do {
for(i=0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
/* RULE_ID column */
check_val( rule_id_drr_col, ROW_VALUES(row), DB_INT, 1, 0);
int_vals[INT_VALS_RULE_ID_DRR_COL] = VAL_INT (ROW_VALUES(row));
/* GROUP column */
check_val( group_drr_col, ROW_VALUES(row)+1, DB_STRING, 1, 1);
str_vals[STR_VALS_GROUP_DRR_COL] = (char*)VAL_STRING(ROW_VALUES(row)+1);
/* PREFIX column - it may be null or empty */
check_val( prefix_drr_col, ROW_VALUES(row)+2, DB_STRING, 0, 0);
if ((ROW_VALUES(row)+2)->nul || VAL_STRING(ROW_VALUES(row)+2)==0){
tmp.s = NULL;
tmp.len = 0;
} else {
str_vals[STR_VALS_PREFIX_DRR_COL] = (char*)VAL_STRING(ROW_VALUES(row)+2);
tmp.s = str_vals[STR_VALS_PREFIX_DRR_COL];
tmp.len = strlen(str_vals[STR_VALS_PREFIX_DRR_COL]);
}
/* TIME column */
check_val( time_drr_col, ROW_VALUES(row)+3, DB_STRING, 0, 0);
str_vals[STR_VALS_TIME_DRR_COL] = (char*)VAL_STRING(ROW_VALUES(row)+3);
/* PRIORITY column */
check_val( priority_drr_col, ROW_VALUES(row)+4, DB_INT, 1, 0);
int_vals[INT_VALS_PRIORITY_DRR_COL] = VAL_INT (ROW_VALUES(row)+4);
/* ROUTE_ID column */
check_val( routeid_drr_col, ROW_VALUES(row)+5, DB_STRING, 0, 0);
str_vals[STR_VALS_ROUTEID_DRR_COL] = (char*)VAL_STRING(ROW_VALUES(row)+5);
/* DSTLIST column */
check_val( dstlist_drr_col, ROW_VALUES(row)+6, DB_STRING, 1, 1);
str_vals[STR_VALS_DSTLIST_DRR_COL] = (char*)VAL_STRING(ROW_VALUES(row)+6);
/* ATTRS column */
check_val( attrs_drr_col, ROW_VALUES(row)+7, DB_STRING, 0, 0);
str_vals[STR_VALS_ATTRS_DRR_COL] = (char*)VAL_STRING(ROW_VALUES(row)+7);
/* parse the time definition */
if (str_vals[STR_VALS_TIME_DRR_COL] == NULL || *(str_vals[STR_VALS_TIME_DRR_COL]) == 0)
time_rec = NULL;
else if ((time_rec=parse_time_def(str_vals[STR_VALS_TIME_DRR_COL]))==0) {
LM_ERR("bad time definition <%s> for rule id %d -> skipping\n",
str_vals[STR_VALS_TIME_DRR_COL], int_vals[INT_VALS_RULE_ID_DRR_COL]);
continue;
}
/* lookup for the script route ID */
if (str_vals[STR_VALS_ROUTEID_DRR_COL] && str_vals[STR_VALS_ROUTEID_DRR_COL][0]) {
int_vals[INT_VALS_SCRIPT_ROUTE_ID] =
get_script_route_ID_by_name( str_vals[STR_VALS_ROUTEID_DRR_COL], rlist, RT_NO);
if (int_vals[INT_VALS_SCRIPT_ROUTE_ID]==-1) {
LM_WARN("route <%s> does not exist\n",
str_vals[STR_VALS_ROUTEID_DRR_COL]);
int_vals[INT_VALS_SCRIPT_ROUTE_ID] = 0;
}
} else {
int_vals[INT_VALS_SCRIPT_ROUTE_ID] = 0;
}
/* build the routing rule */
if ((ri = build_rt_info( int_vals[INT_VALS_RULE_ID_DRR_COL],
int_vals[INT_VALS_PRIORITY_DRR_COL], time_rec,
int_vals[INT_VALS_SCRIPT_ROUTE_ID],
str_vals[STR_VALS_DSTLIST_DRR_COL],
str_vals[STR_VALS_ATTRS_DRR_COL], rdata))== 0 ) {
LM_ERR("failed to add routing info for rule id %d -> "
"skipping\n", int_vals[INT_VALS_RULE_ID_DRR_COL]);
tmrec_free( time_rec );
continue;
}
/* add the rule */
if (add_rule( rdata, str_vals[STR_VALS_GROUP_DRR_COL], &tmp, ri)!=0) {
LM_ERR("failed to add rule id %d -> skipping\n",
int_vals[INT_VALS_RULE_ID_DRR_COL]);
free_rt_info( ri );
continue;
}
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;
}
LM_DBG("additional %d records found in %.*s\n", RES_ROW_N(res),
drr_table->len, drr_table->s);
} else {
break;
}
} while(RES_ROW_N(res)>0);
dr_dbf->free_result(db_hdl, res);
res = 0;
LM_DBG("%d total records loaded from table %.*s\n", n,
drr_table->len, drr_table->s);
return rdata;
error:
if (res)
dr_dbf->free_result(db_hdl, res);
if (rdata)
free_rt_data( rdata, 1 );
rdata = NULL;
return 0;
}
rt_data_t* dr_load_routing_info( db_func_t *dr_dbf, db_con_t* db_hdl,
str *drd_table, str *drc_table, str* drr_table )
{
int int_vals[4];
char * str_vals[6];
str tmp;
db_key_t columns[8];
db_res_t* res;
db_row_t* row;
rt_info_t *ri;
rt_data_t *rdata;
tmrec_t *time_rec;
int i,n;
int no_rows = 10;
res = 0;
ri = 0;
rdata = 0;
/* init new data structure */
if ( (rdata=build_rt_data())==0 ) {
LM_ERR("failed to build rdata\n");
goto error;
}
if (db_check_table_version(dr_dbf, db_hdl, drd_table, 5 )!= 0)
goto error;
/* read the destinations */
if (dr_dbf->use_table( db_hdl, drd_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", drd_table->len,drd_table->s);
goto error;
}
columns[0] = &id_drd_col;
columns[1] = &gwid_drd_col;
columns[2] = &address_drd_col;
columns[3] = &strip_drd_col;
columns[4] = &prefix_drd_col;
columns[5] = &type_drd_col;
columns[6] = &attrs_drd_col;
columns[7] = &probe_drd_col;
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if ( dr_dbf->query( db_hdl, 0, 0, 0, columns, 0, 8, 0, 0 ) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
no_rows = estimate_available_rows( 4+32+15+4+32+4+128+4, 8);
if (no_rows==0) no_rows = 10;
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, 0, 0, 0, columns, 0, 8, 0, &res) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
}
LM_DBG("%d records found in %.*s\n",
RES_ROW_N(res), drd_table->len,drd_table->s);
n = 0;
do {
for(i=0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
/* DB ID column */
check_val(ID_DRD_COL, ROW_VALUES(row), DB_INT, 1, 0);
int_vals[0] = VAL_INT(ROW_VALUES(row));
/* GW ID column */
check_val(GWID_DRD_COL, ROW_VALUES(row)+1, DB_STRING, 1, 1);
str_vals[3] = (char*)VAL_STRING(ROW_VALUES(row)+1);
/* ADDRESS column */
check_val(ADDRESS_DRD_COL, ROW_VALUES(row)+2, DB_STRING, 1, 1);
str_vals[0] = (char*)VAL_STRING(ROW_VALUES(row)+2);
/* STRIP column */
check_val(STRIP_DRD_COL, ROW_VALUES(row)+3, DB_INT, 1, 0);
int_vals[1] = VAL_INT (ROW_VALUES(row)+3);
/* PREFIX column */
check_val(PREFIX_DRD_COL, ROW_VALUES(row)+4, DB_STRING, 0, 0);
str_vals[1] = (char*)VAL_STRING(ROW_VALUES(row)+4);
/* TYPE column */
check_val(TYPE_DRD_COL, ROW_VALUES(row)+5, DB_INT, 1, 0);
int_vals[2] = VAL_INT(ROW_VALUES(row)+5);
/* ATTRS column */
check_val(ATTRS_DRD_COL, ROW_VALUES(row)+6, DB_STRING, 0, 0);
str_vals[2] = (char*)VAL_STRING(ROW_VALUES(row)+6);
/*PROBE_MODE column */
check_val(PROBE_DRD_COL, ROW_VALUES(row)+7, DB_INT, 1, 0);
int_vals[3] = VAL_INT(ROW_VALUES(row)+7);
/* add the destinaton definition in */
if ( add_dst( rdata, str_vals[3], str_vals[0], int_vals[1],
str_vals[1], int_vals[2], str_vals[2], int_vals[3])<0 ) {
LM_ERR("failed to add destination id %d -> skipping\n",
int_vals[0]);
continue;
}
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);
dr_dbf->free_result(db_hdl, res);
res = 0;
/* read the carriers, if any */
if (dr_dbf->use_table( db_hdl, drc_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", drc_table->len,drc_table->s);
goto error;
}
columns[0] = &id_drc_col;
columns[1] = &cid_drc_col;
columns[2] = &flags_drc_col;
columns[3] = &gwlist_drc_col;
columns[4] = &attrs_drc_col;
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if ( dr_dbf->query( db_hdl, 0, 0, 0, columns, 0, 5, 0, 0 ) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
no_rows = estimate_available_rows( 4+4+32+64+64, 5/*cols*/);
if (no_rows==0) no_rows = 10;
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, 0, 0, 0, columns, 0, 5, 0, &res) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
}
if (RES_ROW_N(res) == 0) {
LM_DBG("table \"%.*s\" empty\n", drc_table->len,drc_table->s );
} else {
LM_DBG("%d records found in %.*s\n",
RES_ROW_N(res), drc_table->len,drc_table->s);
do {
for(i=0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
/* ID column */
check_val(ID_DRC_COL, ROW_VALUES(row), DB_INT, 1, 0);
int_vals[0] = VAL_INT(ROW_VALUES(row));
/* CARRIER_ID column */
check_val(CID_DRC_COL, ROW_VALUES(row)+1, DB_STRING, 1, 1);
str_vals[0] = (char*)VAL_STRING(ROW_VALUES(row)+1);
/* ID column */
check_val(ID_DRC_COL, ROW_VALUES(row)+2, DB_INT, 1, 0);
int_vals[1] = VAL_INT(ROW_VALUES(row)+2);
/* GWLIST column */
check_val(GWLIST_DRC_COL, ROW_VALUES(row)+3, DB_STRING, 1, 1);
str_vals[1] = (char*)VAL_STRING(ROW_VALUES(row)+3);
/* ATTRS column */
check_val(ATTRS_DRC_COL, ROW_VALUES(row)+4, DB_STRING, 0, 0);
str_vals[2] = (char*)VAL_STRING(ROW_VALUES(row)+4);
/* add the new carrier */
if ( add_carrier( int_vals[0], str_vals[0], int_vals[1],
str_vals[1], str_vals[2], rdata) != 0 ) {
LM_ERR("failed to add carrier db_id %d -> skipping\n",
int_vals[0]);
continue;
}
}
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);
}
dr_dbf->free_result(db_hdl, res);
res = 0;
/* read the routing rules */
if (dr_dbf->use_table( db_hdl, drr_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", drr_table->len, drr_table->s);
goto error;
}
columns[0] = &rule_id_drr_col;
columns[1] = &group_drr_col;
columns[2] = &prefix_drr_col;
columns[3] = &time_drr_col;
columns[4] = &priority_drr_col;
columns[5] = &routeid_drr_col;
columns[6] = &dstlist_drr_col;
columns[7] = &attrs_drd_col;
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if ( dr_dbf->query( db_hdl, 0, 0, 0, columns, 0, 8, 0, 0) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
no_rows = estimate_available_rows( 4+32+32+128+32+64+128, 8/*cols*/);
if (no_rows==0) no_rows = 10;
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, 0, 0, 0, columns, 0, 8, 0, &res) < 0) {
LM_ERR("DB query failed\n");
goto error;
}
}
if (RES_ROW_N(res) == 0) {
LM_WARN("table \"%.*s\" is empty\n", drr_table->len, drr_table->s);
}
LM_DBG("%d records found in %.*s\n", RES_ROW_N(res),
drr_table->len, drr_table->s);
n = 0;
do {
for(i=0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
/* RULE_ID column */
check_val(RULE_ID_DRR_COL, ROW_VALUES(row), DB_INT, 1, 0);
int_vals[0] = VAL_INT (ROW_VALUES(row));
/* GROUP column */
check_val(GROUP_DRR_COL, ROW_VALUES(row)+1, DB_STRING, 1, 1);
str_vals[0] = (char*)VAL_STRING(ROW_VALUES(row)+1);
/* PREFIX column - it may be null or empty */
check_val(PREFIX_DRR_COL, ROW_VALUES(row)+2, DB_STRING, 0, 0);
if ((ROW_VALUES(row)+2)->nul || VAL_STRING(ROW_VALUES(row)+2)==0){
tmp.s = NULL;
tmp.len = 0;
} else {
str_vals[1] = (char*)VAL_STRING(ROW_VALUES(row)+2);
tmp.s = str_vals[1];
tmp.len = strlen(str_vals[1]);
}
/* TIME column */
check_val(TIME_DRR_COL, ROW_VALUES(row)+3, DB_STRING, 0, 0);
str_vals[2] = (char*)VAL_STRING(ROW_VALUES(row)+3);
/* PRIORITY column */
check_val(PRIORITY_DRR_COL, ROW_VALUES(row)+4, DB_INT, 1, 0);
int_vals[2] = VAL_INT (ROW_VALUES(row)+4);
/* ROUTE_ID column */
check_val(ROUTEID_DRR_COL, ROW_VALUES(row)+5, DB_STRING, 1, 0);
str_vals[3] = (char*)VAL_STRING(ROW_VALUES(row)+5);
/* DSTLIST column */
check_val(DSTLIST_DRR_COL, ROW_VALUES(row)+6, DB_STRING, 1, 1);
str_vals[4] = (char*)VAL_STRING(ROW_VALUES(row)+6);
/* ATTRS column */
check_val(ATTRS_DRD_COL, ROW_VALUES(row)+7, DB_STRING, 0, 0);
str_vals[5] = (char*)VAL_STRING(ROW_VALUES(row)+7);
/* parse the time definition */
if ((time_rec=parse_time_def(str_vals[2]))==0) {
LM_ERR("bad time definition <%s> for rule id %d -> skipping\n",
str_vals[2], int_vals[0]);
continue;
}
/* lookup for the script route ID */
if (str_vals[3][0]) {
int_vals[3] = get_script_route_ID_by_name( str_vals[3],
rlist, RT_NO);
if (int_vals[3]==-1) {
LM_WARN("route <%s> does not exist\n",str_vals[3]);
int_vals[3] = 0;
}
} else {
int_vals[3] = 0;
}
/* build the routing rule */
if ((ri = build_rt_info( int_vals[0], int_vals[2], time_rec,
int_vals[3], str_vals[4], str_vals[5], rdata))== 0 ) {
LM_ERR("failed to add routing info for rule id %d -> "
"skipping\n", int_vals[0]);
tmrec_free( time_rec );
continue;
}
/* add the rule */
if (add_rule( rdata, str_vals[0], &tmp, ri)!=0) {
LM_ERR("failed to add rule id %d -> skipping\n", int_vals[0]);
free_rt_info( ri );
continue;
}
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);
dr_dbf->free_result(db_hdl, res);
res = 0;
if (n==0) {
LM_WARN("no valid routing rules -> discarding all destinations\n");
free_rt_data( rdata, 0 );
}
return rdata;
error:
if (res)
dr_dbf->free_result(db_hdl, res);
if (rdata)
free_rt_data( rdata, 1 );
rdata = NULL;
return 0;
}
static int pdt_load_db(void)
{
db_key_t db_cols[3] = {&sdomain_column, &prefix_column, &domain_column};
str p, d, sdomain;
db_res_t* db_res = NULL;
int i, ret;
pdt_tree_t *_ptree_new = NULL;
pdt_tree_t *old_tree = NULL;
int no_rows = 10;
if(db_con==NULL)
{
LM_ERR("no db connection\n");
return -1;
}
if (pdt_dbf.use_table(db_con, &db_table) < 0)
{
LM_ERR("failed to use_table\n");
return -1;
}
if (DB_CAPABILITY(pdt_dbf, DB_CAP_FETCH)) {
if(pdt_dbf.query(db_con,0,0,0,db_cols,0,3,&sdomain_column,0) < 0)
{
LM_ERR("Error while querying db\n");
return -1;
}
no_rows = estimate_available_rows( 64+16+64, 3);
if (no_rows==0) no_rows = 10;
if(pdt_dbf.fetch_result(db_con, &db_res, no_rows)<0)
{
LM_ERR("Error while fetching result\n");
if (db_res)
pdt_dbf.free_result(db_con, db_res);
goto error;
} else {
if(RES_ROW_N(db_res)==0)
{
return 0;
}
}
} else {
if((ret=pdt_dbf.query(db_con, NULL, NULL, NULL, db_cols,
0, 3, &sdomain_column, &db_res))!=0
|| RES_ROW_N(db_res)<=0 )
{
pdt_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 ?!?! */
sdomain.s = (char*)(RES_ROWS(db_res)[i].values[0].val.string_val);
sdomain.len = strlen(sdomain.s);
p.s = (char*)(RES_ROWS(db_res)[i].values[1].val.string_val);
p.len = strlen(p.s);
d.s = (char*)(RES_ROWS(db_res)[i].values[2].val.string_val);
d.len = strlen(d.s);
if(p.s==NULL || d.s==NULL || sdomain.s==NULL ||
p.len<=0 || d.len<=0 || sdomain.len<=0)
{
LM_ERR("Error - bad values in db\n");
continue;
}
if(pdt_check_domain!=0 && _ptree_new!=NULL
&& pdt_check_pd(_ptree_new, &sdomain, &p, &d)==1)
{
LM_ERR("sdomain [%.*s]: prefix [%.*s] or domain <%.*s> "
"duplicated\n", sdomain.len, sdomain.s, p.len, p.s,
d.len, d.s);
continue;
}
if(pdt_add_to_tree(&_ptree_new, &sdomain, &p, &d)<0)
{
LM_ERR("Error adding info to tree\n");
goto error;
}
}
if (DB_CAPABILITY(pdt_dbf, DB_CAP_FETCH)) {
if(pdt_dbf.fetch_result(db_con, &db_res, no_rows)<0) {
LM_ERR("Error while fetching!\n");
if (db_res)
pdt_dbf.free_result(db_con, db_res);
goto error;
}
} else {
break;
}
} while(RES_ROW_N(db_res)>0);
pdt_dbf.free_result(db_con, db_res);
/* block all readers */
lock_start_write( pdt_lock );
old_tree = *_ptree;
*_ptree = _ptree_new;
lock_stop_write( pdt_lock );
/* free old data */
if (old_tree!=NULL)
pdt_free_tree(old_tree);
return 0;
error:
pdt_dbf.free_result(db_con, db_res);
if (_ptree_new!=NULL)
pdt_free_tree(_ptree_new);
return -1;
}
int pres_htable_restore(void)
{
/* query all records from presentity table and insert records
* in presentity table */
db_key_t result_cols[6];
db_res_t *result= NULL;
db_row_t *rows= NULL ;
db_val_t *row_vals;
int i;
str user, domain, ev_str, uri, body;
int n_result_cols= 0;
int user_col, domain_col, event_col, expires_col, body_col = 0, etag_col;
int event;
event_t ev;
char* sphere= NULL;
int nr_rows;
str etag;
int no_rows = 10;
result_cols[user_col= n_result_cols++]= &str_username_col;
result_cols[domain_col= n_result_cols++]= &str_domain_col;
result_cols[event_col= n_result_cols++]= &str_event_col;
result_cols[expires_col= n_result_cols++]= &str_expires_col;
result_cols[etag_col= n_result_cols++]= &str_etag_col;
if(sphere_enable)
result_cols[body_col= n_result_cols++]= &str_body_col;
if (pa_dbf.use_table(pa_db, &presentity_table) < 0)
{
LM_ERR("unsuccessful use table sql operation\n");
goto error;
}
/* select the whole tabel and all the columns */
if (DB_CAPABILITY(pa_dbf, DB_CAP_FETCH))
{
if(pa_dbf.query(pa_db,0,0,0,result_cols, 0,
n_result_cols, result_cols[user_col], 0) < 0)
{
LM_ERR("Error while querying (fetch) database\n");
return -1;
}
no_rows = estimate_available_rows( 32+32+32+4+64, n_result_cols);
if (no_rows==0) no_rows = 10;
if(pa_dbf.fetch_result(pa_db,&result, no_rows)<0)
{
LM_ERR("fetching rows failed\n");
return -1;
}
} else
{
if (pa_dbf.query (pa_db, 0, 0, 0,result_cols,0, n_result_cols,
result_cols[user_col], &result) < 0)
{
LM_ERR("querying presentity\n");
goto error;
}
}
nr_rows = RES_ROW_N(result);
do {
LM_DBG("loading information from database for %i records\n", nr_rows);
rows = RES_ROWS(result);
/* for every row */
for(i=0; i<nr_rows; i++)
{
row_vals = ROW_VALUES(rows + i);
if (VAL_NULL(row_vals) || VAL_NULL(row_vals+1))
{
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
str_username_col.len, str_username_col.s,
str_domain_col.len, str_domain_col.s);
continue;
}
if (VAL_NULL(row_vals+2) || VAL_NULL(row_vals+3))
{
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
str_event_col.len, str_event_col.s,
str_domain_col.len, str_domain_col.s);
continue;
}
if(row_vals[expires_col].val.int_val< (int)time(NULL))
continue;
sphere= NULL;
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);
ev_str.s= (char*)row_vals[event_col].val.string_val;
ev_str.len= strlen(ev_str.s);
etag.s= (char*)row_vals[etag_col].val.string_val;
etag.len= strlen(etag.s);
if(event_parser(ev_str.s, ev_str.len, &ev)< 0)
{
LM_ERR("parsing event\n");
free_event_params(ev.params, PKG_MEM_TYPE);
goto error;
}
event= ev.parsed;
free_event_params(ev.params, PKG_MEM_TYPE);
if(uandd_to_uri(user, domain, &uri)< 0)
{
LM_ERR("constructing uri\n");
goto error;
}
/* insert in hash_table*/
if(sphere_enable && event== EVENT_PRESENCE )
{
body.s= (char*)row_vals[body_col].val.string_val;
body.len= strlen(body.s);
sphere= extract_sphere(body);
}
if(insert_phtable(&uri, event, &etag, sphere, 0)== NULL)
{
LM_ERR("inserting record in presentity hash table");
pkg_free(uri.s);
if(sphere)
pkg_free(sphere);
goto error;
}
if(sphere)
pkg_free(sphere);
pkg_free(uri.s);
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(pa_dbf, DB_CAP_FETCH))
{
if (pa_dbf.fetch_result( pa_db, &result, no_rows) < 0)
{
LM_ERR("fetching more rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(result);
} else
nr_rows = 0;
}while (nr_rows>0);
pa_dbf.free_result(pa_db, result);
return 0;
error:
if(result)
pa_dbf.free_result(pa_db, result);
return -1;
}
/* loads data from the db */
int load_info(db_func_t *dr_dbf, db_con_t* db_hdl, str *db_table,
struct tls_domain **serv_dom, struct tls_domain **cli_dom)
{
int int_vals[4];
char *str_vals[11];
int i, n;
int no_rows = 5;
int db_cols = 15;
/* the columns from the db table */
db_key_t columns[15];
/* result from a db query */
db_res_t* res;
/* a row from the db table */
db_row_t* row;
res = 0;
columns[0] = &id_col;
columns[1] = &address_col;
columns[2] = &type_col;
columns[3] = &method_col;
columns[4] = &verify_cert_col;
columns[5] = &require_cert_col;
columns[6] = &certificate_col;
columns[7] = &pk_col;
columns[8] = &crl_check_col;
columns[9] = &crl_dir_col;
columns[10] = &calist_col;
columns[11] = &cadir_col;
columns[12] = &cplist_col;
columns[13] = &dhparams_col;
columns[14] = &eccurve_col;
/* 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;
/* table to use*/
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;
}
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if (dr_dbf->query(db_hdl, 0, 0, 0, columns, 0, db_cols, 0, 0) < 0) {
LM_ERR("DB query failed - retrieve valid connections \n");
goto error;
}
no_rows = estimate_available_rows(10 + 45 + 4 + 45 + 4 + 4 + 45 +
45 + 4 + 45 + 45 + 45 + 45 + 45 + 45, 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, 0, 0, 0, columns, 0, 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;
check_val(id_col, ROW_VALUES(row), DB_STRING, 1, 1);
str_vals[STR_VALS_ID_COL] = (char *) VAL_STRING(ROW_VALUES(row));
check_val(address_col, ROW_VALUES(row) + 1, DB_STRING, 1, 1);
str_vals[STR_VALS_ADDRESS_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 1);
check_val(type_col, ROW_VALUES(row) + 2, DB_INT, 1, 0);
int_vals[INT_VALS_TYPE_COL] = VAL_INT(ROW_VALUES(row) + 2);
check_val(method_col, ROW_VALUES(row) + 3, DB_STRING, 0, 0);
str_vals[STR_VALS_METHOD_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 3);
check_val(verify_cert_col, ROW_VALUES(row) + 4, DB_INT, 0, 0);
int_vals[INT_VALS_VERIFY_CERT_COL] = VAL_INT(ROW_VALUES(row) + 4);
check_val(require_cert_col, ROW_VALUES(row) + 5, DB_INT, 0, 0);
int_vals[INT_VALS_REQUIRE_CERT_COL] = VAL_INT(ROW_VALUES(row) + 5);
check_val(certificate_col, ROW_VALUES(row) + 6, DB_STRING, 0, 0);
str_vals[STR_VALS_CERTIFICATE_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 6);
check_val(pk_col, ROW_VALUES(row) + 7, DB_STRING, 0, 0);
str_vals[STR_VALS_PK_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 7);
check_val(crl_check_col, ROW_VALUES(row) + 8, DB_INT, 0, 0);
int_vals[INT_VALS_CRL_CHECK_COL] = VAL_INT(ROW_VALUES(row) + 8);
check_val(crl_dir_col, ROW_VALUES(row) + 9, DB_STRING, 0, 0);
str_vals[STR_VALS_CRL_DIR_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 9);
check_val(calist_col, ROW_VALUES(row) + 10, DB_STRING, 0, 0);
str_vals[STR_VALS_CALIST_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 10);
check_val(cadir_col, ROW_VALUES(row) + 11, DB_STRING, 0, 0);
str_vals[STR_VALS_CADIR_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 11);
check_val(cplist_col, ROW_VALUES(row) + 12, DB_STRING, 0, 0);
str_vals[STR_VALS_CPLIST_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 12);
check_val(dhparams_col, ROW_VALUES(row) + 13, DB_STRING, 0, 0);
str_vals[STR_VALS_DHPARAMS_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 13);
check_val(eccurve_col, ROW_VALUES(row) + 14, DB_STRING, 0, 0);
str_vals[STR_VALS_ECCURVE_COL] = (char *) VAL_STRING(ROW_VALUES(row) + 14);
tlsp_db_add_domain(str_vals, int_vals, serv_dom, cli_dom);
n++;
}
if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) {
if (dr_dbf->fetch_result(db_hdl, &res, no_rows) < 0) {
LM_ERR("fetching rows\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 0;
error:
LM_ERR("database");
return -1;
}
static int get_all_db_ucontacts(void *buf, int len, unsigned int flags,
unsigned int part_idx, unsigned int part_max)
{
static char query_buf[512];
static str query_str;
static struct sip_uri puri;
struct socket_info *sock;
struct proxy_l next_hop;
db_res_t *res = NULL;
db_row_t *row;
db_val_t *val;
dlist_t *dom;
str uri, host, flag_list;
int i, no_rows = 10;
int now_len;
char now_s[25];
char *p, *p1;
int port, proto, p_len, p1_len;
unsigned int dbflags;
int needed;
int shortage = 0;
shortage = 0;
/* Reserve space for terminating 0000 */
len -= sizeof p_len;
/* get the current time in DB format */
now_len = 25;
if (db_time2str(time(NULL), now_s, &now_len) != 0) {
LM_ERR("failed to print now time\n");
return -1;
}
LM_DBG("buf: %p. flags: %d\n", buf, flags);
/* for each table */
for (dom = root; dom; dom = dom->next) {
if (db_check_table_version(&ul_dbf, ul_dbh, dom->d->name, UL_TABLE_VERSION))
goto error;
/* read the destinations */
if (ul_dbf.use_table(ul_dbh, dom->d->name) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", dom->d->name->len,
dom->d->name->s);
goto error;
}
i = snprintf(query_buf, sizeof query_buf, "select %.*s, %.*s, %.*s,"
#ifdef ORACLE_USRLOC
" %.*s, %.*s from %s where %.*s > %.*s and mod(id, %u) = %u",
#else
" %.*s, %.*s from %s where %.*s > %.*s and id %% %u = %u",
#endif
received_col.len, received_col.s,
contact_col.len, contact_col.s,
sock_col.len, sock_col.s,
cflags_col.len, cflags_col.s,
path_col.len, path_col.s,
dom->d->name->s,
expires_col.len, expires_col.s,
now_len, now_s,
part_max, part_idx);
LM_DBG("query: %.*s\n", (int)(sizeof query_buf), query_buf);
if (i >= sizeof query_buf) {
LM_ERR("DB query too long\n");
goto error;
}
query_str.s = query_buf;
query_str.len = i;
if (DB_CAPABILITY(ul_dbf, DB_CAP_FETCH)) {
if (ul_dbf.raw_query(ul_dbh, &query_str, 0) < 0) {
LM_ERR("raw_query failed\n");
goto error;
}
no_rows = estimate_available_rows(20+128+20+128+64, 5);
if (no_rows == 0)
no_rows = 10;
LM_DBG("fetching %d rows\n", no_rows);
if (ul_dbf.fetch_result(ul_dbh, &res, no_rows) < 0) {
LM_ERR("Error fetching rows\n");
goto error;
}
} else if (ul_dbf.raw_query(ul_dbh, &query_str, &res) < 0) {
LM_ERR("raw_query failed\n");
goto error;
}
do {
for (i = 0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
val = ROW_VALUES(row) + 3; /* cflags */
flag_list.s = (char *)VAL_STRING(val);
flag_list.len = strlen(flag_list.s);
LM_DBG("contact cflags: '%.*s'\n", flag_list.len, flag_list.s);
/* contact is not flagged at all */
if (flags && (val->nul || !flag_list.s))
continue;
dbflags = flag_list_to_bitmask(&flag_list,
FLAG_TYPE_BRANCH, FLAG_DELIM);
LM_DBG("masks: param: %d --- %d :db\n", flags, dbflags);
/* check if contact flags match the given bitmask */
if ((dbflags & flags) != flags)
continue;
/* received */
p = (char*)VAL_STRING(ROW_VALUES(row));
if (VAL_NULL(ROW_VALUES(row)) || !p || !p[0]) {
/* contact */
p = (char*)VAL_STRING(ROW_VALUES(row) + 1);
if (VAL_NULL(ROW_VALUES(row) + 1) || !p || *p == '\0') {
LM_ERR("empty contact -> skipping\n");
continue;
}
}
p_len = strlen(p);
/* path */
p1 = (char*)VAL_STRING(ROW_VALUES(row) + 4);
if (VAL_NULL(ROW_VALUES(row) + 4) || !p1 || *p1 == '\0') {
p1 = NULL;
p1_len = 0;
} else
p1_len = strlen(p1);
needed = (int)(p_len + sizeof p_len + p1_len + sizeof p1_len +
sizeof sock + sizeof dbflags + sizeof next_hop);
LM_DBG("len: %d, needed: %d\n", len, needed);
if (len < needed) {
shortage += needed;
continue;
}
/* determine and parse the URI of this contact's next hop */
if (p1_len > 0) {
/* send to first URI in path */
host.s = p1;
host.len = p1_len;
if (get_path_dst_uri(&host, &uri) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
continue;
}
if (parse_uri(uri.s, uri.len, &puri) < 0) {
LM_ERR("failed to parse path URI of next hop: '%*.s'\n",
p1_len, p1);
return -1;
}
} else {
if (parse_uri(p, p_len, &puri) < 0) {
LM_ERR("failed to parse contact of next hop: '%*.s'\n",
p_len, p);
return -1;
}
}
/* write received/contact */
memcpy(buf, &p_len, sizeof p_len);
buf += sizeof p_len;
memcpy(buf, p, p_len);
buf += p_len;
/* write path */
memcpy(buf, &p1_len, sizeof p1_len);
buf += sizeof p1_len;
memcpy(buf, p1, p1_len);
buf += p1_len;
/* sock */
p = (char*)VAL_STRING(ROW_VALUES(row) + 2);
if (VAL_NULL(ROW_VALUES(row)+2) || !p || *p == '\0') {
sock = NULL;
} else {
if (parse_phostport(p, strlen(p), &host.s, &host.len,
&port, &proto) != 0) {
LM_ERR("bad socket <%s>...ignoring\n", p);
sock = NULL;
} else {
sock = grep_sock_info(&host, (unsigned short)port, proto);
if (!sock)
LM_DBG("non-local socket <%s>...ignoring\n", p);
}
}
/* write sock and flags */
memcpy(buf, &sock, sizeof sock);
buf += sizeof sock;
memcpy(buf, &dbflags, sizeof dbflags);
buf += sizeof dbflags;
memset(&next_hop, 0, sizeof next_hop);
next_hop.port = puri.port_no;
next_hop.proto = puri.proto;
next_hop.name = puri.host;
/* write the next hop */
memcpy(buf, &next_hop, sizeof next_hop);
buf += sizeof next_hop;
len -= needed;
}
if (DB_CAPABILITY(ul_dbf, DB_CAP_FETCH)) {
if (ul_dbf.fetch_result(ul_dbh, &res, no_rows) < 0) {
LM_ERR("fetching rows (1)\n");
goto error;
}
} else
break;
} while (RES_ROW_N(res) > 0);
ul_dbf.free_result(ul_dbh, res);
}
/* len < 0 is possible, if size of the buffer < sizeof c->c.len */
if (len >= 0)
memset(buf, 0, sizeof p_len);
/* Shouldn't happen */
if (shortage > 0 && len > shortage)
abort();
shortage -= len;
return shortage > 0 ? shortage : 0;
error:
if (res)
ul_dbf.free_result(ul_dbh, res);
return -1;
}
