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