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; }