void qos_dialog_mi_context_CB(struct dlg_cell* did, int type, struct dlg_cb_params * params)
{
struct mi_node* parent_node = (struct mi_node*)(params->dlg_data);
struct mi_node* node;
qos_ctx_t* qos_ctx = (qos_ctx_t*)*(params->param);
qos_sdp_t* qos_sdp;
qos_sdp = qos_ctx->pending_sdp;
if (qos_sdp) {
node = add_mi_node_child(parent_node, MI_DUP_VALUE, "qos", 3, "pending_sdp", 11);
if (node==NULL) {
LM_ERR("oom\n");
return;
}
if (0 != add_mi_sdp_nodes( node, qos_sdp))
return;
}
qos_sdp = qos_ctx->negotiated_sdp;
if (qos_sdp) {
node = add_mi_node_child(parent_node, MI_DUP_VALUE, "qos", 3, "negotiated_sdp", 14);
if (node==NULL) {
LM_ERR("oom\n");
return;
}
if (0 != add_mi_sdp_nodes( node, qos_sdp))
return;
}
return;
}
int add_mi_session_nodes(struct mi_node* node, int index, sdp_session_cell_t* session)
{
struct mi_node* node1;
struct mi_attr* attr;
sdp_stream_cell_t* stream;
char* p;
int i, len;
switch (index) {
case 0:
node1 = add_mi_node_child( node, MI_IS_ARRAY|MI_DUP_VALUE,
"session", 7, "caller", 6);
if (node1==NULL)
return 1;
break;
case 1:
node1 = add_mi_node_child( node, MI_IS_ARRAY|MI_DUP_VALUE,
"session", 7, "callee", 6);
if (node1==NULL)
return 1;
break;
default:
return 1;
}
attr = add_mi_attr(node1, MI_DUP_VALUE, "cnt_disp", 8, session->cnt_disp.s, session->cnt_disp.len);
if(attr == NULL)
return 1;
attr = add_mi_attr(node1, MI_DUP_VALUE, "bw_type", 7, session->bw_type.s, session->bw_type.len);
if(attr == NULL)
return 1;
attr = add_mi_attr(node1, MI_DUP_VALUE, "bw_width", 8, session->bw_width.s, session->bw_width.len);
if(attr == NULL)
return 1;
p = int2str((unsigned long)(session->streams_num), &len);
attr = add_mi_attr(node1, MI_DUP_VALUE, "streams", 7, p, len);
if(attr == NULL)
return 1;
stream = session->streams;
for(i=session->streams_num-1;i>=0;i--){
if (!stream) {
LM_ERR("got NULL stream\n");
return 1;
}
if (0!=add_mi_stream_nodes(node1, i, stream)){
return 1;
}
stream = stream->next;
}
return 0;
}
struct mi_root *mi_help(struct mi_root *root, void *param)
{
struct mi_root *rpl_tree = 0;
struct mi_node *node;
struct mi_node *rpl;
struct mi_cmd *cmd;
if (!root) {
LM_ERR("invalid MI command\n");
return 0;
}
node = root->node.kids;
if (!node || !node->value.len || !node->value.s) {
rpl_tree = init_mi_tree(200, MI_SSTR(MI_OK));
if (!rpl_tree) {
LM_ERR("cannot init mi tree\n");
return 0;
}
rpl = &rpl_tree->node;
if (!add_mi_node_child(rpl, 0, "Usage", 5, MI_SSTR(MI_HELP_STR))) {
LM_ERR("cannot add new child\n");
goto error;
}
} else {
/* search the command */
cmd = lookup_mi_cmd(node->value.s, node->value.len);
if (!cmd)
return init_mi_tree(404, MI_SSTR(MI_UNKNOWN_CMD));
rpl_tree = init_mi_tree(200, MI_SSTR(MI_OK));
if (!rpl_tree) {
LM_ERR("cannot init mi tree\n");
return 0;
}
rpl = &rpl_tree->node;
if (!addf_mi_node_child(rpl, 0, "Help", 4, "%s", cmd->help.s ?
cmd->help.s : MI_NO_HELP)) {
LM_ERR("cannot add new child\n");
goto error;
}
if (cmd->module.len && cmd->module.s &&
!add_mi_node_child(rpl, 0, "Exported by", 11,
cmd->module.s, cmd->module.len)) {
LM_ERR("cannot add new child\n");
goto error;
}
}
return rpl_tree;
error:
if (rpl_tree)
free_mi_tree(rpl_tree);
return 0;
}
static struct mi_root * clusterer_list_cap(struct mi_root *cmd_tree, void *param)
{
cluster_info_t *cl;
struct local_cap *cap;
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_ok = str_init("Ok");
static str str_not_synced = str_init("not synced");
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);
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;
for (cap = cl->capabilities; cap; cap = cap->next) {
val.s = cap->reg.name.s;
val.len = cap->reg.name.len;
node_s = add_mi_node_child(node, MI_DUP_VALUE|MI_IS_ARRAY,
MI_SSTR("Capability"), val.s, val.len);
if (!node_s) goto error;
lock_get(cl->lock);
val.s = int2str((cap->flags & CAP_STATE_OK) ? 1 : 0, &val.len);
lock_release(cl->lock);
attr = add_mi_attr(node_s, MI_DUP_VALUE, MI_SSTR("State"),
(cap->flags & CAP_STATE_OK) ? str_ok.s : str_not_synced.s,
(cap->flags & CAP_STATE_OK) ? str_ok.len : str_not_synced.len);
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;
}
/* mi function implementations */
struct mi_root* mi_stats(struct mi_root* cmd_tree, void* param)
{
struct mi_root *rpl_tree;
struct mi_node *node=NULL, *rpl=NULL;
struct mi_attr* attr;
char* p;
int i, len;
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==0)
return 0;
rpl = &rpl_tree->node;
LOCK_GET(rl_lock);
for (i=0; i<MAX_PIPES; i++) {
if (*pipes[i].algo != PIPE_ALGO_NOP) {
node = add_mi_node_child(rpl, 0, "PIPE", 4, 0, 0);
if(node == NULL)
goto error;
p = int2str((unsigned long)(i), &len);
attr = add_mi_attr(node, MI_DUP_VALUE, "id", 2, p, len);
if(attr == NULL)
goto error;
p = int2str((unsigned long)(*pipes[i].load), &len);
attr = add_mi_attr(node, MI_DUP_VALUE, "load", 4, p, len);
if(attr == NULL)
goto error;
p = int2str((unsigned long)(*pipes[i].last_counter), &len);
attr = add_mi_attr(node, MI_DUP_VALUE, "counter", 7, p, len);
if(attr == NULL)
goto error;
}
}
p = int2str((unsigned long)(*drop_rate), &len);
node = add_mi_node_child(rpl, MI_DUP_VALUE, "DROP_RATE", 9, p, len);
LOCK_RELEASE(rl_lock);
return rpl_tree;
error:
LOCK_RELEASE(rl_lock);
LM_ERR("Unable to create reply\n");
free_mi_tree(rpl_tree);
return 0;
}
int ds_print_mi_list(struct mi_node* rpl)
{
int len, j;
char* p;
char c;
ds_set_p list;
struct mi_node* node = NULL;
struct mi_node* set_node = NULL;
struct mi_attr* attr = NULL;
if(_ds_list==NULL || _ds_list_nr<=0)
{
LM_DBG("empty destination sets\n");
return 0;
}
p= int2str(_ds_list_nr, &len);
node = add_mi_node_child(rpl, MI_DUP_VALUE, "SET_NO",6, p, len);
if(node== NULL)
return -1;
for(list = _ds_list; list!= NULL; list= list->next)
{
p = int2str(list->id, &len);
set_node= add_mi_node_child(rpl, MI_DUP_VALUE,"SET", 3, p, len);
if(set_node == NULL)
return -1;
for(j=0; j<list->nr; j++)
{
node= add_mi_node_child(set_node, 0, "URI", 3,
list->dlist[j].uri.s, list->dlist[j].uri.len);
if(node == NULL)
return -1;
if (list->dlist[j].flags & DS_INACTIVE_DST) c = 'I';
else if (list->dlist[j].flags & DS_PROBING_DST) c = 'P';
else c = 'A';
attr = add_mi_attr (node, MI_DUP_VALUE, "flag",4, &c, 1);
if(attr == 0)
return -1;
}
}
return 0;
}
struct mi_root* mi_get_pid(struct mi_root* cmd_tree, void* param)
{
struct mi_root *rpl_tree;
struct mi_node *node=NULL, *rpl=NULL;
struct mi_attr* attr;
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==0)
return 0;
rpl = &rpl_tree->node;
node = add_mi_node_child(rpl, 0, "PID", 3, 0, 0);
if(node == NULL)
goto error;
rpl_pipe_lock(0);
attr= addf_mi_attr(node, 0, "ki", 2, "%0.3f", *pid_ki);
if(attr == NULL)
goto error;
attr= addf_mi_attr(node, 0, "kp", 2, "%0.3f", *pid_kp);
if(attr == NULL)
goto error;
attr= addf_mi_attr(node, 0, "kd", 2, "%0.3f", *pid_kd);
rpl_pipe_release(0);
if(attr == NULL)
goto error;
return rpl_tree;
error:
rpl_pipe_release(0);
LM_ERR("Unable to create reply\n");
free_mi_tree(rpl_tree);
return 0;
}
static struct mi_root *mi_which(struct mi_root *cmd, void *param)
{
struct mi_root *rpl_tree;
struct mi_cmd *cmds;
struct mi_node *rpl;
struct mi_node *node;
int size;
int i;
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK));
if (rpl_tree==0)
return 0;
rpl = &rpl_tree->node;
get_mi_cmds( &cmds, &size);
for ( i=0 ; i<size ; i++ ) {
node = add_mi_node_child( rpl, 0, 0, 0, cmds[i].name.s,
cmds[i].name.len);
if (node==0) {
LM_ERR("failed to add node\n");
free_mi_tree(rpl_tree);
return 0;
}
}
return rpl_tree;
}
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;
}
/* used to list all the registered events */
struct mi_root * mi_events_list(struct mi_root *cmd_tree, void *param)
{
struct mi_root *rpl_tree;
struct mi_node *node=NULL, *rpl=NULL;
unsigned i;
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==0)
return 0;
rpl = &rpl_tree->node;
for (i = 0; i < events_no; i++) {
node = add_mi_node_child(rpl, 0, "Event", 5,
events[i].name.s, events[i].name.len);
if(node == NULL)
goto error;
if (!addf_mi_attr(node, 0, "id", 2, "%d", events[i].id))
goto error;
if ((i + 1) % 50 == 0) {
flush_mi_tree(rpl_tree);
}
}
return rpl_tree;
error:
free_mi_tree(rpl_tree);
return 0;
}
static struct mi_root* mi_list_root_path(struct mi_root* cmd, void* param)
{
struct mi_root *rpl_tree;
struct mi_node *node, *rpl;
struct mi_attr* attr;
struct httpd_cb *cb = httpd_cb_list;
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==NULL) return NULL;
rpl = &rpl_tree->node;
rpl->flags |= MI_IS_ARRAY;
while(cb) {
node = add_mi_node_child(rpl, 0, "http_root", 9,
cb->http_root->s, cb->http_root->len);
if(node == NULL) goto error;
attr = add_mi_attr(node, 0, "module", 6,
(char*)cb->module, strlen(cb->module));
if(attr == NULL) goto error;
cb = cb->next;
}
return rpl_tree;
error:
LM_ERR("Unable to create reply\n");
free_mi_tree(rpl_tree);
return NULL;
}
int rl_bin_status(struct mi_root *rpl_tree)
{
int index = 0;
struct mi_node *node;
char* p;
int len;
for (index = 0; index < rl_dests_nr; index++) {
if (!(node = add_mi_node_child(&rpl_tree->node, 0, "Instance", 8,
rl_dests[index].dst.s, rl_dests[index].dst.len))) {
LM_ERR("cannot add a new instance\n");
return -1;
}
if (*rl_dests[index].last_msg) {
p = int2str((unsigned long)(*rl_dests[index].last_msg), &len);
} else {
p = "never";
len = 5;
}
if (!add_mi_attr(node, MI_DUP_VALUE, "timestamp", 9, p, len)) {
LM_ERR("cannot add last update\n");
return -1;
}
}
return 0;
}
static struct mi_root* ds_mi_list(struct mi_root* cmd_tree, void* param)
{
struct mi_root* rpl_tree;
struct mi_node* part_node;
int flags = 0;
if (cmd_tree->node.kids){
if(cmd_tree->node.kids->value.len == 4 && memcmp(cmd_tree->node.kids->value.s,"full",4)==0)
flags |= MI_FULL_LISTING;
else
return init_mi_tree(400, MI_SSTR(MI_BAD_PARM_S));
}
rpl_tree = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==NULL)
return 0;
rpl_tree->node.flags |= MI_IS_ARRAY;
ds_partition_t *part_it;
for (part_it = partitions; part_it; part_it = part_it->next) {
part_node = add_mi_node_child(&rpl_tree->node, MI_IS_ARRAY,"PARTITION",
9, part_it->name.s, part_it->name.len);
if (part_node == NULL
|| ds_print_mi_list(part_node, part_it, flags) < 0) {
LM_ERR("failed to add node\n");
free_mi_tree(rpl_tree);
return 0;
}
}
return rpl_tree;
}
int add_mi_stream_nodes(struct mi_node* node, int index, sdp_stream_cell_t* stream)
{
struct mi_node* node1;
struct mi_attr* attr;
sdp_payload_attr_t* sdp_payload;
char* p;
int i, len;
p = int2str((unsigned long)(index), &len);
node1 = add_mi_node_child( node, MI_DUP_VALUE, "stream", 6, p, len);
if (node1==NULL)
return 1;
attr = add_mi_attr(node1, MI_DUP_VALUE, "media", 5, stream->media.s, stream->media.len);
if(attr == NULL)
return 1;
attr = add_mi_attr(node1, MI_DUP_VALUE, "IP", 2, stream->ip_addr.s, stream->ip_addr.len);
if(attr == NULL)
return 1;
attr = add_mi_attr(node1, MI_DUP_VALUE, "port", 4, stream->port.s, stream->port.len);
if(attr == NULL)
return 1;
attr = add_mi_attr(node1, MI_DUP_VALUE, "transport", 9, stream->transport.s, stream->transport.len);
if(attr == NULL)
return 1;
if (stream->sendrecv_mode.s!=NULL && stream->sendrecv_mode.len!=0) {
attr = add_mi_attr(node1, MI_DUP_VALUE, "sendrecv", 8, stream->sendrecv_mode.s, stream->sendrecv_mode.len);
if(attr == NULL)
return 1;
}
if (stream->ptime.s!=NULL && stream->ptime.len!=0) {
attr = add_mi_attr(node1, MI_DUP_VALUE, "ptime", 5, stream->ptime.s, stream->ptime.len);
if(attr == NULL)
return 1;
}
p = int2str((unsigned long)(stream->payloads_num), &len);
attr = add_mi_attr(node1, MI_DUP_VALUE, "payloads_num", 12, p, len);
if(attr == NULL)
return 1;
sdp_payload = stream->payload_attr;
for(i=stream->payloads_num-1;i>=0;i--){
if (!sdp_payload) {
LM_ERR("got NULL sdp_payload\n");
return 1;
}
if (0!=add_mi_sdp_payload_nodes(node1, i, sdp_payload)){
return 1;
}
sdp_payload = sdp_payload->next;
}
return 0;
}
static struct mi_root* mi_cc_list_flows(struct mi_root *cmd, void *param)
{
struct cc_flow *flow;
struct mi_root *rpl_tree;
struct mi_node *node;
struct mi_node *rpl;
struct mi_attr *attr;
int len;
char *p;
rpl_tree = init_mi_tree( 200, MI_SSTR("OK") );
if ( rpl_tree==NULL)
return NULL;
rpl = &rpl_tree->node;
/* block access to data */
lock_get( data->lock );
for( flow=data->flows; flow ; flow=flow->next ) {
node = add_mi_node_child( rpl, MI_DUP_VALUE, MI_SSTR("Flow"),
flow->id.s, flow->id.len );
if (node==NULL)
goto error;
p = int2str( (unsigned long)(flow->avg_call_duration), &len);
attr = add_mi_attr( node, MI_DUP_VALUE, MI_SSTR("Avg Call Duration"), p, len);
if (attr==NULL)
goto error;
p = int2str( (unsigned long)(flow->processed_calls), &len);
attr = add_mi_attr( node, MI_DUP_VALUE, MI_SSTR("Processed Calls"), p, len);
if (attr==NULL)
goto error;
p = int2str( (unsigned long)(flow->logged_agents), &len);
attr = add_mi_attr( node, MI_DUP_VALUE, MI_SSTR("Logged Agents"), p, len);
if (attr==NULL)
goto error;
p = int2str( (unsigned long)(flow->ongoing_calls), &len);
attr = add_mi_attr( node, MI_DUP_VALUE, MI_SSTR("Ongoing Calls"), p, len);
if (attr==NULL)
goto error;
p = int2str( (unsigned long)(flow->ref_cnt), &len);
attr = add_mi_attr( node, MI_DUP_VALUE, MI_SSTR("Ref"), p, len);
if (attr==NULL)
goto error;
}
lock_release( data->lock );
return rpl_tree;
error:
lock_release( data->lock );
return 0;
}
static struct mi_root * mi_show_partition(struct mi_root *cmd_tree, void *param)
{
struct mi_node *node = NULL;
struct mi_root *rpl_tree = NULL;
struct mi_node* root= NULL;
struct mi_attr* attr;
dp_connection_list_t *el;
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==NULL) return NULL;
if (cmd_tree) node = cmd_tree->node.kids;
if (node == NULL) {
el = dp_get_connections();
root = &rpl_tree->node;
while (el) {
node = add_mi_node_child(root, 0, "Partition", 9, el->partition.s, el->partition.len);
if( node == NULL) goto error;
attr = add_mi_attr(node, 0, "table", 5, el->table_name.s, el->table_name.len);
if(attr == NULL) goto error;
db_get_url(&el->db_url);
if(database_url.len == 0) goto error;
attr = add_mi_attr(node, MI_DUP_VALUE, "db_url", 6, database_url.s, database_url.len);
if(attr == NULL) goto error;
el = el->next;
}
} else {
el = dp_get_connection(&node->value);
if (!el) goto error;
root = &rpl_tree->node;
node = add_mi_node_child(root, 0, "Partition", 9, el->partition.s, el->partition.len);
if( node == NULL) goto error;
attr = add_mi_attr(node, 0, "table", 5, el->table_name.s, el->table_name.len);
if(attr == NULL) goto error;
db_get_url(&el->db_url);
if(database_url.len == 0) goto error;
attr = add_mi_attr(node, MI_DUP_VALUE, "db_url", 6, database_url.s, database_url.len);
if(attr == NULL) goto error;
}
return rpl_tree;
error:
if(rpl_tree) free_mi_tree(rpl_tree);
return NULL;
}
/**
* MI command format:
* name: trace_to_database
* attribute: name=none, value=[on|off]
*/
static struct mi_root* trace_to_database_mi (struct mi_root* cmd_tree, void* param )
{
struct mi_node* node;
struct mi_node *rpl;
struct mi_root *rpl_tree ;
node = cmd_tree->node.kids;
if(node == NULL) {
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK));
if (rpl_tree == 0)
return 0;
rpl = &rpl_tree->node;
if (*trace_to_database_flag == 0 ) {
node = add_mi_node_child(rpl,0,0,0,MI_SSTR("off"));
} else if (*trace_to_database_flag == 1) {
node = add_mi_node_child(rpl,0,0,0,MI_SSTR("on"));
}
return rpl_tree ;
}
if(trace_to_database_flag==NULL)
return init_mi_tree( 500, MI_SSTR(MI_INTERNAL_ERR));
if ( node->value.len==2 &&
(node->value.s[0]=='o'|| node->value.s[0]=='O') &&
(node->value.s[1]=='n'|| node->value.s[1]=='N'))
{
if (db_con!=NULL) {
*trace_to_database_flag = 1;
return init_mi_tree( 200, MI_SSTR(MI_OK));
}
else {
return init_mi_tree( 501, MI_SSTR(MI_INTERNAL_ERR));
}
} else if ( node->value.len==3 &&
(node->value.s[0]=='o'|| node->value.s[0]=='O') &&
(node->value.s[1]=='f'|| node->value.s[1]=='F') &&
(node->value.s[2]=='f'|| node->value.s[2]=='F'))
{
*trace_to_database_flag = 0;
return init_mi_tree( 200, MI_SSTR(MI_OK));
} else {
return init_mi_tree( 400, MI_SSTR(MI_BAD_PARM));
}
}
struct mi_root* mt_mi_summary(struct mi_root* cmd_tree, void* param)
{
m_tree_t *pt;
struct mi_root* rpl_tree = NULL;
struct mi_node* node = NULL;
struct mi_attr* attr= NULL;
str val;
if(!mt_defined_trees())
{
LM_ERR("empty tree list\n");
return init_mi_tree( 500, "No trees", 8);
}
rpl_tree = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if(rpl_tree == NULL)
return 0;
pt = mt_get_first_tree();
while(pt!=NULL)
{
node = add_mi_node_child(&rpl_tree->node, 0, "MT", 2, 0, 0);
if(node == NULL)
goto error;
attr = add_mi_attr(node, MI_DUP_VALUE, "TNAME", 5,
pt->tname.s, pt->tname.len);
if(attr == NULL)
goto error;
val.s = int2str(pt->type, &val.len);
attr = add_mi_attr(node, MI_DUP_VALUE, "TTYPE", 5,
val.s, val.len);
if(attr == NULL)
goto error;
val.s = int2str(pt->memsize, &val.len);
attr = add_mi_attr(node, MI_DUP_VALUE, "MEMSIZE", 7,
val.s, val.len);
if(attr == NULL)
goto error;
val.s = int2str(pt->nrnodes, &val.len);
attr = add_mi_attr(node, MI_DUP_VALUE, "NRNODES", 7,
val.s, val.len);
if(attr == NULL)
goto error;
val.s = int2str(pt->nritems, &val.len);
attr = add_mi_attr(node, MI_DUP_VALUE, "NRITEMS", 7,
val.s, val.len);
if(attr == NULL)
goto error;
pt = pt->next;
}
return rpl_tree;
error:
free_mi_tree(rpl_tree);
return 0;
}
static int rl_map_print(void *param, str key, void *value)
{
struct mi_attr* attr;
char* p;
int len;
rl_pipe_t *pipe = (rl_pipe_t *)value;
struct mi_node * rpl = (struct mi_node *)param;
struct mi_node * node;
str *alg;
if (!pipe) {
LM_ERR("invalid pipe value\n");
return -1;
}
if (!rpl) {
LM_ERR("no reply node\n");
return -1;
}
if (!key.len || !key.s) {
LM_ERR("no key found\n");
return -1;
}
LM_DBG("Algorithm is %d (%p)\n", pipe->algo, pipe);
/* skip if no algo */
if (pipe->algo == PIPE_ALGO_NOP)
return 0;
if (!(node = add_mi_node_child(rpl, 0, "PIPE", 4, 0, 0)))
return -1;
if (!(attr = add_mi_attr(node, MI_DUP_VALUE, "id", 2, key.s, key.len)))
return -1;
if (!(alg = get_rl_algo_name(pipe->algo))) {
LM_ERR("[BUG] unknown algorithm %d\n", pipe->algo);
return -1;
}
if (!(attr = add_mi_attr(node, MI_DUP_VALUE, "algorithm", 9,
alg->s, alg->len)))
return -1;
p = int2str((unsigned long)(pipe->limit), &len);
if (!(attr = add_mi_attr(node, MI_DUP_VALUE, "limit", 5, p, len)))
return -1;
p = int2str((unsigned long)(pipe->last_counter), &len);
if (!(attr = add_mi_attr(node, MI_DUP_VALUE, "counter", 7, p, len)))
return -1;
return 0;
}
static struct mi_root* tls_trace_mi(struct mi_root* cmd_tree, void* param )
{
struct mi_node* node;
struct mi_node *rpl;
struct mi_root *rpl_tree ;
node = cmd_tree->node.kids;
if(node == NULL) {
/* display status on or off */
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK));
if (rpl_tree == 0)
return 0;
rpl = &rpl_tree->node;
if ( *trace_is_on ) {
node = add_mi_node_child(rpl,0,MI_SSTR("TLS tracing"),MI_SSTR("on"));
} else {
node = add_mi_node_child(rpl,0,MI_SSTR("TLS tracing"),MI_SSTR("off"));
}
return rpl_tree ;
} else if ( node && !node->next ) {
if ( (node->value.s[0] | 0x20) == 'o' &&
(node->value.s[1] | 0x20) == 'n' ) {
*trace_is_on = 1;
return init_mi_tree( 200, MI_SSTR(MI_OK));
} else
if ( (node->value.s[0] | 0x20) == 'o' &&
(node->value.s[1] | 0x20) == 'f' &&
(node->value.s[2] | 0x20) == 'f' ) {
*trace_is_on = 0;
return init_mi_tree( 200, MI_SSTR(MI_OK));
} else {
return init_mi_tree( 500, MI_SSTR(MI_INTERNAL_ERR));
}
} else {
return init_mi_tree( 500, MI_SSTR(MI_INTERNAL_ERR));
}
return NULL;
}
int pdt_print_mi_node(pdt_node_t *pt, struct mi_node* rpl, char *code,
int len, str *sdomain, str *sd, str *sp)
{
int i;
struct mi_node* node = NULL;
struct mi_attr* attr= NULL;
str *cl;
if(pt==NULL || len>=PDT_MAX_DEPTH)
return 0;
cl = pdt_get_char_list();
for(i=0; i<cl->len; i++)
{
code[len]=cl->s[i];
if(pt[i].domain.s!=NULL)
{
if((sp->s==NULL && sd->s==NULL)
|| (sp->s==NULL && (sd->s!=NULL && pt[i].domain.len==sd->len
&& strncasecmp(pt[i].domain.s, sd->s, sd->len)==0))
|| (sd->s==NULL && (len+1>=sp->len
&& strncmp(code, sp->s, sp->len)==0))
|| ((sp->s!=NULL && len+1>=sp->len
&& strncmp(code, sp->s, sp->len)==0)
&& (sd->s!=NULL && pt[i].domain.len>=sd->len
&& strncasecmp(pt[i].domain.s, sd->s, sd->len)==0)))
{
node = add_mi_node_child(rpl, 0, "PDT", 3, 0, 0);
if(node == NULL)
goto error;
attr = add_mi_attr(node, MI_DUP_VALUE, "SDOMAIN", 7,
sdomain->s, sdomain->len);
if(attr == NULL)
goto error;
attr = add_mi_attr(node, MI_DUP_VALUE, "PREFIX", 6,
code, len+1);
if(attr == NULL)
goto error;
attr = add_mi_attr(node, MI_DUP_VALUE,"DOMAIN", 6,
pt[i].domain.s, pt[i].domain.len);
if(attr == NULL)
goto error;
}
}
if(pdt_print_mi_node(pt[i].child, rpl, code, len+1, sdomain, sd, sp)<0)
goto error;
}
return 0;
error:
return -1;
}
/************************* MI ***********************/
static struct mi_root* imc_mi_list_rooms(struct mi_root* cmd_tree, void* param)
{
int i, len;
struct mi_root* rpl_tree= NULL;
struct mi_node* rpl= NULL;
struct mi_node* node= NULL;
struct mi_attr* attr= NULL;
imc_room_p irp = NULL;
char* p = NULL;
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if(rpl_tree == NULL)
return 0;
rpl = &rpl_tree->node;
rpl->flags |= MI_IS_ARRAY;
for(i=0; i<imc_hash_size; i++)
{
lock_get(&_imc_htable[i].lock);
irp = _imc_htable[i].rooms;
while(irp){
node = add_mi_node_child(rpl, 0, "ROOM", 4, 0, 0);
if( node == NULL)
goto error;
attr= add_mi_attr(node, MI_DUP_VALUE, "URI", 3, irp->uri.s,
irp->uri.len);
if(attr == NULL)
goto error;
p = int2str(irp->nr_of_members, &len);
attr= add_mi_attr(node, 0, "MEMBERS", 7,p, len );
if(attr == NULL)
goto error;
attr= add_mi_attr(node, MI_DUP_VALUE, "OWNER", 5,
irp->members->uri.s, irp->members->uri.len);
if(attr == NULL)
goto error;
irp = irp->next;
}
lock_release(&_imc_htable[i].lock);
}
return rpl_tree;
error:
lock_release(&_imc_htable[i].lock);
free_mi_tree(rpl_tree);
return 0;
}
static struct mi_root *mi_version(struct mi_root *cmd, void *param)
{
struct mi_root *rpl_tree;
struct mi_node *rpl;
struct mi_node *node;
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK));
if (rpl_tree==0)
return 0;
rpl = &rpl_tree->node;
node = add_mi_node_child( rpl, 0, MI_SSTR("Server"), SERVER_HDR+8,
SERVER_HDR_LEN-8);
if (node==0)
goto error;
node = add_mi_node_child( rpl, 0, MI_SSTR("Build"), BUILD_STR,
BUILD_STR_LEN);
if (node==0)
goto error;
node = add_mi_node_child( rpl, 0, MI_SSTR("Flags"), (char*)ver_flags,
strlen(ver_flags));
if (node==0)
goto error;
node = add_mi_node_child( rpl, 0, MI_SSTR("GIT"), (char*)repo_hash,
strlen(repo_hash));
if (node==0)
goto error;
return rpl_tree;
error:
LM_ERR("failed to add node\n");
free_mi_tree(rpl_tree);
return 0;
}
struct mi_root* mi_get_pipes(struct mi_root* cmd_tree, void* param)
{
struct mi_root *rpl_tree;
struct mi_node *node=NULL, *rpl=NULL;
struct mi_attr* attr;
str algo;
char* p;
int i, len;
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==0)
return 0;
rpl = &rpl_tree->node;
LOCK_GET(rl_lock);
for (i=0; i<MAX_PIPES; i++) {
if (*pipes[i].algo != PIPE_ALGO_NOP) {
node = add_mi_node_child(rpl, 0, "PIPE", 4, 0, 0);
if(node == NULL)
goto error;
p = int2str((unsigned long)(i), &len);
attr = add_mi_attr(node, MI_DUP_VALUE, "id" , 2, p, len);
if(attr == NULL)
goto error;
p = int2str((unsigned long)(*pipes[i].algo), &len);
if (str_map_int(algo_names, *pipes[i].algo, &algo))
goto error;
attr = add_mi_attr(node, 0, "algorithm", 9, algo.s, algo.len);
if(attr == NULL)
goto error;
p = int2str((unsigned long)(*pipes[i].limit), &len);
attr = add_mi_attr(node, MI_DUP_VALUE, "limit", 5, p, len);
if(attr == NULL)
goto error;
p = int2str((unsigned long)(*pipes[i].counter), &len);
attr = add_mi_attr(node, MI_DUP_VALUE, "counter", 7, p, len);
if(attr == NULL)
goto error;
}
}
LOCK_RELEASE(rl_lock);
return rpl_tree;
error:
LOCK_RELEASE(rl_lock);
LM_ERR("Unable to create reply\n");
free_mi_tree(rpl_tree);
return 0;
}
int mt_print_mi_node(m_tree_t *tree, mt_node_t *pt, struct mi_node* rpl,
char *code, int len)
{
int i;
struct mi_node* node = NULL;
struct mi_attr* attr= NULL;
mt_is_t *tvalues;
str val;
if(pt==NULL || len>=MT_MAX_DEPTH)
return 0;
for(i=0; i<MT_NODE_SIZE; i++)
{
code[len]=mt_char_list.s[i];
tvalues = pt[i].tvalues;
if (tvalues != NULL)
{
node = add_mi_node_child(rpl, 0, "MT", 2, 0, 0);
if(node == NULL)
goto error;
attr = add_mi_attr(node, MI_DUP_VALUE, "TNAME", 5,
tree->tname.s, tree->tname.len);
if(attr == NULL)
goto error;
attr = add_mi_attr(node, MI_DUP_VALUE, "TPREFIX", 7,
code, len+1);
if(attr == NULL)
goto error;
while (tvalues != NULL) {
if (tree->type == MT_TREE_IVAL) {
val.s = int2str(tvalues->tvalue.n, &val.len);
attr = add_mi_attr(node, MI_DUP_VALUE, "TVALUE", 6,
val.s, val.len);
} else {
attr = add_mi_attr(node, MI_DUP_VALUE, "TVALUE", 6,
tvalues->tvalue.s.s,
tvalues->tvalue.s.len);
}
if(attr == NULL)
goto error;
tvalues = tvalues->next;
}
}
if(mt_print_mi_node(tree, pt[i].child, rpl, code, len+1)<0)
goto error;
}
return 0;
error:
return -1;
}
struct mi_root *mi_rpc_read_params(rpc_t *rpc, void *ctx)
{
struct mi_root *root;
struct mi_node *node;
str name;
str value;
root = init_mi_tree(0,0,0);
if (!root) {
LM_ERR("the MI tree cannot be initialized!\n");
goto error;
}
node = &root->node;
while (rpc->scan(ctx, "*.S", &value) == 1)
{
name.s = 0;
name.len = 0;
if(value.len>=2 && value.s[0]=='-' && value.s[1]=='-')
{
/* name */
if(value.len>2)
{
name.s = value.s + 2;
name.len = value.len - 2;
}
/* value */
if(rpc->scan(ctx, "*.S", &value) != 1)
{
LM_ERR("value expected\n");
goto error;
}
}
if(!add_mi_node_child(node, 0, name.s, name.len,
value.s, value.len))
{
LM_ERR("cannot add the child node to the MI tree\n");
goto error;
}
}
return root;
error:
if (root)
free_mi_tree(root);
return 0;
}
static struct mi_root* mi_is_gflag(struct mi_root* cmd_tree, void* param )
{
unsigned int flag;
struct mi_root* rpl_tree = NULL;
struct mi_node* node = NULL;
node = cmd_tree->node.kids;
if(node == NULL)
return init_mi_tree( 400, MI_MISSING_PARM_S, MI_MISSING_PARM_LEN);
flag = 0;
if( strno2int( &node->value, &flag) <0)
goto error_param;
if (!flag) {
LM_ERR("incorrect flag\n");
goto error_param;
}
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if(rpl_tree ==0)
return 0;
if( ((*gflags) & flag)== flag )
node = add_mi_node_child( &rpl_tree->node, 0, 0, 0, "TRUE", 4);
else
node = add_mi_node_child( &rpl_tree->node, 0, 0, 0, "FALSE", 5);
if(node == NULL)
{
LM_ERR("failed to add node\n");
free_mi_tree(rpl_tree);
return 0;
}
return rpl_tree;
error_param:
return init_mi_tree( 400, MI_BAD_PARM_S, MI_BAD_PARM_LEN);
}
int add_mi_sdp_nodes(struct mi_node* node, qos_sdp_t* qos_sdp)
{
struct mi_node* node1;
struct mi_attr* attr;
char* p;
int i, len;
sdp_session_cell_t* session;
if ( qos_sdp->prev != NULL ) LM_ERR("got qos_sdp->prev=%p\n", qos_sdp->prev);
while (qos_sdp) {
node1 = add_mi_node_child( node, MI_DUP_VALUE, "sdp", 3, NULL, 0);
if (node1==NULL)
return 1;
p = int2str((unsigned long)(qos_sdp->method_dir), &len);
attr = add_mi_attr(node1, MI_DUP_VALUE, "m_dir", 5, p, len);
if(attr == NULL)
return 1;
p = int2str((unsigned long)(qos_sdp->method_id), &len);
attr = add_mi_attr(node1, MI_DUP_VALUE, "m_id", 4, p, len);
if(attr == NULL)
return 1;
attr = add_mi_attr(node1, MI_DUP_VALUE, "method", 6, qos_sdp->method.s, qos_sdp->method.len);
if(attr == NULL)
return 1;
attr = add_mi_attr(node1, MI_DUP_VALUE, "cseq", 4, qos_sdp->cseq.s, qos_sdp->cseq.len);
if(attr == NULL)
return 1;
p = int2str((unsigned long)(qos_sdp->negotiation), &len);
attr = add_mi_attr(node1, MI_DUP_VALUE, "negotiation", 11, p, len);
if(attr == NULL)
return 1;
for (i=1;i>=0;i--){
session = qos_sdp->sdp_session[i];
if (session) {
if (0 != add_mi_session_nodes(node1, i, session))
return 1;
}
}
qos_sdp = qos_sdp->next;
}
return 0;
}
/*! \brief parsing the datagram buffer*/
struct mi_root * mi_datagram_parse_tree(datagram_stream * datagram) {
struct mi_root *root;
struct mi_node *node;
str name;
str value;
int ret;
root = init_mi_tree(0,0,0);
if (!root) {
LM_ERR("the MI tree cannot be initialized!\n");
goto error;
}
if(!datagram || datagram->current[0] == '\0')
{
LM_DBG("no data in the datagram\n");
return root;
}
node = &root->node;
name.s = value.s = 0;
name.len = value.len = 0;
/* every tree for a command ends with a \n that is alone on its line */
while ((ret=mi_datagram_parse_node(datagram, &name, &value))>=0 ) {
if(ret == 1)
return root;
LM_DBG("adding node <%.*s> ; val <%.*s>\n",
name.len,name.s, value.len,value.s);
if(!add_mi_node_child(node,0,name.s,name.len,value.s,value.len)){
LM_ERR("cannot add the child node to the tree\n");
goto error;
}
LM_DBG("the remaining datagram has %i bytes\n",datagram->len);
/*end condition*/
if(datagram->len == 0) {
LM_DBG("found end of input\n");
return root;
}
}
LM_ERR("parse error!\n");
error:
if (root)
free_mi_tree(root);
return 0;
}
static struct mi_root *mi_uptime(struct mi_root *cmd, void *param)
{
struct mi_root *rpl_tree;
struct mi_node *rpl;
struct mi_node *node;
time_t now;
char *p;
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK));
if (rpl_tree==0)
return NULL;
rpl = &rpl_tree->node;
time(&now);
p = ctime(&now);
node = add_mi_node_child( rpl, MI_DUP_VALUE, MI_SSTR("Now"),
p, strlen(p)-1);
if (node==0)
goto error;
node = add_mi_node_child( rpl, 0, MI_SSTR("Up since"),
up_since_ctime.s, up_since_ctime.len);
if (node==0)
goto error;
node = addf_mi_node_child( rpl, 0, MI_SSTR("Up time"),
"%lu [sec]", (unsigned long)difftime(now, startup_time) );
if (node==0)
goto error;
return rpl_tree;
error:
LM_ERR("failed to add node\n");
free_mi_tree(rpl_tree);
return NULL;
}
