1/* 2 * Zebra configuration command interface routine 3 * Copyright (C) 1997, 98 Kunihiro Ishiguro 4 * 5 * This file is part of GNU Zebra. 6 * 7 * GNU Zebra is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published 9 * by the Free Software Foundation; either version 2, or (at your 10 * option) any later version. 11 * 12 * GNU Zebra is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with GNU Zebra; see the file COPYING. If not, write to the 19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 20 * Boston, MA 02111-1307, USA. 21 */ 22 23#ifndef _ZEBRA_COMMAND_H 24#define _ZEBRA_COMMAND_H 25 26#include "vector.h" 27#include "vty.h" 28#include "lib/route_types.h" 29 30/* Host configuration variable */ 31struct host 32{ 33 /* Host name of this router. */ 34 char *name; 35 36 /* Password for vty interface. */ 37 char *password; 38 char *password_encrypt; 39 40 /* Enable password */ 41 char *enable; 42 char *enable_encrypt; 43 44 /* System wide terminal lines. */ 45 int lines; 46 47 /* Log filename. */ 48 char *logfile; 49 50 /* config file name of this host */ 51 char *config; 52 53 /* Flags for services */ 54 int advanced; 55 int encrypt; 56 57 /* Banner configuration. */ 58 const char *motd; 59 char *motdfile; 60}; 61 62/* There are some command levels which called from command node. */ 63enum node_type 64{ 65 AUTH_NODE, /* Authentication mode of vty interface. */ 66 RESTRICTED_NODE, /* Restricted view mode */ 67 VIEW_NODE, /* View node. Default mode of vty interface. */ 68 AUTH_ENABLE_NODE, /* Authentication mode for change enable. */ 69 ENABLE_NODE, /* Enable node. */ 70 CONFIG_NODE, /* Config node. Default mode of config file. */ 71 SERVICE_NODE, /* Service node. */ 72 DEBUG_NODE, /* Debug node. */ 73 AAA_NODE, /* AAA node. */ 74 KEYCHAIN_NODE, /* Key-chain node. */ 75 KEYCHAIN_KEY_NODE, /* Key-chain key node. */ 76 INTERFACE_NODE, /* Interface mode node. */ 77 ZEBRA_NODE, /* zebra connection node. */ 78 TABLE_NODE, /* rtm_table selection node. */ 79 RIP_NODE, /* RIP protocol mode node. */ 80 RIPNG_NODE, /* RIPng protocol mode node. */ 81 BABEL_NODE, /* Babel protocol mode node. */ 82 BGP_NODE, /* BGP protocol mode which includes BGP4+ */ 83 BGP_VPNV4_NODE, /* BGP MPLS-VPN PE exchange. */ 84 BGP_IPV4_NODE, /* BGP IPv4 unicast address family. */ 85 BGP_IPV4M_NODE, /* BGP IPv4 multicast address family. */ 86 BGP_IPV6_NODE, /* BGP IPv6 address family */ 87 BGP_IPV6M_NODE, /* BGP IPv6 multicast address family. */ 88 OSPF_NODE, /* OSPF protocol mode */ 89 OSPF6_NODE, /* OSPF protocol for IPv6 mode */ 90 ISIS_NODE, /* ISIS protocol mode */ 91 PIM_NODE, /* PIM protocol mode */ 92 MASC_NODE, /* MASC for multicast. */ 93 IRDP_NODE, /* ICMP Router Discovery Protocol mode. */ 94 IP_NODE, /* Static ip route node. */ 95 ACCESS_NODE, /* Access list node. */ 96 PREFIX_NODE, /* Prefix list node. */ 97 ACCESS_IPV6_NODE, /* Access list node. */ 98 PREFIX_IPV6_NODE, /* Prefix list node. */ 99 AS_LIST_NODE, /* AS list node. */ 100 COMMUNITY_LIST_NODE, /* Community list node. */ 101 RMAP_NODE, /* Route map node. */ 102 SMUX_NODE, /* SNMP configuration node. */ 103 DUMP_NODE, /* Packet dump node. */ 104 FORWARDING_NODE, /* IP forwarding node. */ 105 PROTOCOL_NODE, /* protocol filtering node */ 106 VTY_NODE, /* Vty node. */ 107}; 108 109/* Node which has some commands and prompt string and configuration 110 function pointer . */ 111struct cmd_node 112{ 113 /* Node index. */ 114 enum node_type node; 115 116 /* Prompt character at vty interface. */ 117 const char *prompt; 118 119 /* Is this node's configuration goes to vtysh ? */ 120 int vtysh; 121 122 /* Node's configuration write function */ 123 int (*func) (struct vty *); 124 125 /* Vector of this node's command list. */ 126 vector cmd_vector; 127}; 128 129enum 130{ 131 CMD_ATTR_DEPRECATED = 1, 132 CMD_ATTR_HIDDEN, 133}; 134 135/* Structure of command element. */ 136struct cmd_element 137{ 138 const char *string; /* Command specification by string. */ 139 int (*func) (struct cmd_element *, struct vty *, int, const char *[]); 140 const char *doc; /* Documentation of this command. */ 141 int daemon; /* Daemon to which this command belong. */ 142 vector tokens; /* Vector of cmd_tokens */ 143 u_char attr; /* Command attributes */ 144}; 145 146 147enum cmd_token_type 148{ 149 TOKEN_TERMINAL = 0, 150 TOKEN_MULTIPLE, 151 TOKEN_KEYWORD, 152}; 153 154/* Command description structure. */ 155struct cmd_token 156{ 157 enum cmd_token_type type; 158 159 /* Used for type == MULTIPLE */ 160 vector multiple; /* vector of cmd_token, type == FINAL */ 161 162 /* Used for type == KEYWORD */ 163 vector keyword; /* vector of vector of cmd_tokens */ 164 165 /* Used for type == TERMINAL */ 166 char *cmd; /* Command string. */ 167 char *desc; /* Command's description. */ 168}; 169 170/* Return value of the commands. */ 171#define CMD_SUCCESS 0 172#define CMD_WARNING 1 173#define CMD_ERR_NO_MATCH 2 174#define CMD_ERR_AMBIGUOUS 3 175#define CMD_ERR_INCOMPLETE 4 176#define CMD_ERR_EXEED_ARGC_MAX 5 177#define CMD_ERR_NOTHING_TODO 6 178#define CMD_COMPLETE_FULL_MATCH 7 179#define CMD_COMPLETE_MATCH 8 180#define CMD_COMPLETE_LIST_MATCH 9 181#define CMD_SUCCESS_DAEMON 10 182 183/* Argc max counts. */ 184#define CMD_ARGC_MAX 25 185 186/* Turn off these macros when uisng cpp with extract.pl */ 187#ifndef VTYSH_EXTRACT_PL 188 189/* helper defines for end-user DEFUN* macros */ 190#define DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, attrs, dnum) \ 191 struct cmd_element cmdname = \ 192 { \ 193 .string = cmdstr, \ 194 .func = funcname, \ 195 .doc = helpstr, \ 196 .attr = attrs, \ 197 .daemon = dnum, \ 198 }; 199 200#define DEFUN_CMD_FUNC_DECL(funcname) \ 201 static int funcname (struct cmd_element *, struct vty *, int, const char *[]); 202 203#define DEFUN_CMD_FUNC_TEXT(funcname) \ 204 static int funcname \ 205 (struct cmd_element *self __attribute__ ((unused)), \ 206 struct vty *vty __attribute__ ((unused)), \ 207 int argc __attribute__ ((unused)), \ 208 const char *argv[] __attribute__ ((unused)) ) 209 210/* DEFUN for vty command interafce. Little bit hacky ;-). 211 * 212 * DEFUN(funcname, cmdname, cmdstr, helpstr) 213 * 214 * funcname 215 * ======== 216 * 217 * Name of the function that will be defined. 218 * 219 * cmdname 220 * ======= 221 * 222 * Name of the struct that will be defined for the command. 223 * 224 * cmdstr 225 * ====== 226 * 227 * The cmdstr defines the command syntax. It is used by the vty subsystem 228 * and vtysh to perform matching and completion in the cli. So you have to take 229 * care to construct it adhering to the following grammar. The names used 230 * for the production rules losely represent the names used in lib/command.c 231 * 232 * cmdstr = cmd_token , { " " , cmd_token } ; 233 * 234 * cmd_token = cmd_terminal 235 * | cmd_multiple 236 * | cmd_keyword ; 237 * 238 * cmd_terminal_fixed = fixed_string 239 * | variable 240 * | range 241 * | ipv4 242 * | ipv4_prefix 243 * | ipv6 244 * | ipv6_prefix ; 245 * 246 * cmd_terminal = cmd_terminal_fixed 247 * | option 248 * | vararg ; 249 * 250 * multiple_part = cmd_terminal_fixed ; 251 * cmd_multiple = "(" , multiple_part , ( "|" | { "|" , multiple_part } ) , ")" ; 252 * 253 * keyword_part = fixed_string , { " " , ( cmd_terminal_fixed | cmd_multiple ) } ; 254 * cmd_keyword = "{" , keyword_part , { "|" , keyword_part } , "}" ; 255 * 256 * lowercase = "a" | ... | "z" ; 257 * uppercase = "A" | ... | "Z" ; 258 * digit = "0" | ... | "9" ; 259 * number = digit , { digit } ; 260 * 261 * fixed_string = (lowercase | digit) , { lowercase | digit | uppercase | "-" | "_" } ; 262 * variable = uppercase , { uppercase | "_" } ; 263 * range = "<" , number , "-" , number , ">" ; 264 * ipv4 = "A.B.C.D" ; 265 * ipv4_prefix = "A.B.C.D/M" ; 266 * ipv6 = "X:X::X:X" ; 267 * ipv6_prefix = "X:X::X:X/M" ; 268 * option = "[" , variable , "]" ; 269 * vararg = "." , variable ; 270 * 271 * To put that all in a textual description: A cmdstr is a sequence of tokens, 272 * separated by spaces. 273 * 274 * Terminal Tokens: 275 * 276 * A very simple cmdstring would be something like: "show ip bgp". It consists 277 * of three Terminal Tokens, each containing a fixed string. When this command 278 * is called, no arguments will be passed down to the function implementing it, 279 * as it only consists of fixed strings. 280 * 281 * Apart from fixed strings, Terminal Tokens can also contain variables: 282 * An example would be "show ip bgp A.B.C.D". This command expects an IPv4 283 * as argument. As this is a variable, the IP address entered by the user will 284 * be passed down as an argument. Apart from two exceptions, the other options 285 * for Terminal Tokens behave exactly as we just discussed and only make a 286 * difference for the CLI. The two exceptions will be discussed in the next 287 * paragraphs. 288 * 289 * A Terminal Token can contain a so called option match. This is a simple 290 * string variable that the user may omit. An example would be: 291 * "show interface [IFNAME]". If the user calls this without an interface as 292 * argument, no arguments will be passed down to the function implementing 293 * this command. Otherwise, the interface name will be provided to the function 294 * as a regular argument. 295 296 * Also, a Terminal Token can contain a so called vararg. This is used e.g. in 297 * "show ip bgp regexp .LINE". The last token is a vararg match and will 298 * consume all the arguments the user inputs on the command line and append 299 * those to the list of arguments passed down to the function implementing this 300 * command. (Therefore, it doesn't make much sense to have any tokens after a 301 * vararg because the vararg will already consume all the words the user entered 302 * in the CLI) 303 * 304 * Multiple Tokens: 305 * 306 * The Multiple Token type can be used if there are multiple possibilities what 307 * arguments may be used for a command, but it should map to the same function 308 * nonetheless. An example would be "ip route A.B.C.D/M (reject|blackhole)" 309 * In that case both "reject" and "blackhole" would be acceptable as last 310 * arguments. The words matched by Multiple Tokens are always added to the 311 * argument list, even if they are matched by fixed strings. Such a Multiple 312 * Token can contain almost any type of token that would also be acceptable 313 * for a Terminal Token, the exception are optional variables and varag. 314 * 315 * There is one special case that is used in some places of Quagga that should be 316 * pointed out here shortly. An example would be "password (8|) WORD". This 317 * construct is used to have fixed strings communicated as arguments. (The "8" 318 * will be passed down as an argument in this case) It does not mean that 319 * the "8" is optional. Another historic and possibly surprising property of 320 * this construct is that it consumes two parts of helpstr. (Help 321 * strings will be explained later) 322 * 323 * Keyword Tokens: 324 * 325 * There are commands that take a lot of different and possibly optional arguments. 326 * An example from ospf would be the "default-information originate" command. This 327 * command takes a lot of optional arguments that may be provided in any order. 328 * To accomodate such commands, the Keyword Token has been implemented. 329 * Using the keyword token, the "default-information originate" command and all 330 * its possible options can be represented using this single cmdstr: 331 * "default-information originate \ 332 * {always|metric <0-16777214>|metric-type (1|2)|route-map WORD}" 333 * 334 * Keywords always start with a fixed string and may be followed by arguments. 335 * Except optional variables and vararg, everything is permitted here. 336 * 337 * For the special case of a keyword without arguments, either NULL or the 338 * keyword itself will be pushed as an argument, depending on whether the 339 * keyword is present. 340 * For the other keywords, arguments will be only pushed for 341 * variables/Multiple Tokens. If the keyword is not present, the arguments that 342 * would have been pushed will be substituted by NULL. 343 * 344 * A few examples: 345 * "default information originate metric-type 1 metric 1000" 346 * would yield the following arguments: 347 * { NULL, "1000", "1", NULL } 348 * 349 * "default information originate always route-map RMAP-DEFAULT" 350 * would yield the following arguments: 351 * { "always", NULL, NULL, "RMAP-DEFAULT" } 352 * 353 * helpstr 354 * ======= 355 * 356 * The helpstr is used to show a short explantion for the commands that 357 * are available when the user presses '?' on the CLI. It is the concatenation 358 * of the helpstrings for all the tokens that make up the command. 359 * 360 * There should be one helpstring for each token in the cmdstr except those 361 * containing other tokens, like Multiple or Keyword Tokens. For those, there 362 * will only be the helpstrings of the contained tokens. 363 * 364 * The individual helpstrings are expected to be in the same order as their 365 * respective Tokens appear in the cmdstr. They should each be terminated with 366 * a linefeed. The last helpstring should be terminated with a linefeed as well. 367 * 368 * Care should also be taken to avoid having similar tokens with different 369 * helpstrings. Imagine e.g. the commands "show ip ospf" and "show ip bgp". 370 * they both contain a helpstring for "show", but only one will be displayed 371 * when the user enters "sh?". If those two helpstrings differ, it is not 372 * defined which one will be shown and the behavior is therefore unpredictable. 373 */ 374#define DEFUN(funcname, cmdname, cmdstr, helpstr) \ 375 DEFUN_CMD_FUNC_DECL(funcname) \ 376 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, 0, 0) \ 377 DEFUN_CMD_FUNC_TEXT(funcname) 378 379#define DEFUN_ATTR(funcname, cmdname, cmdstr, helpstr, attr) \ 380 DEFUN_CMD_FUNC_DECL(funcname) \ 381 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, attr, 0) \ 382 DEFUN_CMD_FUNC_TEXT(funcname) 383 384#define DEFUN_HIDDEN(funcname, cmdname, cmdstr, helpstr) \ 385 DEFUN_ATTR (funcname, cmdname, cmdstr, helpstr, CMD_ATTR_HIDDEN) 386 387#define DEFUN_DEPRECATED(funcname, cmdname, cmdstr, helpstr) \ 388 DEFUN_ATTR (funcname, cmdname, cmdstr, helpstr, CMD_ATTR_DEPRECATED) \ 389 390/* DEFUN_NOSH for commands that vtysh should ignore */ 391#define DEFUN_NOSH(funcname, cmdname, cmdstr, helpstr) \ 392 DEFUN(funcname, cmdname, cmdstr, helpstr) 393 394/* DEFSH for vtysh. */ 395#define DEFSH(daemon, cmdname, cmdstr, helpstr) \ 396 DEFUN_CMD_ELEMENT(NULL, cmdname, cmdstr, helpstr, 0, daemon) \ 397 398/* DEFUN + DEFSH */ 399#define DEFUNSH(daemon, funcname, cmdname, cmdstr, helpstr) \ 400 DEFUN_CMD_FUNC_DECL(funcname) \ 401 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, 0, daemon) \ 402 DEFUN_CMD_FUNC_TEXT(funcname) 403 404/* DEFUN + DEFSH with attributes */ 405#define DEFUNSH_ATTR(daemon, funcname, cmdname, cmdstr, helpstr, attr) \ 406 DEFUN_CMD_FUNC_DECL(funcname) \ 407 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, attr, daemon) \ 408 DEFUN_CMD_FUNC_TEXT(funcname) 409 410#define DEFUNSH_HIDDEN(daemon, funcname, cmdname, cmdstr, helpstr) \ 411 DEFUNSH_ATTR (daemon, funcname, cmdname, cmdstr, helpstr, CMD_ATTR_HIDDEN) 412 413#define DEFUNSH_DEPRECATED(daemon, funcname, cmdname, cmdstr, helpstr) \ 414 DEFUNSH_ATTR (daemon, funcname, cmdname, cmdstr, helpstr, CMD_ATTR_DEPRECATED) 415 416/* ALIAS macro which define existing command's alias. */ 417#define ALIAS(funcname, cmdname, cmdstr, helpstr) \ 418 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, 0, 0) 419 420#define ALIAS_ATTR(funcname, cmdname, cmdstr, helpstr, attr) \ 421 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, attr, 0) 422 423#define ALIAS_HIDDEN(funcname, cmdname, cmdstr, helpstr) \ 424 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, CMD_ATTR_HIDDEN, 0) 425 426#define ALIAS_DEPRECATED(funcname, cmdname, cmdstr, helpstr) \ 427 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, CMD_ATTR_DEPRECATED, 0) 428 429#define ALIAS_SH(daemon, funcname, cmdname, cmdstr, helpstr) \ 430 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, 0, daemon) 431 432#define ALIAS_SH_HIDDEN(daemon, funcname, cmdname, cmdstr, helpstr) \ 433 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, CMD_ATTR_HIDDEN, daemon) 434 435#define ALIAS_SH_DEPRECATED(daemon, funcname, cmdname, cmdstr, helpstr) \ 436 DEFUN_CMD_ELEMENT(funcname, cmdname, cmdstr, helpstr, CMD_ATTR_DEPRECATED, daemon) 437 438#endif /* VTYSH_EXTRACT_PL */ 439 440/* Some macroes */ 441#define CMD_OPTION(S) ((S[0]) == '[') 442#define CMD_VARIABLE(S) (((S[0]) >= 'A' && (S[0]) <= 'Z') || ((S[0]) == '<')) 443#define CMD_VARARG(S) ((S[0]) == '.') 444#define CMD_RANGE(S) ((S[0] == '<')) 445 446#define CMD_IPV4(S) ((strcmp ((S), "A.B.C.D") == 0)) 447#define CMD_IPV4_PREFIX(S) ((strcmp ((S), "A.B.C.D/M") == 0)) 448#define CMD_IPV6(S) ((strcmp ((S), "X:X::X:X") == 0)) 449#define CMD_IPV6_PREFIX(S) ((strcmp ((S), "X:X::X:X/M") == 0)) 450 451/* Common descriptions. */ 452#define SHOW_STR "Show running system information\n" 453#define IP_STR "IP information\n" 454#define IPV6_STR "IPv6 information\n" 455#define NO_STR "Negate a command or set its defaults\n" 456#define REDIST_STR "Redistribute information from another routing protocol\n" 457#define CLEAR_STR "Reset functions\n" 458#define RIP_STR "RIP information\n" 459#define BGP_STR "BGP information\n" 460#define OSPF_STR "OSPF information\n" 461#define NEIGHBOR_STR "Specify neighbor router\n" 462#define DEBUG_STR "Debugging functions (see also 'undebug')\n" 463#define UNDEBUG_STR "Disable debugging functions (see also 'debug')\n" 464#define ROUTER_STR "Enable a routing process\n" 465#define AS_STR "AS number\n" 466#define MBGP_STR "MBGP information\n" 467#define MATCH_STR "Match values from routing table\n" 468#define SET_STR "Set values in destination routing protocol\n" 469#define OUT_STR "Filter outgoing routing updates\n" 470#define IN_STR "Filter incoming routing updates\n" 471#define V4NOTATION_STR "specify by IPv4 address notation(e.g. 0.0.0.0)\n" 472#define OSPF6_NUMBER_STR "Specify by number\n" 473#define INTERFACE_STR "Interface infomation\n" 474#define IFNAME_STR "Interface name(e.g. ep0)\n" 475#define IP6_STR "IPv6 Information\n" 476#define OSPF6_STR "Open Shortest Path First (OSPF) for IPv6\n" 477#define OSPF6_ROUTER_STR "Enable a routing process\n" 478#define OSPF6_INSTANCE_STR "<1-65535> Instance ID\n" 479#define SECONDS_STR "<1-65535> Seconds\n" 480#define ROUTE_STR "Routing Table\n" 481#define PREFIX_LIST_STR "Build a prefix list\n" 482#define OSPF6_DUMP_TYPE_LIST \ 483"(neighbor|interface|area|lsa|zebra|config|dbex|spf|route|lsdb|redistribute|hook|asbr|prefix|abr)" 484#define ISIS_STR "IS-IS information\n" 485#define AREA_TAG_STR "[area tag]\n" 486 487#define CONF_BACKUP_EXT ".sav" 488 489/* IPv4 only machine should not accept IPv6 address for peer's IP 490 address. So we replace VTY command string like below. */ 491#ifdef HAVE_IPV6 492#define NEIGHBOR_CMD "neighbor (A.B.C.D|X:X::X:X) " 493#define NO_NEIGHBOR_CMD "no neighbor (A.B.C.D|X:X::X:X) " 494#define NEIGHBOR_ADDR_STR "Neighbor address\nIPv6 address\n" 495#define NEIGHBOR_CMD2 "neighbor (A.B.C.D|X:X::X:X|WORD) " 496#define NO_NEIGHBOR_CMD2 "no neighbor (A.B.C.D|X:X::X:X|WORD) " 497#define NEIGHBOR_ADDR_STR2 "Neighbor address\nNeighbor IPv6 address\nNeighbor tag\n" 498#else 499#define NEIGHBOR_CMD "neighbor A.B.C.D " 500#define NO_NEIGHBOR_CMD "no neighbor A.B.C.D " 501#define NEIGHBOR_ADDR_STR "Neighbor address\n" 502#define NEIGHBOR_CMD2 "neighbor (A.B.C.D|WORD) " 503#define NO_NEIGHBOR_CMD2 "no neighbor (A.B.C.D|WORD) " 504#define NEIGHBOR_ADDR_STR2 "Neighbor address\nNeighbor tag\n" 505#endif /* HAVE_IPV6 */ 506 507/* Prototypes. */ 508extern void install_node (struct cmd_node *, int (*) (struct vty *)); 509extern void install_default (enum node_type); 510extern void install_element (enum node_type, struct cmd_element *); 511 512/* Concatenates argv[shift] through argv[argc-1] into a single NUL-terminated 513 string with a space between each element (allocated using 514 XMALLOC(MTYPE_TMP)). Returns NULL if shift >= argc. */ 515extern char *argv_concat (const char **argv, int argc, int shift); 516 517extern vector cmd_make_strvec (const char *); 518extern void cmd_free_strvec (vector); 519extern vector cmd_describe_command (vector, struct vty *, int *status); 520extern char **cmd_complete_command (vector, struct vty *, int *status); 521extern const char *cmd_prompt (enum node_type); 522extern int config_from_file (struct vty *, FILE *, unsigned int *line_num); 523extern enum node_type node_parent (enum node_type); 524extern int cmd_execute_command (vector, struct vty *, struct cmd_element **, int); 525extern int cmd_execute_command_strict (vector, struct vty *, struct cmd_element **); 526extern void cmd_init (int); 527extern void cmd_terminate (void); 528 529/* Export typical functions. */ 530extern struct cmd_element config_end_cmd; 531extern struct cmd_element config_exit_cmd; 532extern struct cmd_element config_quit_cmd; 533extern struct cmd_element config_help_cmd; 534extern struct cmd_element config_list_cmd; 535extern char *host_config_file (void); 536extern void host_config_set (char *); 537 538extern void print_version (const char *); 539 540/* struct host global, ick */ 541extern struct host host; 542 543/* "<cr>" global */ 544extern char *command_cr; 545#endif /* _ZEBRA_COMMAND_H */ 546