/** * context: {link} * tokens : {igp-weight} * options: {--bidir --tos=<>} */ int cli_net_link_igpweight(cli_ctx_t * ctx, cli_cmd_t * cmd) { net_iface_t * link= _link_from_context(ctx); const char * arg= cli_get_arg_value(cmd, 0); const char * opt; igp_weight_t weight; net_tos_t tos= 0; int bidir= 0; int result; //cli_args_dump(gdsout, cmd->opts); // Get optional TOS opt= cli_get_opt_value(cmd, "tos"); if (opt != NULL) if (!str2tos(opt, &tos)) { cli_set_user_error(cli_get(), "invalid TOS \"%s\"", opt); return CLI_ERROR_COMMAND_FAILED; } // Check option --bidir if (cli_has_opt_value(cmd, "bidir")) { if (link->type != NET_IFACE_RTR) { cli_set_user_error(cli_get(), ": --bidir only works with ptp links"); return CLI_ERROR_COMMAND_FAILED; } bidir= 1; } // Get new IGP weight if (str2weight(arg, &weight)) { cli_set_user_error(cli_get(), "invalid weight \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } // Change link weight result= net_iface_set_metric(link, tos, weight, bidir); if (result != ESUCCESS) { cli_set_user_error(cli_get(), "cannot set metric (%s)", network_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {router, peer} * tokens: {} */ static int cli_peer_reset(cli_ctx_t * ctx, cli_cmd_t * cmd) { bgp_peer_t * peer= _peer_from_context(ctx); // Try to close session if (bgp_peer_close_session(peer)) { cli_set_user_error(cli_get(), "could not close session"); return CLI_ERROR_COMMAND_FAILED; } // Try to open session if (bgp_peer_open_session(peer)) { cli_set_user_error(cli_get(), "could not close session"); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
after(): call(void loadConfig()) { kcli = cli_get(); jem_command = cli_register_command(kcli, NULL, "jem", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL); jemtst_command = cli_register_command(kcli, NULL, "utest", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL); cli_register_command(kcli, jemtst_command, "enter", jem_test_mode, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Enter jem test mode."); }
/** * context: {} * tokens: {file} * options: * --addr-sch=default|local * --format=default|caida */ static int cli_bgp_topology_load(cli_ctx_t * ctx, cli_cmd_t * cmd) { const char * arg; uint8_t addr_scheme= ASLEVEL_ADDR_SCH_DEFAULT; uint8_t format= ASLEVEL_FORMAT_DEFAULT; int line_number; int result; // Optional addressing scheme specified ? arg= cli_opts_get_value(cmd->opts, "addr-sch"); if (arg != NULL) { if (aslevel_str2addr_sch(arg, &addr_scheme) != ASLEVEL_SUCCESS) { cli_set_user_error(cli_get(), "invalid addressing scheme \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } } // Optional format specified ? arg= cli_opts_get_value(cmd->opts, "format"); if (arg != NULL) { if (aslevel_topo_str2format(arg, &format) != ASLEVEL_SUCCESS) { cli_set_user_error(cli_get(), "invalid format \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } } // Load AS-level topology arg= cli_get_arg_value(cmd, 0); result= aslevel_topo_load(arg, format, addr_scheme, &line_number); if (result != ASLEVEL_SUCCESS) { if (line_number > 0) cli_set_user_error(cli_get(), "could not load topology \"%s\" " "(%s, at line %u)", arg, aslevel_strerror(result), line_number); else cli_set_user_error(cli_get(), "could not load topology \"%s\" " "(%s)", arg, aslevel_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {} * tokens : {prefix} * options: {--output=FILE,--exact-match,--preserve-dups} */ static int cli_bgp_topology_recordroute(cli_ctx_t * ctx, cli_cmd_t * cmd) { ip_pfx_t prefix; gds_stream_t * stream= gdsout; const char * arg= cli_get_arg_value(cmd, 0); int result; uint8_t options= 0; // Destination prefix if (str2prefix(arg, &prefix) < 0) { cli_set_user_error(cli_get(), "invalid prefix \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } // Optional output file ? arg= cli_get_opt_value(cmd, "output"); if (arg != NULL) { stream= stream_create_file(arg); if (stream == NULL) { cli_set_user_error(cli_get(), "unable to create \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } } if (cli_has_opt_value(cmd, "exact-match")) options|= AS_RECORD_ROUTE_OPT_EXACT_MATCH; if (cli_has_opt_value(cmd, "preserve-dups")) options|= AS_RECORD_ROUTE_OPT_PRESERVE_DUPS; // Record routes result= aslevel_topo_record_route(stream, prefix, options); if (result != ASLEVEL_SUCCESS) { cli_set_user_error(cli_get(), "could not record route (%s)", aslevel_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } if (stream != gdsout) stream_destroy(&stream); return CLI_SUCCESS; }
/** * context: {router, peer} * tokens: {src-addr} */ static int cli_peer_update_source(cli_ctx_t * ctx, cli_cmd_t * cmd) { bgp_peer_t * peer= _peer_from_context(ctx); const char * arg= cli_get_arg_value(cmd, 0); net_addr_t src_addr; // Get source address if (str2address(arg, &src_addr)) { cli_set_user_error(cli_get(), "invalid source address \"%s\".", arg); return CLI_ERROR_COMMAND_FAILED; } // Try to open session if (bgp_peer_set_source(peer, src_addr)) { cli_set_user_error(cli_get(), "could not set source address"); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {} * tokens: {} */ static int cli_bgp_topology_run(cli_ctx_t * ctx, cli_cmd_t * cmd) { int result= aslevel_topo_run(); if (result != ASLEVEL_SUCCESS) { cli_set_user_error(cli_get(), "could not run topology (%s)", aslevel_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {router, peer} * tokens: {addr} */ static int cli_peer_nexthop(cli_ctx_t * ctx, cli_cmd_t * cmd) { bgp_peer_t * peer= _peer_from_context(ctx); const char * arg= cli_get_arg_value(cmd, 0); net_addr_t next_hop; // Get next-hop address if (str2address(arg, &next_hop)) { cli_set_user_error(cli_get(), "invalid next-hop \"%s\".", arg); return CLI_ERROR_COMMAND_FAILED; } // Set the next-hop to be used for routes advertised to this peer if (bgp_peer_set_nexthop(peer, next_hop)) { cli_set_user_error(cli_get(), "could not change next-hop"); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {} * tokens: {<asn>} */ static int cli_bgp_topology_filter_asn(cli_ctx_t * ctx, cli_cmd_t * cmd) { const char * arg= cli_get_arg_value(cmd, 0); asn_t asn; int result; // Get ASN if (str2asn(arg, &asn)) { cli_set_user_error(cli_get(), "invalid ASN (%s)", arg); return CLI_ERROR_COMMAND_FAILED; } // Remove AS from topology result= aslevel_topo_filter_as(asn); if (result != ASLEVEL_SUCCESS) { cli_set_user_error(cli_get(), "could not filter ASN (%s)", aslevel_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
// ----- cli_ctx_create_net_subnet ---------------------------------- int cli_ctx_create_net_subnet(cli_ctx_t * ctx, cli_cmd_t * cmd, void ** item) { const char * arg= cli_get_arg_value(cmd, 0); net_subnet_t * subnet; if (str2subnet(arg, &subnet)) { cli_set_user_error(cli_get(), "unable to find subnet \"%s\"", arg); return CLI_ERROR_CTX_CREATE; } *item= subnet; return CLI_SUCCESS; }
/** * context: {} * tokens: {ntf_file} */ int cli_net_ntf_load(cli_ctx_t * ctx, cli_cmd_t * cmd) { const char * arg= cli_get_arg_value(cmd, 0); // Load given NTF file if (ntf_load(arg) < 0) { cli_set_user_error(cli_get(), "could not load NTF file \"%s\" (%s%s)", arg, ntf_strerror(), ntf_strerrorloc()); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {router, peer} * tokens: {} */ static int cli_peer_softrestart(cli_ctx_t * ctx, cli_cmd_t * cmd) { bgp_peer_t * peer= _peer_from_context(ctx); // Set the virtual flag of this peer if (!bgp_peer_flag_get(peer, PEER_FLAG_VIRTUAL)) { cli_set_user_error(cli_get(), "soft-restart option only available to virtual peers"); return CLI_ERROR_COMMAND_FAILED; } bgp_peer_flag_set(peer, PEER_FLAG_SOFT_RESTART, 1); return CLI_SUCCESS; }
/** * context: {iface} * tokens: {weight} */ static int cli_iface_igpweight(cli_ctx_t * ctx, cli_cmd_t * cmd) { net_iface_t * iface= _iface_from_context(ctx); const char * arg= cli_get_arg_value(cmd, 0); igp_weight_t weight; int result; // Get IGP weight if (str2weight(arg, &weight)) { cli_set_user_error(cli_get(), "invalid weight \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } // Change link weight in forward direction result= net_iface_set_metric(iface, 0, weight, 0); if (result != ESUCCESS) { cli_set_user_error(cli_get(), "cannot set weight (%s)", network_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {router} -> {router, peer} * tokens: {addr} */ static int cli_ctx_create_peer(cli_ctx_t * ctx, cli_cmd_t * cmd, void ** item) { bgp_router_t* router= _router_from_context(ctx); bgp_peer_t * peer; const char * arg= cli_get_arg_value(cmd, 0); net_addr_t addr; // Get the peer ID (address, ASN, ...) if (str2addr_id(arg, &addr)) { cli_set_user_error(cli_get(), "invalid peer address \"%s\"", arg); return CLI_ERROR_CTX_CREATE; } // Get the peer peer= bgp_router_find_peer(router, addr); if (peer == NULL) { cli_set_user_error(cli_get(), "unknown peer"); return CLI_ERROR_CTX_CREATE; } *item= peer; return CLI_SUCCESS; }
/** * context: {} * tokens : {file} */ int cli_net_traffic_save(cli_ctx_t * ctx, cli_cmd_t * cmd) { const char * arg= cli_get_arg_value(cmd, 0); gds_stream_t * stream; int result; // Get the optional parameter stream= stream_create_file(arg); if (stream == NULL) { cli_set_user_error(cli_get(), "could not create \"%d\"", arg); return CLI_ERROR_COMMAND_FAILED; } // Save traffic matrix result= network_links_save(stream, network_get_default()); if (result != 0) { cli_set_user_error(cli_get(), "could not save traffic matrix (%s)", network_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
static int cli_peer_walton_limit(cli_ctx_t * ctx, cli_cmd_t * cmd) { bgp_peer_t * peer= _peer_from_context(ctx); const char * arg= cli_get_arg_value(cmd, 0); unsigned int limit; if (str_as_uint(arg, &limit)) { cli_set_user_error(cli_get(), "invalid walton limit \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } peer_set_walton_limit(peer, limit); return CLI_SUCCESS; }
/** * context: {iface} * tokens: {load} */ static int cli_iface_load_add(cli_ctx_t * ctx, cli_cmd_t * cmd) { net_iface_t * iface= _iface_from_context(ctx); const char * arg= cli_get_arg_value(cmd, 0); net_link_load_t load; // Get load if (str2capacity(arg, &load)) { cli_set_user_error(cli_get(), "invalid load \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } net_iface_set_load(iface, load); return CLI_SUCCESS; }
/** * context: {} * tokens: {<what>} */ static int cli_bgp_topology_filter_group(cli_ctx_t * ctx, cli_cmd_t * cmd) { const char * arg= cli_get_arg_value(cmd, 0); int result; uint8_t filter; // Get filter parameter result= aslevel_filter_str2filter(arg, &filter); if (result != ASLEVEL_SUCCESS) { cli_set_user_error(cli_get(), "could not filter topology (%s)", aslevel_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } // Filter topology result= aslevel_topo_filter_group(filter); if (result != ASLEVEL_SUCCESS) { cli_set_user_error(cli_get(), "could not filter topology (%s)", aslevel_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
static int cli_peer_readv(cli_ctx_t * ctx, cli_cmd_t * cmd) { bgp_peer_t * peer= _peer_from_context(ctx); bgp_router_t* router= peer->router; const char * arg= cli_get_arg_value(cmd, 0); ip_pfx_t prefix; /* Get prefix */ if (!strcmp(arg, "*")) { prefix.mask= 0; } else if (!str2prefix(arg, &prefix)) { } else { cli_set_user_error(cli_get(), "invalid prefix|* \"%s\"", arg); return CLI_ERROR_COMMAND_FAILED; } /* Re-advertise */ if (bgp_router_peer_readv_prefix(router, peer, prefix)) { cli_set_user_error(cli_get(), "could not re-advertise"); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {} * tokens : {addr} * options: {no-loopback} */ int cli_net_add_node(cli_ctx_t * ctx, cli_cmd_t * cmd) { net_addr_t addr; net_node_t * node; int error; int options= 0; // default is: create loopback with address = node ID // Node address ? if (str2address(cli_get_arg_value(cmd, 0), &addr)) { cli_set_user_error(cli_get(), "could not add node (invalid address)"); return CLI_ERROR_COMMAND_FAILED; } // Option: no-loopback ? if (!cli_opts_has_value(cmd->opts, "no-loopback")) { options|= NODE_OPTIONS_LOOPBACK; } // Create new node error= node_create(addr, &node, options); if (error != ESUCCESS) { cli_set_user_error(cli_get(), "could not add node (%s)", network_strerror(error)); return CLI_ERROR_COMMAND_FAILED; } // Add node error= network_add_node(network_get_default(), node); if (error != ESUCCESS) { node_destroy(&node); cli_set_user_error(cli_get(), "could not add node (%s)", network_strerror(error)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {} * tokens: {} * options: {--verbose} */ static int cli_bgp_topology_check(cli_ctx_t * ctx, cli_cmd_t * cmd) { int result; int verbose= 0; // Verbose check ? if (cli_opts_has_value(cmd->opts, "verbose")) verbose= 1; result= aslevel_topo_check(verbose); if (result != ASLEVEL_SUCCESS) { cli_set_user_error(cli_get(), "check failed (%s)", aslevel_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {node} * tokens: {addr, area} */ int cli_net_node_ospf_area(SCliContext * pContext, STokens * pTokens) { net_node_t * pNode; ospf_area_t uArea; // Get node from context pNode= (net_node_t *) cli_context_get_item_at_top(pContext); // Add ospf area to node tokens_get_uint_at(pTokens, 1, &uArea); if (node_add_OSPFArea(pNode, uArea) < 0) { cli_set_user_error(cli_get(), "unexpected error"); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {router, peer} * tokens: {in|out} */ static int cli_ctx_create_peer_filter(cli_ctx_t * ctx, cli_cmd_t * cmd, void ** item_ref) { bgp_peer_t * peer= _peer_from_context(ctx); const char * arg= cli_get_arg_value(cmd, 0); // Create filter context if (!strcmp(arg, "in")) *item_ref= &(peer->filter[FILTER_IN]); else if (!strcmp(arg, "out")) *item_ref= &(peer->filter[FILTER_OUT]); else { cli_set_user_error(cli_get(), "invalid filter type \"%s\"", arg); return CLI_ERROR_CTX_CREATE; } return CLI_SUCCESS; }
int cli_get_last(int statement) { return cli_get(statement, cli_cmd_get_last); }
int cli_get_next(int statement) { return cli_get(statement, cli_cmd_get_next); }
/** * context: {} * tokens: {src-addr, src-iface-id, dst-addr, dst-iface-id} */ int cli_net_add_linkptp(cli_ctx_t * ctx, cli_cmd_t * cmd) { const char * arg_src = cli_get_arg_value(cmd, 0); const char * arg_src_if= cli_get_arg_value(cmd, 1); const char * arg_dst = cli_get_arg_value(cmd, 2); const char * arg_dst_if= cli_get_arg_value(cmd, 3); const char * opt; net_node_t * src_node; net_node_t * dst_node; net_iface_id_t src_if; net_iface_id_t dst_if; int result; net_iface_t * iface; net_link_delay_t delay= 0; net_link_load_t capacity= 0; // Get source node if (str2node(arg_src, &src_node)) { cli_set_user_error(cli_get(), "could not find node \"%s\"", arg_src); return CLI_ERROR_COMMAND_FAILED; } // Get source address if (net_iface_str2id(arg_src_if, &src_if)) { cli_set_user_error(cli_get(), "invalid interface id \"%\"", arg_src_if); return CLI_ERROR_COMMAND_FAILED; } // Get destination node if (str2node(arg_dst, &dst_node)) { cli_set_user_error(cli_get(), "could not find node \"%s\"", arg_dst); return CLI_ERROR_COMMAND_FAILED; } // get destination address if (net_iface_str2id(arg_dst_if, &dst_if)) { cli_set_user_error(cli_get(), "invalid interface id \"%\"", arg_dst_if); return CLI_ERROR_COMMAND_FAILED; } // Get optional link capacity opt= cli_get_opt_value(cmd, "bw"); if (opt != NULL) { if (str2capacity(opt, &capacity)) { cli_set_user_error(cli_get(), "invalid link capacity \"%s\"", opt); return CLI_ERROR_COMMAND_FAILED; } } // Get optional link delay opt= cli_get_opt_value(cmd, "delay"); if (opt != NULL) { if (str2delay(opt, &delay)) { cli_set_user_error(cli_get(), "invalid link delay \"%s\"", opt); return CLI_ERROR_CMD_FAILED; } } // Create link result= net_link_create_ptp(src_node, src_if, dst_node, dst_if, BIDIR, &iface); if (result != ESUCCESS) { cli_set_user_error(cli_get(), "could not create ptp link " "from %s (%s) to %s (%s) (%s)", arg_src, arg_src_if, arg_dst, arg_dst_if, network_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } result= net_link_set_phys_attr(iface, delay, capacity, BIDIR); if (result != ESUCCESS) { cli_set_user_error(cli_get(), "could not set physical attributes (%s)", network_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
/** * context: {} * tokens: {addr-src, prefix-dst} * options: [--depth=, --capacity=, delay=] */ int cli_net_add_link(cli_ctx_t * ctx, cli_cmd_t * cmd) { const char * arg_src= cli_get_arg_value(cmd, 0); const char * arg_dst= cli_get_arg_value(cmd, 1); const char * opt; net_node_t * src_node; net_node_t * dst_node; ip_dest_t dest; int result; uint8_t depth= 1; net_link_delay_t delay= 0; net_link_load_t capacity= 0; net_iface_dir_t dir; net_iface_t * iface; net_subnet_t * subnet; // Get optional link depth opt= cli_get_opt_value(cmd, "depth"); if (opt != NULL) { if (str2depth(opt, &depth)) { cli_set_user_error(cli_get(), "invalid link depth \"%s\"", opt); return CLI_ERROR_COMMAND_FAILED; } } // Get optional link capacity opt= cli_get_opt_value(cmd, "bw"); if (opt != NULL) { if (str2capacity(opt, &capacity)) { cli_set_user_error(cli_get(), "invalid link capacity \"%s\"", opt); return CLI_ERROR_COMMAND_FAILED; } } // Get optional link delay opt= cli_get_opt_value(cmd, "delay"); if (opt != NULL) { if (str2delay(opt, &delay)) { cli_set_user_error(cli_get(), "invalid link delay \"%s\"", opt); return CLI_ERROR_CMD_FAILED; } } // Get source node if (str2node(arg_src, &src_node)) { cli_set_user_error(cli_get(), "could not find node \"%s\"", arg_src); return CLI_ERROR_COMMAND_FAILED; } // Get destination: can be a node / a subnet if ((ip_string_to_dest(arg_dst, &dest) < 0) || (dest.type == NET_DEST_ANY)) { cli_set_user_error(cli_get(), "invalid destination \"%s\".", arg_dst); return CLI_ERROR_COMMAND_FAILED; } // Add link: RTR (to node) / PTMP (to subnet) if (dest.type == NET_DEST_ADDRESS) { dst_node= network_find_node(network_get_default(), dest.addr); if (dst_node == NULL) { cli_set_user_error(cli_get(), "tail-end \"%s\" does not exist.", arg_dst); return CLI_ERROR_COMMAND_FAILED; } dir= BIDIR; result= net_link_create_rtr(src_node, dst_node, dir, &iface); } else { subnet= network_find_subnet(network_get_default(), dest.prefix); if (subnet == NULL) { cli_set_user_error(cli_get(), "tail-end \"%s\" does not exist.", arg_dst); return CLI_ERROR_COMMAND_FAILED; } dir= UNIDIR; result= net_link_create_ptmp(src_node, subnet, dest.prefix.network, &iface); } if (result != ESUCCESS) { cli_set_user_error(cli_get(), "could not add link %s -> %s (%s)", arg_src, arg_dst, network_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } result= net_link_set_phys_attr(iface, delay, capacity, dir); if (result != ESUCCESS) { cli_set_user_error(cli_get(), "could not set physical attributes (%s)", network_strerror(result)); return CLI_ERROR_COMMAND_FAILED; } return CLI_SUCCESS; }
int cli_get_prev(int statement) { return cli_get(statement, cli_cmd_get_prev); }