*/ REBSER *List_Func_Types(REBVAL *func)
/*
** Return a block of function arg types.
** Note: skips 0th entry.
**
***********************************************************************/
{
REBSER *block;
REBSER *words = VAL_FUNC_WORDS(func);
REBCNT n;
REBVAL *value;
REBVAL *word;
block = Make_Block(SERIES_TAIL(words));
word = BLK_SKIP(words, 1);
for (n = 1; n < SERIES_TAIL(words); word++, n++) {
value = Alloc_Tail_Blk(block);
VAL_SET(value, VAL_TYPE(word));
VAL_WORD_SYM(value) = VAL_BIND_SYM(word);
UNBIND(value);
}
return block;
}
int update_db_state(int state) {
db_key_t node_id_key = &id_col;
db_val_t node_id_val;
db_key_t update_key;
db_val_t update_val;
VAL_TYPE(&node_id_val) = DB_INT;
VAL_NULL(&node_id_val) = 0;
VAL_INT(&node_id_val) = current_id;
update_key = &state_col;
CON_OR_RESET(db_hdl);
if (dr_dbf.use_table(db_hdl, &db_table) < 0) {
LM_ERR("cannot select table: \"%.*s\"\n", db_table.len, db_table.s);
return -1;
}
VAL_TYPE(&update_val) = DB_INT;
VAL_NULL(&update_val) = 0;
VAL_INT(&update_val) = state;
if (dr_dbf.update(db_hdl, &node_id_key, 0, &node_id_val, &update_key,
&update_val, 1, 1) < 0)
return -1;
return 0;
}
*/ static void Loop_Series(REBVAL *out, REBVAL *var, REBSER* body, REBVAL *start, REBINT ei, REBINT ii)
/*
***********************************************************************/
{
REBINT si = VAL_INDEX(start);
REBCNT type = VAL_TYPE(start);
*var = *start;
if (ei >= cast(REBINT, VAL_TAIL(start)))
ei = cast(REBINT, VAL_TAIL(start));
if (ei < 0) ei = 0;
SET_NONE(out); // Default result to NONE if the loop does not run
for (; (ii > 0) ? si <= ei : si >= ei; si += ii) {
VAL_INDEX(var) = si;
if (Do_Block_Throws(out, body, 0)) {
if (Loop_Throw_Should_Return(out)) break;
}
if (VAL_TYPE(var) != type) raise Error_1(RE_INVALID_TYPE, var);
si = VAL_INDEX(var);
}
}
*/ REBINT CT_None(REBVAL *a, REBVAL *b, REBINT mode)
/*
***********************************************************************/
{
if (mode >= 0) return (VAL_TYPE(a) == VAL_TYPE(b));
return -1;
}
//
// Is_Type_Of: C
//
// Types can be: word or block. Each element must be either
// a datatype or a typeset.
//
static REBOOL Is_Type_Of(const REBVAL *value, REBVAL *types)
{
const REBVAL *val;
val = IS_WORD(types) ? GET_OPT_VAR_MAY_FAIL(types) : types;
if (IS_DATATYPE(val))
return LOGICAL(VAL_TYPE_KIND(val) == VAL_TYPE(value));
if (IS_TYPESET(val))
return LOGICAL(TYPE_CHECK(val, VAL_TYPE(value)));
if (IS_BLOCK(val)) {
for (types = VAL_ARRAY_AT(val); NOT_END(types); types++) {
val = IS_WORD(types) ? GET_OPT_VAR_MAY_FAIL(types) : types;
if (IS_DATATYPE(val)) {
if (VAL_TYPE_KIND(val) == VAL_TYPE(value)) return TRUE;
}
else if (IS_TYPESET(val)) {
if (TYPE_CHECK(val, VAL_TYPE(value))) return TRUE;
}
else
fail (Error(RE_INVALID_TYPE, Type_Of(val)));
}
return FALSE;
}
fail (Error_Invalid_Arg(types));
}
//
// Partial1: C
//
// Process the /part (or /skip) and other length modifying
// arguments.
//
REBINT Partial1(REBVAL *sval, REBVAL *lval)
{
REBI64 len;
REBINT maxlen;
REBINT is_ser = ANY_SERIES(sval);
// If lval is not set or is BAR!, use the current len of the target value:
if (IS_UNSET(lval) || IS_BAR(lval)) {
if (!is_ser) return 1;
if (VAL_INDEX(sval) >= VAL_LEN_HEAD(sval)) return 0;
return (VAL_LEN_HEAD(sval) - VAL_INDEX(sval));
}
if (IS_INTEGER(lval) || IS_DECIMAL(lval)) len = Int32(lval);
else {
if (is_ser && VAL_TYPE(sval) == VAL_TYPE(lval) && VAL_SERIES(sval) == VAL_SERIES(lval))
len = (REBINT)VAL_INDEX(lval) - (REBINT)VAL_INDEX(sval);
else
fail (Error(RE_INVALID_PART, lval));
}
if (is_ser) {
// Restrict length to the size available:
if (len >= 0) {
maxlen = (REBINT)VAL_LEN_AT(sval);
if (len > maxlen) len = maxlen;
} else {
len = -len;
if (len > (REBINT)VAL_INDEX(sval)) len = (REBINT)VAL_INDEX(sval);
VAL_INDEX(sval) -= (REBCNT)len;
}
}
return (REBINT)len;
}
*/ static void Loop_Series(REBVAL *out, REBVAL *var, REBSER* body, REBVAL *start, REBINT ei, REBINT ii)
/*
***********************************************************************/
{
REBINT si = VAL_INDEX(start);
REBCNT type = VAL_TYPE(start);
*var = *start;
if (ei >= cast(REBINT, VAL_TAIL(start)))
ei = cast(REBINT, VAL_TAIL(start));
if (ei < 0) ei = 0;
SET_NONE(out); // Default result to NONE if the loop does not run
for (; (ii > 0) ? si <= ei : si >= ei; si += ii) {
VAL_INDEX(var) = si;
if (!DO_BLOCK(out, body, 0) && Check_Error(out) >= 0) break;
if (VAL_TYPE(var) != type) Trap1(RE_INVALID_TYPE, var);
si = VAL_INDEX(var);
}
}
static void acc_db_init_keys(void)
{
struct acc_extra *extra;
int time_idx;
int i;
int n;
/* init the static db keys */
n = 0;
/* caution: keys need to be aligned to core format */
db_keys[n++] = &acc_method_col;
db_keys[n++] = &acc_fromtag_col;
db_keys[n++] = &acc_totag_col;
db_keys[n++] = &acc_callid_col;
db_keys[n++] = &acc_sipcode_col;
db_keys[n++] = &acc_sipreason_col;
db_keys[n++] = &acc_time_col;
time_idx = n-1;
/* init the extra db keys */
for(extra=db_extra; extra ; extra=extra->next)
db_keys[n++] = &extra->name;
/* multi leg call columns */
for( extra=leg_info ; extra ; extra=extra->next)
db_keys[n++] = &extra->name;
/* init the values */
for(i=0; i<n; i++) {
VAL_TYPE(db_vals+i)=DB1_STR;
VAL_NULL(db_vals+i)=0;
}
VAL_TYPE(db_vals+time_idx)=DB1_DATETIME;
}
static REBSER *Trim_Object(REBSER *obj)
{
REBVAL *val;
REBINT cnt = 0;
REBSER *nobj;
REBVAL *nval;
REBVAL *word;
REBVAL *nwrd;
word = FRM_WORDS(obj)+1;
for (val = FRM_VALUES(obj)+1; NOT_END(val); val++, word++) {
if (VAL_TYPE(val) > REB_NONE && !VAL_GET_OPT(word, OPTS_HIDE))
cnt++;
}
nobj = Make_Frame(cnt);
nval = FRM_VALUES(nobj)+1;
word = FRM_WORDS(obj)+1;
nwrd = FRM_WORDS(nobj)+1;
for (val = FRM_VALUES(obj)+1; NOT_END(val); val++, word++) {
if (VAL_TYPE(val) > REB_NONE && !VAL_GET_OPT(word, OPTS_HIDE)) {
*nval++ = *val;
*nwrd++ = *word;
}
}
SET_END(nval);
SET_END(nwrd);
SERIES_TAIL(nobj) = cnt+1;
SERIES_TAIL(FRM_WORD_SERIES(nobj)) = cnt+1;
return nobj;
}
//
// Find_Key: C
//
// Returns hash index (either the match or the new one).
// A return of zero is valid (as a hash index);
//
// Wide: width of record (normally 2, a key and a value).
//
// Modes:
// 0 - search, return hash if found or not
// 1 - search, return hash, else return -1 if not
// 2 - search, return hash, else append value and return -1
//
REBINT Find_Key(REBSER *series, REBSER *hser, const REBVAL *key, REBINT wide, REBCNT cased, REBYTE mode)
{
REBCNT *hashes;
REBCNT skip;
REBCNT hash;
REBCNT len;
REBCNT n;
REBVAL *val;
// Compute hash for value:
len = hser->tail;
hash = Hash_Value(key, len);
if (!hash) fail (Error_Has_Bad_Type(key));
// Determine skip and first index:
skip = (len == 0) ? 0 : (hash & 0x0000FFFF) % len;
if (skip == 0) skip = 1;
hash = (len == 0) ? 0 : (hash & 0x00FFFF00) % len;
// Scan hash table for match:
hashes = (REBCNT*)hser->data;
if (ANY_WORD(key)) {
while ((n = hashes[hash])) {
val = BLK_SKIP(series, (n-1) * wide);
if (
ANY_WORD(val) &&
(VAL_WORD_SYM(key) == VAL_WORD_SYM(val) ||
(!cased && VAL_WORD_CANON(key) == VAL_WORD_CANON(val)))
) return hash;
hash += skip;
if (hash >= len) hash -= len;
}
}
else if (ANY_BINSTR(key)) {
while ((n = hashes[hash])) {
val = BLK_SKIP(series, (n-1) * wide);
if (
VAL_TYPE(val) == VAL_TYPE(key)
&& 0 == Compare_String_Vals(key, val, (REBOOL)(!IS_BINARY(key) && !cased))
) return hash;
hash += skip;
if (hash >= len) hash -= len;
}
} else {
while ((n = hashes[hash])) {
val = BLK_SKIP(series, (n-1) * wide);
if (VAL_TYPE(val) == VAL_TYPE(key) && 0 == Cmp_Value(key, val, !cased)) return hash;
hash += skip;
if (hash >= len) hash -= len;
}
}
// Append new value the target series:
if (mode > 1) {
hashes[hash] = SERIES_TAIL(series) + 1;
Append_Values_Len(series, key, wide);
}
return (mode > 0) ? NOT_FOUND : hash;
}
/* this is only called from destroy_dlg, where the cell's entry
* lock is acquired
*/
int remove_dialog_from_db(struct dlg_cell * cell)
{
static db_ps_t my_ps = NULL;
db_val_t values[2];
db_key_t match_keys[2] = { &h_entry_column, &h_id_column};
/*if the dialog hasn 't been yet inserted in the database*/
LM_DBG("trying to remove a dialog, update_flag is %i\n", cell->flags);
if (cell->flags & DLG_FLAG_NEW)
return 0;
if (use_dialog_table()!=0)
return -1;
VAL_TYPE(values) = VAL_TYPE(values+1) = DB_INT;
VAL_NULL(values) = VAL_NULL(values+1) = 0;
VAL_INT(values) = cell->h_entry;
VAL_INT(values+1) = cell->h_id;
CON_PS_REFERENCE(dialog_db_handle) = &my_ps;
if(dialog_dbf.delete(dialog_db_handle, match_keys, 0, values, 2) < 0) {
LM_ERR("failed to delete database information\n");
return -1;
}
LM_DBG("callid was %.*s\n", cell->callid.len, cell->callid.s );
/* dialog saved */
run_dlg_callbacks( DLGCB_SAVED, cell, 0, DLG_DIR_NONE, 0);
return 0;
}
*/ REBINT Cmp_Block(REBVAL *sval, REBVAL *tval, REBFLG is_case)
/*
** Compare two blocks and return the difference of the first
** non-matching value.
**
***********************************************************************/
{
REBVAL *s = VAL_BLK_DATA(sval);
REBVAL *t = VAL_BLK_DATA(tval);
REBINT diff;
CHECK_STACK(&s);
if ((VAL_SERIES(sval)==VAL_SERIES(tval))&&
(VAL_INDEX(sval)==VAL_INDEX(tval)))
return 0;
while (!IS_END(s) && (VAL_TYPE(s) == VAL_TYPE(t) ||
(IS_NUMBER(s) && IS_NUMBER(t)))) {
if ((diff = Cmp_Value(s, t, is_case)) != 0)
return diff;
s++, t++;
}
return VAL_TYPE(s) - VAL_TYPE(t);
}
*/ static void Trim_Block(REBSER *ser, REBCNT index, REBCNT flags)
/*
** See Trim_String().
**
***********************************************************************/
{
REBVAL *blk = BLK_HEAD(ser);
REBCNT out = index;
REBCNT end = ser->tail;
if (flags & AM_TRIM_TAIL) {
for (; end >= (index+1); end--) {
if (VAL_TYPE(blk+end-1) > REB_NONE) break;
}
Remove_Series(ser, end, ser->tail - end);
if (!(flags & AM_TRIM_HEAD) || index >= end) return;
}
if (flags & AM_TRIM_HEAD) {
for (; index < end; index++) {
if (VAL_TYPE(blk+index) > REB_NONE) break;
}
Remove_Series(ser, out, index - out);
}
if (flags == 0) {
for (; index < end; index++) {
if (VAL_TYPE(blk+index) > REB_NONE) {
*BLK_SKIP(ser, out) = blk[index];
out++;
}
}
Remove_Series(ser, out, end - out);
}
}
/*
* 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;
}
static REBOOL Equal_Object(REBVAL *val, REBVAL *arg)
{
REBSER *f1;
REBSER *f2;
REBSER *w1;
REBSER *w2;
REBINT n;
if (VAL_TYPE(arg) != VAL_TYPE(val)) return FALSE;
f1 = VAL_OBJ_FRAME(val);
f2 = VAL_OBJ_FRAME(arg);
if (f1 == f2) return TRUE;
if (f1->tail != f2->tail) return FALSE;
w1 = FRM_WORD_SERIES(f1);
w2 = FRM_WORD_SERIES(f2);
if (w1->tail != w2->tail) return FALSE;
// Compare each entry:
for (n = 1; n < (REBINT)(f1->tail); n++) {
if (Cmp_Value(BLK_SKIP(w1, n), BLK_SKIP(w2, n), FALSE)) return FALSE;
// Use Compare_Values();
if (Cmp_Value(BLK_SKIP(f1, n), BLK_SKIP(f2, n), FALSE)) return FALSE;
}
return TRUE;
}
static REBOOL Same_Func(REBVAL *val, REBVAL *arg)
{
if (VAL_TYPE(val) == VAL_TYPE(arg) &&
VAL_FUNC_SPEC(val) == VAL_FUNC_SPEC(arg) &&
VAL_FUNC_ARGS(val) == VAL_FUNC_ARGS(arg) &&
VAL_FUNC_CODE(val) == VAL_FUNC_CODE(arg)) return TRUE;
return FALSE;
}
int db_build_userbl_tree(const str *username, const str *domain, const str *table, struct dtrie_node_t *root, int use_domain)
{
db_key_t columns[2] = { &userblacklist_prefix_col, &userblacklist_whitelist_col };
db_key_t key[2] = { &userblacklist_username_col, &userblacklist_domain_col };
db_val_t val[2];
db1_res_t *res;
int i;
int n = 0;
void *nodeflags;
VAL_TYPE(val) = VAL_TYPE(val + 1) = DB1_STR;
VAL_NULL(val) = VAL_NULL(val + 1) = 0;
VAL_STR(val).s = username->s;
VAL_STR(val).len = username->len;
VAL_STR(val + 1).s = domain->s;
VAL_STR(val + 1).len = domain->len;
if (userblacklist_dbf.use_table(userblacklist_dbh, table) < 0) {
LM_ERR("cannot use table '%.*s'.\n", table->len, table->s);
return -1;
}
if (userblacklist_dbf.query(userblacklist_dbh, key, 0, val, columns, (!use_domain) ? (1) : (2), 2, 0, &res) < 0) {
LM_ERR("error while executing query.\n");
return -1;
}
dtrie_clear(root, NULL, match_mode);
if (RES_COL_N(res) > 1) {
for(i = 0; i < RES_ROW_N(res); i++) {
if ((!RES_ROWS(res)[i].values[0].nul) && (!RES_ROWS(res)[i].values[1].nul)) {
if ((RES_ROWS(res)[i].values[0].type == DB1_STRING) &&
(RES_ROWS(res)[i].values[1].type == DB1_INT)) {
/* LM_DBG("insert into tree prefix %s, whitelist %d",
RES_ROWS(res)[i].values[0].val.string_val,
RES_ROWS(res)[i].values[1].val.int_val); */
if (RES_ROWS(res)[i].values[1].val.int_val == 0) {
nodeflags=(void *)MARK_BLACKLIST;
} else {
nodeflags=(void *)MARK_WHITELIST;
}
if (dtrie_insert(root, RES_ROWS(res)[i].values[0].val.string_val, strlen(RES_ROWS(res)[i].values[0].val.string_val),
nodeflags, match_mode) < 0) LM_ERR("could not insert values into trie.\n");
n++;
}
else {
LM_ERR("got invalid result type from query.\n");
}
}
}
}
userblacklist_dbf.free_result(userblacklist_dbh, res);
return n;
}
static REBOOL Same_Object(REBVAL *val, REBVAL *arg)
{
if (
VAL_TYPE(arg) == VAL_TYPE(val) &&
//VAL_OBJ_SPEC(val) == VAL_OBJ_SPEC(arg) &&
VAL_OBJ_FRAME(val) == VAL_OBJ_FRAME(arg)
) return TRUE;
return FALSE;
}
void bdb_free_field(bdb_val_p _v)
{
if (!VAL_NULL(&(_v->v))) {
if (VAL_TYPE(&(_v->v)) == DB_STR || VAL_TYPE(&(_v->v)) == DB_STRING ||
VAL_TYPE(&(_v->v)) == DB_BLOB) {
pkg_free(VAL_STR(&(_v->v)).s);
}
}
pkg_free(_v);
};
//
// Partial: C
//
// Args:
// aval: target value
// bval: argument to modify target (optional)
// lval: length value (or none)
//
// Determine the length of a /PART value. It can be:
// 1. integer or decimal
// 2. relative to A value (bval is null)
// 3. relative to B value
//
// NOTE: Can modify the value's index!
// The result can be negative. ???
//
REBINT Partial(REBVAL *aval, REBVAL *bval, REBVAL *lval)
{
REBVAL *val;
REBINT len;
REBINT maxlen;
// If lval is unset, use the current len of the target value:
if (IS_UNSET(lval)) {
val = (bval && ANY_SERIES(bval)) ? bval : aval;
if (VAL_INDEX(val) >= VAL_LEN_HEAD(val)) return 0;
return (VAL_LEN_HEAD(val) - VAL_INDEX(val));
}
if (IS_INTEGER(lval) || IS_DECIMAL(lval)) {
len = Int32(lval);
val = bval;
}
else {
// So, lval must be relative to aval or bval series:
if (
VAL_TYPE(aval) == VAL_TYPE(lval)
&& VAL_SERIES(aval) == VAL_SERIES(lval)
) {
val = aval;
}
else if (
bval
&& VAL_TYPE(bval) == VAL_TYPE(lval)
&& VAL_SERIES(bval) == VAL_SERIES(lval)
) {
val = bval;
}
else
fail (Error(RE_INVALID_PART, lval));
len = cast(REBINT, VAL_INDEX(lval)) - cast(REBINT, VAL_INDEX(val));
}
if (!val) val = aval;
// Restrict length to the size available
//
if (len >= 0) {
maxlen = (REBINT)VAL_LEN_AT(val);
if (len > maxlen) len = maxlen;
}
else {
len = -len;
if (len > cast(REBINT, VAL_INDEX(val)))
len = cast(REBINT, VAL_INDEX(val));
VAL_INDEX(val) -= (REBCNT)len;
}
return len;
}
/**
* Release a result set from memory.
* \param _h handle to the database
* \param _r result set that should be freed
* \return zero on success, negative value on failure
*/
int db_sqlite_free_result(db_con_t* _h, db_res_t* _r)
{
int i;
int j;
db_val_t* v;
db_row_t* res_col;
if (!_h) {
LM_ERR("invalid database handle\n");
return -1;
}
if (!_r) {
LM_DBG("nothing to free!\n");
return 0;
}
if (RES_ROWS(_r)) {
LM_DBG("freeing rows at %p\n", RES_ROWS(_r));
for (i = 0; i < RES_ROW_N(_r); i++) {
for (j = 0; j < RES_COL_N(_r); j++) {
res_col = &_r->rows[i];
v = &res_col->values[j];
if (VAL_NULL(v))
continue;
/* only allocated types; STR and BLOB;*/
if (VAL_TYPE(v) == DB_STR) {
pkg_free(VAL_STR(v).s);
VAL_STR(v).s = 0;
} else if (VAL_TYPE(v) == DB_BLOB) {
pkg_free(VAL_BLOB(v).s);
VAL_BLOB(v).s = 0;
}
}
}
pkg_free(_r->rows[0].values);
pkg_free(_r->rows);
RES_ROWS(_r) = NULL;
}
RES_ROW_N(_r) = 0;
pkg_free(_r);
_r = NULL;
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;
}
/**
* Builds a d-tree using database entries.
* \return negative on failure, postive on success, indicating the number of d-tree entries
*/
int db_build_userbl_tree(const str *username, const str *domain, const str *table, struct dt_node_t *root, int use_domain)
{
db_key_t columns[2] = { &prefix_col, &whitelist_col };
db_key_t key[2] = { &username_key, &domain_key };
db_val_t val[2];
VAL_TYPE(val) = VAL_TYPE(val + 1) = DB_STR;
VAL_NULL(val) = VAL_NULL(val + 1) = 0;
VAL_STR(val).s = username->s;
VAL_STR(val).len = username->len;
VAL_STR(val + 1).s = domain->s;
VAL_STR(val + 1).len = domain->len;
db_res_t *res;
int i;
int n = 0;
if (dbf.use_table(dbc, table) < 0) {
LM_ERR("cannot use table '%.*s'.\n", table->len, table->s);
return -1;
}
if (dbf.query(dbc, key, 0, val, columns, (!use_domain) ? (1) : (2), 2, 0, &res) < 0) {
LM_ERR("error while executing query.\n");
return -1;
}
dt_clear(root);
if (RES_COL_N(res) > 1) {
for(i = 0; i < RES_ROW_N(res); i++) {
if ((!RES_ROWS(res)[i].values[0].nul) && (!RES_ROWS(res)[i].values[1].nul)) {
if ((RES_ROWS(res)[i].values[0].type == DB_STRING) &&
(RES_ROWS(res)[i].values[1].type == DB_INT)) {
/* LM_DBG("insert into tree prefix %s, whitelist %d",
RES_ROWS(res)[i].values[0].val.string_val,
RES_ROWS(res)[i].values[1].val.int_val); */
dt_insert(root, RES_ROWS(res)[i].values[0].val.string_val,
RES_ROWS(res)[i].values[1].val.int_val);
n++;
}
else {
LM_ERR("got invalid result type from query.\n");
}
}
}
}
dbf.free_result(dbc, res);
return n;
}
/*!
* \brief Check if username in specified header field is in a table
* \param _msg SIP message
* \param _hf Header field
* \param _grp checked table
* \return 1 on success, negative on failure
*/
int is_user_in(struct sip_msg* _msg, char* _hf, char* _grp)
{
db_key_t keys[3];
db_val_t vals[3];
db_key_t col[1];
db1_res_t* res = NULL;
keys[0] = &user_column;
keys[1] = &group_column;
keys[2] = &domain_column;
col[0] = &group_column;
if ( get_username_domain( _msg, (group_check_p)_hf, &(VAL_STR(vals)),
&(VAL_STR(vals+2)))!=0) {
LM_ERR("failed to get username@domain\n");
return -1;
}
if (VAL_STR(vals).s==NULL || VAL_STR(vals).len==0 ) {
LM_DBG("no username part\n");
return -1;
}
VAL_TYPE(vals) = VAL_TYPE(vals + 1) = VAL_TYPE(vals + 2) = DB1_STR;
VAL_NULL(vals) = VAL_NULL(vals + 1) = VAL_NULL(vals + 2) = 0;
VAL_STR(vals + 1) = *((str*)_grp);
if (group_dbf.use_table(group_dbh, &table) < 0) {
LM_ERR("failed to use_table\n");
return -5;
}
if (group_dbf.query(group_dbh, keys, 0, vals, col, (use_domain) ? (3): (2),
1, 0, &res) < 0) {
LM_ERR("failed to query database\n");
return -5;
}
if (RES_ROW_N(res) == 0) {
LM_DBG("user is not in group '%.*s'\n",
((str*)_grp)->len, ZSW(((str*)_grp)->s));
group_dbf.free_result(group_dbh, res);
return -6;
} else {
LM_DBG("user is in group '%.*s'\n",
((str*)_grp)->len, ZSW(((str*)_grp)->s));
group_dbf.free_result(group_dbh, res);
return 1;
}
}
int bdb_ufield_db2bdb(bdb_uval_p v, db_val_t* _v)
{
char *s;
VAL_NULL(&(v->v)) = VAL_NULL(_v);
VAL_TYPE(&(v->v)) = VAL_TYPE(_v);
if (!VAL_NULL(&(v->v))) {
switch (VAL_TYPE(_v)) {
case DB_INT:
VAL_INT(&(v->v)) = VAL_INT(_v);
break;
case DB_FLOAT:
VAL_FLOAT(&(v->v)) = VAL_FLOAT(_v);
break;
case DB_DATETIME:
VAL_TIME(&(v->v)) = VAL_TIME(_v);
break;
case DB_BLOB:
s = pkg_malloc(VAL_BLOB(_v).len);
memcpy(s, VAL_BLOB(_v).s, VAL_BLOB(_v).len);
VAL_BLOB(&(v->v)).s = s;
VAL_BLOB(&(v->v)).len = VAL_BLOB(_v).len;
break;
case DB_DOUBLE:
VAL_DOUBLE(&(v->v)) = VAL_DOUBLE(_v);
break;
case DB_STRING:
VAL_STR(&(v->v)).len = strlen(VAL_STRING(_v)) + 1;
s = pkg_malloc(VAL_STR(&(v->v)).len);
strcpy(s, VAL_STRING(_v));
VAL_STRING(&(v->v)) = s;
break;
case DB_STR:
s = pkg_malloc(VAL_STR(_v).len);
memcpy(s, VAL_STR(_v).s, VAL_STR(_v).len);
VAL_STR(&(v->v)).s = s;
VAL_STR(&(v->v)).len = VAL_STR(_v).len;
break;
case DB_BITMAP:
VAL_BITMAP(&(v->v)) = VAL_BITMAP(_v);
break;
default:
LOG(L_ERR, "BDB:bdb_ufield_db2bdb: unknown column type: %0X\n", VAL_TYPE(_v));
return -1;
break;
}
}
return 0;
};
int bdb_set_key(bdb_row_p _r, bdb_val_p _v)
{
/* NULL is not allowed for primary key */
if (VAL_NULL(&(_v->v))) {
LOG(L_ERR, "BDB:bdb_set_key: NULL is not allowed for primary key\n");
return -1;
}
switch (VAL_TYPE(&(_v->v))) {
case DB_INT:
_r->key.data = &VAL_INT(&(_v->v));
_r->key.size = sizeof(VAL_INT(&(_v->v)));
break;
case DB_FLOAT:
_r->key.data = &VAL_FLOAT(&(_v->v));
_r->key.size = sizeof(VAL_FLOAT(&(_v->v)));
break;
case DB_DATETIME:
_r->key.data = &VAL_TIME(&(_v->v));
_r->key.size = sizeof(VAL_TIME(&(_v->v)));
break;
case DB_BLOB:
_r->key.data = VAL_BLOB(&(_v->v)).s;
_r->key.size = VAL_BLOB(&(_v->v)).len;
break;
case DB_DOUBLE:
_r->key.data = &VAL_DOUBLE(&(_v->v));
_r->key.size = sizeof(VAL_DOUBLE(&(_v->v)));
break;
case DB_STRING:
_r->key.data = (void *)VAL_STRING(&(_v->v));
_r->key.size = strlen(VAL_STRING(&(_v->v))) + 1;
break;
case DB_STR:
_r->key.data = VAL_STR(&(_v->v)).s;
_r->key.size = VAL_STR(&(_v->v)).len;
break;
case DB_BITMAP:
_r->key.data = &VAL_BITMAP(&(_v->v));
_r->key.size = sizeof(VAL_BITMAP(&(_v->v)));
break;
default:
LOG(L_ERR, "BDB:bdb_set_skey: unknown column type: %0X\n", VAL_TYPE(&(_v->v)));
return -1;
break;
}
return 0;
};
/*
* Check if uri belongs to a local user
*/
int does_uri_exist(struct sip_msg* _msg, char* _s1, char* _s2)
{
db_key_t keys[2];
db_val_t vals[2];
db_key_t cols[1];
db_res_t* res;
if (parse_sip_msg_uri(_msg) < 0) {
LOG(L_ERR, "does_uri_exist(): Error while parsing URI\n");
return -1;
}
if (use_uri_table) {
if (db_use_table(db_handle, uri_table) < 0) {
LOG(L_ERR, "does_uri_exist(): Error while trying to use uri table\n");
}
keys[0] = uri_uriuser_col;
keys[1] = uri_domain_col;
cols[0] = uri_uriuser_col;
} else {
if (db_use_table(db_handle, subscriber_table) < 0) {
LOG(L_ERR, "does_uri_exist(): Error while trying to use subscriber table\n");
}
keys[0] = subscriber_user_col;
keys[1] = subscriber_domain_col;
cols[0] = subscriber_user_col;
}
VAL_TYPE(vals) = VAL_TYPE(vals + 1) = DB_STR;
VAL_NULL(vals) = VAL_NULL(vals + 1) = 0;
VAL_STR(vals) = _msg->parsed_uri.user;
VAL_STR(vals + 1) = _msg->parsed_uri.host;
if (db_query(db_handle, keys, 0, vals, cols, (use_domain ? 2 : 1), 1, 0, &res) < 0) {
LOG(L_ERR, "does_uri_exist(): Error while querying database\n");
return -2;
}
if (RES_ROW_N(res) == 0) {
DBG("does_uri_exit(): User in request uri does not exist\n");
db_free_query(db_handle, res);
return -3;
} else {
DBG("does_uri_exit(): User in request uri does exist\n");
db_free_query(db_handle, res);
return 1;
}
}
void bdb_set_skey(bdb_srow_p _r, bdb_sval_p _v)
{
/* NULL is not allowed for primary key */
if (VAL_NULL(&(_v->v)))
return;
switch (VAL_TYPE(&(_v->v))) {
case DB_INT:
_r->key.data = &VAL_INT(&(_v->v));
_r->key.size = sizeof(VAL_INT(&(_v->v)));
break;
case DB_FLOAT:
_r->key.data = &VAL_FLOAT(&(_v->v));
_r->key.size = sizeof(VAL_FLOAT(&(_v->v)));
break;
case DB_DATETIME:
_r->key.data = &VAL_TIME(&(_v->v));
_r->key.size = sizeof(VAL_TIME(&(_v->v)));
break;
case DB_BLOB:
_r->key.data = VAL_BLOB(&(_v->v)).s;
_r->key.size = VAL_BLOB(&(_v->v)).len;
break;
case DB_DOUBLE:
_r->key.data = &VAL_DOUBLE(&(_v->v));
_r->key.size = sizeof(VAL_DOUBLE(&(_v->v)));
break;
case DB_STRING:
_r->key.data = (void *)VAL_STRING(&(_v->v));
_r->key.size = strlen(VAL_STRING(&(_v->v))) + 1;
break;
case DB_STR:
_r->key.data = VAL_STR(&(_v->v)).s;
_r->key.size = VAL_STR(&(_v->v)).len;
break;
case DB_BITMAP:
_r->key.data = &VAL_BITMAP(&(_v->v));
_r->key.size = sizeof(VAL_BITMAP(&(_v->v)));
break;
default:
LOG(L_ERR, "BDB:bdb_set_skey: unknown column type: %0X\n", VAL_TYPE(&(_v->v)));
break;
}
#ifdef BDB_EXTRA_DEBUG
LOG(L_NOTICE, "BDB:bdb_set_skey: use key '%.*s' (%d bytes)\n", _r->key.size, (char *)_r->key.data, _r->key.size);
#endif
};
/*
* Check if uri belongs to a local user
*/
int does_uri_exist(struct sip_msg* _msg, char* _s1, char* _s2)
{
static db_ps_t my_ps = NULL;
db_key_t keys[2];
db_val_t vals[2];
db_key_t cols[1];
db_res_t* res = NULL;
if (parse_sip_msg_uri(_msg) < 0) {
LM_ERR("Error while parsing URI\n");
return ERR_INTERNAL;
}
if (use_uri_table != 0) {
uridb_dbf.use_table(db_handle, &db_table);
keys[0] = &uridb_uriuser_col;
keys[1] = &uridb_domain_col;
cols[0] = &uridb_uriuser_col;
} else {
uridb_dbf.use_table(db_handle, &db_table);
keys[0] = &uridb_user_col;
keys[1] = &uridb_domain_col;
cols[0] = &uridb_user_col;
}
VAL_TYPE(vals) = VAL_TYPE(vals + 1) = DB_STR;
VAL_NULL(vals) = VAL_NULL(vals + 1) = 0;
VAL_STR(vals) = _msg->parsed_uri.user;
VAL_STR(vals + 1) = _msg->parsed_uri.host;
CON_PS_REFERENCE(db_handle) = &my_ps;
if (uridb_dbf.query(db_handle, keys, 0, vals, cols, (use_domain ? 2 : 1),
1, 0, &res) < 0) {
LM_ERR("Error while querying database\n");
return ERR_USERNOTFOUND;
}
if (RES_ROW_N(res) == 0) {
LM_DBG("User in request uri does not exist\n");
uridb_dbf.free_result(db_handle, res);
return ERR_DBEMTPYRES;
} else {
LM_DBG("User in request uri does exist\n");
uridb_dbf.free_result(db_handle, res);
return OK;
}
}
*/ REBINT PD_File(REBPVS *pvs)
/*
***********************************************************************/
{
REBSER *ser;
REB_MOLD mo = {0};
REBCNT n;
REBUNI c;
REBSER *arg;
if (pvs->setval) return PE_BAD_SET;
ser = Copy_Series_Value(pvs->value);
n = SERIES_TAIL(ser);
if (n > 0) c = GET_ANY_CHAR(ser, n-1);
if (n == 0 || c != '/') Append_Byte(ser, '/');
if (ANY_STR(pvs->select))
arg = VAL_SERIES(pvs->select);
else {
Reset_Mold(&mo);
Mold_Value(&mo, pvs->select, 0);
arg = mo.series;
}
c = GET_ANY_CHAR(arg, 0);
n = (c == '/' || c == '\\') ? 1 : 0;
Append_String(ser, arg, n, arg->tail-n);
Set_Series(VAL_TYPE(pvs->value), pvs->store, ser);
return PE_USE;
}
