static mi_response_t *mi_list_root_path(const mi_params_t *params,
struct mi_handler *async_hdl)
{
mi_response_t *resp;
mi_item_t *resp_arr;
mi_item_t *root_item;
struct httpd_cb *cb = httpd_cb_list;
resp = init_mi_result_array(&resp_arr);
if (!resp)
return 0;
while(cb) {
root_item = add_mi_object(resp_arr, 0, 0);
if (!root_item)
goto error;
if (add_mi_string(root_item, MI_SSTR("http_root"),
cb->http_root->s, cb->http_root->len) < 0)
goto error;
if (add_mi_string(root_item, MI_SSTR("module"),
(char*)cb->module, strlen(cb->module)) < 0)
goto error;
cb = cb->next;
}
return resp;
error:
free_mi_response(resp);
return 0;
}
int run_rcv_mi_cmd(str *cmd_name, str *cmd_params_arr, int no_params)
{
mi_response_t *resp;
mi_item_t *err_item;
resp = cl_run_mi_cmd(cmd_name, NULL, cmd_params_arr, no_params);
if (resp) {
err_item = cJSON_GetObjectItem(resp, JSONRPC_ERROR_S);
free_mi_response(resp);
return err_item ? 1 : 0;
} else {
LM_ERR("Failed to build MI command response\n");
return -1;
}
}
mi_response_t *mi_get_prob(const mi_params_t *params,
struct mi_handler *async_hdl)
{
mi_response_t *resp;
mi_item_t *resp_obj;
resp = init_mi_result_object(&resp_obj);
if (!resp)
return 0;
if (add_mi_number(resp_obj, MI_SSTR("actual probability percent"),
*probability) < 0) {
free_mi_response(resp);
return 0;
}
return resp;
}
static mi_response_t *mi_b2be_list(const mi_params_t *params,
struct mi_handler *async_hdl)
{
mi_response_t *resp;
mi_item_t *resp_arr;
resp = init_mi_result_array(&resp_arr);
if (!resp)
return 0;
if (server_htable)
if (mi_print_b2be_dlg(resp_arr, server_htable, server_hsize)!=0)
goto error;
if (client_htable)
if (mi_print_b2be_dlg(resp_arr, client_htable, client_hsize)!=0)
goto error;
return resp;
error:
LM_ERR("Unable to create response\n");
free_mi_response(resp);
return NULL;
}
mi_response_t *mi_sca_list(const mi_params_t *params,
struct mi_handler *async_hdl)
{
int i, index;
b2b_sca_record_t *rec;
b2b_sca_call_t *call;
str_lst_t *watcher;
mi_response_t *resp;
mi_item_t *resp_arr;
mi_item_t *resp_item, *watchers_arr, *apps_arr, *app_item;
resp = init_mi_result_array(&resp_arr);
if (!resp)
return 0;
for(index = 0; index<b2b_sca_hsize; index++) {
lock_get(&b2b_sca_htable[index].lock);
rec = b2b_sca_htable[index].first;
while(rec) {
resp_item = add_mi_object(resp_arr, NULL, 0);
if (!resp_item)
goto error;
if (add_mi_string(resp_item, MI_SSTR("shared_line"),
rec->shared_line.s, rec->shared_line.len) < 0)
goto error;
watchers_arr = add_mi_array(resp_item, MI_SSTR("watchers"));
if (!watchers_arr)
goto error;
watcher = rec->watchers;
while (watcher) {
if (add_mi_string(watchers_arr, 0, 0,
watcher->watcher.s, watcher->watcher.len) < 0)
goto error;
watcher = watcher->next;
}
apps_arr = add_mi_array(resp_item, MI_SSTR("appearances"));
if (!apps_arr)
goto error;
for (i=0; i<MAX_APPEARANCE_INDEX; i++) {
if (rec->call[i]) {
call = rec->call[i];
app_item = add_mi_object(apps_arr, NULL, 0);
if (!app_item)
goto error;
if (add_mi_string(app_item, MI_SSTR("index"),
call->appearance_index_str.s,
call->appearance_index_str.len) < 0)
goto error;
if (add_mi_string(app_item, MI_SSTR("state"),
app_state[call->call_state].s,
app_state[call->call_state].len) < 0)
goto error;
if (add_mi_string(app_item, MI_SSTR("b2b_key"),
call->b2bl_key.s, call->b2bl_key.len) < 0)
goto error;
if (add_mi_string(app_item, MI_SSTR("app_uri"),
call->call_info_apperance_uri.s,
call->call_info_apperance_uri.len) < 0)
goto error;
}
}
rec = rec->next;
}
lock_release(&b2b_sca_htable[index].lock);
}
return resp;
error:
lock_release(&b2b_sca_htable[index].lock);
LM_ERR("Unable to create reply\n");
free_mi_response(resp);
return NULL;
}
/* lists the clusters' topology as viewed by the current node*/
static mi_response_t *clusterer_list_topology(const mi_params_t *params,
struct mi_handler *async_hdl)
{
mi_response_t *resp = NULL;
mi_item_t *resp_obj;
mi_item_t *clusters_arr, *cluster_item, *nodes_arr, *node_item;
mi_item_t *neigh_arr;
cluster_info_t *cl;
node_info_t *n_info;
struct neighbour *neigh;
resp = init_mi_result_object(&resp_obj);
if (!resp)
return 0;
clusters_arr = add_mi_array(resp_obj, MI_SSTR("Clusters"));
if (!clusters_arr) {
free_mi_response(resp);
return 0;
}
lock_start_read(cl_list_lock);
/* iterate through clusters */
for (cl = *cluster_list; cl; cl = cl->next) {
cluster_item = add_mi_object(clusters_arr, NULL, 0);
if (!cluster_item)
goto error;
if (add_mi_number(cluster_item, MI_SSTR("cluster_id"), cl->cluster_id) < 0)
goto error;
nodes_arr = add_mi_array(cluster_item, MI_SSTR("Nodes"));
if (!nodes_arr)
goto error;
node_item = add_mi_object(nodes_arr, 0, 0);
if (!node_item)
goto error;
if (add_mi_number(node_item, MI_SSTR("node_id"), current_id) < 0)
goto error;
neigh_arr = add_mi_array(node_item, MI_SSTR("Neighbours"));
if (!neigh_arr)
goto error;
for (neigh = cl->current_node->neighbour_list; neigh; neigh = neigh->next)
if (add_mi_number(neigh_arr, 0,0, neigh->node->node_id) < 0)
goto error;
for (n_info = cl->node_list; n_info; n_info = n_info->next) {
node_item = add_mi_object(nodes_arr, NULL, 0);
if (!node_item)
goto error;
if (add_mi_number(node_item, MI_SSTR("node_id"), n_info->node_id) < 0)
goto error;
neigh_arr = add_mi_array(node_item, MI_SSTR("Neighbours"));
if (!neigh_arr)
goto error;
lock_get(n_info->lock);
for (neigh = n_info->neighbour_list; neigh; neigh = neigh->next)
if (add_mi_number(neigh_arr, 0,0, neigh->node->node_id) < 0) {
lock_release(n_info->lock);
goto error;
}
if (n_info->link_state == LS_UP)
if (add_mi_number(neigh_arr, 0,0, current_id) < 0) {
lock_release(n_info->lock);
goto error;
}
lock_release(n_info->lock);
}
}
lock_stop_read(cl_list_lock);
return resp;
error:
lock_stop_read(cl_list_lock);
if (resp) free_mi_response(resp);
return NULL;
}
static mi_response_t *clusterer_list_cap(const mi_params_t *params,
struct mi_handler *async_hdl)
{
mi_response_t *resp = NULL;
mi_item_t *resp_obj;
mi_item_t *clusters_arr, *cluster_item;
mi_item_t *cap_arr, *cap_item;
cluster_info_t *cl;
struct local_cap *cap;
static str str_ok = str_init("Ok");
static str str_not_synced = str_init("not synced");
resp = init_mi_result_object(&resp_obj);
if (!resp)
return 0;
clusters_arr = add_mi_array(resp_obj, MI_SSTR("Clusters"));
if (!clusters_arr) {
free_mi_response(resp);
return 0;
}
lock_start_read(cl_list_lock);
for (cl = *cluster_list; cl; cl = cl->next) {
cluster_item = add_mi_object(clusters_arr, NULL, 0);
if (!cluster_item)
goto error;
if (add_mi_number(cluster_item, MI_SSTR("cluster_id"), cl->cluster_id) < 0)
goto error;
cap_arr = add_mi_array(cluster_item, MI_SSTR("Capabilities"));
if (!cap_arr)
goto error;
for (cap = cl->capabilities; cap; cap = cap->next) {
cap_item = add_mi_object(cap_arr, NULL, 0);
if (!cap_item)
goto error;
if (add_mi_string(cap_item, MI_SSTR("name"),
cap->reg.name.s, cap->reg.name.len) < 0)
goto error;
lock_get(cl->lock);
if (add_mi_string(cap_item, 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) < 0) {
lock_release(cl->lock);
goto error;
}
lock_release(cl->lock);
}
}
lock_stop_read(cl_list_lock);
return resp;
error:
lock_stop_read(cl_list_lock);
if (resp) free_mi_response(resp);
return NULL;
}
static mi_response_t *clusterer_list(const mi_params_t *params,
struct mi_handler *async_hdl)
{
cluster_info_t *cl;
node_info_t *n_info;
str val;
mi_response_t *resp = NULL;
mi_item_t *resp_obj;
mi_item_t *clusters_arr, *cluster_item, *nodes_arr, *node_item;
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;
resp = init_mi_result_object(&resp_obj);
if (!resp)
return 0;
clusters_arr = add_mi_array(resp_obj, MI_SSTR("Clusters"));
if (!clusters_arr) {
free_mi_response(resp);
return 0;
}
lock_start_read(cl_list_lock);
/* iterate through clusters */
for (cl = *cluster_list; cl; cl = cl->next) {
cluster_item = add_mi_object(clusters_arr, NULL, 0);
if (!cluster_item)
goto error;
if (add_mi_number(cluster_item, MI_SSTR("cluster_id"), cl->cluster_id) < 0)
goto error;
nodes_arr = add_mi_array(cluster_item, MI_SSTR("Nodes"));
if (!nodes_arr)
goto error;
/* iterate through nodes */
for (n_info = cl->node_list; n_info; n_info = n_info->next) {
node_item = add_mi_object(nodes_arr, NULL, 0);
if (!node_item)
goto error;
if (add_mi_number(node_item, MI_SSTR("node_id"), n_info->node_id) < 0)
goto error;
if (add_mi_number(node_item, MI_SSTR("db_id"), n_info->id) < 0)
goto error;
if (add_mi_string(node_item, MI_SSTR("url"),
n_info->url.s, n_info->url.len) < 0)
goto error;
lock_get(n_info->lock);
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;
if (add_mi_string(node_item, MI_SSTR("link_state"),
val.s, val.len) < 0) {
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);
if (add_mi_string(node_item, MI_SSTR("next_hop"), val.s, val.len) < 0)
goto error;
if (n_info->description.s) {
if (add_mi_string(node_item, MI_SSTR("description"),
n_info->description.s, n_info->description.len) < 0)
goto error;
} else
if (add_mi_string(node_item, MI_SSTR("description"),
MI_SSTR("none")) < 0)
goto error;
}
}
lock_stop_read(cl_list_lock);
return resp;
error:
lock_stop_read(cl_list_lock);
if (resp) free_mi_response(resp);
return NULL;
}
static mi_response_t *mi_b2b_list(const mi_params_t *params,
struct mi_handler *async_hdl)
{
int i, index;
b2bl_tuple_t* tuple;
mi_response_t *resp;
mi_item_t *resp_obj;
mi_item_t *tuples_arr, *tuple_item;
mi_item_t *servers_arr, *server_item;
mi_item_t *clients_arr, *clients_item;
mi_item_t *b_entities_arr, *b_entities_item;
resp = init_mi_result_object(&resp_obj);
if (!resp)
return 0;
tuples_arr = add_mi_array(resp_obj, MI_SSTR("Tuples"));
if (!tuples_arr) {
free_mi_response(resp);
return 0;
}
for(i = 0; i< b2bl_hsize; i++)
{
lock_get(&b2bl_htable[i].lock);
tuple = b2bl_htable[i].first;
while(tuple)
{
tuple_item = add_mi_object(tuples_arr, NULL, 0);
if (!tuple_item)
goto error;
if (add_mi_number(tuple_item, MI_SSTR("id"), tuple->id) < 0)
goto error;
if (add_mi_string(tuple_item, MI_SSTR("key"),
tuple->key->s, tuple->key->len) < 0)
goto error;
if (add_mi_number(tuple_item, MI_SSTR("scenario_state"),
tuple->scenario_state) < 0)
goto error;
if (add_mi_number(tuple_item, MI_SSTR("lifetime"),
tuple->lifetime) < 0)
goto error;
if (add_mi_number(tuple_item, MI_SSTR("db_flag"),
tuple->db_flag) < 0)
goto error;
if (tuple->scenario) {
if (add_mi_string(tuple_item, MI_SSTR("scenario"),
tuple->scenario->id.s, tuple->scenario->id.len) < 0)
goto error;
if (add_mi_number(tuple_item, MI_SSTR("next_scenario_state"),
tuple->next_scenario_state) < 0)
goto error;
}
servers_arr = add_mi_array(tuple_item, MI_SSTR("SERVERS"));
if (!servers_arr)
goto error;
for (index=0; index < MAX_B2BL_ENT; index++)
{
if (tuple->servers[index] != NULL)
{
server_item = add_mi_object(servers_arr, NULL, 0);
if (!server_item)
goto error;
if (add_mi_number(server_item, MI_SSTR("index"), index) < 0)
goto error;
if (internal_mi_print_b2bl_entity_id(server_item,
tuple->servers[index])!=0)
goto error;
}
}
clients_arr = add_mi_array(tuple_item, MI_SSTR("CLIENTS"));
if (!clients_arr)
goto error;
for (index=0; index < MAX_B2BL_ENT; index++)
{
if (tuple->clients[index] != NULL)
{
clients_item = add_mi_object(clients_arr, NULL, 0);
if (!clients_item)
goto error;
if (add_mi_number(clients_item, MI_SSTR("index"), index) < 0)
goto error;
if (internal_mi_print_b2bl_entity_id(clients_item,
tuple->clients[index])!=0)
goto error;
}
}
b_entities_arr = add_mi_array(tuple_item, MI_SSTR("BRIDGE_ENTITIES"));
if (!b_entities_arr)
goto error;
for (index=0; index < MAX_BRIDGE_ENT; index++)
{
if (tuple->bridge_entities[index] != NULL)
{
b_entities_item = add_mi_object(b_entities_arr, NULL, 0);
if (!b_entities_item)
goto error;
if (add_mi_number(b_entities_item, MI_SSTR("index"), index) < 0)
goto error;
if (internal_mi_print_b2bl_entity_id(b_entities_item,
tuple->bridge_entities[index])!=0)
goto error;
}
}
tuple = tuple->next;
}
lock_release(&b2bl_htable[i].lock);
}
return resp;
error:
lock_release(&b2bl_htable[i].lock);
LM_ERR("Unable to create reply\n");
free_mi_response(resp);
return NULL;
}
