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