static int md_nkn_events_commit_apply(md_commit *commit, const mdb_db *old_db, const mdb_db *new_db, mdb_db_change_array *change_list, void *arg) { int err = 0; int i = 0, num_changes = 0; const mdb_db_change *change = NULL; tstring *val = NULL; tstring *source = NULL; num_changes = mdb_db_change_array_length_quick (change_list); for (i = 0; i < num_changes; i++) { change = mdb_db_change_array_get_quick (change_list, i); bail_null (change); if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 7, "net", "interface", "config", "*", "offloading", "gro", "enable")) && (mdct_modify == change->mdc_change_type || mdct_add == change->mdc_change_type)) { const char *intf_name = NULL; const bn_attrib *new_val = NULL; uint32_t gro_toggle = 0; ts_free(&source); node_name_t intf_nd = {0}; tbool intf_valid = false; ts_free(&val); intf_name = tstr_array_get_str_quick(change->mdc_name_parts, 3); bail_null(intf_name); new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); bail_null(new_val); err = bn_attrib_get_tstr(new_val, NULL, bt_bool, NULL, &val); bail_error_null(err, val); if (ts_equal_str(val , "true", false)) { gro_toggle = 1; } else { gro_toggle = 0; } snprintf(intf_nd, sizeof(intf_nd), "/net/interface/state/%s/devsource", intf_name); err = mdb_get_node_value_tstr(commit, new_db, intf_nd, 0, &intf_valid, &source); bail_error(err); if(source && ts_equal_str(source, "physical", false)) { err = md_nkn_ethtool(intf_name, NKN_ETHTOOL_GRO_SET, &gro_toggle); bail_error(err); } ts_free(&val); } if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 7, "net", "interface", "config", "*", "offloading", "gso", "enable")) && (mdct_modify == change->mdc_change_type || mdct_add == change->mdc_change_type)) { const char *intf_name = NULL; const bn_attrib *new_val = NULL; uint32_t gso_toggle = 0; ts_free(&source); node_name_t intf_nd = {0}; tbool intf_valid = false; ts_free(&val); intf_name = tstr_array_get_str_quick(change->mdc_name_parts, 3); bail_null(intf_name); new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); bail_null(new_val); err = bn_attrib_get_tstr(new_val, NULL, bt_bool, NULL, &val); bail_error_null(err, val); if (ts_equal_str(val , "true", false)) { gso_toggle = 1; } else { gso_toggle = 0; } snprintf(intf_nd, sizeof(intf_nd), "/net/interface/state/%s/devsource", intf_name); err = mdb_get_node_value_tstr(commit, new_db, intf_nd, 0, &intf_valid, &source); bail_error(err); if(source && ts_equal_str(source, "physical", false)) { err = md_nkn_ethtool(intf_name, NKN_ETHTOOL_GSO_SET, &gso_toggle); bail_error(err); } ts_free(&val); } if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 7, "net", "interface", "config", "*", "offloading", "tso", "enable")) && (mdct_modify == change->mdc_change_type || mdct_add == change->mdc_change_type)) { const char *intf_name = NULL; const bn_attrib *new_val = NULL; uint32_t tso_toggle = 0; ts_free(&source); node_name_t intf_nd = {0}; tbool intf_valid = false; ts_free(&val); intf_name = tstr_array_get_str_quick(change->mdc_name_parts, 3); bail_null(intf_name); new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); bail_null(new_val); err = bn_attrib_get_tstr(new_val, NULL, bt_bool, NULL, &val); bail_error_null(err, val); if (ts_equal_str(val , "true", false)) { tso_toggle = 1; } else { tso_toggle = 0; } snprintf(intf_nd, sizeof(intf_nd), "/net/interface/state/%s/devsource", intf_name); err = mdb_get_node_value_tstr(commit, new_db, intf_nd, 0, &intf_valid, &source); bail_error(err); if(source && ts_equal_str(source, "physical", false)) { err = md_nkn_ethtool(intf_name, NKN_ETHTOOL_TSO_SET, &tso_toggle); bail_error(err); } ts_free(&val); } if (bn_binding_name_pattern_match(ts_str(change->mdc_name), arp_announce_node)) { const char *intf_name = NULL; const bn_attrib *new_val = NULL; uint32_t arp_announce = 0; node_name_t intf_nd = {0}; node_name_t proc_file = {0}; tbool intf_valid = false; ts_free(&source); intf_name = tstr_array_get_str_quick(change->mdc_name_parts, 3); bail_null(intf_name); new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); bail_null(new_val); err = bn_attrib_get_uint32(new_val, NULL, NULL, &arp_announce); bail_error(err); snprintf(intf_nd, sizeof(intf_nd), "/net/interface/state/%s/devsource", intf_name); err = mdb_get_node_value_tstr(commit, new_db, intf_nd, 0, &intf_valid, &source); bail_error(err); if (source && (ts_equal_str(source, "physical", false) || ts_equal_str(source, "bond", false))) { snprintf(proc_file, sizeof(proc_file), "/proc/sys/net/ipv4/conf/%s/arp_announce", intf_name); md_nkn_proc_ctl_int(proc_file, arp_announce); } } if (bn_binding_name_pattern_match(ts_str(change->mdc_name), arp_ignore_node)) { const char *intf_name = NULL; const bn_attrib *new_val = NULL; uint32_t arp_ignore = 0; node_name_t intf_nd = {0}; node_name_t proc_file = {0}; tbool intf_valid = false; ts_free(&source); intf_name = tstr_array_get_str_quick(change->mdc_name_parts, 3); bail_null(intf_name); new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); bail_null(new_val); err = bn_attrib_get_uint32(new_val, NULL, NULL, &arp_ignore); bail_error(err); snprintf(intf_nd, sizeof(intf_nd), "/net/interface/state/%s/devsource", intf_name); err = mdb_get_node_value_tstr(commit, new_db, intf_nd, 0, &intf_valid, &source); bail_error(err); if (source && (ts_equal_str(source, "physical", false) || ts_equal_str(source, "bond", false))) { snprintf(proc_file, sizeof(proc_file), "/proc/sys/net/ipv4/conf/%s/arp_ignore", intf_name); md_nkn_proc_ctl_int(proc_file, arp_ignore); } } } bail: ts_free(&val); ts_free(&source); return(err); }
static int md_nkn_get_proc_intf_conf ( md_commit *commit, const mdb_db *db, const char *node_name, const bn_attrib_array *node_attribs, bn_binding **ret_binding, uint32 *ret_node_flags, void *arg) { int err = 0; uint32_t arp_value = 0; tstring *t_str = NULL; node_name_t intf_nd = {0}; node_name_t proc_file = {0}; tbool intf_valid = false; tstring *source = NULL; const char *arp_string = "NA"; err = bn_binding_name_to_parts_va(node_name, false, 1, 4, &t_str); bail_error_null(err, t_str); snprintf(intf_nd, sizeof(intf_nd), "/net/interface/state/%s/devsource", ts_str(t_str)); err = mdb_get_node_value_tstr(commit, db, intf_nd, 0, &intf_valid, &source); bail_error(err); if(source && (ts_equal_str(source, "physical", false) || ts_equal_str(source, "bond", false))) { snprintf(proc_file, sizeof(proc_file), "/proc/sys/net/ipv4/conf/%s/%s", ts_str(t_str), (char *) arg); md_nkn_get_proc_ctl_int(proc_file, &arp_value); } if (0 == strcmp(arg, "arp_announce")) { switch(arp_value) { case 2: arp_string = "best"; break; case 0: default: arp_string = "any"; } } if (0 == strcmp(arg, "arp_ignore")) { switch(arp_value) { case 1: arp_string = "no-ip-match"; break; case 2: arp_string = "no-match"; break; case 8: arp_string = "all"; break; case 0: default: arp_string = "none"; } } err = bn_binding_new_str(ret_binding, node_name, ba_value, bt_string, 0, arp_string); bail_error(err); bail: ts_free(&t_str); ts_free(&source); return err; }
/*----------------------------------------------------------------------------- * IMPLEMENTATION */ static int wcf_handle_mfpadd(void) { const bn_response *resp = NULL; bn_request *req = NULL; bn_binding *binding = NULL; const tstring *mfp_value = NULL; const tstring *action_value = NULL; const tstring *media_value = NULL; const tstring *live_encap_value = NULL; const tstring *file_encap_value = NULL; char *bn_mfp_name = NULL; char *bn_mfp_media = NULL; char *bn_mfp_encap = NULL; char *bn_mfp_status = NULL; char *ret_msg = NULL; uint32 ret_err=0; tstring *msg = NULL; tstring *profile_rec = NULL; uint32 code = 0; int err = 0; const tstring *old_stream_profile = NULL; err = web_get_request_param_str(g_web_data, wcf_field_streamname, ps_post_data, &mfp_value); bail_error(err); if (mfp_value == NULL || ts_num_chars(mfp_value) <= 0) { err = ts_new_str(&msg, _("No session name entered.")); bail_error(err); ret_err = 1; goto check_error; } err = web_get_request_param_str(g_web_data, wcf_field_media, ps_post_data, &media_value); bail_error(err); err = web_get_request_param_str(g_web_data, wcf_field_file_encap, ps_post_data, &file_encap_value); bail_error(err); err = web_get_request_param_str(g_web_data, wcf_field_live_encap, ps_post_data, &live_encap_value); bail_error(err); err = web_get_request_param_str(g_web_data, wcf_field_old_stream, ps_post_data, &old_stream_profile); bail_error(err); /*session name*/ err = mdc_get_binding_tstr_fmt (web_mcc, NULL, NULL, NULL, &profile_rec, NULL, "/nkn/nvsd/mfp/config/%s", ts_str(mfp_value)); bail_error(err); if (profile_rec && ts_num_chars(profile_rec) > 0) { ret_msg = smprintf(_("Profile \"%s\" already exists."), ts_str(mfp_value)); bail_null(ret_msg); err = web_set_msg_result_str(g_web_data, 1, ret_msg); bail_error(err); goto bail; } if(!ts_equal_str(old_stream_profile, "(none)", false)){ bn_mfp_name = smprintf("/nkn/nvsd/mfp/config/%s", ts_str(old_stream_profile)); bail_null(bn_mfp_name); err = mdc_reparent_binding_ex(web_mcc, &code, &msg, bn_mfp_name, NULL, ts_str(mfp_value), 0, bsnf_reparent_by_copy); bail_error(err); if (code) { err = web_set_msg_result_str(g_web_data, code, ts_str(msg)); bail_error(err); goto bail; } } else { /*Get the values from the different fields*/ if(ts_equal_str(media_value,"File",true) && (ts_equal_str(file_encap_value,"not_selected",true))) { err = ts_new_str(&msg, _("No encapsulation type selected for File media.")); bail_error(err); ret_err = 1; goto check_error; } if(ts_equal_str(media_value,"Live",true) && (ts_equal_str(live_encap_value,"not_selected",true))) { err = ts_new_str(&msg, _("No encapsulation type selected for Live media.")); bail_error(err); ret_err = 1; goto check_error; } /*session name*/ bn_mfp_name= smprintf("/nkn/nvsd/mfp/config/%s",ts_str(mfp_value)); bail_null(bn_mfp_name); err = mdc_set_binding(web_mcc, &ret_err, &msg, bsso_modify,bt_string,ts_str(mfp_value), bn_mfp_name); bail_error(err); if(ret_err) { goto check_error; } /* media */ bn_mfp_media=smprintf("/nkn/nvsd/mfp/config/%s/media-type",ts_str(mfp_value)); bail_null(bn_mfp_name); err = mdc_set_binding(web_mcc, &ret_err, &msg, bsso_modify,bt_string,ts_str(media_value), bn_mfp_media); bail_error(err); if(ret_err) { goto check_error; } /* encap */ bn_mfp_encap=smprintf("/nkn/nvsd/mfp/config/%s/media-encap",ts_str(mfp_value)); bail_null(bn_mfp_encap); if(ts_equal_str(media_value,"File",true)){ err = mdc_set_binding(web_mcc, &ret_err, &msg, bsso_modify,bt_string,ts_str(file_encap_value), bn_mfp_encap); bail_error(err); if(ret_err) { goto check_error; } }else{ err = mdc_set_binding(web_mcc, &ret_err, &msg, bsso_modify,bt_string,ts_str(live_encap_value), bn_mfp_encap); bail_error(err); if(ret_err) { goto check_error; } } } /* status */ bn_mfp_status=smprintf("/nkn/nvsd/mfp/config/%s/status",ts_str(mfp_value)); bail_null(bn_mfp_status); err = mdc_set_binding(web_mcc, &ret_err, &msg, bsso_modify,bt_string,"NEW", bn_mfp_status); bail_error(err); if(ret_err) { goto check_error; } /*session value name*/ bn_mfp_name= smprintf("/nkn/nvsd/mfp/config/%s/name",ts_str(mfp_value)); bail_null(bn_mfp_name); err = mdc_set_binding(web_mcc, &ret_err, &msg, bsso_modify,bt_string,ts_str(mfp_value), bn_mfp_name); bail_error(err); if(ret_err) { goto check_error; } check_error: err = web_set_msg_result(g_web_data, ret_err,msg); bail_error(err); if (!ret_err) { err = web_set_msg_result(g_web_data,ret_err,msg); bail_error(err); err = web_clear_post_data(g_web_data); bail_error(err); } bail: bn_binding_free(&binding); bn_request_msg_free(&req); ts_free(&msg); safe_free(bn_mfp_name); safe_free(bn_mfp_media); safe_free(bn_mfp_encap); safe_free(bn_mfp_status); return(err); }
static int wcf_handle_mfpsave(void) { int err = 0; bn_request *req = NULL; uint32 code = 0; uint32 i = 0, num_others = 0; tstring *msg = NULL; tstring *clear_str = NULL; tstring *list_others = NULL; tstr_array *others = NULL; const char *suffix = NULL; const bn_response *resp = NULL; tstring *action = NULL; tstr_array *fields = NULL; const tstring *field = NULL; bn_type type = bt_none; tstring *field_value = NULL; tstring *fields_str = NULL; uint32 num_fields = 0; char *ret_msg = NULL; /*dump params*/ //web_dump_params(g_web_data); /* create the message */ err = bn_set_request_msg_create(&req, 0); bail_error(err); err = wcf_do_list_root(req, "", &msg, &code); bail_error(err); if (code) { goto check_error; } if (!code) { lc_log_basic(LOG_NOTICE, _("Sending data to mgmt\n")); err = mdc_send_mgmt_msg(web_mcc, req, false, NULL, &code, &msg); bail_error(err); } check_error: err = web_set_msg_result(g_web_data, code, msg); bail_error(err); /* * Dont clear the data here , since this function is used for action handler for publish * to save any unsaved data */ #if 0 if (!code) { if (clear_str == NULL || !ts_equal_str(clear_str, "false", false)) { err = web_clear_post_data(g_web_data); bail_error(err); } } #endif bail: ts_free(&msg); if(code) { return code; } return err; }
static int agentd_op_show_crawler_name (agentd_context_t * context, void *data, const char * crawl_name){ int err = 0; node_name_t cfg_node_pat = {0}; node_name_t mon_node_pat = {0}; bn_binding_array * cfg_bindings = NULL; bn_binding_array * mon_bindings = NULL; uint8 status = 0, op_status = 0, auto_gen = 0; uint32 file_ext_count = 0, preload_files_count = 0, nonpreload_files_count = 0; char crawler_cfg_status [MAX_TMP_BUF_LEN] = {0}; char crawler_op_status [MAX_TMP_BUF_LEN] = {0}; agentd_crawler_file_context files_context = {0,0}; tstring * url = NULL; tstring * depth = NULL; tstring * auto_gen_new = NULL; tstring * auto_gen_source = NULL; tstring * last_start = NULL; tstring * last_end = NULL; const char * agentd_crawler_op_status_str [] = {"CRAWL_NOT_SCHEDULED", "CRAWL_IN_PROGRESS", "CRAWL_IN_PROGRESS", "CRAWL_STOPPED", "CRAWL_STOPPED" }; #define MAX_CRAWLER_OP_STATUS (sizeof(agentd_crawler_op_status_str)/sizeof (const char *)) bail_null (crawl_name); /* Get the configuration nodes */ snprintf(cfg_node_pat, sizeof(cfg_node_pat), "/nkn/crawler/config/profile/%s", crawl_name); err = mdc_get_binding_children(agentd_mcc, NULL, NULL, true, &cfg_bindings, true, true, cfg_node_pat); bail_error_null(err, cfg_bindings); bn_binding_array_dump("CRAWLER-CFG-BINDINGS", cfg_bindings, jnpr_log_level); err = agentd_binding_array_get_value_tstr_fmt (cfg_bindings, &url, "/nkn/crawler/config/profile/%s/url", crawl_name); bail_error (err); if (!url) { /* URL is mandatory for crawler. If it is null, probably crawler is not configured. Throw error */ lc_log_debug (jnpr_log_level, "Crawler %s is not configured", crawl_name); err = 1; goto bail; } err = agentd_binding_array_get_value_tstr_fmt (cfg_bindings, &depth, "/nkn/crawler/config/profile/%s/link_depth", crawl_name); bail_error (err); err = agentd_binding_array_get_value_uint8_fmt (cfg_bindings, &status, "/nkn/crawler/config/profile/%s/status", crawl_name); bail_error (err); snprintf(crawler_cfg_status, sizeof(crawler_cfg_status), "%s", (status ? "Active" : "Inactive")); err = agentd_binding_array_get_value_uint8_fmt (cfg_bindings, &auto_gen, "/nkn/crawler/config/profile/%s/auto_generate", crawl_name); bail_error (err); if (auto_gen){ /* TODO : Get the file types from TM nodes */ /* Hardcoding now as currently we are supporting only one action */ ts_new_str(&auto_gen_new, "ASX"); ts_new_str(&auto_gen_source, "WMV"); } /* Get the list of preloaded and non-preloaded file extensions */ tstr_array_new (&files_context.preloaded_files, NULL); tstr_array_new (&files_context.nonpreloaded_files, NULL); err = mdc_foreach_binding_prequeried (cfg_bindings, "/nkn/crawler/config/profile/*/file_extension/*", NULL, agentd_crawler_foreach_file_extn, &files_context, &file_ext_count); bail_error (err); lc_log_debug (jnpr_log_level, "Number of file extensions: %d", file_ext_count); /* Get the monitoring nodes */ snprintf(mon_node_pat, sizeof(mon_node_pat), "/nkn/crawler/monitor/profile/external/%s", crawl_name); err = mdc_get_binding_children(agentd_mcc, NULL, NULL, true, &mon_bindings, true, true, mon_node_pat); bail_error (err); bn_binding_array_dump("CRAWLER-MON-BINDINGS", mon_bindings, jnpr_log_level); err = agentd_binding_array_get_value_tstr_fmt (mon_bindings, &last_start, "/nkn/crawler/monitor/profile/external/%s/start_ts", crawl_name); bail_error (err); err = agentd_binding_array_get_value_tstr_fmt (mon_bindings, &last_end, "/nkn/crawler/monitor/profile/external/%s/end_ts", crawl_name); bail_error (err); err = agentd_binding_array_get_value_uint8_fmt (mon_bindings, &op_status, "/nkn/crawler/monitor/profile/external/%s/status", crawl_name); bail_error (err); snprintf(crawler_op_status, sizeof(crawler_op_status), "%s", (op_status >= MAX_CRAWLER_OP_STATUS)? "UNKNOWN":agentd_crawler_op_status_str[op_status]); /* Construct XML response */ OP_EMIT_TAG_START(context, ODCI_MFC_CRAWLER_DETAIL); OP_EMIT_TAG_VALUE(context, ODCI_CRAWLER_NAME, crawl_name); OP_EMIT_TAG_VALUE(context, ODCI_URL, ts_str(url)); OP_EMIT_TAG_VALUE(context, ODCI_DEPTH, ts_str(depth)); OP_EMIT_TAG_VALUE(context, ODCI_CRAWLER_CFG_STATUS, crawler_cfg_status); preload_files_count = tstr_array_length_quick(files_context.preloaded_files); nonpreload_files_count = tstr_array_length_quick(files_context.nonpreloaded_files); if (preload_files_count){ OP_EMIT_TAG_START(context, ODCI_PRELOADED_FILES); for (uint32 i = 0; i < preload_files_count; i++) { OP_EMIT_TAG_VALUE(context, ODCI_CRAWL_FILE_TYPE,tstr_array_get_str_quick(files_context.preloaded_files, i)); } OP_EMIT_TAG_END (context, ODCI_PRELOADED_FILES); } if (nonpreload_files_count){ OP_EMIT_TAG_START(context, ODCI_NON_PRELOADED_FILES); for (uint32 i = 0; i < nonpreload_files_count; i++) { OP_EMIT_TAG_VALUE(context, ODCI_CRAWL_FILE_TYPE,tstr_array_get_str_quick(files_context.nonpreloaded_files, i)); } OP_EMIT_TAG_END (context, ODCI_NON_PRELOADED_FILES); } if (auto_gen) { OP_EMIT_TAG_START (context, ODCI_AUTO_GENERATE); OP_EMIT_TAG_START (context, ODCI_AUTO_GENERATE_CFG); OP_EMIT_TAG_VALUE(context, ODCI_NEW_FILE_TYPE, ts_str(auto_gen_new)); OP_EMIT_TAG_VALUE(context, ODCI_SOURCE_FILE_TYPE, ts_str(auto_gen_source)); OP_EMIT_TAG_END (context, ODCI_AUTO_GENERATE_CFG); OP_EMIT_TAG_END (context, ODCI_AUTO_GENERATE); } OP_EMIT_TAG_VALUE(context, ODCI_LAST_START, ts_str(last_start)); OP_EMIT_TAG_VALUE(context, ODCI_LAST_END, ts_str(last_end)); OP_EMIT_TAG_VALUE(context, ODCI_CRAWL_STATUS, crawler_op_status); OP_EMIT_TAG_END(context, ODCI_MFC_CRAWLER_DETAIL); bail: bn_binding_array_free(&cfg_bindings); bn_binding_array_free(&mon_bindings); ts_free(&url); ts_free(&depth); ts_free(&auto_gen_new); ts_free(&auto_gen_source); ts_free(&last_start); ts_free(&last_end); tstr_array_free(&files_context.preloaded_files); tstr_array_free(&files_context.nonpreloaded_files); return err; }
static int wcf_do_list_root(bn_request *req, const char *list_sfx, tstring **inout_msg, uint32 *ret_code) { bn_binding *binding = NULL; tstr_array *fields = NULL; tstr_array *list_fields = NULL; const tstring *display_name = NULL; const tstring *field = NULL; const tstring *list_field = NULL; char *node_name = NULL; char *list_name = NULL; char *list_root_fn = NULL, *list_index_fn = NULL; char *list_fields_fn = NULL; tstring *root = NULL; tstring *windex = NULL; tstring *windex_value = NULL; char *windex_value_esc = NULL; tstring *value = NULL; tstring *fields_str = NULL; tstring *list_value_fields_str = NULL; tstring *list_field_value = NULL; char *list_field_value_esc = NULL; bn_type type = bt_none; tbool required = false; uint32 code = 0; uint32 num_fields = 0; uint32 num_list_fields = 0; uint32 i = 0; uint32 j = 0; int err = 0; tstring *msg = NULL; tstring *profile_rec = NULL; bail_null(req); bail_null(inout_msg); bail_null(ret_code); const tstring *mfp_value = NULL; err = web_get_request_param_str(g_web_data, wcf_field_name, ps_post_data,&mfp_value); bail_error(err); /* get the root */ list_root_fn = smprintf("%s%s", "/nkn/nvsd/mfp/config", list_sfx); bail_null(list_root_fn); /* get the fields to process */ list_fields_fn = smprintf("%s%s", wcf_id_list_fields, list_sfx); bail_null(list_fields_fn); err = web_get_trimmed_form_field_str(g_web_data, list_fields_fn, &fields_str); bail_error_null(err, fields_str); lc_log_basic(LOG_DEBUG, _("field_str:%s\n"), ts_str(fields_str)); err = ts_tokenize(fields_str, ',', 0, 0, ttf_ignore_leading_separator | ttf_ignore_trailing_separator | ttf_single_empty_token_null, &fields); bail_error(err); /*BUG:6580: Check if the node exists first.Else throw error saying the node wasn't even created * or was deleted recently before the config changes could be saved. */ err = mdc_get_binding_tstr_fmt (web_mcc, &code, NULL, NULL, &profile_rec, NULL, "/nkn/nvsd/mfp/config/%s/media-type", ts_str(mfp_value)); bail_error(err); if (code || (!profile_rec) || (ts_length(profile_rec)== 0)) { err = ts_new_sprintf(inout_msg, _("The session \"%s\"doesn't exists or was deleted recently.\n"), ts_str(mfp_value)); code = 1; //Set the error code goto bail; } node_name = smprintf("/nkn/nvsd/mfp/config/%s", ts_str(mfp_value)); bail_null(node_name); err = bn_binding_new_str_autoinval( &binding, node_name, ba_value, bt_string, 0, ts_str(mfp_value)); bail_error(err); safe_free(node_name); err = bn_set_request_msg_append(req, bsso_modify, 0, binding, NULL); bail_error(err); bn_binding_free(&binding); /* go through all the fields */ if (fields != NULL) { err = tstr_array_length(fields, &num_fields); bail_error(err); } for (i = 0; i < num_fields; ++i) { field = tstr_array_get_quick(fields, i); bail_null(field); /* * if list values exist for this field, then this field is a * wildcard so we need to populate with other fields. */ list_name = smprintf("%s%s%s", wcf_child_prefix, ts_str(field), wcf_child_list_suffix); bail_null(list_name); lc_log_basic(LOG_DEBUG, _("field:%s,list_name:%s\n"), ts_str(field),list_name); err = web_get_trimmed_value_str(g_web_data, list_name, &list_value_fields_str); bail_error(err); if (list_value_fields_str) { err = ts_tokenize(list_value_fields_str, ',', 0, 0, ttf_ignore_leading_separator | ttf_ignore_trailing_separator | ttf_single_empty_token_null, &list_fields); bail_error(err); if (list_fields) { err = tstr_array_length(list_fields, &num_list_fields); bail_error(err); } for (j = 0; j < num_list_fields; ++j) { list_field = tstr_array_get_quick(list_fields, j); bail_null(list_field); err = web_get_type_for_form_field(g_web_data, list_field, &type); bail_error(err); err = web_get_trimmed_form_field(g_web_data, list_field, &list_field_value); bail_error_null(err, list_field_value); err = bn_binding_name_escape_str(ts_str(list_field_value), &list_field_value_esc); bail_error_null(err, list_field_value_esc); err = web_is_required_form_field(g_web_data, list_field, &required); bail_error(err); /* * check if the field is required. if the field is required * and there is no value, inform the user. if the field is not * required and there is no value, don't insert a node for it * so that the mgmt module fills in the default value. */ if (required && ts_length(list_field_value) == 0) { err = web_get_field_display_name(g_web_data, list_field, &display_name); bail_error(err); code = 1; err = ts_new_sprintf(inout_msg, _("No value specified for %s."), ts_str(display_name)); bail_error(err); goto bail; } else if (!required && ts_length(list_field_value) == 0) { goto list_loop_clean; } node_name = smprintf("/nkn/nvsd/mfp/config/%s/%s/%s", ts_str(mfp_value), ts_str(field), list_field_value_esc); lc_log_basic(LOG_DEBUG, "Nodename:%s\n", node_name); bail_null(node_name); err = bn_binding_new_str_autoinval( &binding, node_name, ba_value, type, 0, ts_str(list_field_value)); bail_error(err); err = bn_set_request_msg_append( req, bsso_modify, 0, binding, NULL); bail_error(err); list_loop_clean: ts_free(&list_field_value); safe_free(list_field_value_esc); safe_free(node_name); bn_binding_free(&binding); } goto loop_clean; } err = web_get_type_for_form_field(g_web_data, field, &type); bail_error(err); err = web_get_trimmed_form_field(g_web_data, field, &value); bail_error(err); lc_log_basic(LOG_DEBUG, ("Field:%s\n"), ts_str(field)); if ((value == NULL) && (type == bt_bool)) { /* XXX should we really default to false if no value? */ err = ts_new_str(&value, "false"); bail_error(err); } else if (value == NULL && !ts_cmp_str(field,"smooth/dvrlength", 0)) { err = ts_new_str(&value, "30"); bail_error(err); } else { bail_null(value); } err = web_is_required_form_field(g_web_data, field, &required); bail_error(err); /* * check if the field is required. if the field is required * and there is no value, inform the user. if the field is not * required and there is no value, don't insert a node for it * so that the mgmt module fills in the default value. */ if (required && ts_length(value) == 0) { err = web_get_field_display_name(g_web_data, field, &display_name); bail_error(err); code = 1; err = ts_new_sprintf(inout_msg, _("No value specified for %s."), ts_str(display_name)); bail_error(err); goto bail; } else if (!required && ts_length(value) == 0) { node_name = smprintf("/nkn/nvsd/mfp/config/%s/%s", ts_str(mfp_value), ts_str(field)); bail_null(node_name); err = bn_binding_new_str_autoinval( &binding, node_name, ba_value, type, 0, ts_str(value)); bail_error(err); err = bn_set_request_msg_append(req, bsso_reset, 0, binding, NULL); bail_error(err); goto loop_clean; } node_name = smprintf("/nkn/nvsd/mfp/config/%s/%s", ts_str(mfp_value), ts_str(field)); bail_null(node_name); lc_log_basic(LOG_DEBUG, "Nodename:%s\n", node_name); err = bn_binding_new_str_autoinval( &binding, node_name, ba_value, type, 0, ts_str(value)); bail_error(err); err = bn_set_request_msg_append(req, bsso_modify, 0, binding, NULL); bail_error(err); loop_clean: tstr_array_free(&list_fields); ts_free(&value); ts_free(&list_value_fields_str); ts_free(&list_field_value); safe_free(list_field_value_esc); safe_free(node_name); safe_free(list_name); bn_binding_free(&binding); } bail: *ret_code = code; bn_binding_free(&binding); tstr_array_free(&fields); tstr_array_free(&list_fields); ts_free(&list_value_fields_str); ts_free(&root); ts_free(&windex); ts_free(&windex_value); safe_free(windex_value_esc); ts_free(&value); ts_free(&fields_str); ts_free(&list_field_value); safe_free(list_field_value_esc); safe_free(node_name); safe_free(list_name); safe_free(list_root_fn); safe_free(list_index_fn); safe_free(list_fields_fn); ts_free(&profile_rec); return(err); }
static int agentd_show_interfaces_show_one_config( const bn_binding_array *bindings, uint32 idx, const bn_binding *binding, const tstring *name, const tstr_array *name_components, const tstring *name_last_part, const tstring *value, void *callback_data) { int err = 0; uint8 masklen = 0; agentd_interface_show_context *ctxt = NULL; const bn_binding_array *config_bindings = NULL; node_name_t bn_name = {0}; tstring *alias_ifdevname = NULL; tbool is_alias = false; void *alias_list_v = NULL; const tstring *alias_list = NULL; char* o_netmask = NULL; tbool found = false; tbool display = true, has_display = false; tstring *masklen_tstr = NULL; tstring* os_comment=NULL; tstring* os_enabled=NULL; #ifdef PROD_FEATURE_DHCP_CLIENT tstring* os_dhcp=NULL; #endif /*PROD_FEATURE_DHCP_CLIENT*/ #ifdef PROD_FEATURE_ZEROCONF tstring* os_zeroconf=NULL; #endif /*PROD_FEATURE_ZEROCONF*/ tstring* os_ip_addr=NULL; tstring* os_alias_of=NULL; tstring* os_speed=NULL; tstring* os_duplex=NULL; tstring* os_mtu=NULL; tstring* os_arp=NULL; tstring* s_devsource=NULL; tstring * os_ipv6_enabled = NULL; const char* r = ts_str(name); bail_null(r); bail_null(callback_data); ctxt = callback_data; config_bindings = bindings; if (ctxt->cisc_show_all) { snprintf(bn_name,sizeof(bn_name),"/net/interface/config/%s/display",ts_str(name_last_part)); err = bn_binding_array_get_value_tbool_by_name(config_bindings, bn_name, &has_display, &display); bail_error_msg(err, "Failed to get IF display configuration"); if (!display) goto bail; /* * If has_display is false, * If we're showing interface configuration, something's * wrong, since we were iterating only over interfaces that * had configuration... */ if (!has_display) { lc_log_basic(LOG_WARNING, I_("Could not find node %s"),bn_name); goto bail; } } err = bn_binding_array_get_value_tstr_by_name_fmt( config_bindings, NULL,&alias_ifdevname, "/net/interface/config/%s/alias/ifdevname",ts_str(name_last_part) ); bail_error(err); if (alias_ifdevname && (ts_length(alias_ifdevname) > 0)) { is_alias = true; } err=agentd_binding_array_get_value_tstr_fmt(bindings,&masklen_tstr,"%s/addr/ipv4/static/1/mask_len",r); bail_error(err); if (masklen_tstr) { err = lia_masklen_str_to_ipv4addr_str(ts_str(masklen_tstr), &o_netmask); bail_error(err); } else { o_netmask = strdup(""); bail_null(o_netmask); } lc_log_debug(jnpr_log_level,"netmask of %s = %s",name?ts_str(name):"*", o_netmask ); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_comment,"%s/comment",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_enabled,"%s/enable",r); bail_error(err); #ifdef PROD_FEATURE_DHCP_CLIENT err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_dhcp,"%s/addr/ipv4/dhcp",r); #endif /*PROD_FEATURE_DHCP_CLIENT*/ #ifdef PROD_FEATURE_ZEROCONF err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_zeroconf,"%s/addr/ipv4/zeroconf",r); #endif /* PROD_FEATURE_ZEROCONF */ err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_arp,"%s/arp",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_ip_addr,"%s/addr/ipv4/static/1/ip",r); lc_log_debug(jnpr_log_level,"IP Addr = %s",ts_str(os_ip_addr) ); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_ipv6_enabled,"%s/addr/ipv6/enable",r); bail_error(err); err = ht_lookup(ctxt->cisc_aliases, name_last_part, ts_length(name_last_part), &found, NULL, NULL, &alias_list_v); bail_error(err); alias_list = alias_list_v; if (alias_list && ts_num_chars(alias_list) > 0) { lc_log_debug(jnpr_log_level,"Aliases : %s",ts_str(alias_list)); } if (is_alias) { err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_alias_of,"%s/alias/ifdevname",r); bail_error(err); lc_log_debug(jnpr_log_level,"Alias of = %s",ts_str(os_alias_of) ); } else { err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_speed,"%s/type/ethernet/speed",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_duplex,"%s/type/ethernet/duplex",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_mtu,"%s/mtu",r); bail_error(err); lc_log_debug(jnpr_log_level,"speed = %s",ts_str(os_speed) ); lc_log_debug(jnpr_log_level,"duplex = %s",ts_str(os_duplex) ); lc_log_debug(jnpr_log_level,"mtu = %s",ts_str(os_mtu) ); } { //This block retrieves the devsource needed to check if the if is bond agentd_mdc_get_value_tstr_fmt(&s_devsource,"/net/interface/state/%s/devsource",ts_str_maybe(name_last_part) ); } OP_EMIT_TAG_START(ctxt->agentd_context, ODCI_INTERFACE_CONFIGURED); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_NAME,ts_str_maybe_empty(name_last_part) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_COMMENT,ts_str_maybe_empty(os_comment) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_ENABLED,agentd_ts_map_true_false(os_enabled) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_DHCP,agentd_ts_map_true_false(os_dhcp) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_ZEROCONF,agentd_ts_map_true_false(os_zeroconf) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_IP_ADDRESS,ts_str_maybe_empty(os_ip_addr) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_NETMASK,o_netmask ); OP_EMIT_TAG_START(ctxt->agentd_context, ODCI_IPV6); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_ENABLED, agentd_ts_map_true_false(os_ipv6_enabled)); agentd_show_ipv6_addresses (ctxt, bindings, r); OP_EMIT_TAG_END(ctxt->agentd_context, ODCI_IPV6); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_ARP,agentd_ts_map_true_false(os_arp) ); agentd_show_bond_maybe(ctxt,name_last_part,s_devsource); if(is_alias) { OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_ALIAS_OF,ts_str_maybe_empty(alias_ifdevname) ); } else { OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_SPEED,ts_str_maybe_empty(os_speed) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_DUPLEX,ts_str_maybe_empty(os_duplex) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_MTU,ts_str_maybe_empty(os_mtu) ); agentd_show_if_alias_names_for_config(ctxt,alias_list); } OP_EMIT_TAG_END(ctxt->agentd_context, ODCI_INTERFACE_CONFIGURED); bail: lc_log_debug(jnpr_log_level,"crossed bail..."); ts_free(&alias_ifdevname); ts_free(&masklen_tstr); safe_free(o_netmask); { //This block is to free objects created to emit XML content ts_free(&os_comment); ts_free(&os_enabled); #ifdef PROD_FEATURE_DHCP_CLIENT ts_free(&os_dhcp); #endif /*PROD_FEATURE_DHCP_CLIENT*/ #ifdef PROD_FEATURE_ZEROCONF ts_free(&os_zeroconf); #endif /*PROD_FEATURE_ZEROCONF*/ ts_free(&os_ip_addr); ts_free(&os_alias_of); ts_free(&os_speed); ts_free(&os_duplex); ts_free(&os_mtu); ts_free(&s_devsource); ts_free(&os_ipv6_enabled); } return err; }
static int md_pub_point_commit_check(md_commit *commit, const mdb_db *old_db, const mdb_db *new_db, mdb_db_change_array *change_list, void *arg) { int err = 0; tstring *ret_msg = NULL; int i = 0; int num_changes = 0; const mdb_db_change *change = NULL; const char *t_pp_name = NULL; const bn_attrib *new_val = NULL; tstring *t_duration = NULL; tstring *t_sdp = NULL; tstring *t_pub_server = NULL; tstring *t_mode = NULL; lt_time_sec ret_ts = 0; num_changes = mdb_db_change_array_length_quick (change_list); for (i = 0; i < num_changes; ++i) { change = mdb_db_change_array_get_quick (change_list, i); bail_null(change); if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 5, "nkn", "nvsd", "pub-point", "config", "*")) && ((mdct_add == change->mdc_change_type))) { t_pp_name = tstr_array_get_str_quick(change->mdc_name_parts, 4); err = md_nvsd_pp_validate_name(t_pp_name, &ret_msg); if (err) { err = md_commit_set_return_status_msg_fmt(commit, 1, "error: %s", ts_str(ret_msg)); bail_error(err); goto bail; } } /* Check if EVENT-DURATION is correct format */ if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 7, "nkn", "nvsd", "pub-point", "config", "*", "event", "duration")) && ((mdct_modify == change->mdc_change_type))) { new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); if (new_val) { err = bn_attrib_get_tstr(new_val, NULL, bt_string, NULL, &t_duration); bail_error(err); if (ts_length(t_duration) != 0) { err = lt_str_to_daytime_sec(ts_str(t_duration), &ret_ts); if ( err || (ret_ts < 0)) { err = md_commit_set_return_status_msg_fmt(commit, 1, "error: Bad duration"); bail_error(err); goto bail; } } } } /* Check if START-TIME is correct format */ if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 7, "nkn", "nvsd", "pub-point", "config", "*", "pub-server", "start-time")) && ((mdct_modify == change->mdc_change_type))) { new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); if (new_val) { err = bn_attrib_get_tstr(new_val, NULL, bt_string, NULL, &t_duration); bail_error(err); if (ts_length(t_duration) != 0) { err = lt_str_to_daytime_sec(ts_str(t_duration), &ret_ts); lc_log_basic(LOG_NOTICE, "ret = %d, %s", ret_ts, ts_str(t_duration)); if ( err || (ret_ts < 0)) { err = md_commit_set_return_status_msg_fmt(commit, 1, "error: Bad Start-time"); bail_error(err); goto bail; } } } } /* Check if END-TIME is correct format */ if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 7, "nkn", "nvsd", "pub-point", "config", "*", "pub-server", "end-time")) && ((mdct_modify == change->mdc_change_type))) { new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); if (new_val) { err = bn_attrib_get_tstr(new_val, NULL, bt_string, NULL, &t_duration); bail_error(err); if (ts_length(t_duration) != 0) { err = lt_str_to_daytime_sec(ts_str(t_duration), &ret_ts); lc_log_basic(LOG_NOTICE, "ret = %d, %s", ret_ts, ts_str(t_duration)); if ( err || (ret_ts < 0)) { err = md_commit_set_return_status_msg_fmt(commit, 1, "error: Bad Start-time"); bail_error(err); goto bail; } } } } /* Check if SDP-STATIC is correct format */ if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 7, "nkn", "nvsd", "pub-point", "config", "*", "sdp", "static")) && ((mdct_modify == change->mdc_change_type))) { new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); if (new_val) { err = bn_attrib_get_tstr(new_val, NULL, bt_uri, NULL, &t_sdp); bail_error(err); } } /* Check if pub-server is correct format */ if ((bn_binding_name_parts_pattern_match_va(change->mdc_name_parts, 0, 7, "nkn", "nvsd", "pub-point", "config", "*", "pub-server", "uri")) && ((mdct_modify == change->mdc_change_type))) { new_val = bn_attrib_array_get_quick(change->mdc_new_attribs, ba_value); if (new_val) { err = bn_attrib_get_tstr(new_val, NULL, bt_uri, NULL, &t_pub_server); bail_error(err); if (ts_length(t_pub_server) != 0) { /* validate URI */ err = md_nvsd_pp_validate_pub_server_uri(t_pub_server, &ret_msg); if (err) { err = md_commit_set_return_status_msg_fmt(commit, 1, "error: %s", ts_str(ret_msg)); bail_error(err); goto bail; } } } } } err = md_commit_set_return_status(commit, 0); bail_error(err); bail: ts_free(&ret_msg); ts_free(&t_duration); ts_free(&t_sdp); ts_free(&t_pub_server); ts_free(&t_mode); return err; }
static int agentd_show_if_aliases(agentd_interface_show_context *ctxt, const tstring* name_last_part) { int err =0; char *addr_subtree = NULL; uint32 num_addr_bindings = 0, i = 0; const bn_binding *addr_binding = NULL; node_name_t amask_bn = {0}; node_name_t aifname_bn = {0}; tstring *amask = NULL, *aifname = NULL, *os_arp=NULL; const tstring *addrroot_bn = NULL; tstr_array *name_parts_var = NULL; const tstr_array *name_parts = NULL; const tstring *ifdevname = NULL; const char *addr_str = NULL; char *mask_len = NULL; /* /net/interface/address/state/ifdevname/vlan1249/ipv4addr */ err = bn_binding_name_append_parts_va (&addr_subtree, "/net/interface/address/state/ifdevname", 2, ts_str(name_last_part), "ipv4addr"); bail_error_null(err, addr_subtree); num_addr_bindings = bn_binding_array_length_quick(ctxt->cisc_addr_bindings); lc_log_debug(jnpr_log_level,"into show aliases for %s",ts_str(name_last_part) ); for (i = 0; i < num_addr_bindings; ++i) { ts_free(&amask); safe_free(mask_len); ts_free(&aifname); ts_free(&os_arp); addr_binding = bn_binding_array_get_quick(ctxt->cisc_addr_bindings, i); bail_null(addr_binding); err = bn_binding_get_name(addr_binding, &addrroot_bn); bail_error(err); /* * We want to find the parent of the addr nodes, which are like: * /net/interface/address/state/ifdevname/vlan1249/ipv4addr/10.99.3.241 */ if (!lc_is_prefix(addr_subtree, ts_str(addrroot_bn), false)) { continue; } tstr_array_free(&name_parts_var); name_parts = NULL; name_parts = bn_binding_get_name_parts_const_quick(addr_binding); if (!name_parts) { err = bn_binding_get_name_parts(addr_binding, &name_parts_var); bail_error(err); name_parts = name_parts_var; } if (tstr_array_length_quick(name_parts) != 8) { continue; } err = tstr_array_get(name_parts, 5, (tstring **)&ifdevname); bail_error(err); err = tstr_array_get_str(name_parts, 7, &addr_str); bail_error(err); if ( (ts_num_chars(ifdevname) <= 0) || !ts_equal(name_last_part, ifdevname)) continue; snprintf(aifname_bn,sizeof(aifname_bn),"%s/ifname", ts_str(addrroot_bn)); err = bn_binding_array_get_value_tstr_by_name (ctxt->cisc_addr_bindings, aifname_bn, NULL, &aifname); bail_error(err); bail_null(aifname); /* Any address on the interface itself is not a secondary */ if (!ts_str_maybe(aifname) || !safe_strcmp(ts_str(aifname), ts_str(ifdevname))) { continue; } snprintf(amask_bn,sizeof(amask_bn),"%s/mask", ts_str(addrroot_bn)); err = bn_binding_array_get_value_tstr_by_name (ctxt->cisc_addr_bindings, amask_bn, NULL, &amask); bail_error(err); err = lia_ipv4addr_maskspec_to_masklen_str(ts_str(amask),&mask_len); bail_error(err); err = agentd_binding_array_get_value_tstr_fmt(ctxt->cisc_config_bindings, &os_arp,"/net/interface/config/%s/arp",ts_str_maybe_empty(aifname) ); bail_error(err); lc_log_debug(jnpr_log_level,"Secondary address: %s/%s (alias: '%s')\n", addr_str, mask_len, ts_str(aifname) ); const char* aindex = NULL; aindex = ts_str_nth(aifname,ts_length(name_last_part)+1); //Move past the "<name>:" OP_EMIT_TAG_START(ctxt->agentd_context, ODCI_ALIAS_DETAILS); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_NAME,aindex); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_IP_ADDRESS,addr_str); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_NETMASK,mask_len); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_ARP,agentd_ts_map_true_false(os_arp) ); OP_EMIT_TAG_END(ctxt->agentd_context, ODCI_ALIAS_DETAILS); } bail: ts_free(&os_arp); ts_free(&amask); ts_free(&aifname); safe_free(addr_subtree); return 0; }
static int agentd_show_interfaces_show_stats ( const bn_binding_array *bindings, const tstring* name, agentd_interface_show_context *ctxt ) { int err = 0; const char* r = ts_str(name); tstring* rx_by=NULL; tstring* tx_by=NULL; tstring* rx_pa=NULL; tstring* tx_pa=NULL; tstring* rx_mcast=NULL; tstring* rx_disc=NULL; tstring* tx_disc=NULL; tstring* rx_err=NULL; tstring* tx_err=NULL; tstring* rx_oruns=NULL; tstring* tx_oruns=NULL; tstring* tx_carrier=NULL; tstring* rx_frame=NULL; tstring* tx_colli=NULL; tstring* tx_queuelen=NULL; err=agentd_binding_array_get_value_tstr_fmt(bindings,&rx_by,"%s/stats/rx/bytes",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&tx_by,"%s/stats/tx/bytes",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&rx_pa,"%s/stats/rx/packets",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&tx_pa,"%s/stats/tx/packets",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&rx_mcast,"%s/stats/rx/multicast_packets",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&rx_disc,"%s/stats/rx/discards",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&tx_disc,"%s/stats/tx/discards",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&rx_err,"%s/stats/rx/errors",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&tx_err,"%s/stats/tx/errors",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&rx_oruns,"%s/stats/rx/overruns",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&tx_oruns,"%s/stats/tx/overruns",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&tx_carrier,"%s/stats/tx/carrier",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&rx_frame,"%s/stats/rx/frame",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&tx_colli,"%s/stats/tx/collisions",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&tx_queuelen,"%s/txqueuelen",r); bail_error(err); OP_EMIT_TAG_START(ctxt->agentd_context, ODCI_INTERFACE_STATS); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_RX_BY,ts_str(rx_by) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_TX_BY,ts_str(tx_by) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_RX_PA,ts_str(rx_pa) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_TX_PA,ts_str(tx_pa) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_RX_MCAST,ts_str(rx_mcast) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_RX_DISC,ts_str(rx_disc) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_TX_DISC,ts_str(tx_disc) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_RX_ERR,ts_str(rx_err) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_TX_ERR,ts_str(tx_err) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_RX_ORUNS,ts_str(rx_oruns) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_TX_ORUNS,ts_str(tx_oruns) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_TX_CARRIER,ts_str(tx_carrier) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_RX_FRAME,ts_str(rx_frame) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_TX_COLLI,ts_str(tx_colli) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_TX_QUEUELEN,ts_str(tx_queuelen) ); OP_EMIT_TAG_END(ctxt->agentd_context, ODCI_INTERFACE_STATS); bail: { ts_free(&rx_by); ts_free(&tx_by); ts_free(&rx_pa); ts_free(&tx_pa); ts_free(&rx_mcast); ts_free(&rx_disc); ts_free(&tx_disc); ts_free(&rx_err); ts_free(&tx_err); ts_free(&rx_oruns); ts_free(&tx_oruns); ts_free(&tx_carrier); ts_free(&rx_frame); ts_free(&tx_colli); ts_free(&tx_queuelen); } return err; }
static int agentd_show_ipv6_addresses (agentd_interface_show_context *ctxt, const bn_binding_array * bindings, const char * node_parent) { int err = 0; node_name_t ipv6_addr_wc_name = {0}, ipv6_addr_name = {0}; int ipv6_wc_pos = 0; tstr_array * static_ids = NULL; uint32 num_addrs = 0, i = 0; const char * static_id = NULL; tstring * os_ipv6_addr = NULL; tstring * os_ipv6_mask_len = NULL; str_value_t ipv6_addr_mask = {0}; lc_log_debug (jnpr_log_level, "IPv6 addresses from node :%s", node_parent); if (strstr (node_parent, "/net/interface/config") ) { snprintf(ipv6_addr_name, sizeof(ipv6_addr_name), "%s/addr/ipv6/static", node_parent); snprintf(ipv6_addr_wc_name, sizeof(ipv6_addr_wc_name), "%s/addr/ipv6/static/*", node_parent); ipv6_wc_pos = 7; } else if (strstr (node_parent, "/net/interface/state") ) { snprintf(ipv6_addr_name, sizeof(ipv6_addr_name), "%s/addr/ipv6", node_parent); snprintf (ipv6_addr_wc_name, sizeof(ipv6_addr_wc_name), "%s/addr/ipv6/*", node_parent); ipv6_wc_pos = 6; } else { lc_log_basic (LOG_ERR, "Incorrect parent node for gettng ipv6 addresses"); err = 1; bail_error (err); } err = bn_binding_array_get_name_part_tstr_array(bindings, ipv6_addr_wc_name, ipv6_wc_pos, &static_ids); bail_error (err); num_addrs = tstr_array_length_quick (static_ids); lc_log_debug (jnpr_log_level, "Number of IPv6 addresses :%d", num_addrs); for (i = 0; i < num_addrs; i++) { static_id = tstr_array_get_str_quick (static_ids, i); bail_null (static_id); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_ipv6_addr, "%s/%s/ip",ipv6_addr_name, static_id); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_ipv6_mask_len, "%s/%s/mask_len",ipv6_addr_name, static_id); bail_error(err); snprintf (ipv6_addr_mask , sizeof (ipv6_addr_mask), "%s/%s", ts_str(os_ipv6_addr), ts_str(os_ipv6_mask_len)); OP_EMIT_TAG_VALUE (ctxt->agentd_context, ODCI_ADDRESS, ipv6_addr_mask); ts_free (&os_ipv6_addr); ts_free (&os_ipv6_mask_len); } bail: tstr_array_free (&static_ids); ts_free (&os_ipv6_addr); ts_free (&os_ipv6_mask_len); return err; }
static int agentd_bonding_show_one( const bn_binding_array *bindings, uint32 idx, const bn_binding *binding, const tstring *name, const tstr_array *name_components, const tstring *name_last_part, const tstring *value, void *callback_data) { int err = 0; const char *node_name = NULL; /* node name */ const char *bonding = NULL; uint32 num_intfs = 0; node_name_t node_name_tmp = {0}; agentd_context_t* ctxt = callback_data; tstring* os_link_mon_time=NULL; tstring* os_up_delay_time=NULL; tstring* os_down_delay_time=NULL; tstring* os_name=NULL; tstring* os_enabled=NULL; tstring* os_mode=NULL; bail_null(ctxt); node_name = ts_str(name); bail_null(node_name); bonding = ts_str(name_last_part); bail_null(bonding); lc_log_debug(jnpr_log_level,"Showing bond %s and last part = %s",node_name,bonding); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_link_mon_time,"/net/bonding/config/%s/link-mon-time", bonding); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_up_delay_time,"/net/bonding/config/%s/up-delay-time", bonding); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_down_delay_time,"/net/bonding/config/%s/down-delay-time", bonding); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_name, "%s/name", node_name); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_enabled, "%s/enable",node_name); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_mode, "%s/mode", node_name); bail_error(err); { //This block outputs xml content OP_EMIT_TAG_START(ctxt, ODCI_BOND_DETAIL); OP_EMIT_TAG_VALUE(ctxt, ODCI_NAME,ts_str(os_name) ); OP_EMIT_TAG_VALUE(ctxt, ODCI_ENABLED,agentd_ts_map_true_false(os_enabled) ); OP_EMIT_TAG_VALUE(ctxt, ODCI_MODE,ts_str(os_mode) ); OP_EMIT_TAG_VALUE(ctxt, ODCI_LINK_MON_TIME,ts_str(os_link_mon_time) ); OP_EMIT_TAG_VALUE(ctxt, ODCI_DOWN_DEL_TIME,ts_str(os_down_delay_time) ); OP_EMIT_TAG_VALUE(ctxt, ODCI_UP_DEL_TIME,ts_str(os_up_delay_time) ); snprintf(node_name_tmp,sizeof(node_name_tmp),"/net/bonding/config/%s/interface/*", bonding); err = mdc_foreach_binding_prequeried(bindings,node_name_tmp, NULL, agentd_bonding_show_one_bond_if,ctxt,&num_intfs); OP_EMIT_TAG_END(ctxt, ODCI_BOND_DETAIL); } bail_error(err); if (num_intfs == 0) lc_log_debug(jnpr_log_level,"No interfaces for %s",ts_str(os_name)); bail: ts_free(&os_link_mon_time); ts_free(&os_up_delay_time); ts_free(&os_down_delay_time); ts_free(&os_name); ts_free(&os_enabled); ts_free(&os_mode); return(err); }
static int md_nvsd_pp_validate_pub_server_uri(const tstring *name, tstring **ret_msg) { int err = 0, length = 0; unsigned int i = 0; int32 colon_offset =0, slash_offset = 0, uri_offset = 0; tstring *absuri = NULL; tstring *port = NULL; const char *c_port = NULL; if ( !(ts_has_prefix_str(name, "rtsp://", true) || ts_has_prefix_str(name, "http://", true))) { err = ts_new_sprintf(ret_msg, "only rtsp:// and http:// URLs are supported"); err = lc_err_not_found; goto bail; } err = ts_find_str(name, 0, "://", &uri_offset); length = ts_length(name) - uri_offset + strlen("://"); err = ts_substr (name, 7, length, &absuri); bail_null(absuri); err = ts_find_str(absuri, 0, ":", &colon_offset); err = ts_find_str(absuri, 0, "/", &slash_offset); if (colon_offset != -1) { if(slash_offset != -1) { if(slash_offset < colon_offset){ err = ts_new_sprintf(ret_msg, "Invalid Pub Server URL \n"); err = lc_err_not_found; goto bail; } err = ts_substr (absuri, colon_offset, slash_offset - colon_offset, &port); bail_null(port); } else { err = ts_substr (absuri, colon_offset, length - colon_offset, &port); bail_null( port); } err = ts_trim (port, ':', '/'); bail_null(port); c_port = ts_str(port); for ( i = 0 ; i < strlen ( c_port) ; i++) { if ( !(isdigit(c_port [i]) ) ) { err = ts_new_sprintf(ret_msg, "Invalid Pub Server Port Number \n"); err = lc_err_not_found; goto bail; } } } bail: ts_free(&absuri); ts_free(&port); return err; }
int md_nkn_ethtool(const char *intf_name, nkn_ethtool_cmd_t cmd, uint32_t *data) { int err = 0; tstring *output = NULL; tstr_array *ret_params = NULL; const char *cmd_str = NULL; const char* oper = NULL; int32_t status = 0; struct ethtool_value edata; int need_change = 0; bail_null(intf_name); bail_null(data); if (cmd == NKN_ETHTOOL_GRO_SET) { oper = *data? "on":"off"; cmd_str = "gro"; err = lc_launch_quick_status(&status, &output, true, 5 ,"/usr/sbin/ethtool", "-K" ,intf_name, cmd_str, oper); bail_error(err); memset(&edata, 0, sizeof(struct ethtool_value)); edata.cmd = ETHTOOL_GFLAGS; if (!md_nkn_ethtool_ioctl(intf_name, &edata)) { if(*data && !(ETH_FLAG_LRO & edata.data)) { edata.data |= ETH_FLAG_LRO; need_change = 1; lc_log_basic(LOG_NOTICE, "Enabling RSC/LRO for intf '%s'\n", intf_name); } else if (!*data && (ETH_FLAG_LRO & edata.data)) { edata.data &= ~ETH_FLAG_LRO; need_change = 1; lc_log_basic(LOG_NOTICE, "Disabling RSC/LRO for intf '%s'\n", intf_name); } else { need_change = 0; } if (need_change) { edata.cmd = ETHTOOL_SFLAGS; md_nkn_ethtool_ioctl(intf_name, &edata); } } complain_error(status); } else if (cmd == NKN_ETHTOOL_GRO_GET) { uint32_t gro_idx = 0; const char *gro_status = NULL; str_value_t gro = {0}; err = lc_launch_quick_status(&status, &output, true,3, "/usr/sbin/ethtool", "-k", intf_name); bail_error(err); complain_error(status); err = ts_tokenize(output, '\n', '\\', '"', 0, &ret_params); bail_error(err); err = tstr_array_linear_search_prefix_str(ret_params, "generic-receive-offload:", false, true, 0, &gro_idx); bail_error(err); gro_status = tstr_array_get_str_quick(ret_params, gro_idx); bail_null(gro_status); sscanf(gro_status, "generic-receive-offload: %s", gro); *data = (!strcmp(gro, "on")) ? 1 : 0; } if (cmd == NKN_ETHTOOL_GSO_SET) { oper = *data? "on":"off"; cmd_str = "gso"; err = lc_launch_quick_status(&status, &output, true, 5 ,"/usr/sbin/ethtool", "-K" ,intf_name, cmd_str, oper); bail_error(err); memset(&edata, 0, sizeof(struct ethtool_value)); edata.cmd = ETHTOOL_GGSO; if (!md_nkn_ethtool_ioctl(intf_name, &edata)) { if(*data && !(NETIF_F_GSO & edata.data)) { edata.data |= NETIF_F_GSO; need_change = 1; lc_log_basic(LOG_NOTICE, "Enabling GSO for intf '%s'\n", intf_name); } else if (!*data && (NETIF_F_GSO & edata.data)) { edata.data &= ~NETIF_F_GSO; need_change = 1; lc_log_basic(LOG_NOTICE, "Disabling GSO for intf '%s'\n", intf_name); } else { need_change = 0; } if (need_change) { edata.cmd = ETHTOOL_SGSO; md_nkn_ethtool_ioctl(intf_name, &edata); } } complain_error(status); } else if (cmd == NKN_ETHTOOL_GSO_GET) { uint32_t gso_idx = 0; const char *gso_status = NULL; str_value_t gso = {0}; err = lc_launch_quick_status(&status, &output, true,3, "/usr/sbin/ethtool", "-k", intf_name); bail_error(err); complain_error(status); err = ts_tokenize(output, '\n', '\\', '"', 0, &ret_params); bail_error(err); err = tstr_array_linear_search_prefix_str(ret_params, "generic-segmentation-offload:", false, true, 0, &gso_idx); bail_error(err); gso_status = tstr_array_get_str_quick(ret_params, gso_idx); bail_null(gso_status); sscanf(gso_status, "generic-segmentation-offload: %s", gso); *data = (!strcmp(gso, "on")) ? 1 : 0; } if (cmd == NKN_ETHTOOL_TSO_SET) { oper = *data? "on":"off"; cmd_str = "tso"; err = lc_launch_quick_status(&status, &output, true, 5 ,"/usr/sbin/ethtool", "-K" ,intf_name, cmd_str, oper); bail_error(err); memset(&edata, 0, sizeof(struct ethtool_value)); edata.cmd = ETHTOOL_GTSO; if (!md_nkn_ethtool_ioctl(intf_name, &edata)) { if(*data && !(NETIF_F_TSO & edata.data)) { edata.data |= NETIF_F_TSO; need_change = 1; lc_log_basic(LOG_NOTICE, "Enabling TSO for intf '%s'\n", intf_name); } else if (!*data && (NETIF_F_TSO & edata.data)) { edata.data &= ~NETIF_F_TSO; need_change = 1; lc_log_basic(LOG_NOTICE, "Disabling TSO for intf '%s'\n", intf_name); } else { need_change = 0; } if (need_change) { edata.cmd = ETHTOOL_STSO; md_nkn_ethtool_ioctl(intf_name, &edata); } } complain_error(status); } else if (cmd == NKN_ETHTOOL_TSO_GET) { uint32_t tso_idx = 0; const char *tso_status = NULL; str_value_t tso = {0}; err = lc_launch_quick_status(&status, &output, true,3, "/usr/sbin/ethtool", "-k", intf_name); bail_error(err); complain_error(status); err = ts_tokenize(output, '\n', '\\', '"', 0, &ret_params); bail_error(err); err = tstr_array_linear_search_prefix_str(ret_params, "tcp-segmentation-offload:", false, true, 0, &tso_idx); bail_error(err); tso_status = tstr_array_get_str_quick(ret_params, tso_idx); bail_null(tso_status); sscanf(tso_status, "tcp-segmentation-offload: %s", tso); *data = (!strcmp(tso, "on")) ? 1 : 0; } bail: tstr_array_free(&ret_params); ts_free(&output); return err; }
static int agentd_show_interfaces_show_one_state( const bn_binding_array *bindings, uint32 idx, const bn_binding *binding, const tstring *name, const tstr_array *name_components, const tstring *name_last_part, const tstring *value, void *callback_data) { int err = 0; lc_log_debug(jnpr_log_level, "showing interface %s = %s", ts_str(name), ts_str(name_last_part) ); uint8 masklen = 0; const char *r = NULL; tstring *masklen_tstr = NULL; char *o_netmask = NULL; uint32 show_type = 0; agentd_interface_show_context *ctxt = NULL; tbool display = true; node_name_t bn_name = {0}; str_value_t o_speed = {0}; tstring *alias_ifdevname = NULL; tbool is_alias = false; const bn_binding_array *config_bindings = NULL; node_name_t node_name = {0}; tstring* os_comment=NULL; tstring* os_ip_addr=NULL; tstring* os_speed=NULL; tstring* os_duplex=NULL; tstring* os_mtu=NULL; tstring* os_admin_up=NULL; tstring* os_link_up=NULL; tstring* os_devsource=NULL; tstring* os_hwaddr=NULL; tstring* os_iftype=NULL; tstring* os_arp=NULL; tstring* os_dhcp=NULL; tstring *os_ipv6_enabled=NULL; bail_null(callback_data); ctxt = callback_data; show_type = ctxt->cisc_magic; config_bindings = ctxt->cisc_config_bindings; if (ctxt->cisc_show_all) { snprintf(bn_name,sizeof(bn_name),"/net/interface/config/%s/display", ts_str(name_last_part)); err = bn_binding_array_get_value_tbool_by_name(config_bindings, bn_name, NULL, &display); bail_error_msg(err, "Failed to get IF display configuration"); if (!display) { goto bail; } } err = bn_binding_array_get_value_tstr_by_name_fmt( config_bindings, NULL, &alias_ifdevname,"/net/interface/config/%s/alias/ifdevname", ts_str(name_last_part) ); bail_error(err); if (alias_ifdevname && (ts_length(alias_ifdevname) > 0)) { is_alias = true; } r = ts_str(name); bail_null(r); err=agentd_binding_array_get_value_tstr_fmt(bindings,&masklen_tstr,"%s/addr/ipv4/1/mask_len",r); bail_error(err); if (masklen_tstr) { err =lia_masklen_str_to_ipv4addr_str(ts_str(masklen_tstr), &o_netmask); bail_error(err); } else { o_netmask = strdup(""); bail_null(o_netmask); } lc_log_debug(jnpr_log_level,"netmask of %s = %s",name?ts_str(name):"*", o_netmask ); /* Run-time interface state */ err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_admin_up,"%s/flags/oper_up",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_link_up,"%s/flags/link_up",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_ip_addr,"%s/addr/ipv4/1/ip",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_devsource,"%s/devsource",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_speed,"%s/type/ethernet/speed",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_duplex,"%s/type/ethernet/duplex",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_iftype,"%s/iftype",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_mtu,"%s/mtu",r); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(config_bindings,&os_comment,"/net/interface/config/%s/comment",ts_str(name_last_part)); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(config_bindings,&os_arp,"/net/interface/config/%s/arp",ts_str(name_last_part)); bail_error(err); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_ipv6_enabled,"%s/addr/settings/ipv6/enable",r); bail_error(err); #ifdef PROD_FEATURE_DHCP_CLIENT err=agentd_binding_array_get_value_tstr_fmt(config_bindings,&os_dhcp,"/net/interface/config/%s/addr/ipv4/dhcp",ts_str(name_last_part) ); bail_error(err); #endif /*PROD_FEATURE_DHCP_CLIENT*/ err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_hwaddr,"%s/type/ethernet/mac",r); bail_error(err); if ( !os_hwaddr || ts_length(os_hwaddr) == 0 || ts_cmp_str(os_hwaddr, "N/A", false) == 0 ) { /* * The ethernet mac was empty, see if the top level "hwaddr" * has something. */ ts_free(&os_hwaddr); err=agentd_binding_array_get_value_tstr_fmt(bindings,&os_hwaddr,"%s/hwaddr",r); bail_error(err); } {//This block does the necessary manipulations on the collected data /* * the retrieved speed value is like : "1000Mb/s (auto)" or "100Mb/s" * we need to only pass the numeric part of the value to MFA * */ unsigned int speed = strtoul(ts_str_maybe_empty(os_speed),NULL,10); if(speed>0) snprintf(o_speed,sizeof(o_speed),"%u",speed); /* * The retrieved duplex has value like : "full (auto)", "half (auto)" * but we need to prove only : full or half to MFA */ err = agentd_cook_duplex_state_value(os_duplex); bail_error(err); } { //This block of code is used to do XML output int showStats = (show_type != cid_interface_show_brief) && !is_alias; OP_EMIT_TAG_START(ctxt->agentd_context, ODCI_INTERFACE_BRIEF); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_NAME,ts_str_maybe_empty(name_last_part) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_ADMIN_STATE,agentd_ts_map_true_false(os_admin_up) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_LINK_STATE,agentd_ts_map_true_false(os_link_up) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_IP_ADDRESS,ts_str_maybe_empty(os_ip_addr) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_NETMASK,o_netmask ); OP_EMIT_TAG_START(ctxt->agentd_context, ODCI_IPV6); OP_EMIT_TAG_VALUE (ctxt->agentd_context, ODCI_ENABLED, agentd_ts_map_true_false(os_ipv6_enabled) ); agentd_show_ipv6_addresses (ctxt, bindings, r); OP_EMIT_TAG_END(ctxt->agentd_context, ODCI_IPV6); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_SPEED,o_speed ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_DUPLEX,ts_str_maybe_empty(os_duplex) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_INTERFACE_TYPE,ts_str_maybe_empty(os_iftype) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_INTERFACE_SOURCE,ts_str_maybe_empty(os_devsource) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_MTU,ts_str_maybe_empty(os_mtu) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_HW_ADDRESS,ts_str_maybe_empty(os_hwaddr) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_COMMENT,ts_str_maybe_empty(os_comment) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_ARP,agentd_ts_map_true_false(os_arp) ); OP_EMIT_TAG_VALUE(ctxt->agentd_context, ODCI_DHCP,agentd_ts_map_true_false(os_dhcp) ); agentd_show_if_aliases(ctxt,name_last_part); agentd_show_bond_maybe(ctxt,name_last_part,os_devsource); OP_EMIT_TAG_END(ctxt->agentd_context, ODCI_INTERFACE_BRIEF); if (showStats) { agentd_show_interfaces_show_stats(bindings,name,ctxt); } } bail: lc_log_debug(jnpr_log_level,"crossed bail..."); ts_free(&alias_ifdevname); ts_free(&masklen_tstr); safe_free(o_netmask); { //This block is to free objects created to emit XML content ts_free(&os_comment); ts_free(&os_ip_addr); ts_free(&os_speed); ts_free(&os_duplex); ts_free(&os_mtu); ts_free(&os_admin_up); ts_free(&os_link_up); ts_free(&os_devsource); ts_free(&os_hwaddr); ts_free(&os_iftype); ts_free(&os_ipv6_enabled); }; return(err); }
void ts_crypto_free(struct ts_crypto_ctx *ctx) { ts_free(ctx); }
int geodbd_mgmt_handle_action_request(gcl_session *sess, bn_request **inout_action_request, void *arg) { int err = 0; bn_msg_type req_type = bbmt_none; bn_binding_array *bindings = NULL; tstring *action_name = NULL; tstring *t_filename = NULL; tstring *t_app_name = NULL; tstring *ret_output = NULL; bn_request *req = NULL; /* Standard Samara logic first */ bail_null(inout_action_request); bail_null(*inout_action_request); err = bn_request_get (*inout_action_request, &req_type, NULL, true, &bindings, NULL, NULL); bail_error(err); bail_require(req_type == bbmt_action_request); err = bn_action_request_msg_get_action_name(*inout_action_request, &action_name); bail_error(err); lc_log_basic(LOG_INFO, "Received action %s", ts_str(action_name)); if (ts_equal_str (action_name, "/nkn/geodb/actions/install", false)){ err = bn_binding_array_get_value_tstr_by_name (bindings, "filename", NULL, &t_filename); if (!t_filename) { lc_log_basic(LOG_NOTICE, "No filename entered\n"); goto bail; } lc_log_basic(LOG_NOTICE, I_("Got the install action for %s \n"), ts_str(t_filename)); /* Call the Geodbd function*/ err = geodbd_install(ts_str(t_filename), &ret_output); /* Send response message*/ err = bn_response_msg_create_send (sess, bbmt_action_response, bn_request_get_msg_id(*inout_action_request), err, ts_str(ret_output), 0); /*Raise an event to notify the installation*/ err = bn_event_request_msg_create(&req, "/nkn/geodb/events/installation"); bail_error(err); err = mdc_send_mgmt_msg(geodbd_mcc, req, false, NULL, NULL, NULL); bail_error(err); } else if (ts_equal_str (action_name, "/nkn/geodb/actions/info_display", false)){ err = bn_binding_array_get_value_tstr_by_name (bindings, "app_name", NULL, &t_app_name); if (!t_app_name) { lc_log_basic(LOG_NOTICE, "No application entered\n"); goto bail; } lc_log_basic(LOG_NOTICE, I_("Got the info_display action for %s \n"), ts_str(t_app_name)); /* Call the Geodbd function*/ err = geodbd_info_display(ts_str(t_app_name), &ret_output); /* Send response message*/ err = bn_response_msg_create_send (sess, bbmt_action_response, bn_request_get_msg_id(*inout_action_request), err, ts_str(ret_output), 0); } bail: ts_free(&action_name); ts_free(&ret_output); ts_free(&t_filename); bn_binding_array_free(&bindings); bn_request_msg_free(&req); return err; }