static struct mi_root *mi_debug(struct mi_root *cmd, void *param)
{
struct mi_root *rpl_tree;
struct mi_node *node;
char *p;
int len;
int new_debug;
node = cmd->node.kids;
if (node!=NULL) {
if (str2sint( &node->value, &new_debug) < 0)
return init_mi_tree( 400, MI_SSTR(MI_BAD_PARM));
} else
new_debug = debug;
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK));
if (rpl_tree==0)
return 0;
p = sint2str((long)new_debug, &len);
node = add_mi_node_child( &rpl_tree->node, MI_DUP_VALUE,
MI_SSTR("DEBUG"),p, len);
if (node==0) {
free_mi_tree(rpl_tree);
return 0;
}
debug = new_debug;
return rpl_tree;
}
int pv_get_json (struct sip_msg* msg, pv_param_t* pvp, pv_value_t* val)
{
pv_json_t * var ;
json_t * obj;
json_name * id = (json_name *) pvp->pvn.u.dname;
UNUSED(id);
if( expand_tag_list( msg, ((json_name *)pvp->pvn.u.dname)->tags ) < 0)
{
LM_ERR("Cannot expand variables in path\n");
return pv_get_null( msg, pvp, val);
}
var = get_pv_json(pvp);
if( var == NULL )
{
/* this is not an error - we simply came across a json spec
* pointing a json var which was never set/init */
LM_DBG("Variable named:%.*s not found\n",id->name.len,id->name.s);
return pv_get_null( msg, pvp, val);
}
obj = get_object(var, pvp, NULL, 0);
memset(val, 0, sizeof(pv_value_t));
if( obj == NULL )
return pv_get_null( msg, pvp, val);
if( json_object_is_type(obj, json_type_int) )
{
val->rs.s = sint2str(json_object_get_int(obj), &val->rs.len);
val->ri = json_object_get_int(obj);;
val->flags |= PV_VAL_INT|PV_TYPE_INT|PV_VAL_STR;
}
else if( json_object_is_type(obj, json_type_string))
{
val->flags = PV_VAL_STR;
val->rs.s = (char*)json_object_get_string( obj );
#if JSON_LIB_VERSION >= 10
val->rs.len = json_object_get_string_len( obj );
#else
val->rs.len = strlen(val->rs.s);
#endif
} else {
val->flags = PV_VAL_STR;
val->rs.s = (char*)json_object_to_json_string( obj );
val->rs.len = strlen(val->rs.s);
}
return 0;
}
static int mt_pack_values(m_tree_t *pt, db1_res_t* db_res,
int row, int cols, str *tvalue)
{
static char vbuf[4096];
int c;
int len;
char *p;
str iv;
len = 0;
for(c=1; c<cols; c++) {
if(VAL_NULL(&RES_ROWS(db_res)[row].values[c])) {
len += 1;
} else if(RES_ROWS(db_res)[row].values[c].type == DB1_STRING) {
len += strlen(RES_ROWS(db_res)[row].values[c].val.string_val);
} else if(RES_ROWS(db_res)[row].values[c].type == DB1_STR) {
len += RES_ROWS(db_res)[row].values[c].val.str_val.len;
} else if(RES_ROWS(db_res)[row].values[c].type == DB1_INT) {
len += 12;
} else {
LM_ERR("unsupported data type for column %d\n", c);
return -1;
}
}
if(len + c>=4096) {
LM_ERR("too large values (need %d)\n", len+c);
return -1;
}
p = vbuf;
for(c=1; c<cols; c++) {
if(VAL_NULL(&RES_ROWS(db_res)[row].values[c])) {
*p = pt->pack[2];
p++;
} else if(RES_ROWS(db_res)[row].values[c].type == DB1_STRING) {
strcpy(p, RES_ROWS(db_res)[row].values[c].val.string_val);
p += strlen(RES_ROWS(db_res)[row].values[c].val.string_val);
} else if(RES_ROWS(db_res)[row].values[c].type == DB1_STR) {
strncpy(p, RES_ROWS(db_res)[row].values[c].val.str_val.s,
RES_ROWS(db_res)[row].values[c].val.str_val.len);
p += RES_ROWS(db_res)[row].values[c].val.str_val.len;
} else if(RES_ROWS(db_res)[row].values[c].type == DB1_INT) {
iv.s = sint2str(RES_ROWS(db_res)[row].values[c].val.int_val, &iv.len);
strncpy(p, iv.s, iv.len);
p += iv.len;
}
if(c+1<cols) {
*p = pt->pack[1];
p++;
}
}
tvalue->s = vbuf;
tvalue->len = p - vbuf;
LM_DBG("packed: [%.*s]\n", tvalue->len, tvalue->s);
return 0;
}
/* item functions */
int pv_get_tm_branch_idx(struct sip_msg *msg, pv_param_t *param,
pv_value_t *res)
{
int l = 0;
char *ch = NULL;
struct cell *t;
tm_ctx_t *tcx = 0;
int idx = T_BR_UNDEFINED;
if(msg==NULL || res==NULL)
return -1;
/* statefull replies have the branch_index set */
if(msg->first_line.type == SIP_REPLY) {
tcx = _tmx_tmb.tm_ctx_get();
if(tcx != NULL)
idx = tcx->branch_index;
} else switch(route_type) {
case BRANCH_ROUTE:
case BRANCH_FAILURE_ROUTE:
/* branch and branch_failure routes have their index set */
tcx = _tmx_tmb.tm_ctx_get();
if(tcx != NULL)
idx = tcx->branch_index;
break;
case REQUEST_ROUTE:
/* take the branch number from the number of added branches */
idx = nr_branches;
break;
case FAILURE_ROUTE:
/* first get the transaction */
t = _tmx_tmb.t_gett();
if ( t == NULL || t == T_UNDEFINED ) {
return -1;
}
/* add the currently added branches to the number of
* completed branches in the transaction
*/
idx = t->nr_of_outgoings + nr_branches;
break;
}
ch = sint2str(idx, &l);
res->rs.s = ch;
res->rs.len = l;
res->ri = idx;
res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
return 0;
}
int pv_get_shvar(struct sip_msg *msg, pv_param_t *param,
pv_value_t *res)
{
int len = 0;
char *sval = NULL;
sh_var_t *shv=NULL;
if(msg==NULL || res==NULL)
return -1;
if(param==NULL || param->pvn.u.dname==0)
return pv_get_null(msg, param, res);
shv= (sh_var_t*)param->pvn.u.dname;
lock_shvar(shv);
if(shv->v.flags&VAR_VAL_STR)
{
if(param->pvv.s==NULL || param->pvv.len < shv->v.value.s.len)
{
if(param->pvv.s!=NULL)
pkg_free(param->pvv.s);
param->pvv.s = (char*)pkg_malloc(shv->v.value.s.len*sizeof(char));
if(param->pvv.s==NULL)
{
unlock_shvar(shv);
LM_ERR("no more pkg mem\n");
return pv_get_null(msg, param, res);
}
}
strncpy(param->pvv.s, shv->v.value.s.s, shv->v.value.s.len);
param->pvv.len = shv->v.value.s.len;
unlock_shvar(shv);
res->rs = param->pvv;
res->flags = PV_VAL_STR;
} else {
res->ri = shv->v.value.n;
unlock_shvar(shv);
sval = sint2str(res->ri, &len);
res->rs.s = sval;
res->rs.len = len;
res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
}
return 0;
}
/**
* convert signed int to pv_value_t
*/
int pv_get_sintval(struct sip_msg *msg, pv_param_t *param,
pv_value_t *res, int sival)
{
int l = 0;
char *ch = NULL;
if(res==NULL)
return -1;
ch = sint2str(sival, &l);
res->rs.s = ch;
res->rs.len = l;
res->ri = sival;
res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
return 0;
}
/* TODO - once memcached_touch gets into libmemcached, also take care of expires */
int wrap_memcached_sub(cachedb_con *connection,str* attr,int val,
int expires,int *new_val)
{
memcached_return_t rc;
memcached_con *con;
uint64_t res;
str ins_val;
struct timeval start;
start_expire_timer(start,memcache_exec_threshold);
con = (memcached_con *)connection->data;
rc = memcached_decrement(con->memc,attr->s,attr->len,val,&res);
if( rc != MEMCACHED_SUCCESS ) {
if (rc == MEMCACHED_NOTFOUND) {
ins_val.s = sint2str(val,&ins_val.len);
if (wrap_memcached_insert(connection,attr,&ins_val,expires) < 0) {
LM_ERR("failed to insert value\n");
stop_expire_timer(start,memcache_exec_threshold,
"cachedb_memcached sub",attr->s,attr->len,0);
return -1;
}
if (new_val)
*new_val = val;
stop_expire_timer(start,memcache_exec_threshold,
"cachedb_memcached sub",attr->s,attr->len,0);
return 0;
} else {
LM_ERR("Failed to sub: %s\n",memcached_strerror(con->memc,rc));
stop_expire_timer(start,memcache_exec_threshold,
"cachedb_memcached sub",attr->s,attr->len,0);
return -1;
}
}
if (new_val)
*new_val = (int)res;
stop_expire_timer(start,memcache_exec_threshold,
"cachedb_memcached sub",attr->s,attr->len,0);
return 0;
}
static struct mi_root *mi_debug(struct mi_root *cmd, void *param)
{
struct mi_root *rpl_tree;
struct mi_node *node;
char *p;
int len;
int new_debug = 0;
str group_name = {"core", 4};
str var_name = {"debug", 5};
void *vval = 0;
int set = 0;
unsigned int val_type;
node = cmd->node.kids;
if (node!=NULL) {
if (str2sint( &node->value, &new_debug) < 0)
return init_mi_tree( 400, MI_SSTR(MI_BAD_PARM));
set = 1;
} else {
if(cfg_get_by_name(_kex_cfg_ctx, &group_name, NULL /* group id */, &var_name, &vval,
&val_type)!=0)
return init_mi_tree( 500, MI_SSTR(MI_INTERNAL_ERR));
new_debug = (int)(long)vval;
}
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK));
if (rpl_tree==0)
return 0;
p = sint2str((long)new_debug, &len);
node = add_mi_node_child( &rpl_tree->node, MI_DUP_VALUE,
MI_SSTR("DEBUG"),p, len);
if (node==0) {
free_mi_tree(rpl_tree);
return 0;
}
if(set==1) {
cfg_set_now(_kex_cfg_ctx, &group_name, NULL /* group id */, &var_name,
(void *)(long)new_debug, CFG_VAR_INT);
}
return rpl_tree;
}
int pv_get_stat(struct sip_msg *msg, pv_param_t *param, pv_value_t *res)
{
stat_var *stat;
if(msg==NULL || res==NULL)
return -1;
if (get_stat_name( msg, &(param->pvn), 0, &stat)!=0) {
LM_ERR("failed to generate/get statistic name\n");
return -1;
}
if (stat==NULL)
return pv_get_null(msg, param, res);
res->ri = (int)get_stat_val( stat );
res->rs.s = sint2str(res->ri, &res->rs.len);
res->flags = PV_VAL_INT|PV_VAL_STR|PV_TYPE_INT;
return 0;
}
static int _tr_eval_sql_val(pv_value_t *val)
{
int i;
static char _tr_buffer[TR_BUFFER_SIZE];
if(val->flags&PV_TYPE_INT || !(val->flags&PV_VAL_STR)) {
val->rs.s = sint2str(val->ri, &val->rs.len);
val->flags = PV_VAL_STR;
return 0;
}
if(val->rs.len>TR_BUFFER_SIZE/2-1) {
LM_ERR("escape buffer to short");
return -1;
}
_tr_buffer[0] = '\'';
i = escape_common(_tr_buffer+1, val->rs.s, val->rs.len);
_tr_buffer[++i] = '\'';
_tr_buffer[++i] = '\0';
memset(val, 0, sizeof(pv_value_t));
val->flags = PV_VAL_STR;
val->rs.s = _tr_buffer;
val->rs.len = i;
return 0;
}
int pv_get_tm_branch_avp(struct sip_msg *msg, pv_param_t *param,
pv_value_t *val)
{
int avp_name;
int_str avp_value;
unsigned short name_type;
int idx, idxf, res=0;
struct usr_avp **old_list=NULL;
struct usr_avp **avp_list=NULL;
struct usr_avp *avp;
int_str avp_value0;
struct usr_avp *avp0;
int n=0;
char *p;
if (!msg || !val)
goto error;
avp_list = get_bavp_list();
if (!avp_list) {
pv_get_null(msg, param, val);
goto success;
}
if (!param) {
LM_ERR("bad parameters\n");
goto error;
}
if (pv_get_avp_name(msg, param, &avp_name, &name_type)) {
LM_ALERT("BUG in getting bavp name\n");
goto error;
}
/* get the index */
if(pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
LM_ERR("invalid index\n");
goto error;
}
/* setting the avp head */
old_list = set_avp_list(avp_list);
if (!old_list) {
LM_CRIT("no bavp head list found\n");
goto error;
}
if ((avp=search_first_avp(name_type, avp_name, &avp_value, 0))==0) {
pv_get_null(msg, param, val);
goto success;
}
val->flags = PV_VAL_STR;
if ( (idxf==0 || idxf==PV_IDX_INT) && idx==0) {
if(avp->flags & AVP_VAL_STR) {
val->rs = avp_value.s;
} else {
val->rs.s = sint2str(avp_value.n, &val->rs.len);
val->ri = avp_value.n;
val->flags |= PV_VAL_INT|PV_TYPE_INT;
}
goto success;
}
if(idxf==PV_IDX_ALL) {
p = pv_local_buf;
do {
if(avp->flags & AVP_VAL_STR) {
val->rs = avp_value.s;
} else {
val->rs.s = sint2str(avp_value.n, &val->rs.len);
}
if(p-pv_local_buf+val->rs.len+1>PV_LOCAL_BUF_SIZE) {
LM_ERR("local buffer length exceeded!\n");
pv_get_null(msg, param, val);
goto success;
}
memcpy(p, val->rs.s, val->rs.len);
p += val->rs.len;
if(p-pv_local_buf+PV_FIELD_DELIM_LEN+1>PV_LOCAL_BUF_SIZE) {
LM_ERR("local buffer length exceeded\n");
pv_get_null(msg, param, val);
goto success;
}
memcpy(p, PV_FIELD_DELIM, PV_FIELD_DELIM_LEN);
p += PV_FIELD_DELIM_LEN;
} while ((avp=search_first_avp(name_type, avp_name,
&avp_value, avp))!=0);
*p = 0;
val->rs.s = pv_local_buf;
val->rs.len = p - pv_local_buf;
goto success;
}
/* we have a numeric index */
if(idx<0) {
n = 1;
avp0 = avp;
while ((avp0=search_first_avp(name_type, avp_name,
&avp_value0, avp0))!=0) n++;
idx = -idx;
if(idx>n) {
LM_DBG("index out of range\n");
pv_get_null(msg, param, val);
goto success;
}
idx = n - idx;
if(idx==0) {
if(avp->flags & AVP_VAL_STR) {
val->rs = avp_value.s;
} else {
val->rs.s = sint2str(avp_value.n, &val->rs.len);
val->ri = avp_value.n;
val->flags |= PV_VAL_INT|PV_TYPE_INT;
}
goto success;
}
}
n=0;
while(n<idx &&
(avp=search_first_avp(name_type, avp_name, &avp_value, avp))!=0)
n++;
if(avp!=0) {
if(avp->flags & AVP_VAL_STR) {
val->rs = avp_value.s;
} else {
val->rs.s = sint2str(avp_value.n, &val->rs.len);
val->ri = avp_value.n;
val->flags |= PV_VAL_INT|PV_TYPE_INT;
}
}
goto success;
error:
res = -1;
success:
if (old_list)
set_avp_list(old_list);
return res;
}
static struct mi_root* ht_mi_dump(struct mi_root* cmd_tree, void* param)
{
struct mi_node* node;
struct mi_node* node2;
struct mi_root *rpl_tree;
struct mi_node *rpl;
str htname;
ht_t *ht;
ht_cell_t *it;
int i;
int len;
char *p;
node = cmd_tree->node.kids;
if(node == NULL)
return init_mi_tree( 400, MI_MISSING_PARM_S, MI_MISSING_PARM_LEN);
htname = node->value;
if(htname.len<=0 || htname.s==NULL)
{
LM_ERR("bad hash table name\n");
return init_mi_tree( 500, "bad hash table name", 19);
}
ht = ht_get_table(&htname);
if(ht==NULL)
{
LM_ERR("bad hash table name\n");
return init_mi_tree( 500, "no such hash table", 18);
}
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==NULL)
return 0;
rpl = &rpl_tree->node;
for(i=0; i<ht->htsize; i++)
{
ht_slot_lock(ht, i);
it = ht->entries[i].first;
if(it)
{
/* add entry node */
p = int2str((unsigned long)i, &len);
node = add_mi_node_child(rpl, MI_DUP_VALUE, "Entry", 5, p, len);
if (node==0)
goto error;
while(it)
{
if(it->flags&AVP_VAL_STR) {
node2 = add_mi_node_child(node, MI_DUP_VALUE, it->name.s, it->name.len,
it->value.s.s, it->value.s.len);
} else {
p = sint2str((long)it->value.n, &len);
node2 = add_mi_node_child(node, MI_DUP_VALUE, it->name.s, it->name.len,
p, len);
}
if (node2==0)
goto error;
it = it->next;
}
}
ht_slot_unlock(ht, i);
}
return rpl_tree;
error:
free_mi_tree(rpl_tree);
return 0;
}
static struct mi_root * clusterer_list(struct mi_root *cmd_tree, void *param)
{
cluster_info_t *cl;
node_info_t *n_info;
struct mi_root *rpl_tree = NULL;
struct mi_node *node = NULL;
struct mi_node *node_s = NULL;
struct mi_attr* attr;
str val;
static str str_up = str_init("Up ");
static str str_prob = str_init("Probe ");
static str str_down = str_init("Down ");
static str str_none = str_init("none");
int n_hop;
rpl_tree = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if (!rpl_tree)
return NULL;
rpl_tree->node.flags |= MI_IS_ARRAY;
lock_start_read(cl_list_lock);
/* iterate through clusters */
for (cl = *cluster_list; cl; cl = cl->next) {
val.s = int2str(cl->cluster_id, &val.len);
node = add_mi_node_child(&rpl_tree->node, MI_DUP_VALUE|MI_IS_ARRAY,
MI_SSTR("Cluster"), val.s, val.len);
if (!node) goto error;
/* iterate through servers */
for (n_info = cl->node_list; n_info; n_info = n_info->next) {
val.s = int2str(n_info->node_id, &val.len);
node_s = add_mi_node_child(node, MI_DUP_VALUE,
MI_SSTR("Node"), val.s, val.len);
if (!node) goto error;
val.s = sint2str(n_info->id, &val.len);
attr = add_mi_attr(node_s, MI_DUP_VALUE,
MI_SSTR("DB_ID"), val.s, val.len);
if (!attr) goto error;
attr = add_mi_attr(node_s, MI_DUP_VALUE,
MI_SSTR("URL"), n_info->url.s, n_info->url.len);
if (!attr) goto error;
lock_get(n_info->lock);
val.s = int2str(n_info->flags & NODE_STATE_ENABLED ? 1 : 0, &val.len);
attr = add_mi_attr(node_s, MI_DUP_VALUE,
MI_SSTR("Enabled"), val.s, val.len);
if (!attr) {
lock_release(n_info->lock);
goto error;
}
if (n_info->link_state == LS_UP)
val = str_up;
else if (n_info->link_state == LS_DOWN)
val = str_down;
else
val = str_prob;
attr = add_mi_attr(node_s, MI_DUP_VALUE,
MI_SSTR("Link_state"), val.s, val.len);
if (!attr) {
lock_release(n_info->lock);
goto error;
}
lock_release(n_info->lock);
n_hop = get_next_hop(n_info);
if (n_hop <= 0)
val = str_none;
else
val.s = int2str(n_hop, &val.len);
attr = add_mi_attr(node_s, MI_DUP_VALUE,
MI_SSTR("Next_hop"), val.s, val.len);
if (!attr)
goto error;
if (n_info->description.s)
attr = add_mi_attr(node_s, MI_DUP_VALUE,
MI_SSTR("Description"),
n_info->description.s, n_info->description.len);
else
attr = add_mi_attr(node_s, MI_DUP_VALUE,
MI_SSTR("Description"),
"none", 4);
if (!attr) goto error;
}
}
lock_stop_read(cl_list_lock);
return rpl_tree;
error:
lock_stop_read(cl_list_lock);
if (rpl_tree) free_mi_tree(rpl_tree);
return NULL;
}
struct mi_root* mi_shvar_get(struct mi_root* cmd_tree, void* param)
{
struct mi_root* rpl_tree = NULL;
struct mi_node* node;
struct mi_attr* attr = NULL;
str name;
int ival;
sh_var_t *shv = NULL;
node = cmd_tree->node.kids;
if(node != NULL)
{
name = node->value;
if(name.len<=0 || name.s==NULL)
{
LM_ERR("bad shv name\n");
return init_mi_tree( 500, MI_SSTR("bad shv name"));
}
shv = get_shvar_by_name(&name);
if(shv==NULL)
return init_mi_tree(404, MI_SSTR("Not found"));
rpl_tree = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==NULL)
return NULL;
node = add_mi_node_child(&rpl_tree->node, MI_DUP_VALUE,
"VAR",3, name.s, name.len);
if(node == NULL)
goto error;
lock_shvar(shv);
if(shv->v.flags&VAR_VAL_STR)
{
attr = add_mi_attr (node, MI_DUP_VALUE, "type", 4, "string", 6);
if(attr == 0)
{
unlock_shvar(shv);
goto error;
}
attr = add_mi_attr (node, MI_DUP_VALUE, "value", 5,
shv->v.value.s.s, shv->v.value.s.len);
if(attr == 0)
{
unlock_shvar(shv);
goto error;
}
unlock_shvar(shv);
} else {
ival = shv->v.value.n;
unlock_shvar(shv);
attr = add_mi_attr (node, MI_DUP_VALUE, "type",4, "integer", 7);
if(attr == 0)
goto error;
name.s = sint2str(ival, &name.len);
attr = add_mi_attr (node, MI_DUP_VALUE, "value",5,
name.s, name.len);
if(attr == 0)
goto error;
}
goto done;
}
rpl_tree = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==NULL)
return NULL;
for(shv=sh_vars; shv; shv=shv->next)
{
node = add_mi_node_child(&rpl_tree->node, MI_DUP_VALUE,
"VAR", 3, shv->name.s, shv->name.len);
if(node == NULL)
goto error;
lock_shvar(shv);
if(shv->v.flags&VAR_VAL_STR)
{
attr = add_mi_attr (node, MI_DUP_VALUE, "type", 4, "string", 6);
if(attr == 0)
{
unlock_shvar(shv);
goto error;
}
attr = add_mi_attr (node, MI_DUP_VALUE, "value", 5,
shv->v.value.s.s, shv->v.value.s.len);
if(attr == 0)
{
unlock_shvar(shv);
goto error;
}
unlock_shvar(shv);
} else {
ival = shv->v.value.n;
unlock_shvar(shv);
attr = add_mi_attr (node, MI_DUP_VALUE, "type",4, "integer", 7);
if(attr == 0)
goto error;
name.s = sint2str(ival, &name.len);
attr = add_mi_attr (node, MI_DUP_VALUE, "value",5,
name.s, name.len);
if(attr == 0)
goto error;
}
}
done:
return rpl_tree;
error:
if(rpl_tree!=NULL)
free_mi_tree(rpl_tree);
return NULL;
}
int pv_get_json_ext(struct sip_msg* msg, pv_param_t* pvp, pv_value_t* val, int flags)
{
pv_json_t * var ;
json_t * obj;
json_name * id = (json_name *) pvp->pvn.u.dname;
UNUSED(id);
if( expand_tag_list( msg, ((json_name *)pvp->pvn.u.dname)->tags ) < 0)
{
LM_ERR("Cannot expand variables in path\n");
return pv_get_null( msg, pvp, val);
}
var = get_pv_json(pvp);
if( var == NULL )
{
/* this is not an error - we simply came across a json spec
* pointing a json var which was never set/init */
LM_DBG("Variable named:%.*s not found\n",id->name.len,id->name.s);
return pv_get_null( msg, pvp, val);
}
obj = get_object(var, pvp, NULL, 0, 0);
memset(val, 0, sizeof(pv_value_t));
if( obj == NULL )
return pv_get_null( msg, pvp, val);
if (pvp->pvi.type == PV_IDX_INT) {
if (pv_json_iterate(&obj, pvp, id, val) < 0) {
LM_DBG("Failed to iterate\n");
return pv_get_null(msg, pvp, val);
}
if (val->flags == PV_VAL_STR || val->flags == PV_VAL_NULL)
/* val is set */
return 0;
/* else we got an object */
} else if (pvp->pvi.type == PV_IDX_ALL) {
LM_ERR("\"[*]\" index only supported in for each statement\n");
return pv_get_null(msg, pvp, val);
}
if( json_object_is_type(obj, json_type_int) )
{
val->rs.s = sint2str(json_object_get_int(obj), &val->rs.len);
val->ri = json_object_get_int(obj);;
val->flags |= PV_VAL_INT|PV_TYPE_INT|PV_VAL_STR;
}
else if( json_object_is_type(obj, json_type_string))
{
val->flags = PV_VAL_STR;
val->rs.s = (char*)json_object_get_string( obj );
#if JSON_C_VERSION_NUM >= JSON_C_VERSION_010
val->rs.len = json_object_get_string_len( obj );
#else
val->rs.len = strlen(val->rs.s);
#endif
} else {
val->flags = PV_VAL_STR;
val->rs.s = (char*)json_object_to_json_string_ext( obj, flags);
val->rs.len = strlen(val->rs.s);
}
return 0;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------//
int main(int argc, char *argv[])
{
int rc;
if (argc != 1)
{
if
(
(strcmp(argv[1], "-h") == 0) ||
(strcmp(argv[1], "-help") == 0) ||
(strcmp(argv[1], "--help") == 0)
)
{
printf("example: %s\n", argv[0]);
return 0;
}
}
rc = uint2str();
if (rc == -1) return 1;
rc = sint2str();
if (rc == -1) return 1;
rc = is_hex();
if (rc == -1) return 1;
rc = is_udec();
if (rc == -1) return 1;
rc = is_sdec();
if (rc == -1) return 1;
rc = is_uint_string_overflow();
if (rc == -1) return 1;
rc = is_sint_string_overflow();
if (rc == -1) return 1;
rc = hex2uint();
if (rc == -1) return 1;
rc = hex2sint();
if (rc == -1) return 1;
rc = sign_expand();
if (rc == -1) return 1;
/*
// convert dec string to uint
bool dec2uint(uint64_t &result, uint64_t default_value, const char *pstr, size_t size);
bool dec2uint(uint64_t &result, uint64_t default_value, const char *pstr);
bool dec2uint(uint64_t &result, uint64_t default_value, const std::string &str);
bool dec2uint(uint64_t &result, const char *pstr, size_t size);
bool dec2uint(uint64_t &result, const char *pstr);
bool dec2uint(uint64_t &result, const std::string &str);
*/
rc = dec2sint();
if (rc == -1) return 1;
rc = str2uint();
if (rc == -1) return 1;
rc = str2bool();
if (rc == -1) return 1;
/*
// convert byte to hex string
const char *bin2hex(const uint8_t byte, bool flag_up = false);
// convert sibmol to number, example: '0' -> 0, 'F' -> 15
bool hex2bin(uint8_t source, uint8_t &target);
// block read from handle
size_t blk_read(int handle, off64_t offset, void *pdata, size_t size);
// block write to handle
size_t blk_write(int handle, off64_t offset, const void *pdata, size_t size, bool flag_sync = false);
// block recv from handle
size_t blk_recv(int handle, void *pdata, size_t size);
// block send to handle
size_t blk_send(int handle, const void *pdata, size_t size);
// file open read only
int file_open_ro(const char *pfilename);
// file open read/write
int file_open_rw(const char *pfilename, bool flag_truncate = false, bool flag_excl = false);
// file close
int file_close(int handle, bool flag_sync = false);
// read data from exist file
int file_get(const char *pfilename, off_t offset, void *pdata, size_t data_size);
int file_get(const char *pfilename, void **pdata, size_t *data_size);
int file_get(const char *pfilename, std::string &data);
// write data to exist file
int file_set(const char *pfilename, off_t offset, const void *pdata, size_t data_size, bool flag_sync = false, bool flag_truncate = false, bool flag_excl = false);
int file_set(const char *pfilename, off_t offset, const std::string &data, bool flag_sync = false, bool flag_truncate = false, bool flag_excl = false);
int file_set(const char *pfilename, const std::string &data, bool flag_sync = false, bool flag_truncate = false, bool flag_excl = false);
// return (concat str1 and str2) or NULL
char *concat_str(const char *pstr1, const char *pstr2);
// get env var and convert to bool
bool env2bool(bool &result, bool value_default, const char *pname);
*/
rc = get_signal_name();
if (rc == -1) return 1;
rc = flip();
if (rc == -1) return 1;
rc = remove_file_ext();
if (rc == -1) return 1;
/*
// check ipv4 string like '127.0.0.1'
bool is_ipaddress(const char *str);
// set signal
bool set_signal(int signo, void (*sig_handler)(int));
// string to lower
void strtolower(const std::string &source, std::string &target);
// check pointer and strlen
size_t strlen(const char *pstr);
*/
rc = find();
if (rc == -1) return 1;
rc = bin2print();
if (rc == -1) return 1;
rc = rnd();
if (rc == -1) return 1;
return 0;
}
int lcache_htable_add(cachedb_con *con,str *attr,int val,int expires,int *new_val)
{
int hash_code;
lcache_entry_t *it=NULL,*it_prev=NULL;
int old_value;
char *new_value;
int new_len;
str ins_val;
struct timeval start;
start_expire_timer(start,local_exec_threshold);
hash_code = core_hash(attr,0,cache_htable_size);
lock_get(&cache_htable[hash_code].lock);
it = cache_htable[hash_code].entries;
while (it) {
if (it->attr.len == attr->len &&
memcmp(it->attr.s,attr->s,attr->len) == 0) {
if (it->expires !=0 && it->expires < get_ticks()) {
/* found an expired entry -> delete it */
if(it_prev)
it_prev->next = it->next;
else
cache_htable[hash_code].entries = it->next;
shm_free(it);
lock_release(&cache_htable[hash_code].lock);
ins_val.s = sint2str(val,&ins_val.len);
if (lcache_htable_insert(con,attr,&ins_val,expires) < 0) {
LM_ERR("failed to insert value\n");
stop_expire_timer(start,local_exec_threshold,
"cachedb_local add",attr->s,attr->len,0);
return -1;
}
if (new_val)
*new_val = val;
stop_expire_timer(start,local_exec_threshold,
"cachedb_local add",attr->s,attr->len,0);
return 0;
}
/* found our valid entry */
if (str2sint(&it->value,&old_value) < 0) {
LM_ERR("not an integer\n");
lock_release(&cache_htable[hash_code].lock);
stop_expire_timer(start,local_exec_threshold,
"cachedb_local add",attr->s,attr->len,0);
return -1;
}
old_value+=val;
expires = it->expires;
new_value = sint2str(old_value,&new_len);
it = shm_realloc(it,sizeof(lcache_entry_t) + attr->len +new_len);
if (it == NULL) {
LM_ERR("failed to realloc struct\n");
lock_release(&cache_htable[hash_code].lock);
stop_expire_timer(start,local_exec_threshold,
"cachedb_local add",attr->s,attr->len,0);
return -1;
}
if (it_prev)
it_prev->next = it;
else
cache_htable[hash_code].entries = it;
it->attr.s = (char*)(it + 1);
it->value.s =(char *)(it + 1) + attr->len;
it->expires = expires;
memcpy(it->value.s,new_value,new_len);
it->value.len = new_len;
lock_release(&cache_htable[hash_code].lock);
if (new_val)
*new_val = old_value;
stop_expire_timer(start,local_exec_threshold,
"cachedb_local add",attr->s,attr->len,0);
return 0;
}
it_prev = it;
it = it->next;
}
lock_release(&cache_htable[hash_code].lock);
/* not found */
ins_val.s = sint2str(val,&ins_val.len);
if (lcache_htable_insert(con,attr,&ins_val,expires) < 0) {
LM_ERR("failed to insert value\n");
stop_expire_timer(start,local_exec_threshold,
"cachedb_local add",attr->s,attr->len,0);
return -1;
}
if (new_val)
*new_val = val;
stop_expire_timer(start,local_exec_threshold,
"cachedb_local add",attr->s,attr->len,0);
return 0;
}
/**
* save hash table content back to database
*/
int ht_db_save_table(ht_t *ht, str *dbtable)
{
db_key_t db_cols[5] = {&ht_db_name_column, &ht_db_ktype_column,
&ht_db_vtype_column, &ht_db_value_column, &ht_db_expires_column};
db_val_t db_vals[5];
ht_cell_t *it;
str tmp;
int i;
time_t now;
int ncols;
if(ht_db_con==NULL)
{
LM_ERR("no db connection\n");
return -1;
}
if (ht_dbf.use_table(ht_db_con, dbtable) < 0)
{
LM_ERR("failed to use_table\n");
return -1;
}
LM_DBG("save the content of hash table [%.*s] to database in [%.*s]\n",
ht->name.len, ht->name.s, dbtable->len, dbtable->s);
now = time(NULL);
for(i=0; i<ht->htsize; i++)
{
lock_get(&ht->entries[i].lock);
it = ht->entries[i].first;
while(it)
{
if(it->flags&AVP_VAL_STR) {
LM_DBG("entry key: [%.*s] value: [%.*s] (str)\n",
it->name.len, it->name.s, it->value.s.len, it->value.s.s);
} else {
LM_DBG("entry key: [%.*s] value: [%d] (int)\n",
it->name.len, it->name.s, it->value.n);
}
if(ht->htexpire > 0) {
if (it->expire <= now) {
LM_DBG("skipping expired entry");
it = it->next;
continue;
}
}
db_vals[0].type = DB1_STR;
db_vals[0].nul = 0;
db_vals[0].val.str_val.s = it->name.s;
db_vals[0].val.str_val.len = it->name.len;
db_vals[1].type = DB1_INT;
db_vals[1].nul = 0;
db_vals[1].val.int_val = 0;
db_vals[2].type = DB1_INT;
db_vals[2].nul = 0;
db_vals[3].type = DB1_STR;
db_vals[3].nul = 0;
if(it->flags&AVP_VAL_STR) {
db_vals[2].val.int_val = 0;
db_vals[3].val.str_val.s = it->value.s.s;
db_vals[3].val.str_val.len = it->value.s.len;
} else {
db_vals[2].val.int_val = 1;
tmp.s = sint2str((long)it->value.n, &tmp.len);
db_vals[3].val.str_val.s = tmp.s;
db_vals[3].val.str_val.len = tmp.len;
}
ncols = 4;
if(ht_db_expires_flag!=0 && ht->htexpire > 0) {
db_vals[4].type = DB1_INT;
db_vals[4].nul = 0;
db_vals[4].val.int_val = (int)it->expire;
ncols = 5;
}
if(ht_dbf.insert(ht_db_con, db_cols, db_vals, ncols) < 0)
{
LM_ERR("failed to store key [%.*s] in table [%.*s]\n",
it->name.len, it->name.s,
dbtable->len, dbtable->s);
}
it = it->next;
}
}
return 0;
}
static struct mi_root* mi_get_dbg_mod_level(struct mi_root *cmd_tree, void *param) {
struct mi_node *node, *crt_node;
struct mi_root *root = NULL;
struct mi_attr *attr;
int l;
str mod_str, level_str;
str level_attr = {"level", strlen("level")};
/* get first param */
node = cmd_tree->node.kids;
if (node == NULL) {
return init_mi_tree(400, MI_MISSING_PARM_S, MI_MISSING_PARM_LEN);
}
if (node->value.s == NULL || node->value.len == 0) {
return init_mi_tree(400, MI_BAD_PARM_S, MI_BAD_PARM_LEN);
}
/* get module str */
mod_str = node->value;
/* no further params expected */
node = node->next;
if (node != NULL) {
return init_mi_tree(400, MI_MISSING_PARM_S, MI_MISSING_PARM_LEN);
}
/* get module log level */
l = get_debug_level(mod_str.s, mod_str.len);
level_str.s = sint2str(l, &level_str.len);
LM_DBG("module=%.*s level_str=%.*s level_int=%d\n",
mod_str.len, mod_str.s, level_str.len, level_str.s, l);
/* return module log level */
root = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if (!root) {
LM_ERR("the MI tree cannot be initialized!\n");
goto error;
}
node = &root->node;
if (!(crt_node = add_mi_node_child(node, 0, mod_str.s, mod_str.len, 0, 0)) ) {
LM_ERR("cannot add the child node to the tree\n");
goto error;
}
if ((attr = add_mi_attr(crt_node, MI_DUP_VALUE,
level_attr.s, level_attr.len,
level_str.s, level_str.len)) == 0) {
LM_ERR("cannot add attributes to the node\n");
goto error;
}
return root;
error:
if (root) {
free_mi_tree(root);
}
return NULL;
}
/*! \brief eval_elem helping function
* \return str op param
*/
inline static int comp_strval(struct sip_msg *msg, int op, str* ival,
operand_t *opd)
{
int ret;
regex_t* re;
char backup;
char backup2;
str res;
pv_value_t value;
if(ival==NULL || ival->s==NULL)
goto error;
res.s = 0; res.len = 0;
if(opd->type == SCRIPTVAR_ST)
{
if(pv_get_spec_value(msg, opd->v.spec, &value)!=0)
{
LM_CRIT("cannot get var value\n");
goto error;
}
if(value.flags&PV_VAL_STR)
{
res = value.rs;
} else {
res.s = sint2str(value.ri, &res.len);
}
} else if(opd->type == NUMBER_ST) {
res.s = sint2str(opd->v.n, &res.len);
}else if(opd->type == STR_ST) {
res = opd->v.s;
} else {
if((op!=MATCH_OP && op!=NOTMATCH_OP) || opd->type != RE_ST)
{
LM_CRIT("invalid operation %d/%d\n", op, opd->type);
goto error;
}
}
ret=-1;
switch(op){
case EQUAL_OP:
if(ival->len != res.len) return 0;
ret=(strncasecmp(ival->s, res.s, ival->len)==0);
break;
case DIFF_OP:
if(ival->len != res.len) return 1;
ret=(strncasecmp(ival->s, res.s, ival->len)!=0);
break;
case MATCH_OP:
case NOTMATCH_OP:
backup=ival->s[ival->len];ival->s[ival->len]='\0';
if(opd->type == SCRIPTVAR_ST) {
re=(regex_t*)pkg_malloc(sizeof(regex_t));
if (re==0){
LM_CRIT("pkg memory allocation failure\n");
ival->s[ival->len]=backup;
goto error;
}
backup2 = res.s[res.len];res.s[res.len] = '\0';
if (regcomp(re, res.s, REG_EXTENDED|REG_NOSUB|REG_ICASE)) {
pkg_free(re);
res.s[res.len] = backup2;
ival->s[ival->len]=backup;
goto error;
}
ret=(regexec(re, ival->s, 0, 0, 0)==0);
regfree(re);
pkg_free(re);
res.s[res.len] = backup2;
} else {
ret=(regexec((regex_t*)opd->v.data, ival->s, 0, 0, 0)==0);
}
ival->s[ival->len]=backup;
if(op==NOTMATCH_OP)
ret = !ret;
break;
default:
LM_CRIT("unknown op %d\n", op);
goto error;
}
return ret;
error:
return -1;
}
static struct mi_root *mi_log_level(struct mi_root *cmd, void *param)
{
struct mi_root *rpl_tree;
struct mi_node *node;
char *p;
int len;
int new_level, i;
pid_t pid = 0;
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK));
if (rpl_tree==0)
return 0;
node = cmd->node.kids;
if (node!=NULL) {
if (str2sint( &node->value, &new_level) < 0)
goto out_bad_param;
node = node->next;
if (node && str2sint( &node->value, &pid) < 0)
goto out_bad_param;
/* if called without arguments, print the table and exit */
} else {
rpl_tree->node.flags |= MI_IS_ARRAY;
for (i = 0; i < counted_processes; i++) {
node = add_mi_node_child(&rpl_tree->node, 0, MI_SSTR("Process"), 0, 0);
if (node==0)
goto out;
p = int2str((unsigned long)pt[i].pid, &len);
if (!add_mi_attr( node, MI_DUP_VALUE, MI_SSTR("PID"), p, len))
goto out;
p = sint2str((unsigned long)pt[i].log_level, &len);
if (!add_mi_attr( node, MI_DUP_VALUE, MI_SSTR("Log level"), p,len))
goto out;
if (!add_mi_attr( node, 0, MI_SSTR("Type"), pt[i].desc,
strlen(pt[i].desc)))
goto out;
}
return rpl_tree;
}
p = sint2str((long)new_level, &len);
if (pid)
node = add_mi_node_child( &rpl_tree->node, MI_DUP_VALUE,
MI_SSTR("New log level"), p, len);
else
node = add_mi_node_child( &rpl_tree->node, MI_DUP_VALUE,
MI_SSTR("New global log level"), p, len);
if (node==0)
goto out;
if (pid) {
/* convert pid to OpenSIPS id */
i = id_of_pid(pid);
if (i == -1)
goto out_bad_param;
__set_proc_default_log_level(i, new_level);
__set_proc_log_level(i, new_level);
} else
set_global_log_level(new_level);
return rpl_tree;
out_bad_param:
free_mi_tree(rpl_tree);
return init_mi_tree( 400, MI_SSTR(MI_BAD_PARM));
out:
free_mi_tree(rpl_tree);
return NULL;
}
