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.");
}
/* Register our commands with the MTF. */
int wlan_cli_init(void)
{
int i;
for (i = 0; i < sizeof(tests) / sizeof(struct cli_command); i++)
if (cli_register_command(&tests[i]))
return WLAN_ERROR_ACTION;
if (board_sdio_pdn_support())
for (i = 0; i < sizeof(pdn_tests) / sizeof(struct cli_command);
i++)
if (cli_register_command(&pdn_tests[i]))
return WLAN_ERROR_ACTION;
return WLAN_ERROR_NONE;
}
int psm_cli_init(void)
{
int i;
for (i = 0; i < sizeof(psm_commands) / sizeof(struct cli_command); i++)
if (cli_register_command(&psm_commands[i]))
return 1;
return 0;
}
int dhcpd_cli_init(void)
{
int i;
for (i = 0; i < sizeof(dhcp_cmds) / sizeof(struct cli_command); i++)
if (cli_register_command(&dhcp_cmds[i]))
return -WM_E_DHCPD_REGISTER_CMDS;
return WM_SUCCESS;
}
before(): cflow(execution(int jemMalloc_test_cmd(struct cli_def *, char *, char *, int)))
{
if (tracingEnabled) {
printk(KERN_INFO "Trace: %s function %s in %s\n", this->kind, this->funcName, this->fileName);
}
}
after(): execution(int jem_init())
{
cli_register_command(kcli, jem_command, "trace", trace_enable_cmd,
PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Enable/Disable function tracing.");
}
int around(): execution(int jemMallocInit())
{
int i;
for (i=0; i<10; i++) {
testRef[i] = NULL;
}
cli_register_command(kcli, NULL, "malloc", jemMalloc_test_cmd,
PRIVILEGE_UNPRIVILEGED, CLI_TEST_MODE, "Run malloc unit tests.");
return proceed();
}
int jemCLIinit(void)
{
int on = 1;
cli = cli_init();
cli_set_banner(cli, "Jem/JVM Command Line Interface");
cli_set_hostname(cli, "Jem/JVM");
cli_register_command(cli, NULL, "uptime", cmdUptime, PRIVILEGE_UNPRIVILEGED,
MODE_EXEC, "Display uptime.");
if ((socketFD = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("Socket creation error for CLI, result=%d.\n", errno);
return errno;
}
setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
int cliPort = getIntVal((char *) "CLIPORT");
if (cliPort == 0) cliPort = 8181;
serverAddr.sin_port = htons(cliPort);
if (bind(socketFD, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
printf("Socket bind error for CLI, result=%d.\n", errno);
return errno;
}
if (listen(socketFD, 50) < 0) {
printf("Socket listen error for CLI, result=%d.\n", errno);
return errno;
}
int result = rt_task_create(&cliTask,"cliTask",0,1,T_FPU|T_JOINABLE);
if (result) {
printf("Failed to create cli task, code=%d \n", result);
return -1;
}
result = rt_task_start(&cliTask,&commandTask,NULL);
if (result) {
printf("Failed to start cli task, code=%d \n", result);
return -1;
}
return 0;
}
int cli(void)
{
struct sockaddr_in servaddr;
struct cli_command
*address,
*clear,
*debug,
*eth_frame,
*frame,
*ip_packet,
*ip_int,
*launch,
*mac_packet,
*macaddr,
*mac_int,
*pld,
*port,
*reset,
*run,
*show,
*tag,
*tcp_packet,
*udp_packet;
struct cli_def *cli;
int on = 1, x, s, cnt=0;
int i;
char TimeStamp[128];
(void) signal(SIGINT, clean_up); // to close and free everything upon SIGINT
// Must be called first to setup data structures
cli = cli_init();
gcli = cli;
// Set the hostname (shown in the the prompt)
cli_set_hostname(cli, "mz");
// Set the greeting
cli_set_banner(cli, "mausezahn " VERSION_LONG);
// Enable usernames and passwords
cli_allow_user(cli, mz_username, mz_password);
cli_allow_enable(cli, mz_enable);
// Initialize MOPS
mp_head = mops_init(); // now mp_head points to the head of the doubly linked list
// Initialize packet sequences list
packet_sequences = mz_ll_create_new_element(NULL);
mops_rx_arp();
lookupdev();
for (i=0; i<device_list_entries; i++) {
get_dev_params(device_list[i].dev);
}
// Initialize sequence list
// **************** THE MAIN CLI COMMANDS ****************
// ---- DEBUG MODE: ----
debug = cli_register_command(cli, NULL, "debug", NULL, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Enter debug mode");
cli_register_command(cli, debug, "packet", debug_packet, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Debug packet processing");
cli_register_command(cli, debug, "all", debug_all, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Debug all (beware!)");
// ---- INTERFACE MODE COMMANDS: ---- (these are defaults for the 'device defaults' command)
cli_register_command(cli, NULL, "interface", enter_interface, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enter interface configuration mode");
ip_int = cli_register_command(cli, NULL, "ip", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_INTERFACE, "Configure interface IP address");
cli_register_command(cli, ip_int, "address", conf_ip_address, PRIVILEGE_PRIVILEGED, MZ_MODE_INTERFACE, "Configure interface IP address");
mac_int= cli_register_command(cli, NULL, "mac", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_INTERFACE, "Configure interface MAC address");
cli_register_command(cli, mac_int, "address", conf_mac_address, PRIVILEGE_PRIVILEGED, MZ_MODE_INTERFACE, "Configure interface MAC address");
tag = cli_register_command(cli, NULL, "tag", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_INTERFACE, "Configure tags");
cli_register_command(cli, tag, "dot1q", conf_tag_dot1q, PRIVILEGE_PRIVILEGED, MZ_MODE_INTERFACE, "Configure 802.1Q and 802.1P parameters");
cli_register_command(cli, tag, "mpls", conf_tag_mpls, PRIVILEGE_PRIVILEGED, MZ_MODE_INTERFACE, "Configure mpls label stack");
// ---- VARIOUS CONFIG MODE COMMANDS : ----
frame = cli_register_command(cli, NULL, "frame", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure global frame settings");
cli_register_command(cli, frame, "limit", conf_frame_limit, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure frame size limits");
cli_register_command(cli, NULL, "sequence", conf_sequence, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure a sequence of packets");
// ---- PACKET CONFIG MODE COMMANDS: ----
cli_register_command(cli, NULL, "packet", enter_packet, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enter packet configuration mode");
cli_register_command(cli, NULL, "clone", cmd_packet_clone, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Clone from another packet");
cli_register_command(cli, NULL, "name", cmd_packet_name, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Assign a unique name");
cli_register_command(cli, NULL, "description", cmd_packet_description, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Assign a packet description text");
cli_register_command(cli, NULL, "bind", cmd_packet_bind, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Select the network interface");
cli_register_command(cli, NULL, "count", cmd_packet_count, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the packet count value");
cli_register_command(cli, NULL, "delay", cmd_packet_delay, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the inter-packet delay");
cli_register_command(cli, NULL, "interval", cmd_packet_interval, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure a greater interval");
cli_register_command(cli, NULL, "type", cmd_packet_type, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Specify packet type");
mac_packet = cli_register_command(cli, NULL, "mac", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's MAC addresses");
address = cli_register_command(cli, mac_packet, "address", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's source IP address");
cli_register_command(cli, address, "source", cmd_packet_mac_address_source, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's source MAC addresses");
cli_register_command(cli, address, "destination", cmd_packet_mac_address_destination, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's destination MAC addresses");
tag = cli_register_command(cli, NULL, "tag", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure tags");
cli_register_command(cli, tag, "dot1q", cmd_packet_dot1q, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure 802.1Q (and 802.1P) parameters");
cli_register_command(cli, tag, "mpls", cmd_packet_mpls, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure MPLS label stack");
pld = cli_register_command(cli, NULL, "payload", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure a payload");
cli_register_command(cli, pld, "hex", cmd_packet_payload_hex, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure a payload in hexadecimal format");
cli_register_command(cli, pld, "ascii", cmd_packet_payload_ascii, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure a payload in ascii format");
cli_register_command(cli, pld, "raw", cmd_packet_payload_raw, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure a raw payload (whole file as it is)");
port = cli_register_command(cli, NULL, "port", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's port numbers");
cli_register_command(cli, port, "source", cmd_port_source, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's source port number");
cli_register_command(cli, port, "destination", cmd_port_destination, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's destination port number");
cli_register_command(cli, NULL, "end", cmd_packet_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "End packet configuration mode");
// ---------- Ethernet related (for all packets that have Ethernet or LLC/SNAP as link layer)
eth_frame = cli_register_command(cli, NULL, "ethernet", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure frame's Ethernet, 802.2, 802.3, or SNAP settings");
macaddr = cli_register_command(cli, eth_frame, "address", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure frame's source or destination MAC address");
cli_register_command(cli, macaddr, "source", cmd_packet_mac_address_source, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure frame's source MAC addresses");
cli_register_command(cli, macaddr, "destination", cmd_packet_mac_address_destination, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure frame's destination MAC addresses");
cli_register_command(cli, eth_frame, "type", cmd_eth_type, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure Ethernet's type field");
cli_register_command(cli, eth_frame, "length", cmd_eth_length, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure IEEE 802.3 length field");
cli_register_command(cli, eth_frame, "llc", cmd_eth_llc, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the IEEE 802.2 field");
cli_register_command(cli, eth_frame, "snap", cmd_eth_snap, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the IEEE 802.2 field");
// ---------- IP related (for all packets that have IPv4 as network layer)
ip_packet = cli_register_command(cli, NULL, "ip", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's IP settings");
address = cli_register_command(cli, ip_packet, "address", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's source or destination IP address");
cli_register_command(cli, address, "source", cmd_ip_address_source, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's source IP address");
cli_register_command(cli, address, "destination", cmd_ip_address_destination, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's destination IP address");
cli_register_command(cli, ip_packet, "version", cmd_ip_version, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure version field in IPv4 header");
cli_register_command(cli, ip_packet, "ttl", cmd_ip_ttl, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure TTL field in IPv4 header");
cli_register_command(cli, ip_packet, "protocol", cmd_ip_protocol, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure protocol field in IPv4 header");
cli_register_command(cli, ip_packet, "hlen", cmd_ip_hlen, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure header-length (aka IHL) field in IPv4 header");
cli_register_command(cli, ip_packet, "length", cmd_ip_len, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure length field in IPv4 header");
cli_register_command(cli, ip_packet, "identification", cmd_ip_id, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure identification field in IPv4 header");
cli_register_command(cli, ip_packet, "offset", cmd_ip_offset, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure fragment offset field in IPv4 header");
cli_register_command(cli, ip_packet, "checksum", cmd_ip_sum, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure checksum field in IPv4 header");
cli_register_command(cli, ip_packet, "tos", cmd_ip_tos, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure type-of-service (ToS) field in IPv4 header");
cli_register_command(cli, ip_packet, "dscp", cmd_ip_dscp, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the ToS as DSCP field in IPv4 header");
cli_register_command(cli, ip_packet, "reserved", cmd_ip_rsv, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the reserved flag in IPv4 header");
cli_register_command(cli, ip_packet, "dont-fragment", cmd_ip_df, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the don't fragment flag in IPv4 header");
cli_register_command(cli, ip_packet, "more-fragments", cmd_ip_mf, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the more fragments flag in IPv4 header");
cli_register_command(cli, ip_packet, "fragment-size", cmd_ip_fragsize, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the fragment size to enable fragmentation");
cli_register_command(cli, ip_packet, "fragment-overlap", cmd_ip_fragoverlap, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure a fragmentation overlap");
cli_register_command(cli, ip_packet, "option", cmd_ip_option, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure IPv4 options");
cli_register_command(cli, ip_packet, "auto-delivery", cmd_ip_delivery, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Enable or disable IP auto-delivery");
// --------- IP commands:
cli_register_command(cli, NULL, "version", cmd_ip_version, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the IP version (default: 4)");
cli_register_command(cli, NULL, "ttl", cmd_ip_ttl, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the TTL (default: 255)");
cli_register_command(cli, NULL, "source-address", cmd_ip_address_source, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the source IP address");
cli_register_command(cli, NULL, "destination-address", cmd_ip_address_destination, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the destination IP address");
cli_register_command(cli, NULL, "protocol", cmd_ip_protocol, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the IP protocol");
cli_register_command(cli, NULL, "hlen", cmd_ip_hlen, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the IP header length");
cli_register_command(cli, NULL, "len", cmd_ip_len, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the IP packet length");
cli_register_command(cli, NULL, "identification", cmd_ip_id, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the IP identification");
cli_register_command(cli, NULL, "offset", cmd_ip_offset, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the fragment offset");
cli_register_command(cli, NULL, "sum", cmd_ip_sum, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the IP header checksum");
cli_register_command(cli, NULL, "tos", cmd_ip_tos, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the Type of Service");
cli_register_command(cli, NULL, "dscp", cmd_ip_dscp, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Specify the DSCP");
cli_register_command(cli, NULL, "reserved", cmd_ip_rsv, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Set or unset the reserved bit");
cli_register_command(cli, NULL, "df", cmd_ip_df, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Set or unset the Don't Fragment (DF) bit");
cli_register_command(cli, NULL, "mf", cmd_ip_mf, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Set or unset the More Fragments (MF) bit");
cli_register_command(cli, NULL, "fragment-size", cmd_ip_fragsize, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Configure the fragment size to enable fragmentation");
cli_register_command(cli, NULL, "fragment-overlap", cmd_ip_fragoverlap, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Configure a fragmentation overlap");
cli_register_command(cli, NULL, "option", cmd_ip_option, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Configure an IP option");
cli_register_command(cli, NULL, "auto-delivery", cmd_ip_delivery, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "Enable or disable IP auto-delivery");
cli_register_command(cli, NULL, "end", cmd_ip_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IP, "End IP configuration mode");
// ---------- UDP related (for all packets that have UDP as transport layer)
udp_packet = cli_register_command(cli, NULL, "udp", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's UDP header parameters");
cli_register_command(cli, udp_packet, "checksum", cmd_udp_sum, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the UDP checksum");
cli_register_command(cli, udp_packet, "length", cmd_udp_len, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the UDP length field");
// ---------- UDP commands:
cli_register_command(cli, NULL, "checksum", cmd_udp_sum, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_UDP, "Configure the UDP checksum");
cli_register_command(cli, NULL, "length", cmd_udp_len, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_UDP, "Configure the UDP length field");
cli_register_command(cli, NULL, "end", cmd_udp_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_UDP, "End UDP configuration mode");
// ---------- TCP related (for all packets that have TCP as transport layer)
tcp_packet = cli_register_command(cli, NULL, "tcp", NULL, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure packet's TCP header parameters");
cli_register_command(cli, tcp_packet, "seqnr", cmd_tcp_seqnr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the TCP sequence number");
cli_register_command(cli, tcp_packet, "acknr", cmd_tcp_acknr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the TCP acknowledgement number");
cli_register_command(cli, tcp_packet, "hlen", cmd_tcp_offset, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the TCP header length");
cli_register_command(cli, tcp_packet, "reserved", cmd_tcp_res, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the TCP reserved field");
cli_register_command(cli, tcp_packet, "flags", cmd_tcp_flags, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure a combination of TCP flags at once");
cli_register_command(cli, tcp_packet, "cwr", cmd_tcp_cwr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Set or unset the TCP CWR flag");
cli_register_command(cli, tcp_packet, "ece", cmd_tcp_ece, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Set or unset the TCP ECE flag");
cli_register_command(cli, tcp_packet, "urg", cmd_tcp_urg, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Set or unset the TCP URG flag");
cli_register_command(cli, tcp_packet, "ack", cmd_tcp_ack, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "set or unset the TCP ACK flag");
cli_register_command(cli, tcp_packet, "psh", cmd_tcp_psh, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "set or unset the TCP PSH flag");
cli_register_command(cli, tcp_packet, "rst", cmd_tcp_rst, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "set or unset the TCP RST flag");
cli_register_command(cli, tcp_packet, "syn", cmd_tcp_syn, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "set or unset the TCP SYN flag");
cli_register_command(cli, tcp_packet, "fin", cmd_tcp_fin, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "set or unset the TCP FIN flag");
cli_register_command(cli, tcp_packet, "window", cmd_tcp_window, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the TCP window size");
cli_register_command(cli, tcp_packet, "checksum", cmd_tcp_sum, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the TCP checksum");
cli_register_command(cli, tcp_packet, "urgent-pointer", cmd_tcp_urgptr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure the TCP urgend pointer");
cli_register_command(cli, tcp_packet, "options", cmd_tcp_options, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET, "Configure TCP options");
// ---------- TCP commands:
cli_register_command(cli, NULL, "seqnr", cmd_tcp_seqnr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure the TCP sequence number");
cli_register_command(cli, NULL, "acknr", cmd_tcp_acknr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure the TCP acknowledgement number");
cli_register_command(cli, NULL, "hlen", cmd_tcp_offset, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure the TCP header length");
cli_register_command(cli, NULL, "reserved", cmd_tcp_res, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure the TCP reserved field");
cli_register_command(cli, NULL, "flags", cmd_tcp_flags, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure a combination of TCP flags at once");
cli_register_command(cli, NULL, "cwr", cmd_tcp_cwr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Set or unset the TCP CWR flag");
cli_register_command(cli, NULL, "ece", cmd_tcp_ece, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Set or unset the TCP ECE flag");
cli_register_command(cli, NULL, "urg", cmd_tcp_urg, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Set or unset the TCP URG flag");
cli_register_command(cli, NULL, "ack", cmd_tcp_ack, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "set or unset the TCP ACK flag");
cli_register_command(cli, NULL, "psh", cmd_tcp_psh, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "set or unset the TCP PSH flag");
cli_register_command(cli, NULL, "rst", cmd_tcp_rst, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "set or unset the TCP RST flag");
cli_register_command(cli, NULL, "syn", cmd_tcp_syn, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "set or unset the TCP SYN flag");
cli_register_command(cli, NULL, "fin", cmd_tcp_fin, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "set or unset the TCP FIN flag");
cli_register_command(cli, NULL, "window", cmd_tcp_window, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure the TCP window size");
cli_register_command(cli, NULL, "checksum", cmd_tcp_sum, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure the TCP checksum");
cli_register_command(cli, NULL, "urgent-pointer", cmd_tcp_urgptr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure the TCP urgend pointer");
cli_register_command(cli, NULL, "options", cmd_tcp_options, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "Configure TCP options");
cli_register_command(cli, NULL, "end", cmd_tcp_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_TCP, "End TCP configuration mode");
// --------- ARP commands:
cli_register_command(cli, NULL, "hardware-type", cmd_arp_hwtype, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the hardware type");
cli_register_command(cli, NULL, "protocol-type", cmd_arp_prtype, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the protocol type");
cli_register_command(cli, NULL, "hw-addr-size", cmd_arp_hwaddrsize, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the hardware address size");
cli_register_command(cli, NULL, "pr-addr-size", cmd_arp_praddrsize, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the protocol address size");
cli_register_command(cli, NULL, "opcode", cmd_arp_opcode, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the ARP opcode");
cli_register_command(cli, NULL, "sender-mac", cmd_arp_smac, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the sender MAC address");
cli_register_command(cli, NULL, "sender-ip", cmd_arp_sip, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the sender IP address");
cli_register_command(cli, NULL, "target-mac", cmd_arp_tmac, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the target MAC address");
cli_register_command(cli, NULL, "target-ip", cmd_arp_tip, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the target IP address");
cli_register_command(cli, NULL, "trailer", cmd_arp_trailer, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "Specify the trailer length");
cli_register_command(cli, NULL, "end", cmd_arp_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_ARP, "End ARP configuration mode");
// --------- BPDU commands:
cli_register_command(cli, NULL, "id", cmd_bpdu_id, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU identifier");
cli_register_command(cli, NULL, "version", cmd_bpdu_version, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU version");
cli_register_command(cli, NULL, "bpdutype", cmd_bpdu_type, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU type");
cli_register_command(cli, NULL, "flags", cmd_bpdu_flags, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU flags");
cli_register_command(cli, NULL, "root-id", cmd_bpdu_rid, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU root identifier");
cli_register_command(cli, NULL, "path-cost", cmd_bpdu_pc, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU root path cost");
cli_register_command(cli, NULL, "bridge-id", cmd_bpdu_bid, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU bridge identifier");
cli_register_command(cli, NULL, "port-id", cmd_bpdu_pid, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU port identifier");
cli_register_command(cli, NULL, "age", cmd_bpdu_age, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU age");
cli_register_command(cli, NULL, "maxage", cmd_bpdu_maxage, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU maxage");
cli_register_command(cli, NULL, "hello-interval", cmd_bpdu_hello, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU hello interval");
cli_register_command(cli, NULL, "forward-delay", cmd_bpdu_fwd, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU forward delay");
cli_register_command(cli, NULL, "mode", cmd_bpdu_mode, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the BPDU mode");
cli_register_command(cli, NULL, "vlan", cmd_bpdu_vlan, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "Specify the vlan for PVST+");
cli_register_command(cli, NULL, "end", cmd_bpdu_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_BPDU, "End BPDU configuration mode");
// --------- IGMP commands:
cli_register_command(cli, NULL, "v2-general-query", cmd_igmpv2_genquery, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IGMP, "Create an IGMPv2 general query");
cli_register_command(cli, NULL, "v2-group-specific-query", cmd_igmpv2_specquery, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IGMP, "Create an IGMPv2 group-specific query");
cli_register_command(cli, NULL, "v2-report", cmd_igmpv2_report, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IGMP, "Create an IGMPv2 membership report");
cli_register_command(cli, NULL, "v2-leave", cmd_igmpv2_leave, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IGMP, "Create an IGMPv2 leave group message");
cli_register_command(cli, NULL, "v1-query", cmd_igmpv1_query, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IGMP, "Create an IGMPv1 query");
cli_register_command(cli, NULL, "v1-report", cmd_igmpv1_report, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IGMP, "Create an IGMPv1 membership report");
cli_register_command(cli, NULL, "end", cmd_ip_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_IGMP, "End IGMP configuration mode"); // we reuse cmd_ip_end here!
cli_register_command(cli, NULL, "conformance", cmd_lldp_conformance, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Enable or disable LLDP standard conformance");
cli_register_command(cli, NULL, "chassis-id", cmd_lldp_chassis_id, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Configure the LLDP Chassis-ID");
cli_register_command(cli, NULL, "port-id", cmd_lldp_port_id, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Configure the LLDP Port-ID");
cli_register_command(cli, NULL, "ttl", cmd_lldp_ttl, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Configure the LLDP Time-to-Live");
cli_register_command(cli, NULL, "vlan", cmd_lldp_vlan, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Configure the LLDP Port VLAN-ID");
cli_register_command(cli, NULL, "generic-tlv", cmd_lldp_opt_tlv, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Configure a generic LLDP TLV");
cli_register_command(cli, NULL, "bad-tlv", cmd_lldp_opt_tlv_bad, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Configure a bad TLV for testing purposes");
cli_register_command(cli, NULL, "organisational-tlv", cmd_lldp_opt_org, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Configure an organisational LLDP TLV");
cli_register_command(cli, NULL, "early-end", cmd_lldp_endtlv, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Insert an 'early' End-of-LLDPU TLV");
cli_register_command(cli, NULL, "reset", cmd_lldp_reset, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "Reset the LLDPU to defaults and clear all optional TLVs");
cli_register_command(cli, NULL, "end", cmd_ip_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_LLDP, "End IGMP configuration mode"); // we reuse cmd_ip_end here!
// --------- RTP commands:
cli_register_command(cli, NULL, "version", cmd_rtp_version, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Specify the RTP version (default: 2)");
cli_register_command(cli, NULL, "padding", cmd_rtp_padding, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Set or unset the padding flag (default: 0)");
cli_register_command(cli, NULL, "xten", cmd_rtp_xten, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Set or unset the eXtension flag (default: 0)");
cli_register_command(cli, NULL, "marker", cmd_rtp_marker, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Set or unset the marker flag (default: 0)");
cli_register_command(cli, NULL, "csrc-count", cmd_rtp_cc, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Configure the CSRC count (default: 0)");
cli_register_command(cli, NULL, "csrc-list", cmd_rtp_cclist, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Configure the CSRC list (default: none)");
cli_register_command(cli, NULL, "payload-type", cmd_rtp_pt, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Configure the payload type (default: G.711, A-law, 20 msec)");
cli_register_command(cli, NULL, "sequence-number", cmd_rtp_sqnr, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Configure the sequence number");
cli_register_command(cli, NULL, "timestamp", cmd_rtp_time, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Configure the timestamp");
cli_register_command(cli, NULL, "ssrc", cmd_rtp_ssrc, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Configure the SSRC (source identifier)");
cli_register_command(cli, NULL, "extension", cmd_rtp_extension, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Configure an extension header");
cli_register_command(cli, NULL, "source", cmd_rtp_source, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "Specify a media source");
cli_register_command(cli, NULL, "end", cmd_ip_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_RTP, "End RTP configuration mode"); // we reuse cmd_ip_end here!
// --------- DNS commands:
cli_register_command(cli, NULL, "ttl", cmd_dns_ttl, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_DNS, "Specify the TTL (default: 0)");
cli_register_command(cli, NULL, "query", cmd_dns_query, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_DNS, "Specify the query");
cli_register_command(cli, NULL, "answer", cmd_dns_answer, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_DNS, "Specify the answer");
cli_register_command(cli, NULL, "end", cmd_dns_end, PRIVILEGE_PRIVILEGED, MZ_MODE_PACKET_DNS, "End DNS configuration mode");
// --------- SEQUENCE COMMANDS
cli_register_command(cli, NULL, "add", sequence_add, PRIVILEGE_PRIVILEGED, MZ_MODE_SEQUENCE, "Add another packet to the current sequence");
cli_register_command(cli, NULL, "delay", sequence_delay, PRIVILEGE_PRIVILEGED, MZ_MODE_SEQUENCE, "Add a delay to the current sequence");
cli_register_command(cli, NULL, "show", sequence_show, PRIVILEGE_PRIVILEGED, MZ_MODE_SEQUENCE, "Show current sequence list");
cli_register_command(cli, NULL, "remove", sequence_remove, PRIVILEGE_PRIVILEGED, MZ_MODE_SEQUENCE, "Remove a packet or delay from the current sequence");
cli_register_command(cli, NULL, "end", cmd_end_to_config, PRIVILEGE_PRIVILEGED, MZ_MODE_SEQUENCE, "End sequence configuration mode");
// ---- BENCHMARK CONFIG MODE COMMANDS: ---
// ---- SCAN CONFIG MODE COMMANDS: ---
// ---- CONTROL COMMANDS: ----
cli_register_command(cli, NULL, "terminate", stop_mausezahn, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Terminate the Mausezahn server");
run = cli_register_command(cli, NULL, "run", NULL, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Run previously configured mops instances or sequences");
cli_register_command(cli, run, "id", cmd_run_id, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Run mops packet(s) by specifying packet identifiers");
cli_register_command(cli, run, "name", cmd_run_name, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Run mops packet(s) by specifying packet names");
cli_register_command(cli, run, "sequence", cmd_run_sequence, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Run a packet sequence");
cli_register_command(cli, run, "all", cmd_run_all, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Run all currently configured mops packet(s)");
cli_register_command(cli, NULL, "tx", transmit, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Send inline configured packet (legacy mode; not recommended)");
cli_register_command(cli, NULL, "stop", cmd_stop, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Stop transmission");
cli_register_command(cli, NULL, "load", cmd_load, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Load commands from a file");
// ---- SET COMMANDS: -----
cli_register_command(cli, NULL, "set", cmd_set, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Set global Mausezahn parameters");
// ---- CLEAR COMMANDS: -----
clear = cli_register_command(cli, NULL, "clear", NULL, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Clear something (use '?')");
cli_register_command(cli, clear, "all", clear_all, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Re-initialize Mausezahn");
cli_register_command(cli, clear, "packet", clear_packet, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Delete a packet (i. e. MOPS entry)");
// ---- SHOW COMMANDS: -----
show = cli_register_command(cli, NULL, "show", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Show something (use '?')");
cli_register_command(cli, show, "packet", show_packets, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Show defined packets");
// cli_register_command(cli, show, "system", show_system, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Show basic system settings");
cli_register_command(cli, show, "interfaces", show_interfaces, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Show detailed interface information");
cli_register_command(cli, show, "mops", show_mops, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Show MOPS details");
// cli_register_command(cli, show, "processes", cmd_test, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "List all Mausezahn processes");
cli_register_command(cli, show, "set", show_set, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "List general packet parameters");
cli_register_command(cli, show, "arp", show_arp, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Show the advanced Mausezahn ARP table");
// cli_register_command(cli, show, "report", cmd_test, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Print reports");
// ---- PRIVILEGE (OTHER) ----
reset = cli_register_command(cli, NULL, "reset", NULL, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Reset something...");
cli_register_command(cli, reset, "interface", cmd_reset_interface, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Reset interfaces");
cli_register_command(cli, reset, "packet", cmd_reset_packet, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Reset interfaces");
// ------- LAUNCH ------
launch = cli_register_command(cli, NULL, "launch", NULL, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Launch a predefined MOPS process");
cli_register_command(cli, launch, "bpdu", launch_bpdu, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Launch a(nother) BPDU process");
cli_register_command(cli, launch, "synflood", launch_synflood, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Launch a(nother) SYN-Flood process");
// cli_register_command(cli, launch, "alot", launch_alot, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Launch lots of traffic");
// cli_register_command(cli, launch, "rtp", launch_rtp, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Launch rtp stream(s)");
// cli_register_command(cli, launch, "arp", launch_arp, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Launch a(nother) ARP process");
// cli_register_command(cli, launch, "lldp", launch_lldp, PRIVILEGE_PRIVILEGED, MODE_EXEC, "Launch a(nother) LLDP process");
// *******************************************************
// Create a socket
s = socket(AF_INET, SOCK_STREAM, 0);
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
// Should we bind the CLI session to a specific interface?
// TODO: This does nothing !?
for (i=0; i<device_list_entries; i++) {
if (device_list[i].cli) {
setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, device_list[i].dev, strnlen(device_list[i].dev, 16));
break; // can only be one interface
}
}
// Listen on port mz_port (default: 25542, towel day)
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
inet_aton(mz_listen_addr, &servaddr.sin_addr);
servaddr.sin_port = htons(mz_port);
bind(s, (struct sockaddr *)&servaddr, sizeof(servaddr));
if (!quiet) {
fprintf(stderr, "Mausezahn accepts incoming Telnet connections on %s:%i.\n", mz_listen_addr, mz_port);
}
// Wait for a connection
listen(s, 50);
while ((x = accept(s, NULL, 0)))
{
if (!quiet)
{
cnt++;
timestamp_human(TimeStamp, NULL);
fprintf(stderr, "Got incoming connection [%i] at %s.\n", cnt, TimeStamp);
fflush(stderr);
}
// Pass the connection off to libcli
cli_loop(cli, x);
if (!quiet)
{
timestamp_human(TimeStamp, NULL);
fprintf(stderr, "Connection [%i] left at %s.\n", cnt, TimeStamp);
}
close(x);
}
// Free data structures
cli_done(cli);
return 0;
}
int main()
{
struct cli_command *c;
struct cli_def *cli;
int s, x;
struct sockaddr_in addr;
int on = 1;
#ifndef WIN32
signal(SIGCHLD, SIG_IGN);
#endif
#ifdef WIN32
if (!winsock_init()) {
printf("Error initialising winsock\n");
return 1;
}
#endif
// Prepare a small user context
char mymessage[] = "I contain user data!";
struct my_context myctx;
myctx.value = 5;
myctx.message = mymessage;
cli = cli_init();
cli_set_banner(cli, "libcli test environment");
cli_set_hostname(cli, "router");
cli_telnet_protocol(cli, 1);
cli_regular(cli, regular_callback);
cli_regular_interval(cli, 5); // Defaults to 1 second
cli_set_idle_timeout_callback(cli, 60, idle_timeout); // 60 second idle timeout
cli_register_command(cli, NULL, "test", cmd_test, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "simple", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "simon", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "set", cmd_set, PRIVILEGE_PRIVILEGED, MODE_EXEC, NULL);
c = cli_register_command(cli, NULL, "show", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, c, "regular", cmd_show_regular, PRIVILEGE_UNPRIVILEGED, MODE_EXEC,
"Show the how many times cli_regular has run");
cli_register_command(cli, c, "counters", cmd_test, PRIVILEGE_UNPRIVILEGED, MODE_EXEC,
"Show the counters that the system uses");
cli_register_command(cli, c, "junk", cmd_test, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "interface", cmd_config_int, PRIVILEGE_PRIVILEGED, MODE_CONFIG,
"Configure an interface");
cli_register_command(cli, NULL, "exit", cmd_config_int_exit, PRIVILEGE_PRIVILEGED, MODE_CONFIG_INT,
"Exit from interface configuration");
cli_register_command(cli, NULL, "address", cmd_test, PRIVILEGE_PRIVILEGED, MODE_CONFIG_INT, "Set IP address");
c = cli_register_command(cli, NULL, "debug", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, c, "regular", cmd_debug_regular, PRIVILEGE_UNPRIVILEGED, MODE_EXEC,
"Enable cli_regular() callback debugging");
// Set user context and its command
cli_set_context(cli, (void*)&myctx);
cli_register_command(cli, NULL, "context", cmd_context, PRIVILEGE_UNPRIVILEGED, MODE_EXEC,
"Test a user-specified context");
cli_set_auth_callback(cli, check_auth);
cli_set_enable_callback(cli, check_enable);
// Test reading from a file
{
FILE *fh;
if ((fh = fopen("clitest.txt", "r")))
{
// This sets a callback which just displays the cli_print() text to stdout
cli_print_callback(cli, pc);
cli_file(cli, fh, PRIVILEGE_UNPRIVILEGED, MODE_EXEC);
cli_print_callback(cli, NULL);
fclose(fh);
}
}
if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("socket");
return 1;
}
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(CLITEST_PORT);
if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0)
{
perror("bind");
return 1;
}
if (listen(s, 50) < 0)
{
perror("listen");
return 1;
}
printf("Listening on port %d\n", CLITEST_PORT);
while ((x = accept(s, NULL, 0)))
{
#ifndef WIN32
int pid = fork();
if (pid < 0)
{
perror("fork");
return 1;
}
/* parent */
if (pid > 0)
{
socklen_t len = sizeof(addr);
if (getpeername(x, (struct sockaddr *) &addr, &len) >= 0)
printf(" * accepted connection from %s\n", inet_ntoa(addr.sin_addr));
close(x);
continue;
}
/* child */
close(s);
cli_loop(cli, x);
exit(0);
#else
cli_loop(cli, x);
shutdown(x, SD_BOTH);
close(x);
#endif
}
cli_done(cli);
return 0;
}
void cmd_config_register_commands(struct cli_def *cli)
{
struct cli_command *c,*c2,*c3,*no;
no=cli_register_command(cli, NULL, "no", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Negate a command or set its defaults");
cli_register_command(cli, NULL, "version", cmd_config_version, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "");
cli_register_command(cli, NULL, "hostname", cmd_config_hostname, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Set system's network host name");
c=cli_register_command(cli, NULL, "mac-address-table", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure the MAC address table");
cli_register_command(cli, c, "aging-time", cmd_config_mac_aging, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Set MAC address table entry maximum age");
{ // ip config
struct cli_command *ip,*ip_igmp,*no_ip,*no_ip_igmp;
ip=cli_register_command(cli, NULL, "ip", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global IP configuration subcommands");
ip_igmp=cli_register_command(cli, ip, "igmp", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "IGMP global configuration");
cli_register_command(cli, ip_igmp, "snooping", cmd_config_ip_igmp_snooping, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global IGMP Snooping enable");
no_ip=cli_register_command(cli, no, "ip", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global IP configuration subcommands");
no_ip_igmp=cli_register_command(cli, no_ip, "igmp", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "IGMP global configuration");
cli_register_command(cli, no_ip_igmp, "snooping", cmd_config_ip_igmp_snooping, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global IGMP Snooping disable");
}
{ // rrcp config
c=cli_register_command(cli, NULL, "rrcp", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global RRCP configuration subcommand");
cli_register_command(cli, c, "enable", cmd_config_rrcp, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable RRCP");
c2=cli_register_command(cli, no, "rrcp", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global RRCP configuration subcommand");
cli_register_command(cli, c2, "enable", cmd_config_rrcp, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable RRCP");
c3=cli_register_command(cli, c, "echo", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global RRCP Echo Protocol configuration subcommand");
cli_register_command(cli, c3, "enable", cmd_config_rrcp, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable RRCP Echo Protocol");
c3=cli_register_command(cli, c2, "echo", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global RRCP Echo Protocol configuration subcommand");
cli_register_command(cli, c3, "enable", cmd_config_rrcp, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable RRCP Echo Protocol");
c3=cli_register_command(cli, c, "loop-detect", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global RRCP-based loop detection configuration subcommand");
cli_register_command(cli, c3, "enable", cmd_config_rrcp, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable RRCP-based loop detection");
c3=cli_register_command(cli, c2, "loop-detect", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global RRCP-based loop detection configuration subcommand");
cli_register_command(cli, c3, "enable", cmd_config_rrcp, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable RRCP-based loop detection");
cli_register_command(cli, c, "authkey", cmd_config_rrcp_authkey, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Set new RRCP Authentication key");
}
{ // vlan config
struct cli_command *vlan,*no_vlan,*vlan_leaky,*no_vlan_leaky,*vlan_drop,*no_vlan_drop;
vlan=cli_register_command(cli, NULL, "vlan", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global VLAN mode");
no_vlan=cli_register_command(cli, no, "vlan", cmd_config_vlan, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Vlan commands");
cli_register_command(cli, vlan, "portbased", cmd_config_vlan, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable port-based VLANs only");
c2=cli_register_command(cli, vlan, "dot1q", cmd_config_vlan, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable full IEEE 802.1Q tagged VLANs");
cli_register_command(cli, c2, "force", cmd_config_vlan, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable IEEE 802.1Q VLANs even on buggy hardware");
vlan_leaky=cli_register_command(cli, vlan, "leaky", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Allow certain type of packets to be switched beetween VLANs");
no_vlan_leaky=cli_register_command(cli, no_vlan, "leaky", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disallow certain type of packets to be switched beetween VLANs");
cli_register_command(cli, vlan_leaky, "arp", cmd_config_vlan_leaky, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Allow ARP packets to be switched beetween VLANs");
cli_register_command(cli, no_vlan_leaky, "arp", cmd_config_vlan_leaky, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disallow ARP packets to be switched beetween VLANs");
cli_register_command(cli, vlan_leaky, "multicast", cmd_config_vlan_leaky, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Allow multicast packets to be switched beetween VLANs");
cli_register_command(cli, no_vlan_leaky, "multicast", cmd_config_vlan_leaky, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disallow multicast packets to be switched beetween VLANs");
cli_register_command(cli, vlan_leaky, "unicast", cmd_config_vlan_leaky, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Allow unicast packets to be switched beetween VLANs");
cli_register_command(cli, no_vlan_leaky, "unicast", cmd_config_vlan_leaky, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disallow unicast packets to be switched beetween VLANs");
vlan_drop=cli_register_command(cli, vlan, "drop", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Allow dropping certain types of non-conforming packets");
no_vlan_drop=cli_register_command(cli, no_vlan, "drop", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disallow dropping certain types of non-conforming packets");
cli_register_command(cli, vlan_drop, "untagged_frames", cmd_config_vlan_drop, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Drop ALL untagged packets, on all ports");
cli_register_command(cli, no_vlan_drop, "untagged_frames", cmd_config_vlan_drop, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Do not drop untagged packets");
cli_register_command(cli, vlan_drop, "invalid_vid", cmd_config_vlan_drop, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Drop tagged frames with VID, that is invalid on this port");
cli_register_command(cli, no_vlan_drop, "invalid_vid", cmd_config_vlan_drop, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Do not drop tagged frames with VID, that is invalid on this port");
}
{ // qos config
struct cli_command *mls,*no_mls,*qos,*no_qos,*trust,*no_trust;
mls=cli_register_command(cli, NULL, "mls", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Multi-Layer Switch configuration");
no_mls=cli_register_command(cli, no, "mls", cmd_config_qos, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Multi-Layer Switch configuration");
qos=cli_register_command(cli, mls, "qos", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global Quality-of-Service configuration");
no_qos=cli_register_command(cli, no_mls, "qos", cmd_config_qos, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Global Quality-of-Service configuration");
trust=cli_register_command(cli, qos, "trust", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Quality-of-Service trust configuration");
no_trust=cli_register_command(cli, no_qos, "trust", cmd_config_qos, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Quality-of-Service trust configuration");
cli_register_command(cli, trust, "dscp", cmd_config_qos, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Trust DSCP(TOS) value in IP header of incoming packets");
cli_register_command(cli, no_trust, "dscp", cmd_config_qos, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Do not trust DSCP(TOS) value in IP header of incoming packets");
cli_register_command(cli, trust, "cos", cmd_config_qos, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Trust CoS (802.1p) tag value of incoming packets");
cli_register_command(cli, no_trust, "cos", cmd_config_qos, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Do not trust CoS (802.1p) tag value of incoming packets");
c=cli_register_command(cli, NULL, "wrr-queue", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure Weighed Round-Robin queue");
cli_register_command(cli, c, "ratio", cmd_config_qos_wrr_queue_ratio, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure ratio of high-priority vs. low-priority traffic to pass");
c=cli_register_command(cli, no, "wrr-queue", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure Weighed Round-Robin queue");
cli_register_command(cli, c, "ratio", cmd_config_qos, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure default high-priority vs. low-priority traffic ratio");
}
{ // flowcontrol config
struct cli_command *flowcontrol,*no_flowcontrol;
flowcontrol=cli_register_command(cli, NULL, "flowcontrol", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Flow control configuration");
no_flowcontrol=cli_register_command(cli, no, "flowcontrol", cmd_config_flowcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Flow control configuration");
cli_register_command(cli, flowcontrol, "dot3x", cmd_config_flowcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable IEEE 802.3x flow control");
cli_register_command(cli, no_flowcontrol, "dot3x", cmd_config_flowcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disable IEEE 802.3x flow control");
cli_register_command(cli, flowcontrol, "backpressure", cmd_config_flowcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable half-duplex back pressure flow control");
cli_register_command(cli, no_flowcontrol, "backpressure", cmd_config_flowcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disable half-duplex back pressure flow control");
cli_register_command(cli, flowcontrol, "ondemand-disable", cmd_config_flowcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Allow on demand temporary disabling all flow control on port, where high-priority frame has arrived - use with care!");
cli_register_command(cli, no_flowcontrol, "ondemand-disable", cmd_config_flowcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Do not allow on demand disabling of flow control");
}
{ // storm-control config
struct cli_command *stormcontrol,*no_stormcontrol,*stormcontrol_broadcast;
stormcontrol=cli_register_command(cli, NULL, "storm-control", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Storm-contol (preventing certain excessive traffic) configuration");
no_stormcontrol=cli_register_command(cli, no, "storm-control", cmd_config_flowcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Storm-contol (preventing certain excessive traffic) configuration");
stormcontrol_broadcast=cli_register_command(cli, stormcontrol, "broadcast", cmd_config_stormcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Storm-control on broadcast traffic");
cli_register_command(cli, stormcontrol_broadcast, "relaxed", cmd_config_stormcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable relaxed storm-control on broadcast traffic");
cli_register_command(cli, stormcontrol_broadcast, "strict", cmd_config_stormcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable strict storm-control on broadcast traffic");
cli_register_command(cli, no_stormcontrol, "broadcast", cmd_config_stormcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disable storm-control on broadcast traffic");
cli_register_command(cli, stormcontrol, "multicast", cmd_config_stormcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable strict storm-control on multicast traffic");
cli_register_command(cli, no_stormcontrol, "multicast", cmd_config_stormcontrol, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disable storm-control on multicast traffic");
}
{ // spanning-tree config
struct cli_command *spanning_tree,*no_spanning_tree;
spanning_tree=cli_register_command(cli, NULL, "spanning-tree", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Spanning Tree Subsystem");
no_spanning_tree=cli_register_command(cli, no, "spanning-tree", cmd_config_spanning_tree, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Spanning Tree Subsystem");
c=cli_register_command(cli, spanning_tree, "bpdufilter", cmd_config_spanning_tree, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Don't send or receive BPDUs on this interface");
cli_register_command(cli, c, "enable", cmd_config_spanning_tree, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Enable BPDU filtering for this interface");
cli_register_command(cli, c, "disable", cmd_config_spanning_tree, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disable BPDU filtering for this interface");
c=cli_register_command(cli, no_spanning_tree, "bpdufilter", cmd_config_spanning_tree, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Don't send or receive BPDUs on this interface");
cli_register_command(cli, c, "enable", cmd_config_spanning_tree, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Disable BPDU filtering for this interface");
}
cli_register_command(cli, NULL, "end", cmd_config_end, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Exit from configure mode");
}
int json_cli_init(void)
{
if (cli_register_command(&json_command))
return 1;
return 0;
}
int main(int argc, char *argv[])
{
struct cli_command *c;
struct cli_def *cli;
cli = cli_init();
cli_set_banner(cli, "libcli test environment");
cli_set_hostname(cli, "router");
cli_set_newline(cli, "\n");
cli_register_command(cli, NULL, "test", cmd_test, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "sex", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "simple", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "simon", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "set", cmd_set, PRIVILEGE_PRIVILEGED, MODE_EXEC, NULL);
c = cli_register_command(cli, NULL, "show", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, c, "counters", cmd_test, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Show the counters that the system uses");
cli_register_command(cli, c, "junk", cmd_test, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, NULL);
cli_register_command(cli, NULL, "interface", cmd_config_int, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "Configure an interface");
cli_register_command(cli, NULL, "exit", cmd_config_int_exit, PRIVILEGE_PRIVILEGED, MODE_CONFIG_INT, "Exit from interface configuration");
cli_register_command(cli, NULL, "address", cmd_test, PRIVILEGE_PRIVILEGED, MODE_CONFIG_INT, "Set IP address");
//cli_set_auth_callback(cli, check_auth);
//cli_set_enable_callback(cli, check_enable);
// Test reading from a file
{
FILE *fh;
if ((fh = fopen("clitest.txt", "r")))
{
// This sets a callback which just displays the cli_print() text to stdout
cli_print_callback(cli, pc);
cli_file(cli, fh, PRIVILEGE_UNPRIVILEGED, MODE_EXEC);
cli_print_callback(cli, NULL);
fclose(fh);
}
}
set_canonical(0);
cli_loop(cli, fileno(stdin), fileno(stdout));
set_canonical(1);
cli_done(cli);
return 0;
}
void ara_init_cli() {
dessert_debug("initalizing CLI");
cli_register_command(dessert_cli, dessert_cli_show, "ara_config", cli_show_ara_config, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ARA configuration");
cli_register_command(dessert_cli, dessert_cli_set, "ara_ack_mode", cli_set_ara_ack_mode, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set acknowledgement mode");
cli_register_command(dessert_cli, dessert_cli_show, "ara_ack_mode", cli_show_ara_ack_mode, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show acknowledgement mode");
cli_register_command(dessert_cli, dessert_cli_set, "ara_ack_miss_credit", cli_set_ara_ack_miss_credit, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set how many ACK may be missed (credit)");
cli_register_command(dessert_cli, dessert_cli_show, "ara_ack_miss_credit", cli_show_ara_ack_miss_credit, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show how many ACK may be missed (credit)");
cli_register_command(dessert_cli, dessert_cli_set, "ara_ack_credit_inc", cli_set_ara_ack_credit_inc, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set value to increase credit on rx ACK");
cli_register_command(dessert_cli, dessert_cli_show, "ara_ack_credit_inc", cli_show_ara_ack_credit_inc, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_ack_credit_inc");
cli_register_command(dessert_cli, dessert_cli_set, "ara_prune_routes", cli_set_prune_routes, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "prune alternative routes");
cli_register_command(dessert_cli, dessert_cli_show, "ara_prune_routes", cli_show_prune_routes, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show route pruning length");
cli_register_command(dessert_cli, dessert_cli_set, "ara_pant_interval", cli_set_pant_interval, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set PANT interval");
cli_register_command(dessert_cli, dessert_cli_show, "ara_pant_interval", cli_show_pant_interval, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show PANT interval");
cli_register_command(dessert_cli, dessert_cli_set, "ara_ack_wait_ms", cli_set_ara_ack_wait_ms, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set timeout for acknowledgements");
cli_register_command(dessert_cli, dessert_cli_show, "ara_ack_wait_ms", cli_show_ara_ack_wait_ms, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show acknowledgement timeout");
cli_register_command(dessert_cli, dessert_cli_set, "ara_ndisjoint", cli_set_ndisjoint, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "enable/disable node disjoint route discovery");
cli_register_command(dessert_cli, dessert_cli_show, "ara_ndisjoint", cli_show_ndisjoint, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show node disjoint setting");
cli_register_command(dessert_cli, dessert_cli_set, "ara_adap_evaporation", cli_set_ara_adap_evaporation, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "enable/disable adaptive evaporation");
cli_register_command(dessert_cli, dessert_cli_show, "ara_adap_evaporation", cli_show_ara_adap_evaporation, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show adaptive evaporation setting");
cli_register_command(dessert_cli, dessert_cli_set, "ara_backwards_inc", cli_set_ara_backwards_inc, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "enable/disable node backwards pheromone increase");
cli_register_command(dessert_cli, dessert_cli_show, "ara_backwards_inc", cli_show_ara_backwards_inc, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_backwards_inc setting");
cli_register_command(dessert_cli, dessert_cli_set, "ara_rtprob_bants", cli_set_rtprob_bants, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "enable/disable route problem BANTs");
cli_register_command(dessert_cli, dessert_cli_show, "ara_rtprob_bants", cli_show_rtprob_bants, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show route problem BANT mode");
cli_register_command(dessert_cli, dessert_cli_set, "ara_retry_delay_ms", cli_set_ara_retry_delay_ms, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set retry timeout [ms]");
cli_register_command(dessert_cli, dessert_cli_show, "ara_retry_delay_ms", cli_show_ara_retry_delay_ms, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show retry timout");
cli_register_command(dessert_cli, dessert_cli_set, "ara_retry_max", cli_set_ara_retry_max, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set maximum number of retries");
cli_register_command(dessert_cli, dessert_cli_show, "ara_retry_max", cli_show_ara_retry_max, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show maximum number of retries");
cli_register_command(dessert_cli, dessert_cli_set, "ara_forw_mode", cli_set_ara_forw_mode, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set forward mode");
cli_register_command(dessert_cli, dessert_cli_show, "ara_forw_mode", cli_show_ara_forw_mode, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show forward mode");
cli_register_command(dessert_cli, dessert_cli_set, "ara_ptrail_mode", cli_set_ara_ptrail_mode, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set pheromone trail mode");
cli_register_command(dessert_cli, dessert_cli_show, "ara_ptrail_mode", cli_show_ara_ptrail_mode, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show pheromone trail mode");
cli_register_command(dessert_cli, dessert_cli_set, "ara_rt_min_pheromone", cli_set_rt_min_pheromone, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set rt_min_pheromone");
cli_register_command(dessert_cli, dessert_cli_show, "ara_rt_min_pheromone", cli_show_rt_min_pheromone, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show rt_min_pheromone");
cli_register_command(dessert_cli, dessert_cli_set, "ara_rt_initial", cli_set_rt_initial, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set rt_initial");
cli_register_command(dessert_cli, dessert_cli_show, "ara_rt_initial", cli_show_rt_initial, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show rt_initial");
cli_register_command(dessert_cli, dessert_cli_set, "ara_rt_delta_q", cli_set_rt_delta_q, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set rt_delta_q");
cli_register_command(dessert_cli, dessert_cli_show, "ara_rt_delta_q", cli_show_rt_delta_q, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show rt_delta_q");
cli_register_command(dessert_cli, dessert_cli_set, "ara_rt_inc", cli_set_rt_inc, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set rt_inc");
cli_register_command(dessert_cli, dessert_cli_show, "ara_rt_inc", cli_show_rt_inc, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show rt_inc");
cli_register_command(dessert_cli, dessert_cli_set, "ara_rt_tick_interval", cli_set_rt_tick_interval, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set rt_tick_interval");
cli_register_command(dessert_cli, dessert_cli_show, "ara_rt_tick_interval", cli_show_rt_tick_interval, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show rt_tick_interval");
cli_register_command(dessert_cli, dessert_cli_set, "ara_trace_broadcastlen", cli_set_ara_trace_broadcastlen, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ara_trace_broadcastlen");
cli_register_command(dessert_cli, dessert_cli_show, "ara_trace_broadcastlen", cli_show_ara_trace_broadcastlen, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_trace_broadcastlen");
cli_register_command(dessert_cli, dessert_cli_set, "ara_print_rt_interval_s", cli_set_ara_print_rt_periodic, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ara_print_rt_interval_s");
cli_register_command(dessert_cli, dessert_cli_show, "ara_print_rt_interval_s", cli_show_ara_print_rt_periodic, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_print_rt_interval_s setting");
cli_register_command(dessert_cli, dessert_cli_set, "ara_print_cl_interval_s", cli_set_ara_print_cl_periodic, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ara_print_cl_interval_s");
cli_register_command(dessert_cli, dessert_cli_show, "ara_print_cl_interval_s", cli_show_ara_print_cl_periodic, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_print_cl_interval_s setting");
cli_register_command(dessert_cli, dessert_cli_set, "ara_clsf_lossmin", cli_set_ara_clsf_lossmin, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set lower classification bound");
cli_register_command(dessert_cli, dessert_cli_show, "ara_clsf_lossmin", cli_show_ara_clsf_lossmin, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show lower classification bound");
cli_register_command(dessert_cli, dessert_cli_set, "ara_clsf_lossmax", cli_set_ara_clsf_lossmax, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set upper classification bound");
cli_register_command(dessert_cli, dessert_cli_show, "ara_clsf_lossmax", cli_show_ara_clsf_lossmax, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show upper classification bound");
cli_register_command(dessert_cli, dessert_cli_set, "ara_clsf_tick_interval_s", cli_set_ara_clsf_tick_interval_s, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ara_clsf_tick_interval_s");
cli_register_command(dessert_cli, dessert_cli_show, "ara_clsf_tick_interval_s", cli_show_ara_clsf_tick_interval_s, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_clsf_tick_interval_s");
cli_register_command(dessert_cli, dessert_cli_set, "ara_clsf_skiptimes", cli_set_ara_clsf_skiptimes, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ara_clsf_skiptimes");
cli_register_command(dessert_cli, dessert_cli_show, "ara_clsf_skiptimes", cli_show_ara_clsf_skiptimes, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_clsf_skiptimes");
cli_register_command(dessert_cli, dessert_cli_set, "ara_clsf_sw_size", cli_set_ara_clsf_sw_size, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ara_clsf_sw_size");
cli_register_command(dessert_cli, dessert_cli_show, "ara_clsf_sw_size", cli_show_ara_clsf_sw_size, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_clsf_sw_size");
cli_register_command(dessert_cli, dessert_cli_set, "ara_clsf_sender_rate", cli_set_ara_clsf_sender_rate, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ara_clsf_sender_rate");
cli_register_command(dessert_cli, dessert_cli_show, "ara_clsf_sender_rate", cli_show_ara_clsf_sender_rate, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_clsf_sender_rate");
cli_register_command(dessert_cli, dessert_cli_set, "ara_classify", cli_set_ara_classify, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "enable/disable path classification");
cli_register_command(dessert_cli, dessert_cli_show, "ara_classify", cli_show_ara_classify, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show path classification setting");
cli_register_command(dessert_cli, dessert_cli_set, "ara_ant_size", cli_set_ara_ant_size, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ara_ant_size");
cli_register_command(dessert_cli, dessert_cli_show, "ara_ant_size", cli_show_ara_ant_size, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ara_ant_size setting");
cli_register_command(dessert_cli, dessert_cli_cfg_iface, "sys", dessert_cli_cmd_addsysif, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "initialize tap interface");
cli_register_command(dessert_cli, dessert_cli_cfg_iface, "mesh", dessert_cli_cmd_addmeshif, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "initialize mesh interface");
cli_register_command(dessert_cli, dessert_cli_show, "packettrap", cli_showpackettrap, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show packet trap");
cli_register_command(dessert_cli, dessert_cli_show, "routing table", cli_showroutingtable, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show the routing table");
cli_register_command(dessert_cli, dessert_cli_show, "path classification table", cli_showclassifictable, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show the classification table");
cli_register_command(dessert_cli, dessert_cli_show, "ack monitor", cli_show_ack_monitor, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show packets waiting for acknowledgement");
cli_show_loopprotect = cli_register_command(dessert_cli, dessert_cli_show, "loopprotect", NULL, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show the loopprotect history");
cli_register_command(dessert_cli, cli_show_loopprotect, "table", cli_showloopprotect_table, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show the loopprotect history");
cli_register_command(dessert_cli, cli_show_loopprotect, "statistics", cli_showloopprotect_statistics, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show the loopprotect statistics");
cli_cfg_flush = cli_register_command(dessert_cli, NULL, "flush", NULL, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "flush data structure");
cli_register_command(dessert_cli, cli_cfg_flush, "routing table", cli_flushroutingtable, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "flush routing table");
cli_register_command(dessert_cli, cli_cfg_flush, "path classification table", cli_flushclassifictable, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "flush classification table");
cli_register_command(dessert_cli, cli_cfg_flush, "ack monitor", cli_flush_ack_monitor, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "flush ack monitor");
cli_register_command(dessert_cli, cli_cfg_flush, "loop protection", cli_flush_loopprotec_table, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "flush loop protection table");
cli_register_command(dessert_cli, cli_cfg_flush, "rmnt", cli_flush_rmnt, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "flush route management table");
cli_register_command(dessert_cli, cli_cfg_flush, "all", cli_flush_all, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "flush all data structures");
dessert_debug("CLI initialized");
}
static void _register_cli_callbacks() {
/* cli initialization */
cli_register_command(dessert_cli, dessert_cli_cfg_iface, "sys", dessert_cli_cmd_addsysif, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "initialize sys interface");
cli_register_command(dessert_cli, dessert_cli_cfg_iface, "mesh", dessert_cli_cmd_addmeshif, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "initialize mesh interface");
cli_register_command(dessert_cli, dessert_cli_set, "hello_size", cli_set_hello_size, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set HELLO packet size");
cli_register_command(dessert_cli, dessert_cli_set, "hello_interval_ms", cli_set_hello_interval, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set HELLO interval");
cli_register_command(dessert_cli, dessert_cli_set, "tc_size", cli_set_tc_size, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set TC packet size");
cli_register_command(dessert_cli, dessert_cli_set, "tc_interval_ms", cli_set_tc_interval, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set TC interval");
cli_register_command(dessert_cli, dessert_cli_set, "ett_interval", cli_set_ett_interval, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set ETT interval");
cli_register_command(dessert_cli, dessert_cli_set, "rt_interval_ms", cli_set_rt_interval, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set routing table update interval");
cli_register_command(dessert_cli, dessert_cli_set, "window_size", cli_set_window_size, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set link quality window size (PDR or ETX)");
cli_register_command(dessert_cli, dessert_cli_set, "max_miss_tc", cli_set_max_missed_tc, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set limit for missed TCs");
cli_register_command(dessert_cli, dessert_cli_set, "max_miss_hello", cli_set_max_missed_hello, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set limit for missed HELLOs");
cli_register_command(dessert_cli, dessert_cli_set, "willingness", cli_set_willingness, PRIVILEGE_PRIVILEGED, MODE_CONFIG, "set willingness for MPR selection");
cli_register_command(dessert_cli, dessert_cli_set, "metric", cli_set_rc_metric, PRIVILEGE_UNPRIVILEGED, MODE_CONFIG, "set metric (PLR | PDR | HC | ETX | ETX-ADD)");
cli_register_command(dessert_cli, dessert_cli_set, "fisheye", cli_set_fisheye, PRIVILEGE_UNPRIVILEGED, MODE_CONFIG, "set fisheye (on | off)");
cli_register_command(dessert_cli, dessert_cli_show, "rt_interval_ms", cli_show_rt_interval, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show routing table update interval");
cli_register_command(dessert_cli, dessert_cli_show, "max_miss_tc", cli_show_max_missed_tc, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show limit for the max. number of missed TCs");
cli_register_command(dessert_cli, dessert_cli_show, "max_miss_hello", cli_show_max_missed_hello, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show limit for the max. number of missed HELLOs");
cli_register_command(dessert_cli, dessert_cli_show, "hello_size", cli_show_hello_size, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show HELLO packet size");
cli_register_command(dessert_cli, dessert_cli_show, "hello_interval_ms", cli_show_hello_interval, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show HELLO interval");
cli_register_command(dessert_cli, dessert_cli_show, "tc_size", cli_show_tc_size, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show TC packet size");
cli_register_command(dessert_cli, dessert_cli_show, "tc_interval_ms", cli_show_tc_interval, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show TC interval");
cli_register_command(dessert_cli, dessert_cli_show, "ett", cli_show_ett, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ETT table");
cli_register_command(dessert_cli, dessert_cli_show, "ett_interval", cli_show_ett_interval, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show ETT interval");
cli_register_command(dessert_cli, dessert_cli_show, "ns", cli_show_ns, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show neighbor set table");
cli_register_command(dessert_cli, dessert_cli_show, "ns_so", cli_show_ns_so, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show neighbor set table (simple output)");
cli_register_command(dessert_cli, dessert_cli_show, "ls", cli_show_ls, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show link set table");
cli_register_command(dessert_cli, dessert_cli_show, "2hns", cli_show_2hns, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show 2-hop neighbor set table");
cli_register_command(dessert_cli, dessert_cli_show, "tc", cli_show_tc, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show TC set table");
cli_register_command(dessert_cli, dessert_cli_show, "rt", cli_show_rt, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show routing table");
cli_register_command(dessert_cli, dessert_cli_show, "rt_so", cli_show_rt_so, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show routing table (simple output)");
cli_register_command(dessert_cli, dessert_cli_show, "metric", cli_show_rc_metric, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show routing metric");
cli_register_command(dessert_cli, dessert_cli_show, "fisheye", cli_show_fisheye, PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "show fisheye");
}
