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