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