int load_location_number(db_func_t * dbf, db1_con_t* dbh, int *loc_nr){
static char query[UL_DB_QUERY_LEN];
db1_res_t * res;
db_row_t * row;
int query_len;
str tmp;
if(!loc_nr || !dbf || !dbh){
LM_ERR("NULL parameter passed \n");
return -1;
}
query_len = 30 + id_col.len + reg_table.len + status_col.len;
if(query_len > UL_DB_QUERY_LEN) {
LM_ERR("weird: query larger than %i bytes.\n", UL_DB_QUERY_LEN);
return -1;
}
memset(query, 0, UL_DB_QUERY_LEN);
if(sprintf(query,
"SELECT MAX(%.*s) "
"FROM "
"%.*s "
"WHERE %.*s = 1;", id_col.len, id_col.s, reg_table.len, reg_table.s, status_col.len, status_col.s) < 0){
LM_ERR("could not sprinf query\n");
return -1;
}
LM_DBG("%s\n",query);
tmp.s = query;
tmp.len = strlen(query);
if (dbf->raw_query (dbh, &tmp, &res) < 0) {
LM_ERR("in database query.\n");
return -1;
}
if (RES_ROW_N (res) == 0) {
dbf->free_result (dbh, res);
LM_DBG ("no data found\n");
return 1;
}
row = RES_ROWS(res) + 0; /* only one row in answer */
if (VAL_NULL (ROW_VALUES(row) + 0)) {
LM_ERR("Weird: Empty Max ID Number\n");
dbf->free_result (dbh, res);
return 1;
}
*loc_nr = VAL_INT (ROW_VALUES(row) + 0);
dbf->free_result (dbh, res);
if(*loc_nr == 0){
LM_ERR("No location in DB?!\n");
return 1;
}
return 0;
}
/*
* Convert a row from result into db API representation
*/
int convert_row(db_con_t* _h, db_res_t* _res, db_row_t* _r)
{
unsigned long* lengths;
int i;
#ifndef PARANOID
if ((!_h) || (!_r) || (!_n)) {
log(L_ERR, "convert_row(): Invalid parameter value\n");
return -1;
}
#endif
ROW_VALUES(_r) = (db_val_t*)pkg_malloc(sizeof(db_val_t) * RES_COL_N(_res));
ROW_N(_r) = RES_COL_N(_res);
if (!ROW_VALUES(_r)) {
LOG(L_ERR, "convert_row(): No memory left\n");
return -1;
}
lengths = mysql_fetch_lengths(CON_RESULT(_h));
for(i = 0; i < RES_COL_N(_res); i++) {
if (str2val(RES_TYPES(_res)[i], &(ROW_VALUES(_r)[i]),
((MYSQL_ROW)CON_ROW(_h))[i], lengths[i]) < 0) {
LOG(L_ERR, "convert_row(): Error while converting value\n");
free_row(_r);
return -3;
}
}
return 0;
}
/*
* Free all memory allocated by get_result
*/
int bdb_free_result(db_con_t* _h, db_res_t* _r)
{
db_row_t* r;
db_val_t* v;
int i, j;
if (!_r) {
#ifdef BDB_EXTRA_DEBUG
LOG(L_NOTICE, "BDB:bdb_free_result: NULL pointer\n");
#endif
return 0;
}
for (i = 0; i < RES_ROW_N(_r); i++) {
r = &(RES_ROWS(_r)[i]);
for (j = 0; j < RES_COL_N(_r); j++) {
v = &(ROW_VALUES(r)[j]);
if (VAL_TYPE(v) == DB_STRING || VAL_TYPE(v) == DB_STR || VAL_TYPE(v) == DB_BLOB) {
free(VAL_STR(v).s);
}
}
free(ROW_VALUES(r));
}
free(RES_ROWS(_r));
for (i = 0; i < RES_COL_N(_r); i++) {
pkg_free((void *)RES_NAMES(_r)[i]);
}
pkg_free(RES_NAMES(_r));
pkg_free(RES_TYPES(_r));
pkg_free(_r);
return 0;
}
/*
* Release memory used by row
*/
int free_row(db_row_t* _r)
{
#ifndef PARANOID
if (!_r) {
LOG(L_ERR, "free_row(): Invalid parameter value\n");
return -1;
}
#endif
if (ROW_VALUES(_r)) pkg_free(ROW_VALUES(_r));
return 0;
}
/*
* Release memory used by row
*/
int dbt_free_row(db_row_t* _r)
{
if (!_r)
{
#ifdef DBT_EXTRA_DEBUG
LOG(L_ERR, "DBT:dbt_free_row: Invalid parameter value\n");
#endif
return -1;
}
if(ROW_VALUES(_r))
pkg_free(ROW_VALUES(_r));
return 0;
}
int load_user_carrier(str * user, str * domain) {
db1_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;
int use_domain = cfg_get(carrierroute, carrierroute_cfg, use_domain);
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;
VAL_TYPE(vals) = DB1_STR;
VAL_NULL(vals) = 0;
VAL_STR(vals) = *user;
keys[1] = subscriber_columns[SUBSCRIBER_DOMAIN_COL];
op[1] = OP_EQ;
VAL_TYPE(vals+1) = DB1_STR;
VAL_NULL(vals+1) = 0;
VAL_STR(vals+1) = *domain;
if (carrierroute_dbf.use_table(carrierroute_dbh, &subscriber_table) < 0) {
LM_ERR("can't use table\n");
return -1;
}
if (carrierroute_dbf.query(carrierroute_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) {
carrierroute_dbf.free_result(carrierroute_dbh, res);
return 0;
}
if (VAL_NULL(ROW_VALUES(RES_ROWS(res)))) {
carrierroute_dbf.free_result(carrierroute_dbh, res);
return 0;
}
id = VAL_INT(ROW_VALUES(RES_ROWS(res)));
carrierroute_dbf.free_result(carrierroute_dbh, res);
return id;
}
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;
}
/**
* Allocate memory for row value.
* \param _res result set
* \param _row filled row
* \return zero on success, negative on errors
*/
inline int db_allocate_row(const db1_res_t* _res, db_row_t* _row)
{
int len = sizeof(db_val_t) * RES_COL_N(_res);
ROW_VALUES(_row) = (db_val_t*)pkg_malloc(len);
if (!ROW_VALUES(_row)) {
LM_ERR("no private memory left\n");
return -1;
}
LM_DBG("allocate %d bytes for row values at %p\n", len, ROW_VALUES(_row));
memset(ROW_VALUES(_row), 0, len);
/* Save the number of columns in the ROW structure */
ROW_N(_row) = RES_COL_N(_res);
return 0;
}
/**
* Convert a row from the result query into db API representation
*/
int db_postgres_convert_row(const db_con_t* _h, db_res_t* _r, db_row_t* _row,
char **row_buf)
{
int col, len;
if (!_h || !_r || !_row) {
LM_ERR("invalid parameter value\n");
return -1;
}
/* Save the number of columns in the ROW structure */
ROW_N(_row) = RES_COL_N(_r);
/* For each column in the row */
for(col = 0; col < ROW_N(_row); col++) {
/* compute the len of the value */
if ( row_buf[col]==NULL || row_buf[col][0]=='\0')
len = 0;
else
len = strlen(row_buf[col]);
/* Convert the string representation into the value representation */
if (db_postgres_str2val(RES_TYPES(_r)[col], &(ROW_VALUES(_row)[col]),
row_buf[col], len) < 0) {
LM_ERR("failed to convert value\n");
LM_DBG("free row at %pn", _row);
db_free_row(_row);
return -3;
}
}
return 0;
}
/*!
* \brief Convert a row from result into DB API representation
* \param _h database connection
* \param _res database result in the DB API representation
* \param _r database result row
* \return 0 on success, -1 on failure
*/
int db_mysql_convert_row(const db1_con_t* _h, db1_res_t* _res, db_row_t* _r)
{
unsigned long* lengths;
int i;
if ((!_h) || (!_res) || (!_r)) {
LM_ERR("invalid parameter value\n");
return -1;
}
if (db_allocate_row(_res, _r) != 0) {
LM_ERR("could not allocate row");
return -2;
}
lengths = mysql_fetch_lengths(CON_RESULT(_h));
for(i = 0; i < RES_COL_N(_res); i++) {
if (db_str2val(RES_TYPES(_res)[i], &(ROW_VALUES(_r)[i]),
((MYSQL_ROW)CON_ROW(_h))[i], lengths[i], 0) < 0) {
LM_ERR("failed to convert value\n");
LM_DBG("free row at %p\n", _r);
db_free_row(_r);
return -3;
}
}
return 0;
}
/*!
* \brief Convert a row from the result query into db API representation
* \param _h database connection
* \param _r result set
* \param _row row
* \param row_buf row buffer
* \return 0 on success, negative on error
*/
int db_postgres_convert_row(const db1_con_t* _h, db1_res_t* _r, db_row_t* _row,
char **row_buf)
{
int col, col_len;
if (!_h || !_r || !_row) {
LM_ERR("invalid parameter value\n");
return -1;
}
if (db_allocate_row(_r, _row) != 0) {
LM_ERR("could not allocate row\n");
return -2;
}
/* For each column in the row */
for(col = 0; col < ROW_N(_row); col++) {
/* because it can contain NULL */
if (!row_buf[col]) {
col_len = 0;
} else {
col_len = strlen(row_buf[col]);
}
/* Convert the string representation into the value representation */
if (db_postgres_str2val(RES_TYPES(_r)[col], &(ROW_VALUES(_row)[col]),
row_buf[col], col_len) < 0) {
LM_ERR("failed to convert value\n");
LM_DBG("free row at %p\n", _row);
db_free_row(_row);
return -3;
}
}
return 0;
}
/**
* Convert a row from result into db API representation
*/
int db_mysql_convert_row(const db_con_t* _h, db_res_t* _res, db_row_t* _r)
{
unsigned long* lengths;
int i;
if ((!_h) || (!_res) || (!_r)) {
LM_ERR("invalid parameter value\n");
return -1;
}
/* Save the number of columns in the ROW structure */
ROW_N(_r) = RES_COL_N(_res);
if (CON_HAS_PS(_h)) {
for(i=0; i < CON_MYSQL_PS(_h)->cols_out; i++) {
if (db_mysql_str2val(RES_TYPES(_res)[i], &(ROW_VALUES(_r)[i]),
CON_PS_OUTCOL(_h, i).null?NULL:CON_PS_OUTCOL(_h, i).buf,
CON_PS_OUTCOL(_h,i).len) < 0) {
LM_ERR("failed to convert value from stmt\n");
db_free_row(_r);
return -3;
}
}
} else {
lengths = mysql_fetch_lengths(CON_RESULT(_h));
for(i = 0; i < RES_COL_N(_res); i++) {
if (db_mysql_str2val(RES_TYPES(_res)[i], &(ROW_VALUES(_r)[i]),
((MYSQL_ROW)CON_ROW(_h))[i], lengths[i]) < 0) {
LM_ERR("failed to convert value\n");
LM_DBG("free row at %p\n", _r);
db_free_row(_r);
return -3;
}
}
}
return 0;
}
int get_max_no_of_db_id(db_func_t * dbf, db1_con_t * dbh, int id){
db1_res_t * res;
db_row_t * row;
int query_len, max;
str tmp;
query_len = 50 + reg_table.len + id_col.len + num_col.len;
if(query_len > UL_DB_QUERY_LEN){
LM_ERR("weird: query too long.\n");
return -1;
}
memset(query, 0, UL_DB_QUERY_LEN);
if (sprintf(query,
"SELECT MAX(%.*s) "
"FROM %.*s "
"WHERE %.*s='%i'",
num_col.len, num_col.s,
reg_table.len, reg_table.s,
id_col.len, id_col.s, id) < 0) {
LM_ERR("could not print query\n");
return -1;
}
tmp.s = query;
tmp.len = strlen(query);
if(dbf->raw_query(dbh, &tmp, &res) < 0){
LM_ERR("weird: could not query %.*s.\n",
reg_table.len, reg_table.s);
return -1;
}
if(RES_ROW_N(res) == 0){
LM_ERR("weird: no data found for id %i\n", id);
dbf->free_result(dbh, res);
return -1;
}
row = RES_ROWS(res);
max = VAL_INT(ROW_VALUES(row));
dbf->free_result(dbh, res);
return max;
}
int bdb_row_match(db_key_t* _k, db_op_t* _op, db_val_t* _v, int _n, db_res_t* _r, int* _lkey )
{
int i, res;
db_row_t* row = NULL;
if(!_r || !_lkey)
return 1;
row = RES_ROWS(_r);
for(i=0; i<_n; i++) {
res = bdb_cmp_val(&(ROW_VALUES(row)[_lkey[i]]), &_v[i]);
if(!_op || !strcmp(_op[i], OP_EQ)) {
if(res!=0)
return 0;
} else {
if(!strcmp(_op[i], OP_LT)) {
if(res!=-1)
return 0;
} else {
if(!strcmp(_op[i], OP_GT)) {
if(res!=1)
return 0;
} else {
if(!strcmp(_op[i], OP_LEQ)) {
if(res==1)
return 0;
} else {
if(!strcmp(_op[i], OP_GEQ)) {
if(res==-1)
return 0;
} else {
return res;
}}}}}
}
return 1;
}
/*
* Convert a row from result into db API representation
*/
int db_unixodbc_convert_row(const db_con_t* _h, const db_res_t* _res,
db_row_t* _r, const unsigned long* lengths)
{
int i;
if ((!_h) || (!_res) || (!_r)) {
LM_ERR("invalid parameter value\n");
return -1;
}
/* Save the number of columns in the ROW structure */
ROW_N(_r) = RES_COL_N(_res);
for(i = 0; i < RES_COL_N(_res); i++) {
if (db_unixodbc_str2val(RES_TYPES(_res)[i], &(ROW_VALUES(_r)[i]),
((CON_ROW(_h))[i]), lengths[i]) < 0) {
LM_ERR("failed to convert value\n");
LM_DBG("free row at %p\n", _r);
db_free_row(_r);
return -3;
}
}
return 0;
}
/*
* Allocate storage for rows in existing
* result structure.
*/
int db_allocate_rows(db_res_t* _res, const unsigned int rows)
{
unsigned int i;
RES_ROWS(_res) = (struct db_row*)pkg_malloc
(rows * (sizeof(db_row_t) + sizeof(db_val_t) * RES_COL_N(_res)) );
if (!RES_ROWS(_res)) {
LM_ERR("no memory left\n");
return -1;
}
memset( RES_ROWS(_res), 0 ,
rows * (sizeof(db_row_t) + sizeof(db_val_t) * RES_COL_N(_res)));
LM_DBG("allocate %d bytes for result rows and values at %p\n",
(int)(rows * (sizeof(db_row_t) + sizeof(db_val_t) * RES_COL_N(_res))),
RES_ROWS(_res));
for( i=0 ; i<rows ; i++ )
/* the values of the row i */
ROW_VALUES( &(RES_ROWS(_res)[i]) ) =
((db_val_t*)(RES_ROWS(_res)+rows)) + RES_COL_N(_res)*i;
return 0;
}
/*
* Convert a row from result into db API representation
*/
static int dbt_convert_row(db1_res_t* _res, db_row_t* _r, dbt_row_p _r1)
{
int i;
if (!_r || !_res || !_r1) {
LM_ERR("invalid parameter value\n");
return -1;
}
if (db_allocate_row(_res, _r) != 0) {
LM_ERR("could not allocate row");
return -2;
}
for(i = 0; i < RES_COL_N(_res); i++) {
(ROW_VALUES(_r)[i]).nul = _r1->fields[i].nul;
switch(RES_TYPES(_res)[i])
{
case DB1_INT:
VAL_INT(&(ROW_VALUES(_r)[i])) =
_r1->fields[i].val.int_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB1_INT;
break;
case DB1_BIGINT:
LM_ERR("BIGINT not supported");
return -1;
case DB1_DOUBLE:
VAL_DOUBLE(&(ROW_VALUES(_r)[i])) =
_r1->fields[i].val.double_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB1_DOUBLE;
break;
case DB1_STRING:
VAL_STR(&(ROW_VALUES(_r)[i])).s =
_r1->fields[i].val.str_val.s;
VAL_STR(&(ROW_VALUES(_r)[i])).len =
_r1->fields[i].val.str_val.len;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB1_STRING;
VAL_FREE(&(ROW_VALUES(_r)[i])) = 0;
break;
case DB1_STR:
VAL_STR(&(ROW_VALUES(_r)[i])).s =
_r1->fields[i].val.str_val.s;
VAL_STR(&(ROW_VALUES(_r)[i])).len =
_r1->fields[i].val.str_val.len;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB1_STR;
VAL_FREE(&(ROW_VALUES(_r)[i])) = 0;
break;
case DB1_DATETIME:
VAL_INT(&(ROW_VALUES(_r)[i])) =
_r1->fields[i].val.int_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB1_DATETIME;
break;
case DB1_BLOB:
VAL_STR(&(ROW_VALUES(_r)[i])).s =
_r1->fields[i].val.str_val.s;
VAL_STR(&(ROW_VALUES(_r)[i])).len =
_r1->fields[i].val.str_val.len;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB1_BLOB;
VAL_FREE(&(ROW_VALUES(_r)[i])) = 0;
break;
case DB1_BITMAP:
VAL_INT(&(ROW_VALUES(_r)[i])) =
_r1->fields[i].val.bitmap_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB1_INT;
break;
default:
LM_ERR("val type [%d] not supported", RES_TYPES(_res)[i]);
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;
}
int b2b_logic_restore(void)
{
int i;
int nr_rows;
int _time;
db_res_t *result= NULL;
db_row_t *rows = NULL;
db_val_t *row_vals= NULL;
b2bl_tuple_t tuple;
str b2bl_key;
str scenario_id;
b2bl_entity_id_t bridge_entities[3];
str* params[MAX_SCENARIO_PARAMS];
if(b2bl_db == NULL)
{
LM_DBG("NULL database connection\n");
return 0;
}
if(b2bl_dbf.use_table(b2bl_db, &b2bl_dbtable)< 0)
{
LM_ERR("sql use table failed\n");
return -1;
}
if (DB_CAPABILITY(b2bl_dbf, DB_CAP_FETCH))
{
if(b2bl_dbf.query(b2bl_db, 0, 0, 0, qcols, 0,
DB_COLS_NO, 0, 0) < 0)
{
LM_ERR("Error while querying (fetch) database\n");
return -1;
}
if(b2bl_dbf.fetch_result(b2bl_db,&result,B2BL_FETCH_SIZE)<0)
{
LM_ERR("fetching rows failed\n");
return -1;
}
}
else
{
if (b2bl_dbf.query(b2bl_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 [%i] records from db\n", nr_rows);
rows = RES_ROWS(result);
/* for every row */
for(i=0; i<nr_rows; i++)
{
row_vals = ROW_VALUES(rows +i);
memset(&tuple, 0, sizeof(b2bl_tuple_t));
b2bl_key.s = (char*)row_vals[0].val.string_val;
b2bl_key.len = b2bl_key.s?strlen(b2bl_key.s):0;
tuple.key = &b2bl_key;
if(row_vals[1].val.string_val)
{
scenario_id.s = (char*)row_vals[1].val.string_val;
scenario_id.len = strlen(scenario_id.s);
tuple.scenario = get_scenario_id(&scenario_id);
}
memset(bridge_entities, 0, 3*sizeof(b2bl_entity_id_t));
memset(params, 0, MAX_SCENARIO_PARAMS* sizeof(str*));
if(row_vals[2].val.string_val)
{
tuple.scenario_params[0].s =(char*)row_vals[2].val.string_val;
tuple.scenario_params[0].len = strlen(tuple.scenario_params[0].s);
params[0] = &tuple.scenario_params[0];
}
if(row_vals[3].val.string_val)
{
tuple.scenario_params[1].s =(char*)row_vals[3].val.string_val;
tuple.scenario_params[1].len = strlen(tuple.scenario_params[1].s);
params[1] = &tuple.scenario_params[1];
}
if(row_vals[4].val.string_val)
{
tuple.scenario_params[2].s =(char*)row_vals[4].val.string_val;
tuple.scenario_params[2].len = strlen(tuple.scenario_params[2].s);
params[2] = &tuple.scenario_params[2];
}
if(row_vals[5].val.string_val)
{
tuple.scenario_params[3].s =(char*)row_vals[5].val.string_val;
tuple.scenario_params[3].len = strlen(tuple.scenario_params[3].s);
params[3] = &tuple.scenario_params[3];
}
if(row_vals[6].val.string_val)
{
tuple.scenario_params[4].s =(char*)row_vals[6].val.string_val;
tuple.scenario_params[4].len = strlen(tuple.scenario_params[4].s);
params[4] = &tuple.scenario_params[4];
}
if(row_vals[7].val.string_val)
{
tuple.sdp.s =(char*)row_vals[7].val.string_val;
tuple.sdp.len = strlen(tuple.sdp.s);
}
tuple.scenario_state =row_vals[8].val.int_val;
tuple.next_scenario_state=row_vals[9].val.int_val;
_time = (int)time(NULL);
if (row_vals[10].val.int_val <= _time)
tuple.lifetime = 1;
else
tuple.lifetime=row_vals[10].val.int_val - _time + get_ticks();
bridge_entities[0].type = row_vals[11].val.int_val;
bridge_entities[0].scenario_id.s =(char*)row_vals[12].val.string_val;
bridge_entities[0].scenario_id.len=
bridge_entities[0].scenario_id.s?strlen(bridge_entities[0].scenario_id.s):0;
bridge_entities[0].to_uri.s =(char*)row_vals[13].val.string_val;
bridge_entities[0].to_uri.len=
bridge_entities[0].to_uri.s?strlen(bridge_entities[0].to_uri.s):0;
bridge_entities[0].from_uri.s=(char*)row_vals[14].val.string_val;
bridge_entities[0].from_uri.len=
bridge_entities[0].from_uri.s?strlen(bridge_entities[0].from_uri.s):0;
bridge_entities[0].key.s =(char*)row_vals[15].val.string_val;
bridge_entities[0].key.len=
bridge_entities[0].key.s?strlen(bridge_entities[0].key.s):0;
bridge_entities[1].type = row_vals[16].val.int_val;
bridge_entities[1].scenario_id.s = (char*)row_vals[17].val.string_val;
bridge_entities[1].scenario_id.len=
bridge_entities[1].scenario_id.s?strlen(bridge_entities[1].scenario_id.s):0;
bridge_entities[1].to_uri.s = (char*)row_vals[18].val.string_val;
bridge_entities[1].to_uri.len=
bridge_entities[1].to_uri.s?strlen(bridge_entities[1].to_uri.s):0;
bridge_entities[1].from_uri.s = (char*)row_vals[19].val.string_val;
bridge_entities[1].from_uri.len=
bridge_entities[1].from_uri.s?strlen(bridge_entities[1].from_uri.s):0;
bridge_entities[1].key.s = (char*)row_vals[20].val.string_val;
bridge_entities[1].key.len=
bridge_entities[1].key.s?strlen(bridge_entities[1].key.s):0;
if(row_vals[21].val.string_val)
{
bridge_entities[2].type = row_vals[21].val.int_val;
bridge_entities[2].scenario_id.s = (char*)row_vals[22].val.string_val;
bridge_entities[2].scenario_id.len=
bridge_entities[2].scenario_id.s?strlen(bridge_entities[2].scenario_id.s):0;
bridge_entities[2].to_uri.s = (char*)row_vals[23].val.string_val;
bridge_entities[2].to_uri.len=
bridge_entities[2].to_uri.s?strlen(bridge_entities[2].to_uri.s):0;
bridge_entities[2].from_uri.s = (char*)row_vals[24].val.string_val;
bridge_entities[2].from_uri.len=
bridge_entities[2].from_uri.s?strlen(bridge_entities[2].from_uri.s):0;
bridge_entities[2].key.s = (char*)row_vals[25].val.string_val;
bridge_entities[2].key.len=
bridge_entities[2].key.s?strlen(bridge_entities[2].key.s):0;
}
tuple.bridge_entities[0] = &bridge_entities[0];
tuple.bridge_entities[1] = &bridge_entities[1];
tuple.bridge_entities[2] = &bridge_entities[2];
if(b2bl_add_tuple(&tuple, params) < 0)
{
LM_ERR("Failed to add new tuple\n");
goto error;
}
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(b2bl_dbf, DB_CAP_FETCH)) {
if (b2bl_dbf.fetch_result( b2bl_db, &result,
B2BL_FETCH_SIZE ) < 0)
{
LM_ERR("fetching more rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(result);
} else {
nr_rows = 0;
}
}while (nr_rows>0);
b2bl_dbf.free_result(b2bl_db, result);
LM_DBG("Finished\n");
return 0;
error:
if(result)
b2bl_dbf.free_result(b2bl_db, result);
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;
}
/*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;
}
/*
* 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;
}
/*
* 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);
}
}
/*
* 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;
}
/*
* Matches from uri against patterns returned from database. Returns number
* of matches or -1 if none of the patterns match.
*/
static int match_res(struct sip_msg* msg, int proto, db1_res_t* _r)
{
int i, tag_avp_type;
str uri, ruri;
char uri_string[MAX_URI_SIZE+1];
char ruri_string[MAX_URI_SIZE+1];
db_row_t* row;
db_val_t* val;
regex_t preg;
int_str tag_avp, avp_val;
int count = 0;
if (IS_SIP(msg)) {
if (parse_from_header(msg) < 0) return -1;
uri = get_from(msg)->uri;
if (uri.len > MAX_URI_SIZE) {
LM_ERR("message has From URI too large\n");
return -1;
}
memcpy(uri_string, uri.s, uri.len);
uri_string[uri.len] = (char)0;
ruri = msg->first_line.u.request.uri;
if (ruri.len > MAX_URI_SIZE) {
LM_ERR("message has Request URI too large\n");
return -1;
}
memcpy(ruri_string, ruri.s, ruri.len);
ruri_string[ruri.len] = (char)0;
}
get_tag_avp(&tag_avp, &tag_avp_type);
row = RES_ROWS(_r);
for(i = 0; i < RES_ROW_N(_r); i++) {
val = ROW_VALUES(row + i);
if ((ROW_N(row + i) == 4) &&
(VAL_TYPE(val) == DB1_STRING) && !VAL_NULL(val) &&
match_proto(VAL_STRING(val), proto) &&
(VAL_NULL(val + 1) ||
((VAL_TYPE(val + 1) == DB1_STRING) && !VAL_NULL(val + 1))) &&
(VAL_NULL(val + 2) ||
((VAL_TYPE(val + 2) == DB1_STRING) && !VAL_NULL(val + 2))) &&
(VAL_NULL(val + 3) ||
((VAL_TYPE(val + 3) == DB1_STRING) && !VAL_NULL(val + 3))))
{
if (IS_SIP(msg)) {
if (!VAL_NULL(val + 1)) {
if (regcomp(&preg, (char *)VAL_STRING(val + 1), REG_NOSUB)) {
LM_ERR("invalid regular expression\n");
if (VAL_NULL(val + 2)) {
continue;
}
}
if (regexec(&preg, uri_string, 0, (regmatch_t *)0, 0)) {
regfree(&preg);
continue;
}
regfree(&preg);
}
if (!VAL_NULL(val + 2)) {
if (regcomp(&preg, (char *)VAL_STRING(val + 2), REG_NOSUB)) {
LM_ERR("invalid regular expression\n");
continue;
}
if (regexec(&preg, ruri_string, 0, (regmatch_t *)0, 0)) {
regfree(&preg);
continue;
}
regfree(&preg);
}
}
/* Found a match */
if (tag_avp.n && !VAL_NULL(val + 3)) {
avp_val.s.s = (char *)VAL_STRING(val + 3);
avp_val.s.len = strlen(avp_val.s.s);
if (add_avp(tag_avp_type|AVP_VAL_STR, tag_avp, avp_val) != 0) {
LM_ERR("failed to set of tag_avp failed\n");
return -1;
}
}
if (!peer_tag_mode)
return 1;
count++;
}
}
if (!count)
return -1;
else
return count;
}
/**
* worker implementation
* - jwl : pointer to the workers list
* - jaddress : address of the jabber server
* - jport : port of the jabber server
* - rank : worker's rank
* - db_con : connection to database
* dbf: database module callbacks structure
* #return : 0 on success or <0 on error
*/
int xj_worker_process(xj_wlist jwl, char* jaddress, int jport, int rank,
db_con_t* db_con, db_func_t* dbf)
{
int pipe, ret, i, pos, maxfd, flag;
xj_jcon_pool jcp;
struct timeval tmv;
fd_set set, mset;
xj_sipmsg jsmsg;
str sto;
xj_jcon jbc = NULL;
xj_jconf jcf = NULL;
char *p, buff[1024], recv_buff[4096];
int flags, nr, ltime = 0;
db_key_t keys[] = {"sip_id", "type"};
db_val_t vals[2];
db_key_t col[] = {"jab_id", "jab_passwd"};
db_res_t* res = NULL;
vals[0].type=DB_STRING;
vals[0].nul=0;
vals[0].val.string_val=buff;
vals[1].type=DB_INT;
vals[1].nul=0;
vals[1].val.int_val=0;
_xj_pid = getpid();
//signal(SIGTERM, xj_sig_handler);
//signal(SIGINT, xj_sig_handler);
//signal(SIGQUIT, xj_sig_handler);
signal(SIGSEGV, xj_sig_handler);
if(registrar)
{
jab_gw_name.s = registrar;
jab_gw_name.len = strlen(registrar);
if(registrar[0]== 's' && registrar[1]== 'i' &&
registrar[2]== 'p' && registrar[3]== ':')
{
jab_gw_name.s += 4;
jab_gw_name.len -= 4;
}
}
if(!jwl || !jwl->aliases || !jwl->aliases->jdm
|| !jaddress || rank >= jwl->len)
{
DBG("XJAB:xj_worker[%d]:%d: exiting - wrong parameters\n",
rank, _xj_pid);
return -1;
}
pipe = jwl->workers[rank].rpipe;
DBG("XJAB:xj_worker[%d]:%d: started - pipe=<%d> : 1st message delay"
" <%d>\n", rank, _xj_pid, pipe, jwl->delayt);
if((jcp=xj_jcon_pool_init(jwl->maxj,XJ_MSG_POOL_SIZE,jwl->delayt))==NULL)
{
DBG("XJAB:xj_worker: cannot allocate the pool\n");
return -1;
}
maxfd = pipe;
tmv.tv_sec = jwl->sleept;
tmv.tv_usec = 0;
FD_ZERO(&set);
FD_SET(pipe, &set);
while(main_loop)
{
mset = set;
tmv.tv_sec = (jcp->jmqueue.size == 0)?jwl->sleept:1;
#ifdef XJ_EXTRA_DEBUG
//DBG("XJAB:xj_worker[%d]:%d: select waiting %ds - queue=%d\n",rank,
// _xj_pid, (int)tmv.tv_sec, jcp->jmqueue.size);
#endif
tmv.tv_usec = 0;
ret = select(maxfd+1, &mset, NULL, NULL, &tmv);
// check the msg queue
xj_worker_check_qmsg(jwl, jcp);
if(ret <= 0)
goto step_x;
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: something is coming\n", _xj_pid);
#endif
if(!FD_ISSET(pipe, &mset))
goto step_y;
if(read(pipe, &jsmsg, sizeof(jsmsg)) < sizeof(jsmsg))
{
DBG("XJAB:xj_worker:%d: BROKEN PIPE - exiting\n", _xj_pid);
break;
}
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: job <%p> from SER\n", _xj_pid, jsmsg);
#endif
if(jsmsg == NULL || jsmsg->jkey==NULL || jsmsg->jkey->id==NULL)
goto step_w;
strncpy(buff, jsmsg->jkey->id->s, jsmsg->jkey->id->len);
buff[jsmsg->jkey->id->len] = 0;
jbc = xj_jcon_pool_get(jcp, jsmsg->jkey);
switch(jsmsg->type)
{
case XJ_SEND_MESSAGE:
if(!xj_jconf_check_addr(&jsmsg->to, jwl->aliases->dlm) &&
(!jbc||!xj_jcon_get_jconf(jbc,&jsmsg->to,jwl->aliases->dlm)))
{
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_NOTJCONF, NULL);
goto step_w;
}
break;
case XJ_REG_WATCHER:
case XJ_JOIN_JCONF:
case XJ_GO_ONLINE:
break;
case XJ_EXIT_JCONF:
if(jbc == NULL)
goto step_w;
// close the conference session here
if(jbc->nrjconf <= 0)
goto step_w;
if(!xj_jconf_check_addr(&jsmsg->to, jwl->aliases->dlm))
xj_jcon_del_jconf(jbc, &jsmsg->to, jwl->aliases->dlm,
XJ_JCMD_UNSUBSCRIBE);
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_INF_JCONFEXIT, NULL);
goto step_w;
case XJ_GO_OFFLINE:
if(jbc != NULL)
jbc->expire = ltime = -1;
goto step_w;
case XJ_DEL_WATCHER:
default:
goto step_w;
}
if(jbc != NULL)
{
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: connection already exists"
" for <%s> ...\n", _xj_pid, buff);
#endif
xj_jcon_update(jbc, jwl->cachet);
goto step_z;
}
// NO OPEN CONNECTION FOR THIS SIP ID
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: new connection for <%s>.\n", _xj_pid, buff);
#endif
if(dbf->query(db_con, keys, 0, vals, col, 2, 2, NULL, &res) != 0 ||
RES_ROW_N(res) <= 0)
{
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: no database result when looking"
" for associated Jabber account\n", _xj_pid);
#endif
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_JGWFORB, NULL);
goto step_v;
}
jbc = xj_jcon_init(jaddress, jport);
if(xj_jcon_connect(jbc))
{
DBG("XJAB:xj_worker:%d: Cannot connect"
" to the Jabber server ...\n", _xj_pid);
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_NOJSRV, NULL);
goto step_v;
}
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker: auth to jabber as: [%s] / [xxx]\n",
(char*)(ROW_VALUES(RES_ROWS(res))[0].val.string_val));
// (char*)(ROW_VALUES(RES_ROWS(res))[1].val.string_val));
#endif
if(xj_jcon_user_auth(jbc,
(char*)(ROW_VALUES(RES_ROWS(res))[0].val.string_val),
(char*)(ROW_VALUES(RES_ROWS(res))[1].val.string_val),
XJAB_RESOURCE) < 0)
{
DBG("XJAB:xj_worker:%d: Authentication to the Jabber server"
" failed ...\n", _xj_pid);
xj_jcon_disconnect(jbc);
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_JAUTH, NULL);
xj_jcon_free(jbc);
goto step_v;
}
if(xj_jcon_set_attrs(jbc, jsmsg->jkey, jwl->cachet, jwl->delayt)
|| xj_jcon_pool_add(jcp, jbc))
{
DBG("XJAB:xj_worker:%d: Keeping connection to Jabber server"
" failed! Not enough memory ...\n", _xj_pid);
xj_jcon_disconnect(jbc);
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_JGWFULL, NULL);
xj_jcon_free(jbc);
goto step_v;
}
/** add socket descriptor to select */
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: add connection on <%d> \n", _xj_pid, jbc->sock);
#endif
if(jbc->sock > maxfd)
maxfd = jbc->sock;
FD_SET(jbc->sock, &set);
xj_jcon_get_roster(jbc);
xj_jcon_send_presence(jbc, NULL, NULL, "Online", "9");
/** wait for a while - the worker is tired */
//sleep(3);
if ((res != NULL) && (dbf->free_result(db_con,res) < 0))
{
DBG("XJAB:xj_worker:%d:Error while freeing"
" SQL result - worker terminated\n", _xj_pid);
return -1;
}
else
res = NULL;
step_z:
if(jsmsg->type == XJ_GO_ONLINE)
goto step_w;
if(jsmsg->type == XJ_REG_WATCHER)
{ // update or register a presence watcher
xj_worker_check_watcher(jwl, jcp, jbc, jsmsg);
goto step_w;
}
flag = 0;
if(!xj_jconf_check_addr(&jsmsg->to, jwl->aliases->dlm))
{
if((jcf = xj_jcon_get_jconf(jbc, &jsmsg->to, jwl->aliases->dlm))
!= NULL)
{
if((jsmsg->type == XJ_JOIN_JCONF) &&
!(jcf->status & XJ_JCONF_READY ||
jcf->status & XJ_JCONF_WAITING))
{
if(!xj_jcon_jconf_presence(jbc,jcf,NULL,"online"))
jcf->status = XJ_JCONF_WAITING;
else
{
// unable to join the conference
// --- send back to SIP user a msg
xj_send_sip_msgz(_PADDR(jwl),jsmsg->jkey->id,&jsmsg->to,
XJ_DMSG_ERR_JOINJCONF, &jbc->jkey->flag);
goto step_w;
}
}
flag |= XJ_ADDRTR_CON;
}
else
{
// unable to get the conference
// --- send back to SIP user a msg
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_NEWJCONF, &jbc->jkey->flag);
goto step_w;
}
}
if(jsmsg->type != XJ_SEND_MESSAGE)
goto step_w;
// here will come only XJ_SEND_MESSAGE
switch(xj_jcon_is_ready(jbc,jsmsg->to.s,jsmsg->to.len,jwl->aliases->dlm))
{
case 0:
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: SENDING the message to Jabber"
" network ...\n", _xj_pid);
#endif
/*** address correction ***/
sto.s = buff;
sto.len = 0;
flag |= XJ_ADDRTR_S2J;
if(xj_address_translation(&jsmsg->to, &sto, jwl->aliases,
flag) == 0)
{
if(xj_jcon_send_msg(jbc, sto.s, sto.len,
jsmsg->msg.s, jsmsg->msg.len,
(flag&XJ_ADDRTR_CON)?XJ_JMSG_GROUPCHAT:XJ_JMSG_CHAT)<0)
xj_send_sip_msgz(_PADDR(jwl),jsmsg->jkey->id,&jsmsg->to,
XJ_DMSG_ERR_SENDJMSG, &jbc->jkey->flag);
}
else
DBG("XJAB:xj_worker:%d: ERROR SENDING as Jabber"
" message ...\n", _xj_pid);
goto step_w;
case 1:
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d:SCHEDULING the message.\n", _xj_pid);
#endif
if(xj_jcon_pool_add_jmsg(jcp, jsmsg, jbc) < 0)
{
DBG("XJAB:xj_worker:%d: SCHEDULING the message FAILED."
" Message was dropped.\n",_xj_pid);
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_STOREJMSG, &jbc->jkey->flag);
goto step_w;
}
else // skip freeing the SIP message - now is in queue
goto step_y;
case 2:
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_NOREGIM, &jbc->jkey->flag);
goto step_w;
case 3: // not joined to Jabber conference
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_NOTJCONF, &jbc->jkey->flag);
goto step_w;
default:
xj_send_sip_msgz(_PADDR(jwl), jsmsg->jkey->id, &jsmsg->to,
XJ_DMSG_ERR_SENDJMSG, &jbc->jkey->flag);
goto step_w;
}
step_v: // error connecting to Jabber server
// cleaning jab_wlist
xj_wlist_del(jwl, jsmsg->jkey, _xj_pid);
// cleaning db_query
if ((res != NULL) && (dbf->free_result(db_con,res) < 0))
{
DBG("XJAB:xj_worker:%d:Error while freeing"
" SQL result - worker terminated\n", _xj_pid);
return -1;
}
else
res = NULL;
step_w:
if(jsmsg!=NULL)
{
xj_sipmsg_free(jsmsg);
jsmsg = NULL;
}
step_y:
// check for new message from ... JABBER
for(i = 0; i < jcp->len && main_loop; i++)
{
if(jcp->ojc[i] == NULL)
continue;
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: checking socket <%d>"
" ...\n", _xj_pid, jcp->ojc[i]->sock);
#endif
if(!FD_ISSET(jcp->ojc[i]->sock, &mset))
continue;
pos = nr = 0;
do
{
p = recv_buff;
if(pos != 0)
{
while(pos < nr)
{
*p = recv_buff[pos];
pos++;
p++;
}
*p = 0;
/**
* flush out the socket - set it to nonblocking
*/
flags = fcntl(jcp->ojc[i]->sock, F_GETFL, 0);
if(flags!=-1 && !(flags & O_NONBLOCK))
{
/* set NONBLOCK bit to enable non-blocking */
fcntl(jcp->ojc[i]->sock, F_SETFL, flags|O_NONBLOCK);
}
}
if((nr = read(jcp->ojc[i]->sock, p,
sizeof(recv_buff)-(p-recv_buff))) == 0
||(nr < 0 && errno != EAGAIN))
{
DBG("XJAB:xj_worker:%d: ERROR -"
" connection to jabber lost on socket <%d> ...\n",
_xj_pid, jcp->ojc[i]->sock);
xj_send_sip_msgz(_PADDR(jwl), jcp->ojc[i]->jkey->id,
&jab_gw_name,XJ_DMSG_ERR_DISCONNECTED,&jbc->jkey->flag);
// make sure that will ckeck expired connections
ltime = jcp->ojc[i]->expire = -1;
FD_CLR(jcp->ojc[i]->sock, &set);
goto step_xx;
}
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: received: %dbytes Err:%d/EA:%d\n",
_xj_pid, nr, errno, EAGAIN);
#endif
xj_jcon_update(jcp->ojc[i], jwl->cachet);
if(nr>0)
p[nr] = 0;
nr = strlen(recv_buff);
pos = 0;
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker: JMSG START ----------\n%.*s\n"
" JABBER: JMSGL:%d END ----------\n", nr, recv_buff, nr);
#endif
} while(xj_manage_jab(recv_buff, nr, &pos, jwl->aliases,
jcp->ojc[i]) == 9 && main_loop);
/**
* flush out the socket - set it back to blocking
*/
flags = fcntl(jcp->ojc[i]->sock, F_GETFL, 0);
if(flags!=-1 && (flags & O_NONBLOCK))
{
/* reset NONBLOCK bit to enable blocking */
fcntl(jcp->ojc[i]->sock, F_SETFL, flags & ~O_NONBLOCK);
}
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB:xj_worker:%d: msgs from socket <%d> parsed"
" ...\n", _xj_pid, jcp->ojc[i]->sock);
#endif
} // end FOR(i = 0; i < jcp->len; i++)
step_x:
if(ret < 0)
{
DBG("XJAB:xj_worker:%d: SIGNAL received!!!!!!!!\n", _xj_pid);
maxfd = pipe;
FD_ZERO(&set);
FD_SET(pipe, &set);
for(i = 0; i < jcp->len; i++)
{
if(jcp->ojc[i] != NULL)
{
FD_SET(jcp->ojc[i]->sock, &set);
if( jcp->ojc[i]->sock > maxfd )
maxfd = jcp->ojc[i]->sock;
}
}
}
step_xx:
if(ltime < 0 || ltime + jwl->sleept <= get_ticks())
{
ltime = get_ticks();
#ifdef XJ_EXTRA_DEBUG
//DBG("XJAB:xj_worker:%d: scanning for expired connection\n",
// _xj_pid);
#endif
xj_worker_check_jcons(jwl, jcp, ltime, &set);
}
} // END while
DBG("XJAB:xj_worker:%d: cleaning procedure\n", _xj_pid);
return 0;
} // end xj_worker_process
/*
* Convert a row from result into db API representation
*/
static int dbt_convert_row(db_con_t* _h, db_res_t* _res, db_row_t* _r)
{
int i;
if (!_h || !_r || !_res) {
LM_ERR("invalid parameter value\n");
return -1;
}
ROW_N(_r) = RES_COL_N(_res);
for(i = 0; i < RES_COL_N(_res); i++) {
(ROW_VALUES(_r)[i]).nul = DBT_CON_ROW(_h)->fields[i].nul;
switch(RES_TYPES(_res)[i])
{
case DB_INT:
VAL_INT(&(ROW_VALUES(_r)[i])) =
DBT_CON_ROW(_h)->fields[i].val.int_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB_INT;
break;
case DB_BIGINT:
VAL_BIGINT(&(ROW_VALUES(_r)[i])) =
DBT_CON_ROW(_h)->fields[i].val.bigint_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB_BIGINT;
break;
case DB_DOUBLE:
VAL_DOUBLE(&(ROW_VALUES(_r)[i])) =
DBT_CON_ROW(_h)->fields[i].val.double_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB_DOUBLE;
break;
case DB_STRING:
VAL_STR(&(ROW_VALUES(_r)[i])).s =
DBT_CON_ROW(_h)->fields[i].val.str_val.s;
VAL_STR(&(ROW_VALUES(_r)[i])).len =
DBT_CON_ROW(_h)->fields[i].val.str_val.len;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB_STRING;
VAL_FREE(&(ROW_VALUES(_r)[i])) = 0;
break;
case DB_STR:
VAL_STR(&(ROW_VALUES(_r)[i])).s =
DBT_CON_ROW(_h)->fields[i].val.str_val.s;
VAL_STR(&(ROW_VALUES(_r)[i])).len =
DBT_CON_ROW(_h)->fields[i].val.str_val.len;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB_STR;
VAL_FREE(&(ROW_VALUES(_r)[i])) = 0;
break;
case DB_DATETIME:
VAL_INT(&(ROW_VALUES(_r)[i])) =
DBT_CON_ROW(_h)->fields[i].val.int_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB_DATETIME;
break;
case DB_BLOB:
VAL_STR(&(ROW_VALUES(_r)[i])).s =
DBT_CON_ROW(_h)->fields[i].val.str_val.s;
VAL_STR(&(ROW_VALUES(_r)[i])).len =
DBT_CON_ROW(_h)->fields[i].val.str_val.len;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB_BLOB;
VAL_FREE(&(ROW_VALUES(_r)[i])) = 0;
break;
case DB_BITMAP:
VAL_INT(&(ROW_VALUES(_r)[i])) =
DBT_CON_ROW(_h)->fields[i].val.bitmap_val;
VAL_TYPE(&(ROW_VALUES(_r)[i])) = DB_INT;
break;
}
}
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;
}
int get_rules_doc(str* user, str* domain, int type, str** rules_doc)
{
db_key_t query_cols[5];
db_val_t query_vals[5];
db_key_t result_cols[3];
int n_query_cols = 0;
db1_res_t *result = 0;
db_row_t *row;
db_val_t *row_vals;
str body;
str* doc= NULL;
int n_result_cols= 0, xcap_doc_col;
static str tmp1 = str_init("username");
static str tmp2 = str_init("domain");
static str tmp3 = str_init("doc_type");
static str tmp4 = str_init("doc");
LM_DBG("[user]= %.*s\t[domain]= %.*s",
user->len, user->s, domain->len, domain->s);
query_cols[n_query_cols] = &tmp1;
query_vals[n_query_cols].type = DB1_STR;
query_vals[n_query_cols].nul = 0;
query_vals[n_query_cols].val.str_val = *user;
n_query_cols++;
query_cols[n_query_cols] = &tmp2;
query_vals[n_query_cols].type = DB1_STR;
query_vals[n_query_cols].nul = 0;
query_vals[n_query_cols].val.str_val = *domain;
n_query_cols++;
query_cols[n_query_cols] = &tmp3;
query_vals[n_query_cols].type = DB1_INT;
query_vals[n_query_cols].nul = 0;
query_vals[n_query_cols].val.int_val= type;
n_query_cols++;
result_cols[xcap_doc_col= n_result_cols++] = &tmp4;
if (pres_dbf.query(pres_dbh, query_cols, 0 , query_vals, result_cols,
n_query_cols, 1, 0, &result) < 0) {
LM_ERR("while querying table xcap for [user]=%.*s\t[domain]= %.*s\n",
user->len, user->s, domain->len, domain->s);
if (result)
pres_dbf.free_result(pres_dbh, result);
return -1;
}
if(result == NULL)
return -1;
if (result->n <= 0) {
LM_DBG("No document found in db table for [user]=%.*s"
"\t[domain]= %.*s\t[doc_type]= %d\n",user->len, user->s,
domain->len, domain->s, type);
pres_dbf.free_result(pres_dbh, result);
return 0;
}
row = &result->rows[xcap_doc_col];
row_vals = ROW_VALUES(row);
body.s = (char*)row_vals[0].val.string_val;
if (body.s== NULL) {
LM_ERR("Xcap doc NULL\n");
goto error;
}
body.len = strlen(body.s);
if (body.len== 0) {
LM_ERR("Xcap doc empty\n");
goto error;
}
LM_DBG("xcap document:\n%.*s", body.len,body.s);
doc= (str*)pkg_malloc(sizeof(str));
if (doc== NULL) {
ERR_MEM(PKG_MEM_STR);
}
doc->s= (char*)pkg_malloc(body.len* sizeof(char));
if (doc->s== NULL) {
pkg_free(doc);
ERR_MEM(PKG_MEM_STR);
}
memcpy(doc->s, body.s, body.len);
doc->len= body.len;
*rules_doc= doc;
if (result)
pres_dbf.free_result(pres_dbh, result);
return 0;
error:
if (result)
pres_dbf.free_result(pres_dbh, result);
return -1;
}
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;
}
