]> git.proxmox.com Git - mirror_frr.git/blob - vtysh/vtysh.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
*: 6.0.3 release
[mirror_frr.git] / vtysh / vtysh.c
1 /* Virtual terminal interface shell.
2 * Copyright (C) 2000 Kunihiro Ishiguro
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22
23 #include <sys/un.h>
24 #include <setjmp.h>
25 #include <sys/wait.h>
26 #include <sys/resource.h>
27 #include <sys/stat.h>
28
29 #include <readline/readline.h>
30 #include <readline/history.h>
31
32 #include <dirent.h>
33 #include <stdio.h>
34 #include <string.h>
35
36 #include "linklist.h"
37 #include "command.h"
38 #include "memory.h"
39 #include "filter.h"
40 #include "vtysh/vtysh.h"
41 #include "log.h"
42 #include "bgpd/bgp_vty.h"
43 #include "ns.h"
44 #include "vrf.h"
45 #include "libfrr.h"
46 #include "command_graph.h"
47 #include "frrstr.h"
48 #include "json.h"
49
50 DEFINE_MTYPE_STATIC(MVTYSH, VTYSH_CMD, "Vtysh cmd copy")
51
52 /* Struct VTY. */
53 struct vty *vty;
54
55 /* VTY shell pager name. */
56 char *vtysh_pager_name = NULL;
57
58 /* VTY shell client structure */
59 struct vtysh_client {
60 int fd;
61 const char *name;
62 int flag;
63 char path[MAXPATHLEN];
64 struct vtysh_client *next;
65 };
66
67 /* Some utility functions for working on vtysh-specific vty tasks */
68
69 static FILE *vty_open_pager(struct vty *vty)
70 {
71 if (vty->is_paged)
72 return vty->of;
73
74 if (!vtysh_pager_name)
75 return NULL;
76
77 vty->of_saved = vty->of;
78 vty->of = popen(vtysh_pager_name, "w");
79 if (vty->of == NULL) {
80 vty->of = vty->of_saved;
81 perror("popen");
82 exit(1);
83 }
84
85 vty->is_paged = true;
86
87 return vty->of;
88 }
89
90 static int vty_close_pager(struct vty *vty)
91 {
92 if (!vty->is_paged)
93 return 0;
94
95 fflush(vty->of);
96 if (pclose(vty->of) == -1) {
97 perror("pclose");
98 exit(1);
99 }
100
101 vty->of = vty->of_saved;
102 vty->is_paged = false;
103
104 return 0;
105 }
106
107 static void vtysh_pager_envdef(bool fallback)
108 {
109 char *pager_defined;
110
111 pager_defined = getenv("VTYSH_PAGER");
112
113 if (pager_defined)
114 vtysh_pager_name = strdup(pager_defined);
115 else if (fallback)
116 vtysh_pager_name = strdup(VTYSH_PAGER);
117 }
118
119 /* --- */
120
121 struct vtysh_client vtysh_client[] = {
122 {.fd = -1, .name = "zebra", .flag = VTYSH_ZEBRA, .next = NULL},
123 {.fd = -1, .name = "ripd", .flag = VTYSH_RIPD, .next = NULL},
124 {.fd = -1, .name = "ripngd", .flag = VTYSH_RIPNGD, .next = NULL},
125 {.fd = -1, .name = "ospfd", .flag = VTYSH_OSPFD, .next = NULL},
126 {.fd = -1, .name = "ospf6d", .flag = VTYSH_OSPF6D, .next = NULL},
127 {.fd = -1, .name = "ldpd", .flag = VTYSH_LDPD, .next = NULL},
128 {.fd = -1, .name = "bgpd", .flag = VTYSH_BGPD, .next = NULL},
129 {.fd = -1, .name = "isisd", .flag = VTYSH_ISISD, .next = NULL},
130 {.fd = -1, .name = "pimd", .flag = VTYSH_PIMD, .next = NULL},
131 {.fd = -1, .name = "nhrpd", .flag = VTYSH_NHRPD, .next = NULL},
132 {.fd = -1, .name = "eigrpd", .flag = VTYSH_EIGRPD, .next = NULL},
133 {.fd = -1, .name = "babeld", .flag = VTYSH_BABELD, .next = NULL},
134 {.fd = -1, .name = "sharpd", .flag = VTYSH_SHARPD, .next = NULL},
135 {.fd = -1, .name = "watchfrr", .flag = VTYSH_WATCHFRR, .next = NULL},
136 {.fd = -1, .name = "pbrd", .flag = VTYSH_PBRD, .next = NULL},
137 {.fd = -1, .name = "staticd", .flag = VTYSH_STATICD, .next = NULL},
138 {.fd = -1, .name = "bfdd", .flag = VTYSH_BFDD, .next = NULL},
139 };
140
141 enum vtysh_write_integrated vtysh_write_integrated =
142 WRITE_INTEGRATED_UNSPECIFIED;
143
144 static int vtysh_reconnect(struct vtysh_client *vclient);
145
146 static void vclient_close(struct vtysh_client *vclient)
147 {
148 if (vclient->fd >= 0) {
149 vty_out(vty,
150 "Warning: closing connection to %s because of an I/O error!\n",
151 vclient->name);
152 close(vclient->fd);
153 /* indicate as candidate for reconnect */
154 vclient->fd = VTYSH_WAS_ACTIVE;
155 }
156 }
157
158 /*
159 * Send a CLI command to a client and read the response.
160 *
161 * Output will be printed to vty->of. If you want to suppress output, set that
162 * to NULL.
163 *
164 * vclient
165 * the client to send the command to
166 *
167 * line
168 * the command to send
169 *
170 * callback
171 * if non-null, this will be called with each line of output received from
172 * the client passed in the second parameter
173 *
174 * cbarg
175 * optional first argument to pass to callback
176 *
177 * Returns:
178 * a status code
179 */
180 static int vtysh_client_run(struct vtysh_client *vclient, const char *line,
181 void (*callback)(void *, const char *), void *cbarg)
182 {
183 int ret;
184 char stackbuf[4096];
185 char *buf = stackbuf;
186 size_t bufsz = sizeof(stackbuf);
187 char *bufvalid, *end = NULL;
188 char terminator[3] = {0, 0, 0};
189
190 /* vclinet was previously active, try to reconnect */
191 if (vclient->fd == VTYSH_WAS_ACTIVE) {
192 ret = vtysh_reconnect(vclient);
193 if (ret < 0)
194 goto out_err;
195 }
196
197 if (vclient->fd < 0)
198 return CMD_SUCCESS;
199
200 ret = write(vclient->fd, line, strlen(line) + 1);
201 if (ret <= 0) {
202 /* close connection and try to reconnect */
203 vclient_close(vclient);
204 ret = vtysh_reconnect(vclient);
205 if (ret < 0)
206 goto out_err;
207 /* retry line */
208 ret = write(vclient->fd, line, strlen(line) + 1);
209 if (ret <= 0)
210 goto out_err;
211 }
212
213 bufvalid = buf;
214 do {
215 ssize_t nread =
216 read(vclient->fd, bufvalid, buf + bufsz - bufvalid - 1);
217
218 if (nread < 0 && (errno == EINTR || errno == EAGAIN))
219 continue;
220
221 if (nread <= 0) {
222 vty_out(vty, "vtysh: error reading from %s: %s (%d)",
223 vclient->name, safe_strerror(errno), errno);
224 goto out_err;
225 }
226
227 bufvalid += nread;
228
229 /* Null terminate so we may pass this to *printf later. */
230 bufvalid[0] = '\0';
231
232 /*
233 * We expect string output from daemons, so instead of looking
234 * for the full 3 null bytes of the terminator, we check for
235 * just one instead and assume it is the first byte of the
236 * terminator. The presence of the full terminator is checked
237 * later.
238 */
239 if (bufvalid - buf >= 4)
240 end = memmem(bufvalid - 4, 4, "\0", 1);
241
242 /*
243 * calculate # bytes we have, up to & not including the
244 * terminator if present
245 */
246 size_t textlen = (end ? end : bufvalid) - buf;
247 bool b = false;
248
249 /* feed line processing callback if present */
250 while (callback && bufvalid > buf && (end > buf || !end)) {
251 textlen = (end ? end : bufvalid) - buf;
252 char *eol = memchr(buf, '\n', textlen);
253 if (eol)
254 /* line break */
255 *eol++ = '\0';
256 else if (end == buf)
257 /*
258 * no line break, end of input, no text left
259 * before end; nothing to write
260 */
261 b = true;
262 else if (end)
263 /* no nl, end of input, but some text left */
264 eol = end;
265 else if (bufvalid == buf + bufsz - 1) {
266 /*
267 * no nl, no end of input, no buffer space;
268 * realloc
269 */
270 char *new;
271
272 bufsz *= 2;
273 if (buf == stackbuf) {
274 new = XMALLOC(MTYPE_TMP, bufsz);
275 memcpy(new, stackbuf, sizeof(stackbuf));
276 } else
277 new = XREALLOC(MTYPE_TMP, buf, bufsz);
278
279 bufvalid = bufvalid - buf + new;
280 buf = new;
281 /* if end != NULL, we won't be reading more
282 * data... */
283 assert(end == NULL);
284 b = true;
285 } else
286 b = true;
287
288 if (b)
289 break;
290
291 /* eol is at line end now, either \n => \0 or \0\0\0 */
292 assert(eol && eol <= bufvalid);
293
294 if (vty->of)
295 vty_out(vty, "%s\n", buf);
296
297 callback(cbarg, buf);
298
299 /* shift back data and adjust bufvalid */
300 memmove(buf, eol, bufvalid - eol);
301 bufvalid -= eol - buf;
302 if (end)
303 end -= eol - buf;
304 }
305
306 /* else if no callback, dump raw */
307 if (!callback) {
308 if (vty->of)
309 vty_out(vty, "%s", buf);
310 memmove(buf, buf + textlen, bufvalid - buf - textlen);
311 bufvalid -= textlen;
312 if (end)
313 end -= textlen;
314
315 /*
316 * ----------------------------------------------------
317 * At this point `buf` should be in one of two states:
318 * - Empty (i.e. buf == bufvalid)
319 * - Contains up to 4 bytes of the terminator
320 * ----------------------------------------------------
321 */
322 assert(((buf == bufvalid)
323 || (bufvalid - buf <= 4 && buf[0] == 0x00)));
324 }
325
326 /* if we have the terminator, break */
327 if (end && bufvalid - buf == 4) {
328 assert(!memcmp(buf, terminator, 3));
329 ret = buf[3];
330 break;
331 }
332
333 } while (true);
334 goto out;
335
336 out_err:
337 vclient_close(vclient);
338 ret = CMD_SUCCESS;
339 out:
340 if (buf != stackbuf)
341 XFREE(MTYPE_TMP, buf);
342 return ret;
343 }
344
345 static int vtysh_client_run_all(struct vtysh_client *head_client,
346 const char *line, int continue_on_err,
347 void (*callback)(void *, const char *),
348 void *cbarg)
349 {
350 struct vtysh_client *client;
351 int rc, rc_all = CMD_SUCCESS;
352 int correct_instance = 0, wrong_instance = 0;
353
354 for (client = head_client; client; client = client->next) {
355 rc = vtysh_client_run(client, line, callback, cbarg);
356 if (rc == CMD_NOT_MY_INSTANCE) {
357 wrong_instance++;
358 continue;
359 }
360 if (client->fd > 0)
361 correct_instance++;
362 if (rc != CMD_SUCCESS) {
363 if (!continue_on_err)
364 return rc;
365 rc_all = rc;
366 }
367 }
368 if (wrong_instance && !correct_instance) {
369 vty_out(vty,
370 "%% [%s]: command ignored as it targets an instance that is not running\n",
371 head_client->name);
372 rc_all = CMD_WARNING_CONFIG_FAILED;
373 }
374 return rc_all;
375 }
376
377 /*
378 * Execute command against all daemons.
379 *
380 * head_client
381 * where to start walking in the daemon list
382 *
383 * line
384 * the specific command to execute
385 *
386 * Returns:
387 * a status code
388 */
389 static int vtysh_client_execute(struct vtysh_client *head_client,
390 const char *line)
391 {
392 return vtysh_client_run_all(head_client, line, 0, NULL, NULL);
393 }
394
395 /*
396 * Retrieve all running config from daemons and parse it with the vtysh config
397 * parser. Returned output is not displayed to the user.
398 *
399 * head_client
400 * where to start walking in the daemon list
401 *
402 * line
403 * the specific command to execute
404 */
405 static void vtysh_client_config(struct vtysh_client *head_client, char *line)
406 {
407 /* watchfrr currently doesn't load any config, and has some hardcoded
408 * settings that show up in "show run". skip it here (for now at
409 * least) so we don't get that mangled up in config-write.
410 */
411 if (head_client->flag == VTYSH_WATCHFRR)
412 return;
413
414 /* suppress output to user */
415 vty->of_saved = vty->of;
416 vty->of = NULL;
417 vtysh_client_run_all(head_client, line, 1, vtysh_config_parse_line,
418 NULL);
419 vty->of = vty->of_saved;
420 }
421
422 /* Command execution over the vty interface. */
423 static int vtysh_execute_func(const char *line, int pager)
424 {
425 int ret, cmd_stat;
426 unsigned int i;
427 vector vline;
428 const struct cmd_element *cmd;
429 int tried = 0;
430 int saved_ret, saved_node;
431
432 /* Split readline string up into the vector. */
433 vline = cmd_make_strvec(line);
434
435 if (vline == NULL)
436 return CMD_SUCCESS;
437
438 if (user_mode) {
439 if (strncmp("en", vector_slot(vline, 0), 2) == 0) {
440 cmd_free_strvec(vline);
441 vty_out(vty, "%% Command not allowed: enable\n");
442 return CMD_WARNING;
443 }
444 }
445
446 saved_ret = ret = cmd_execute(vty, line, &cmd, 1);
447 saved_node = vty->node;
448
449 /*
450 * If command doesn't succeeded in current node, try to walk up in node
451 * tree. Changing vty->node is enough to try it just out without actual
452 * walkup in the vtysh.
453 */
454 while (ret != CMD_SUCCESS && ret != CMD_SUCCESS_DAEMON
455 && ret != CMD_WARNING && ret != CMD_WARNING_CONFIG_FAILED
456 && vty->node > CONFIG_NODE) {
457 vty->node = node_parent(vty->node);
458 ret = cmd_execute(vty, line, &cmd, 1);
459 tried++;
460 }
461
462 vty->node = saved_node;
463
464 /*
465 * If command succeeded in any other node than current (tried > 0) we
466 * have to move into node in the vtysh where it succeeded.
467 */
468 if (ret == CMD_SUCCESS || ret == CMD_SUCCESS_DAEMON
469 || ret == CMD_WARNING) {
470 if ((saved_node == BGP_VPNV4_NODE
471 || saved_node == BGP_VPNV6_NODE
472 || saved_node == BGP_IPV4_NODE
473 || saved_node == BGP_IPV6_NODE
474 || saved_node == BGP_FLOWSPECV4_NODE
475 || saved_node == BGP_FLOWSPECV6_NODE
476 || saved_node == BGP_IPV4M_NODE
477 || saved_node == BGP_IPV4L_NODE
478 || saved_node == BGP_IPV6L_NODE
479 || saved_node == BGP_IPV6M_NODE
480 || saved_node == BGP_EVPN_NODE
481 || saved_node == LDP_IPV4_NODE
482 || saved_node == LDP_IPV6_NODE)
483 && (tried == 1)) {
484 vtysh_execute("exit-address-family");
485 } else if ((saved_node == BGP_EVPN_VNI_NODE) && (tried == 1)) {
486 vtysh_execute("exit-vni");
487 } else if (saved_node == BGP_VRF_POLICY_NODE && (tried == 1)) {
488 vtysh_execute("exit-vrf-policy");
489 } else if ((saved_node == BGP_VNC_DEFAULTS_NODE
490 || saved_node == BGP_VNC_NVE_GROUP_NODE
491 || saved_node == BGP_VNC_L2_GROUP_NODE)
492 && (tried == 1)) {
493 vtysh_execute("exit-vnc");
494 } else if (saved_node == VRF_NODE && (tried == 1)) {
495 vtysh_execute("exit-vrf");
496 } else if ((saved_node == KEYCHAIN_KEY_NODE
497 || saved_node == LDP_PSEUDOWIRE_NODE
498 || saved_node == LDP_IPV4_IFACE_NODE
499 || saved_node == LDP_IPV6_IFACE_NODE)
500 && (tried == 1)) {
501 vtysh_execute("exit");
502 } else if (tried) {
503 vtysh_execute("end");
504 vtysh_execute("configure terminal");
505 }
506 }
507 /*
508 * If command didn't succeed in any node, continue with return value
509 * from first try.
510 */
511 else if (tried) {
512 ret = saved_ret;
513 }
514
515 cmd_free_strvec(vline);
516
517 cmd_stat = ret;
518 switch (ret) {
519 case CMD_WARNING:
520 case CMD_WARNING_CONFIG_FAILED:
521 if (vty->type == VTY_FILE)
522 vty_out(vty, "Warning...\n");
523 break;
524 case CMD_ERR_AMBIGUOUS:
525 vty_out(vty, "%% Ambiguous command: %s\n", line);
526 break;
527 case CMD_ERR_NO_MATCH:
528 vty_out(vty, "%% Unknown command: %s\n", line);
529 break;
530 case CMD_ERR_INCOMPLETE:
531 vty_out(vty, "%% Command incomplete: %s\n", line);
532 break;
533 case CMD_SUCCESS_DAEMON: {
534 /*
535 * FIXME: Don't open pager for exit commands. popen() causes
536 * problems if exited from vtysh at all. This hack shouldn't
537 * cause any problem but is really ugly.
538 */
539 if (pager && strncmp(line, "exit", 4))
540 vty_open_pager(vty);
541
542 if (!strcmp(cmd->string, "configure terminal")) {
543 for (i = 0; i < array_size(vtysh_client); i++) {
544 cmd_stat = vtysh_client_execute(
545 &vtysh_client[i], line);
546 if (cmd_stat == CMD_WARNING)
547 break;
548 }
549
550 if (cmd_stat) {
551 line = "end";
552 vline = cmd_make_strvec(line);
553
554
555 if (vline == NULL) {
556 if (vty->is_paged)
557 vty_close_pager(vty);
558 return CMD_SUCCESS;
559 }
560
561 ret = cmd_execute_command(vline, vty, &cmd, 1);
562 cmd_free_strvec(vline);
563 if (ret != CMD_SUCCESS_DAEMON)
564 break;
565 } else if (cmd->func) {
566 (*cmd->func)(cmd, vty, 0, NULL);
567 break;
568 }
569 }
570
571 cmd_stat = CMD_SUCCESS;
572 struct vtysh_client *vc;
573 for (i = 0; i < array_size(vtysh_client); i++) {
574 if (cmd->daemon & vtysh_client[i].flag) {
575 if (vtysh_client[i].fd < 0
576 && (cmd->daemon == vtysh_client[i].flag)) {
577 for (vc = &vtysh_client[i]; vc;
578 vc = vc->next)
579 if (vc->fd == VTYSH_WAS_ACTIVE)
580 vtysh_reconnect(vc);
581 }
582 if (vtysh_client[i].fd < 0
583 && (cmd->daemon == vtysh_client[i].flag)) {
584 bool any_inst = false;
585 for (vc = &vtysh_client[i]; vc;
586 vc = vc->next)
587 any_inst = any_inst
588 || (vc->fd > 0);
589 if (!any_inst) {
590 fprintf(stderr,
591 "%s is not running\n",
592 vtysh_client[i].name);
593 continue;
594 }
595 }
596 cmd_stat = vtysh_client_execute(
597 &vtysh_client[i], line);
598 if (cmd_stat != CMD_SUCCESS)
599 break;
600 }
601 }
602 if (cmd_stat != CMD_SUCCESS)
603 break;
604
605 if (cmd->func)
606 (*cmd->func)(cmd, vty, 0, NULL);
607 }
608 }
609 if (vty->is_paged)
610 vty_close_pager(vty);
611
612 return cmd_stat;
613 }
614
615 int vtysh_execute_no_pager(const char *line)
616 {
617 return vtysh_execute_func(line, 0);
618 }
619
620 int vtysh_execute(const char *line)
621 {
622 return vtysh_execute_func(line, 1);
623 }
624
625 static char *trim(char *s)
626 {
627 size_t size;
628 char *end;
629
630 size = strlen(s);
631
632 if (!size)
633 return s;
634
635 end = s + size - 1;
636 while (end >= s && isspace((int)*end))
637 end--;
638 *(end + 1) = '\0';
639
640 while (*s && isspace((int)*s))
641 s++;
642
643 return s;
644 }
645
646 int vtysh_mark_file(const char *filename)
647 {
648 struct vty *vty;
649 FILE *confp = NULL;
650 int ret;
651 vector vline;
652 int tried = 0;
653 const struct cmd_element *cmd;
654 int saved_ret, prev_node;
655 int lineno = 0;
656 char *vty_buf_copy = NULL;
657 char *vty_buf_trimmed = NULL;
658
659 if (strncmp("-", filename, 1) == 0)
660 confp = stdin;
661 else
662 confp = fopen(filename, "r");
663
664 if (confp == NULL) {
665 fprintf(stderr, "%% Can't open config file %s due to '%s'.\n",
666 filename, safe_strerror(errno));
667 return (CMD_ERR_NO_FILE);
668 }
669
670 vty = vty_new();
671 vty->wfd = STDERR_FILENO;
672 vty->type = VTY_TERM;
673 vty->node = CONFIG_NODE;
674
675 vtysh_execute_no_pager("enable");
676 vtysh_execute_no_pager("configure terminal");
677 vty_buf_copy = XCALLOC(MTYPE_VTYSH_CMD, VTY_BUFSIZ);
678
679 while (fgets(vty->buf, VTY_BUFSIZ, confp)) {
680 lineno++;
681 tried = 0;
682 strcpy(vty_buf_copy, vty->buf);
683 vty_buf_trimmed = trim(vty_buf_copy);
684
685 switch (vty->node) {
686 case LDP_IPV4_IFACE_NODE:
687 if (strncmp(vty_buf_copy, " ", 3)) {
688 vty_out(vty, " end\n");
689 vty->node = LDP_IPV4_NODE;
690 }
691 break;
692 case LDP_IPV6_IFACE_NODE:
693 if (strncmp(vty_buf_copy, " ", 3)) {
694 vty_out(vty, " end\n");
695 vty->node = LDP_IPV6_NODE;
696 }
697 break;
698 case LDP_PSEUDOWIRE_NODE:
699 if (strncmp(vty_buf_copy, " ", 2)) {
700 vty_out(vty, " end\n");
701 vty->node = LDP_L2VPN_NODE;
702 }
703 break;
704 default:
705 break;
706 }
707
708 if (vty_buf_trimmed[0] == '!' || vty_buf_trimmed[0] == '#') {
709 vty_out(vty, "%s", vty->buf);
710 continue;
711 }
712
713 /* Split readline string up into the vector. */
714 vline = cmd_make_strvec(vty->buf);
715
716 if (vline == NULL) {
717 vty_out(vty, "%s", vty->buf);
718 continue;
719 }
720
721 /*
722 * Ignore the "end" lines, we will generate these where
723 * appropriate
724 */
725 if (strlen(vty_buf_trimmed) == 3
726 && strncmp("end", vty_buf_trimmed, 3) == 0) {
727 cmd_free_strvec(vline);
728 continue;
729 }
730
731 prev_node = vty->node;
732 saved_ret = ret = cmd_execute_command_strict(vline, vty, &cmd);
733
734 /*
735 * If command doesn't succeeded in current node, try to walk up
736 * in node tree. Changing vty->node is enough to try it just
737 * out without actual walkup in the vtysh.
738 */
739 while (ret != CMD_SUCCESS && ret != CMD_SUCCESS_DAEMON
740 && ret != CMD_WARNING && ret != CMD_WARNING_CONFIG_FAILED
741 && vty->node > CONFIG_NODE) {
742 vty->node = node_parent(vty->node);
743 ret = cmd_execute_command_strict(vline, vty, &cmd);
744 tried++;
745 }
746
747 /*
748 * If command succeeded in any other node than current (tried >
749 * 0) we have to move into node in the vtysh where it
750 * succeeded.
751 */
752 if (ret == CMD_SUCCESS || ret == CMD_SUCCESS_DAEMON
753 || ret == CMD_WARNING) {
754 if ((prev_node == BGP_VPNV4_NODE
755 || prev_node == BGP_VPNV6_NODE
756 || prev_node == BGP_IPV4_NODE
757 || prev_node == BGP_IPV6_NODE
758 || prev_node == BGP_FLOWSPECV4_NODE
759 || prev_node == BGP_FLOWSPECV6_NODE
760 || prev_node == BGP_IPV4L_NODE
761 || prev_node == BGP_IPV6L_NODE
762 || prev_node == BGP_IPV4M_NODE
763 || prev_node == BGP_IPV6M_NODE
764 || prev_node == BGP_EVPN_NODE)
765 && (tried == 1)) {
766 vty_out(vty, "exit-address-family\n");
767 } else if ((prev_node == BGP_EVPN_VNI_NODE)
768 && (tried == 1)) {
769 vty_out(vty, "exit-vni\n");
770 } else if ((prev_node == KEYCHAIN_KEY_NODE)
771 && (tried == 1)) {
772 vty_out(vty, "exit\n");
773 } else if (tried) {
774 vty_out(vty, "end\n");
775 }
776 }
777 /*
778 * If command didn't succeed in any node, continue with return
779 * value from first try.
780 */
781 else if (tried) {
782 ret = saved_ret;
783 vty->node = prev_node;
784 }
785
786 cmd_free_strvec(vline);
787 switch (ret) {
788 case CMD_WARNING:
789 case CMD_WARNING_CONFIG_FAILED:
790 if (vty->type == VTY_FILE)
791 fprintf(stderr, "line %d: Warning...: %s\n",
792 lineno, vty->buf);
793 fclose(confp);
794 vty_close(vty);
795 XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
796 return ret;
797 case CMD_ERR_AMBIGUOUS:
798 fprintf(stderr, "line %d: %% Ambiguous command: %s\n",
799 lineno, vty->buf);
800 fclose(confp);
801 vty_close(vty);
802 XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
803 return CMD_ERR_AMBIGUOUS;
804 case CMD_ERR_NO_MATCH:
805 fprintf(stderr, "line %d: %% Unknown command: %s\n",
806 lineno, vty->buf);
807 fclose(confp);
808 vty_close(vty);
809 XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
810 return CMD_ERR_NO_MATCH;
811 case CMD_ERR_INCOMPLETE:
812 fprintf(stderr, "line %d: %% Command incomplete: %s\n",
813 lineno, vty->buf);
814 fclose(confp);
815 vty_close(vty);
816 XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
817 return CMD_ERR_INCOMPLETE;
818 case CMD_SUCCESS:
819 vty_out(vty, "%s", vty->buf);
820 break;
821 case CMD_SUCCESS_DAEMON: {
822 int cmd_stat;
823
824 vty_out(vty, "%s", vty->buf);
825 cmd_stat = vtysh_client_execute(&vtysh_client[0],
826 vty->buf);
827 if (cmd_stat != CMD_SUCCESS)
828 break;
829
830 if (cmd->func)
831 (*cmd->func)(cmd, vty, 0, NULL);
832 }
833 }
834 }
835 /* This is the end */
836 vty_out(vty, "\nend\n");
837 vty_close(vty);
838 XFREE(MTYPE_VTYSH_CMD, vty_buf_copy);
839
840 if (confp != stdin)
841 fclose(confp);
842
843 return (0);
844 }
845
846 /* Configration make from file. */
847 int vtysh_config_from_file(struct vty *vty, FILE *fp)
848 {
849 int ret;
850 const struct cmd_element *cmd;
851 int lineno = 0;
852 /* once we have an error, we remember & return that */
853 int retcode = CMD_SUCCESS;
854
855 while (fgets(vty->buf, VTY_BUFSIZ, fp)) {
856 lineno++;
857
858 ret = command_config_read_one_line(vty, &cmd, 1);
859
860 switch (ret) {
861 case CMD_WARNING:
862 case CMD_WARNING_CONFIG_FAILED:
863 if (vty->type == VTY_FILE)
864 fprintf(stderr, "line %d: Warning[%d]...: %s\n",
865 lineno, vty->node, vty->buf);
866 retcode = ret;
867
868 break;
869 case CMD_ERR_AMBIGUOUS:
870 fprintf(stderr,
871 "line %d: %% Ambiguous command[%d]: %s\n",
872 lineno, vty->node, vty->buf);
873 retcode = CMD_ERR_AMBIGUOUS;
874 break;
875 case CMD_ERR_NO_MATCH:
876 fprintf(stderr, "line %d: %% Unknown command[%d]: %s",
877 lineno, vty->node, vty->buf);
878 retcode = CMD_ERR_NO_MATCH;
879 break;
880 case CMD_ERR_INCOMPLETE:
881 fprintf(stderr,
882 "line %d: %% Command incomplete[%d]: %s\n",
883 lineno, vty->node, vty->buf);
884 retcode = CMD_ERR_INCOMPLETE;
885 break;
886 case CMD_SUCCESS_DAEMON: {
887 unsigned int i;
888 int cmd_stat = CMD_SUCCESS;
889
890 for (i = 0; i < array_size(vtysh_client); i++) {
891 if (cmd->daemon & vtysh_client[i].flag) {
892 cmd_stat = vtysh_client_execute(
893 &vtysh_client[i], vty->buf);
894 /*
895 * CMD_WARNING - Can mean that the
896 * command was parsed successfully but
897 * it was already entered in a few
898 * spots. As such if we receive a
899 * CMD_WARNING from a daemon we
900 * shouldn't stop talking to the other
901 * daemons for the particular command.
902 */
903 if (cmd_stat != CMD_SUCCESS
904 && cmd_stat != CMD_WARNING) {
905 fprintf(stderr,
906 "line %d: Failure to communicate[%d] to %s, line: %s\n",
907 lineno, cmd_stat,
908 vtysh_client[i].name,
909 vty->buf);
910 retcode = cmd_stat;
911 break;
912 }
913 }
914 }
915 if (cmd_stat != CMD_SUCCESS)
916 break;
917
918 if (cmd->func)
919 (*cmd->func)(cmd, vty, 0, NULL);
920 }
921 }
922 }
923
924 return (retcode);
925 }
926
927 /*
928 * Function processes cli commands terminated with '?' character when entered
929 * through either 'vtysh' or 'vtysh -c' interfaces.
930 */
931 static int vtysh_process_questionmark(const char *input, int input_len)
932 {
933 int ret, width = 0;
934 unsigned int i;
935 vector vline, describe;
936 struct cmd_token *token;
937
938 if (!input)
939 return 1;
940
941 vline = cmd_make_strvec(input);
942
943 /* In case of '> ?'. */
944 if (vline == NULL) {
945 vline = vector_init(1);
946 vector_set(vline, NULL);
947 } else if (input_len && isspace((int)input[input_len - 1]))
948 vector_set(vline, NULL);
949
950 describe = cmd_describe_command(vline, vty, &ret);
951
952 /* Ambiguous and no match error. */
953 switch (ret) {
954 case CMD_ERR_AMBIGUOUS:
955 cmd_free_strvec(vline);
956 vector_free(describe);
957 vty_out(vty, "%% Ambiguous command.\n");
958 rl_on_new_line();
959 return 0;
960 break;
961 case CMD_ERR_NO_MATCH:
962 cmd_free_strvec(vline);
963 if (describe)
964 vector_free(describe);
965 vty_out(vty, "%% There is no matched command.\n");
966 rl_on_new_line();
967 return 0;
968 break;
969 }
970
971 /* Get width of command string. */
972 width = 0;
973 for (i = 0; i < vector_active(describe); i++)
974 if ((token = vector_slot(describe, i)) != NULL) {
975 if (token->text[0] == '\0')
976 continue;
977
978 int len = strlen(token->text);
979
980 if (width < len)
981 width = len;
982 }
983
984 for (i = 0; i < vector_active(describe); i++)
985 if ((token = vector_slot(describe, i)) != NULL) {
986 if (!token->desc)
987 vty_out(vty, " %-s\n", token->text);
988 else
989 vty_out(vty, " %-*s %s\n", width, token->text,
990 token->desc);
991
992 if (IS_VARYING_TOKEN(token->type)) {
993 const char *ref = vector_slot(
994 vline, vector_active(vline) - 1);
995
996 vector varcomps = vector_init(VECTOR_MIN_SIZE);
997 cmd_variable_complete(token, ref, varcomps);
998
999 if (vector_active(varcomps) > 0) {
1000 int rows, cols;
1001 rl_get_screen_size(&rows, &cols);
1002
1003 char *ac = cmd_variable_comp2str(
1004 varcomps, cols);
1005 vty_out(vty, "%s\n", ac);
1006 XFREE(MTYPE_TMP, ac);
1007 }
1008
1009 vector_free(varcomps);
1010 }
1011 }
1012
1013 cmd_free_strvec(vline);
1014 vector_free(describe);
1015
1016 return 0;
1017 }
1018
1019 /*
1020 * Entry point for user commands terminated with '?' character and typed through
1021 * the usual vtysh's stdin interface. This is the function being registered with
1022 * readline() api's.
1023 */
1024 static int vtysh_rl_describe(int a, int b)
1025 {
1026 int ret;
1027
1028 vty_out(vty, "\n");
1029
1030 ret = vtysh_process_questionmark(rl_line_buffer, rl_end);
1031 rl_on_new_line();
1032
1033 return ret;
1034 }
1035
1036 /*
1037 * Function in charged of processing vtysh instructions terminating with '?'
1038 * character and received through the 'vtysh -c' interface. If user's
1039 * instruction is well-formatted, we will call the same processing routine
1040 * utilized by the traditional vtysh's stdin interface.
1041 */
1042 int vtysh_execute_command_questionmark(char *input)
1043 {
1044 int input_len, qmark_count = 0;
1045 const char *str;
1046
1047 if (!(input && *input))
1048 return 1;
1049
1050 /* Finding out question_mark count and strlen */
1051 for (str = input; *str; ++str) {
1052 if (*str == '?')
1053 qmark_count++;
1054 }
1055 input_len = str - input;
1056
1057 /*
1058 * Verify that user's input terminates in '?' and that patterns such as
1059 * 'cmd ? subcmd ?' are prevented.
1060 */
1061 if (qmark_count != 1 || input[input_len - 1] != '?')
1062 return 1;
1063
1064 /*
1065 * Questionmark-processing function is not expecting to receive '?'
1066 * character in input string.
1067 */
1068 input[input_len - 1] = '\0';
1069
1070 return vtysh_process_questionmark(input, input_len - 1);
1071 }
1072
1073 /* Result of cmd_complete_command() call will be stored here
1074 * and used in new_completion() in order to put the space in
1075 * correct places only. */
1076 int complete_status;
1077
1078 static char *command_generator(const char *text, int state)
1079 {
1080 vector vline;
1081 static char **matched = NULL;
1082 static int index = 0;
1083
1084 /* First call. */
1085 if (!state) {
1086 index = 0;
1087
1088 if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
1089 return NULL;
1090
1091 vline = cmd_make_strvec(rl_line_buffer);
1092 if (vline == NULL)
1093 return NULL;
1094
1095 if (rl_end && isspace((int)rl_line_buffer[rl_end - 1]))
1096 vector_set(vline, NULL);
1097
1098 matched = cmd_complete_command(vline, vty, &complete_status);
1099 cmd_free_strvec(vline);
1100 }
1101
1102 if (matched && matched[index])
1103 /*
1104 * this is free()'d by readline, but we leak 1 count of
1105 * MTYPE_COMPLETION
1106 */
1107 return matched[index++];
1108
1109 XFREE(MTYPE_TMP, matched);
1110 matched = NULL;
1111
1112 return NULL;
1113 }
1114
1115 static char **new_completion(char *text, int start, int end)
1116 {
1117 char **matches;
1118
1119 matches = rl_completion_matches(text, command_generator);
1120
1121 if (matches) {
1122 rl_point = rl_end;
1123 if (complete_status != CMD_COMPLETE_FULL_MATCH)
1124 /* only append a space on full match */
1125 rl_completion_append_character = '\0';
1126 }
1127
1128 return matches;
1129 }
1130
1131 /* Vty node structures. */
1132 static struct cmd_node bgp_node = {
1133 BGP_NODE, "%s(config-router)# ",
1134 };
1135
1136 static struct cmd_node rip_node = {
1137 RIP_NODE, "%s(config-router)# ",
1138 };
1139
1140 static struct cmd_node isis_node = {
1141 ISIS_NODE, "%s(config-router)# ",
1142 };
1143
1144 static struct cmd_node interface_node = {
1145 INTERFACE_NODE, "%s(config-if)# ",
1146 };
1147
1148 static struct cmd_node pw_node = {
1149 PW_NODE, "%s(config-pw)# ",
1150 };
1151
1152 static struct cmd_node logicalrouter_node = {
1153 LOGICALROUTER_NODE, "%s(config-logical-router)# ",
1154 };
1155
1156 static struct cmd_node vrf_node = {
1157 VRF_NODE, "%s(config-vrf)# ",
1158 };
1159
1160 static struct cmd_node nh_group_node = {
1161 NH_GROUP_NODE,
1162 "%s(config-nh-group)# ",
1163 };
1164
1165 static struct cmd_node rmap_node = {RMAP_NODE, "%s(config-route-map)# "};
1166
1167 static struct cmd_node pbr_map_node = {PBRMAP_NODE, "%s(config-pbr-map)# "};
1168
1169 static struct cmd_node zebra_node = {ZEBRA_NODE, "%s(config-router)# "};
1170
1171 static struct cmd_node bgp_vpnv4_node = {BGP_VPNV4_NODE,
1172 "%s(config-router-af)# "};
1173
1174 static struct cmd_node bgp_vpnv6_node = {BGP_VPNV6_NODE,
1175 "%s(config-router-af)# "};
1176
1177 static struct cmd_node bgp_flowspecv4_node = {BGP_FLOWSPECV4_NODE,
1178 "%s(config-router-af)# "};
1179
1180 static struct cmd_node bgp_flowspecv6_node = {BGP_FLOWSPECV6_NODE,
1181 "%s(config-router-af)# "};
1182
1183 static struct cmd_node bgp_ipv4_node = {BGP_IPV4_NODE,
1184 "%s(config-router-af)# "};
1185
1186 static struct cmd_node bgp_ipv4m_node = {BGP_IPV4M_NODE,
1187 "%s(config-router-af)# "};
1188
1189 static struct cmd_node bgp_ipv4l_node = {BGP_IPV4L_NODE,
1190 "%s(config-router-af)# "};
1191
1192 static struct cmd_node bgp_ipv6_node = {BGP_IPV6_NODE,
1193 "%s(config-router-af)# "};
1194
1195 static struct cmd_node bgp_ipv6m_node = {BGP_IPV6M_NODE,
1196 "%s(config-router-af)# "};
1197
1198 static struct cmd_node bgp_evpn_node = {BGP_EVPN_NODE,
1199 "%s(config-router-af)# "};
1200
1201 static struct cmd_node bgp_evpn_vni_node = {BGP_EVPN_VNI_NODE,
1202 "%s(config-router-af-vni)# "};
1203
1204 static struct cmd_node bgp_ipv6l_node = {BGP_IPV6L_NODE,
1205 "%s(config-router-af)# "};
1206
1207 static struct cmd_node bgp_vnc_defaults_node = {
1208 BGP_VNC_DEFAULTS_NODE, "%s(config-router-vnc-defaults)# "};
1209
1210 static struct cmd_node bgp_vnc_nve_group_node = {
1211 BGP_VNC_NVE_GROUP_NODE, "%s(config-router-vnc-nve-group)# "};
1212
1213 static struct cmd_node bgp_vrf_policy_node = {BGP_VRF_POLICY_NODE,
1214 "%s(config-router-vrf-policy)# "};
1215
1216 static struct cmd_node bgp_vnc_l2_group_node = {
1217 BGP_VNC_L2_GROUP_NODE, "%s(config-router-vnc-l2-group)# "};
1218
1219 static struct cmd_node ospf_node = {OSPF_NODE, "%s(config-router)# "};
1220
1221 static struct cmd_node eigrp_node = {EIGRP_NODE, "%s(config-router)# "};
1222
1223 static struct cmd_node babel_node = {BABEL_NODE, "%s(config-router)# "};
1224
1225 static struct cmd_node ripng_node = {RIPNG_NODE, "%s(config-router)# "};
1226
1227 static struct cmd_node ospf6_node = {OSPF6_NODE, "%s(config-ospf6)# "};
1228
1229 static struct cmd_node ldp_node = {LDP_NODE, "%s(config-ldp)# "};
1230
1231 static struct cmd_node ldp_ipv4_node = {LDP_IPV4_NODE, "%s(config-ldp-af)# "};
1232
1233 static struct cmd_node ldp_ipv6_node = {LDP_IPV6_NODE, "%s(config-ldp-af)# "};
1234
1235 static struct cmd_node ldp_ipv4_iface_node = {LDP_IPV4_IFACE_NODE,
1236 "%s(config-ldp-af-if)# "};
1237
1238 static struct cmd_node ldp_ipv6_iface_node = {LDP_IPV6_IFACE_NODE,
1239 "%s(config-ldp-af-if)# "};
1240
1241 static struct cmd_node ldp_l2vpn_node = {LDP_L2VPN_NODE, "%s(config-l2vpn)# "};
1242
1243 static struct cmd_node ldp_pseudowire_node = {LDP_PSEUDOWIRE_NODE,
1244 "%s(config-l2vpn-pw)# "};
1245
1246 static struct cmd_node keychain_node = {KEYCHAIN_NODE, "%s(config-keychain)# "};
1247
1248 static struct cmd_node keychain_key_node = {KEYCHAIN_KEY_NODE,
1249 "%s(config-keychain-key)# "};
1250
1251 struct cmd_node link_params_node = {
1252 LINK_PARAMS_NODE, "%s(config-link-params)# ",
1253 };
1254
1255 static struct cmd_node rpki_node = {RPKI_NODE, "%s(config-rpki)# ", 1};
1256
1257 #if HAVE_BFDD > 0
1258 static struct cmd_node bfd_node = {
1259 BFD_NODE,
1260 "%s(config-bfd)# ",
1261 };
1262
1263 static struct cmd_node bfd_peer_node = {
1264 BFD_PEER_NODE,
1265 "%s(config-bfd-peer)# ",
1266 };
1267 #endif /* HAVE_BFDD */
1268
1269 /* Defined in lib/vty.c */
1270 extern struct cmd_node vty_node;
1271
1272 /* When '^Z' is received from vty, move down to the enable mode. */
1273 static int vtysh_end(void)
1274 {
1275 switch (vty->node) {
1276 case VIEW_NODE:
1277 case ENABLE_NODE:
1278 /* Nothing to do. */
1279 break;
1280 default:
1281 vty->node = ENABLE_NODE;
1282 break;
1283 }
1284 return CMD_SUCCESS;
1285 }
1286
1287 DEFUNSH(VTYSH_REALLYALL, vtysh_end_all, vtysh_end_all_cmd, "end",
1288 "End current mode and change to enable mode\n")
1289 {
1290 return vtysh_end();
1291 }
1292
1293 DEFUNSH(VTYSH_BGPD, router_bgp, router_bgp_cmd,
1294 "router bgp [(1-4294967295) [<view|vrf> WORD]]",
1295 ROUTER_STR BGP_STR AS_STR
1296 "BGP view\nBGP VRF\n"
1297 "View/VRF name\n")
1298 {
1299 vty->node = BGP_NODE;
1300 return CMD_SUCCESS;
1301 }
1302
1303 DEFUNSH(VTYSH_BGPD, address_family_vpnv4, address_family_vpnv4_cmd,
1304 "address-family vpnv4 [unicast]",
1305 "Enter Address Family command mode\n"
1306 "Address Family\n"
1307 "Address Family modifier\n")
1308 {
1309 vty->node = BGP_VPNV4_NODE;
1310 return CMD_SUCCESS;
1311 }
1312
1313 DEFUNSH(VTYSH_BGPD, address_family_vpnv6, address_family_vpnv6_cmd,
1314 "address-family vpnv6 [unicast]",
1315 "Enter Address Family command mode\n"
1316 "Address Family\n"
1317 "Address Family modifier\n")
1318 {
1319 vty->node = BGP_VPNV6_NODE;
1320 return CMD_SUCCESS;
1321 }
1322
1323 DEFUNSH(VTYSH_BGPD, address_family_ipv4, address_family_ipv4_cmd,
1324 "address-family ipv4 [unicast]",
1325 "Enter Address Family command mode\n"
1326 "Address Family\n"
1327 "Address Family Modifier\n")
1328 {
1329 vty->node = BGP_IPV4_NODE;
1330 return CMD_SUCCESS;
1331 }
1332
1333 DEFUNSH(VTYSH_BGPD, address_family_flowspecv4, address_family_flowspecv4_cmd,
1334 "address-family ipv4 flowspec",
1335 "Enter Address Family command mode\n"
1336 "Address Family\n"
1337 "Address Family Modifier\n")
1338 {
1339 vty->node = BGP_FLOWSPECV4_NODE;
1340 return CMD_SUCCESS;
1341 }
1342
1343 DEFUNSH(VTYSH_BGPD, address_family_flowspecv6, address_family_flowspecv6_cmd,
1344 "address-family ipv6 flowspec",
1345 "Enter Address Family command mode\n"
1346 "Address Family\n"
1347 "Address Family Modifier\n")
1348 {
1349 vty->node = BGP_FLOWSPECV6_NODE;
1350 return CMD_SUCCESS;
1351 }
1352
1353 DEFUNSH(VTYSH_BGPD, address_family_ipv4_multicast,
1354 address_family_ipv4_multicast_cmd, "address-family ipv4 multicast",
1355 "Enter Address Family command mode\n"
1356 "Address Family\n"
1357 "Address Family modifier\n")
1358 {
1359 vty->node = BGP_IPV4M_NODE;
1360 return CMD_SUCCESS;
1361 }
1362
1363 DEFUNSH(VTYSH_BGPD, address_family_ipv4_vpn, address_family_ipv4_vpn_cmd,
1364 "address-family ipv4 vpn",
1365 "Enter Address Family command mode\n"
1366 "Address Family\n"
1367 "Address Family modifier\n")
1368 {
1369 vty->node = BGP_VPNV4_NODE;
1370 return CMD_SUCCESS;
1371 }
1372
1373 DEFUNSH(VTYSH_BGPD, address_family_ipv4_labeled_unicast,
1374 address_family_ipv4_labeled_unicast_cmd,
1375 "address-family ipv4 labeled-unicast",
1376 "Enter Address Family command mode\n"
1377 "Address Family\n"
1378 "Address Family modifier\n")
1379 {
1380 vty->node = BGP_IPV4L_NODE;
1381 return CMD_SUCCESS;
1382 }
1383
1384 DEFUNSH(VTYSH_BGPD, address_family_ipv6, address_family_ipv6_cmd,
1385 "address-family ipv6 [unicast]",
1386 "Enter Address Family command mode\n"
1387 "Address Family\n"
1388 "Address Family modifier\n")
1389 {
1390 vty->node = BGP_IPV6_NODE;
1391 return CMD_SUCCESS;
1392 }
1393
1394 DEFUNSH(VTYSH_BGPD, address_family_ipv6_multicast,
1395 address_family_ipv6_multicast_cmd, "address-family ipv6 multicast",
1396 "Enter Address Family command mode\n"
1397 "Address Family\n"
1398 "Address Family modifier\n")
1399 {
1400 vty->node = BGP_IPV6M_NODE;
1401 return CMD_SUCCESS;
1402 }
1403
1404 DEFUNSH(VTYSH_BGPD, address_family_ipv6_vpn, address_family_ipv6_vpn_cmd,
1405 "address-family ipv6 vpn",
1406 "Enter Address Family command mode\n"
1407 "Address Family\n"
1408 "Address Family modifier\n")
1409 {
1410 vty->node = BGP_VPNV6_NODE;
1411 return CMD_SUCCESS;
1412 }
1413
1414 DEFUNSH(VTYSH_BGPD, address_family_ipv6_labeled_unicast,
1415 address_family_ipv6_labeled_unicast_cmd,
1416 "address-family ipv6 labeled-unicast",
1417 "Enter Address Family command mode\n"
1418 "Address Family\n"
1419 "Address Family modifier\n")
1420 {
1421 vty->node = BGP_IPV6L_NODE;
1422 return CMD_SUCCESS;
1423 }
1424
1425 DEFUNSH(VTYSH_BGPD,
1426 rpki,
1427 rpki_cmd,
1428 "rpki",
1429 "Enable rpki and enter rpki configuration mode\n")
1430 {
1431 vty->node = RPKI_NODE;
1432 return CMD_SUCCESS;
1433 }
1434
1435 DEFUNSH(VTYSH_BGPD, address_family_evpn, address_family_evpn_cmd,
1436 "address-family <l2vpn evpn>",
1437 "Enter Address Family command mode\n"
1438 "Address Family\n"
1439 "Address Family modifier\n")
1440 {
1441 vty->node = BGP_EVPN_NODE;
1442 return CMD_SUCCESS;
1443 }
1444
1445 #if defined(HAVE_CUMULUS)
1446 DEFUNSH_HIDDEN(VTYSH_BGPD, address_family_evpn2, address_family_evpn2_cmd,
1447 "address-family evpn",
1448 "Enter Address Family command mode\n"
1449 "EVPN Address family\n")
1450 {
1451 vty->node = BGP_EVPN_NODE;
1452 return CMD_SUCCESS;
1453 }
1454 #endif
1455
1456 DEFUNSH(VTYSH_BGPD, bgp_evpn_vni, bgp_evpn_vni_cmd, "vni (1-16777215)",
1457 "VXLAN Network Identifier\n"
1458 "VNI number\n")
1459 {
1460 vty->node = BGP_EVPN_VNI_NODE;
1461 return CMD_SUCCESS;
1462 }
1463
1464 #if defined(ENABLE_BGP_VNC)
1465 DEFUNSH(VTYSH_BGPD, vnc_defaults, vnc_defaults_cmd, "vnc defaults",
1466 "VNC/RFP related configuration\n"
1467 "Configure default NVE group\n")
1468 {
1469 vty->node = BGP_VNC_DEFAULTS_NODE;
1470 return CMD_SUCCESS;
1471 }
1472
1473 DEFUNSH(VTYSH_BGPD, vnc_nve_group, vnc_nve_group_cmd, "vnc nve-group NAME",
1474 "VNC/RFP related configuration\n"
1475 "Configure a NVE group\n"
1476 "Group name\n")
1477 {
1478 vty->node = BGP_VNC_NVE_GROUP_NODE;
1479 return CMD_SUCCESS;
1480 }
1481
1482 DEFUNSH(VTYSH_BGPD, vnc_vrf_policy, vnc_vrf_policy_cmd, "vrf-policy NAME",
1483 "Configure a VRF policy group\n"
1484 "Group name\n")
1485 {
1486 vty->node = BGP_VRF_POLICY_NODE;
1487 return CMD_SUCCESS;
1488 }
1489
1490 DEFUNSH(VTYSH_BGPD, vnc_l2_group, vnc_l2_group_cmd, "vnc l2-group NAME",
1491 "VNC/RFP related configuration\n"
1492 "Configure a L2 group\n"
1493 "Group name\n")
1494 {
1495 vty->node = BGP_VNC_L2_GROUP_NODE;
1496 return CMD_SUCCESS;
1497 }
1498 #endif
1499
1500 DEFUNSH(VTYSH_RIPD, key_chain, key_chain_cmd, "key chain WORD",
1501 "Authentication key management\n"
1502 "Key-chain management\n"
1503 "Key-chain name\n")
1504 {
1505 vty->node = KEYCHAIN_NODE;
1506 return CMD_SUCCESS;
1507 }
1508
1509 DEFUNSH(VTYSH_RIPD, key, key_cmd, "key (0-2147483647)",
1510 "Configure a key\n"
1511 "Key identifier number\n")
1512 {
1513 vty->node = KEYCHAIN_KEY_NODE;
1514 return CMD_SUCCESS;
1515 }
1516
1517 DEFUNSH(VTYSH_RIPD, router_rip, router_rip_cmd, "router rip",
1518 ROUTER_STR "RIP\n")
1519 {
1520 vty->node = RIP_NODE;
1521 return CMD_SUCCESS;
1522 }
1523
1524 DEFUNSH(VTYSH_RIPNGD, router_ripng, router_ripng_cmd, "router ripng",
1525 ROUTER_STR "RIPng\n")
1526 {
1527 vty->node = RIPNG_NODE;
1528 return CMD_SUCCESS;
1529 }
1530
1531 DEFUNSH(VTYSH_OSPFD, router_ospf, router_ospf_cmd,
1532 "router ospf [(1-65535)] [vrf NAME]",
1533 "Enable a routing process\n"
1534 "Start OSPF configuration\n"
1535 "Instance ID\n"
1536 VRF_CMD_HELP_STR)
1537 {
1538 vty->node = OSPF_NODE;
1539 return CMD_SUCCESS;
1540 }
1541
1542 DEFUNSH(VTYSH_EIGRPD, router_eigrp, router_eigrp_cmd, "router eigrp (1-65535)",
1543 "Enable a routing process\n"
1544 "Start EIGRP configuration\n"
1545 "AS number to use\n")
1546 {
1547 vty->node = EIGRP_NODE;
1548 return CMD_SUCCESS;
1549 }
1550
1551 DEFUNSH(VTYSH_BABELD, router_babel, router_babel_cmd, "router babel",
1552 "Enable a routing process\n"
1553 "Make Babel instance command\n")
1554 {
1555 vty->node = BABEL_NODE;
1556 return CMD_SUCCESS;
1557 }
1558
1559 DEFUNSH(VTYSH_OSPF6D, router_ospf6, router_ospf6_cmd, "router ospf6",
1560 ROUTER_STR OSPF6_STR)
1561 {
1562 vty->node = OSPF6_NODE;
1563 return CMD_SUCCESS;
1564 }
1565
1566 #if defined(HAVE_LDPD)
1567 DEFUNSH(VTYSH_LDPD, ldp_mpls_ldp, ldp_mpls_ldp_cmd, "mpls ldp",
1568 "Global MPLS configuration subcommands\n"
1569 "Label Distribution Protocol\n")
1570 {
1571 vty->node = LDP_NODE;
1572 return CMD_SUCCESS;
1573 }
1574
1575 DEFUNSH(VTYSH_LDPD, ldp_address_family_ipv4, ldp_address_family_ipv4_cmd,
1576 "address-family ipv4",
1577 "Configure Address Family and its parameters\n"
1578 "IPv4\n")
1579 {
1580 vty->node = LDP_IPV4_NODE;
1581 return CMD_SUCCESS;
1582 }
1583
1584 DEFUNSH(VTYSH_LDPD, ldp_address_family_ipv6, ldp_address_family_ipv6_cmd,
1585 "address-family ipv6",
1586 "Configure Address Family and its parameters\n"
1587 "IPv6\n")
1588 {
1589 vty->node = LDP_IPV6_NODE;
1590 return CMD_SUCCESS;
1591 }
1592
1593 DEFUNSH(VTYSH_LDPD, ldp_exit_address_family, ldp_exit_address_family_cmd,
1594 "exit-address-family", "Exit from Address Family configuration mode\n")
1595 {
1596 if (vty->node == LDP_IPV4_NODE || vty->node == LDP_IPV6_NODE)
1597 vty->node = LDP_NODE;
1598 return CMD_SUCCESS;
1599 }
1600
1601 DEFUNSH(VTYSH_LDPD, ldp_interface_ifname, ldp_interface_ifname_cmd,
1602 "interface IFNAME",
1603 "Enable LDP on an interface and enter interface submode\n"
1604 "Interface's name\n")
1605 {
1606 switch (vty->node) {
1607 case LDP_IPV4_NODE:
1608 vty->node = LDP_IPV4_IFACE_NODE;
1609 break;
1610 case LDP_IPV6_NODE:
1611 vty->node = LDP_IPV6_IFACE_NODE;
1612 break;
1613 default:
1614 break;
1615 }
1616
1617 return CMD_SUCCESS;
1618 }
1619
1620 DEFUNSH(VTYSH_LDPD, ldp_l2vpn_word_type_vpls, ldp_l2vpn_word_type_vpls_cmd,
1621 "l2vpn WORD type vpls",
1622 "Configure l2vpn commands\n"
1623 "L2VPN name\n"
1624 "L2VPN type\n"
1625 "Virtual Private LAN Service\n")
1626 {
1627 vty->node = LDP_L2VPN_NODE;
1628 return CMD_SUCCESS;
1629 }
1630
1631 DEFUNSH(VTYSH_LDPD, ldp_member_pseudowire_ifname,
1632 ldp_member_pseudowire_ifname_cmd, "member pseudowire IFNAME",
1633 "L2VPN member configuration\n"
1634 "Pseudowire interface\n"
1635 "Interface's name\n")
1636 {
1637 vty->node = LDP_PSEUDOWIRE_NODE;
1638 return CMD_SUCCESS;
1639 }
1640 #endif
1641
1642 DEFUNSH(VTYSH_ISISD, router_isis, router_isis_cmd, "router isis WORD",
1643 ROUTER_STR
1644 "ISO IS-IS\n"
1645 "ISO Routing area tag\n")
1646 {
1647 vty->node = ISIS_NODE;
1648 return CMD_SUCCESS;
1649 }
1650
1651 DEFUNSH(VTYSH_RMAP, vtysh_route_map, vtysh_route_map_cmd,
1652 "route-map WORD <deny|permit> (1-65535)",
1653 "Create route-map or enter route-map command mode\n"
1654 "Route map tag\n"
1655 "Route map denies set operations\n"
1656 "Route map permits set operations\n"
1657 "Sequence to insert to/delete from existing route-map entry\n")
1658 {
1659 vty->node = RMAP_NODE;
1660 return CMD_SUCCESS;
1661 }
1662
1663 DEFUNSH(VTYSH_PBRD, vtysh_pbr_map, vtysh_pbr_map_cmd,
1664 "pbr-map NAME seq (1-700)",
1665 "Create pbr-map or enter pbr-map command mode\n"
1666 "The name of the PBR MAP\n"
1667 "Sequence to insert to/delete from existing pbr-map entry\n"
1668 "Sequence number\n")
1669 {
1670 vty->node = PBRMAP_NODE;
1671 return CMD_SUCCESS;
1672 }
1673
1674 #if HAVE_BFDD > 0
1675 DEFUNSH(VTYSH_BFDD, bfd_enter, bfd_enter_cmd, "bfd", "Configure BFD peers\n")
1676 {
1677 vty->node = BFD_NODE;
1678 return CMD_SUCCESS;
1679 }
1680
1681 DEFUNSH(VTYSH_BFDD, bfd_peer_enter, bfd_peer_enter_cmd,
1682 "peer <A.B.C.D|X:X::X:X> [{multihop|local-address <A.B.C.D|X:X::X:X>|interface IFNAME|vrf NAME}]",
1683 "Configure peer\n"
1684 "IPv4 peer address\n"
1685 "IPv6 peer address\n"
1686 "Configure multihop\n"
1687 "Configure local address\n"
1688 "IPv4 local address\n"
1689 "IPv6 local address\n"
1690 INTERFACE_STR
1691 "Configure interface name to use\n"
1692 "Configure VRF\n"
1693 "Configure VRF name\n")
1694 {
1695 vty->node = BFD_PEER_NODE;
1696 return CMD_SUCCESS;
1697 }
1698 #endif /* HAVE_BFDD */
1699
1700 DEFSH(VTYSH_PBRD, vtysh_no_pbr_map_cmd, "no pbr-map WORD [seq (1-700)]",
1701 NO_STR
1702 "Delete pbr-map\n"
1703 "The name of the PBR MAP\n"
1704 "Sequence to delete from existing pbr-map entry\n"
1705 "Sequence number\n")
1706
1707 DEFUNSH(VTYSH_ALL, vtysh_line_vty, vtysh_line_vty_cmd, "line vty",
1708 "Configure a terminal line\n"
1709 "Virtual terminal\n")
1710 {
1711 vty->node = VTY_NODE;
1712 return CMD_SUCCESS;
1713 }
1714
1715 DEFUNSH(VTYSH_REALLYALL, vtysh_enable, vtysh_enable_cmd, "enable",
1716 "Turn on privileged mode command\n")
1717 {
1718 vty->node = ENABLE_NODE;
1719 return CMD_SUCCESS;
1720 }
1721
1722 DEFUNSH(VTYSH_REALLYALL, vtysh_disable, vtysh_disable_cmd, "disable",
1723 "Turn off privileged mode command\n")
1724 {
1725 if (vty->node == ENABLE_NODE)
1726 vty->node = VIEW_NODE;
1727 return CMD_SUCCESS;
1728 }
1729
1730 DEFUNSH(VTYSH_REALLYALL, vtysh_config_terminal, vtysh_config_terminal_cmd,
1731 "configure terminal",
1732 "Configuration from vty interface\n"
1733 "Configuration terminal\n")
1734 {
1735 vty->node = CONFIG_NODE;
1736 return CMD_SUCCESS;
1737 }
1738
1739 static int vtysh_exit(struct vty *vty)
1740 {
1741 switch (vty->node) {
1742 case VIEW_NODE:
1743 case ENABLE_NODE:
1744 exit(0);
1745 break;
1746 case CONFIG_NODE:
1747 vty->node = ENABLE_NODE;
1748 break;
1749 case INTERFACE_NODE:
1750 case PW_NODE:
1751 case LOGICALROUTER_NODE:
1752 case VRF_NODE:
1753 case NH_GROUP_NODE:
1754 case ZEBRA_NODE:
1755 case BGP_NODE:
1756 case RIP_NODE:
1757 case RIPNG_NODE:
1758 case OSPF_NODE:
1759 case OSPF6_NODE:
1760 case EIGRP_NODE:
1761 case BABEL_NODE:
1762 case LDP_NODE:
1763 case LDP_L2VPN_NODE:
1764 case ISIS_NODE:
1765 case RMAP_NODE:
1766 case PBRMAP_NODE:
1767 case VTY_NODE:
1768 case KEYCHAIN_NODE:
1769 case BFD_NODE:
1770 case RPKI_NODE:
1771 vtysh_execute("end");
1772 vtysh_execute("configure terminal");
1773 vty->node = CONFIG_NODE;
1774 break;
1775 case BGP_VPNV4_NODE:
1776 case BGP_VPNV6_NODE:
1777 case BGP_IPV4_NODE:
1778 case BGP_IPV4M_NODE:
1779 case BGP_IPV4L_NODE:
1780 case BGP_IPV6_NODE:
1781 case BGP_IPV6M_NODE:
1782 case BGP_IPV6L_NODE:
1783 case BGP_FLOWSPECV4_NODE:
1784 case BGP_FLOWSPECV6_NODE:
1785 case BGP_VRF_POLICY_NODE:
1786 case BGP_EVPN_NODE:
1787 case BGP_VNC_DEFAULTS_NODE:
1788 case BGP_VNC_NVE_GROUP_NODE:
1789 case BGP_VNC_L2_GROUP_NODE:
1790 vty->node = BGP_NODE;
1791 break;
1792 case BGP_EVPN_VNI_NODE:
1793 vty->node = BGP_EVPN_NODE;
1794 break;
1795 case LDP_IPV4_NODE:
1796 case LDP_IPV6_NODE:
1797 vty->node = LDP_NODE;
1798 break;
1799 case LDP_IPV4_IFACE_NODE:
1800 vty->node = LDP_IPV4_NODE;
1801 break;
1802 case LDP_IPV6_IFACE_NODE:
1803 vty->node = LDP_IPV6_NODE;
1804 break;
1805 case LDP_PSEUDOWIRE_NODE:
1806 vty->node = LDP_L2VPN_NODE;
1807 break;
1808 case KEYCHAIN_KEY_NODE:
1809 vty->node = KEYCHAIN_NODE;
1810 break;
1811 case LINK_PARAMS_NODE:
1812 vty->node = INTERFACE_NODE;
1813 break;
1814 case BFD_PEER_NODE:
1815 vty->node = BFD_NODE;
1816 break;
1817 default:
1818 break;
1819 }
1820 return CMD_SUCCESS;
1821 }
1822
1823 DEFUNSH(VTYSH_REALLYALL, vtysh_exit_all, vtysh_exit_all_cmd, "exit",
1824 "Exit current mode and down to previous mode\n")
1825 {
1826 return vtysh_exit(vty);
1827 }
1828
1829 DEFUNSH(VTYSH_ALL, vtysh_quit_all, vtysh_quit_all_cmd, "quit",
1830 "Exit current mode and down to previous mode\n")
1831 {
1832 return vtysh_exit_all(self, vty, argc, argv);
1833 }
1834
1835 DEFUNSH(VTYSH_BGPD, exit_address_family, exit_address_family_cmd,
1836 "exit-address-family", "Exit from Address Family configuration mode\n")
1837 {
1838 if (vty->node == BGP_IPV4_NODE || vty->node == BGP_IPV4M_NODE
1839 || vty->node == BGP_IPV4L_NODE || vty->node == BGP_VPNV4_NODE
1840 || vty->node == BGP_VPNV6_NODE || vty->node == BGP_IPV6_NODE
1841 || vty->node == BGP_IPV6L_NODE || vty->node == BGP_IPV6M_NODE
1842 || vty->node == BGP_EVPN_NODE
1843 || vty->node == BGP_FLOWSPECV4_NODE
1844 || vty->node == BGP_FLOWSPECV6_NODE)
1845 vty->node = BGP_NODE;
1846 return CMD_SUCCESS;
1847 }
1848
1849 DEFUNSH(VTYSH_BGPD, exit_vni, exit_vni_cmd, "exit-vni", "Exit from VNI mode\n")
1850 {
1851 if (vty->node == BGP_EVPN_VNI_NODE)
1852 vty->node = BGP_EVPN_NODE;
1853 return CMD_SUCCESS;
1854 }
1855
1856 DEFUNSH(VTYSH_BGPD, exit_vnc_config, exit_vnc_config_cmd, "exit-vnc",
1857 "Exit from VNC configuration mode\n")
1858 {
1859 if (vty->node == BGP_VNC_DEFAULTS_NODE
1860 || vty->node == BGP_VNC_NVE_GROUP_NODE
1861 || vty->node == BGP_VNC_L2_GROUP_NODE)
1862 vty->node = BGP_NODE;
1863 return CMD_SUCCESS;
1864
1865 }
1866
1867 DEFUNSH(VTYSH_BGPD, rpki_exit, rpki_exit_cmd, "exit",
1868 "Exit current mode and down to previous mode\n")
1869 {
1870 vtysh_exit(vty);
1871 return CMD_SUCCESS;
1872 }
1873
1874 DEFUNSH(VTYSH_BGPD, rpki_quit, rpki_quit_cmd, "quit",
1875 "Exit current mode and down to previous mode\n")
1876 {
1877 return rpki_exit(self, vty, argc, argv);
1878 }
1879
1880 DEFUNSH(VTYSH_PIMD|VTYSH_ZEBRA, exit_vrf_config, exit_vrf_config_cmd, "exit-vrf",
1881 "Exit from VRF configuration mode\n")
1882 {
1883 if (vty->node == VRF_NODE)
1884 vty->node = CONFIG_NODE;
1885 return CMD_SUCCESS;
1886 }
1887
1888 DEFUNSH(VTYSH_BGPD, exit_vrf_policy, exit_vrf_policy_cmd, "exit-vrf-policy",
1889 "Exit from VRF policy configuration mode\n")
1890 {
1891 if (vty->node == BGP_VRF_POLICY_NODE)
1892 vty->node = BGP_NODE;
1893 return CMD_SUCCESS;
1894 }
1895
1896 DEFUNSH(VTYSH_RIPD, vtysh_exit_ripd, vtysh_exit_ripd_cmd, "exit",
1897 "Exit current mode and down to previous mode\n")
1898 {
1899 return vtysh_exit(vty);
1900 }
1901
1902 DEFUNSH(VTYSH_RIPD, vtysh_quit_ripd, vtysh_quit_ripd_cmd, "quit",
1903 "Exit current mode and down to previous mode\n")
1904 {
1905 return vtysh_exit_ripd(self, vty, argc, argv);
1906 }
1907
1908 DEFUNSH(VTYSH_RIPNGD, vtysh_exit_ripngd, vtysh_exit_ripngd_cmd, "exit",
1909 "Exit current mode and down to previous mode\n")
1910 {
1911 return vtysh_exit(vty);
1912 }
1913
1914 DEFUNSH(VTYSH_RIPNGD, vtysh_quit_ripngd, vtysh_quit_ripngd_cmd, "quit",
1915 "Exit current mode and down to previous mode\n")
1916 {
1917 return vtysh_exit_ripngd(self, vty, argc, argv);
1918 }
1919
1920 DEFUNSH(VTYSH_RMAP, vtysh_exit_rmap, vtysh_exit_rmap_cmd, "exit",
1921 "Exit current mode and down to previous mode\n")
1922 {
1923 return vtysh_exit(vty);
1924 }
1925
1926 DEFUNSH(VTYSH_RMAP, vtysh_quit_rmap, vtysh_quit_rmap_cmd, "quit",
1927 "Exit current mode and down to previous mode\n")
1928 {
1929 return vtysh_exit_rmap(self, vty, argc, argv);
1930 }
1931
1932 DEFUNSH(VTYSH_PBRD, vtysh_exit_pbr_map, vtysh_exit_pbr_map_cmd, "exit",
1933 "Exit current mode and down to previous mode\n")
1934 {
1935 return vtysh_exit(vty);
1936 }
1937
1938 DEFUNSH(VTYSH_PBRD, vtysh_quit_pbr_map, vtysh_quit_pbr_map_cmd, "quit",
1939 "Exit current mode and down to previous mode\n")
1940 {
1941 return vtysh_exit_rmap(self, vty, argc, argv);
1942 }
1943
1944 DEFUNSH(VTYSH_BGPD, vtysh_exit_bgpd, vtysh_exit_bgpd_cmd, "exit",
1945 "Exit current mode and down to previous mode\n")
1946 {
1947 return vtysh_exit(vty);
1948 }
1949
1950 DEFUNSH(VTYSH_BGPD, vtysh_quit_bgpd, vtysh_quit_bgpd_cmd, "quit",
1951 "Exit current mode and down to previous mode\n")
1952 {
1953 return vtysh_exit_bgpd(self, vty, argc, argv);
1954 }
1955
1956 DEFUNSH(VTYSH_OSPFD, vtysh_exit_ospfd, vtysh_exit_ospfd_cmd, "exit",
1957 "Exit current mode and down to previous mode\n")
1958 {
1959 return vtysh_exit(vty);
1960 }
1961
1962 DEFUNSH(VTYSH_OSPFD, vtysh_quit_ospfd, vtysh_quit_ospfd_cmd, "quit",
1963 "Exit current mode and down to previous mode\n")
1964 {
1965 return vtysh_exit_ospfd(self, vty, argc, argv);
1966 }
1967
1968 DEFUNSH(VTYSH_EIGRPD, vtysh_exit_eigrpd, vtysh_exit_eigrpd_cmd, "exit",
1969 "Exit current mode and down to previous mode\n")
1970 {
1971 return vtysh_exit(vty);
1972 }
1973
1974 DEFUNSH(VTYSH_EIGRPD, vtysh_quit_eigrpd, vtysh_quit_eigrpd_cmd, "quit",
1975 "Exit current mode and down to previous mode\n")
1976 {
1977 return vtysh_exit(vty);
1978 }
1979
1980 DEFUNSH(VTYSH_EIGRPD, vtysh_exit_babeld, vtysh_exit_babeld_cmd, "exit",
1981 "Exit current mode and down to previous mode\n")
1982 {
1983 return vtysh_exit(vty);
1984 }
1985
1986 DEFUNSH(VTYSH_BABELD, vtysh_quit_babeld, vtysh_quit_babeld_cmd, "quit",
1987 "Exit current mode and down to previous mode\n")
1988 {
1989 return vtysh_exit(vty);
1990 }
1991
1992 DEFUNSH(VTYSH_OSPF6D, vtysh_exit_ospf6d, vtysh_exit_ospf6d_cmd, "exit",
1993 "Exit current mode and down to previous mode\n")
1994 {
1995 return vtysh_exit(vty);
1996 }
1997
1998 DEFUNSH(VTYSH_OSPF6D, vtysh_quit_ospf6d, vtysh_quit_ospf6d_cmd, "quit",
1999 "Exit current mode and down to previous mode\n")
2000 {
2001 return vtysh_exit_ospf6d(self, vty, argc, argv);
2002 }
2003
2004 #if defined(HAVE_LDPD)
2005 DEFUNSH(VTYSH_LDPD, vtysh_exit_ldpd, vtysh_exit_ldpd_cmd, "exit",
2006 "Exit current mode and down to previous mode\n")
2007 {
2008 return vtysh_exit(vty);
2009 }
2010
2011 ALIAS(vtysh_exit_ldpd, vtysh_quit_ldpd_cmd, "quit",
2012 "Exit current mode and down to previous mode\n")
2013 #endif
2014
2015 DEFUNSH(VTYSH_ISISD, vtysh_exit_isisd, vtysh_exit_isisd_cmd, "exit",
2016 "Exit current mode and down to previous mode\n")
2017 {
2018 return vtysh_exit(vty);
2019 }
2020
2021 DEFUNSH(VTYSH_ISISD, vtysh_quit_isisd, vtysh_quit_isisd_cmd, "quit",
2022 "Exit current mode and down to previous mode\n")
2023 {
2024 return vtysh_exit_isisd(self, vty, argc, argv);
2025 }
2026
2027 #if HAVE_BFDD > 0
2028 DEFUNSH(VTYSH_BFDD, vtysh_exit_bfdd, vtysh_exit_bfdd_cmd, "exit",
2029 "Exit current mode and down to previous mode\n")
2030 {
2031 return vtysh_exit(vty);
2032 }
2033
2034 ALIAS(vtysh_exit_bfdd, vtysh_quit_bfdd_cmd, "quit",
2035 "Exit current mode and down to previous mode\n")
2036 #endif
2037
2038 DEFUNSH(VTYSH_ALL, vtysh_exit_line_vty, vtysh_exit_line_vty_cmd, "exit",
2039 "Exit current mode and down to previous mode\n")
2040 {
2041 return vtysh_exit(vty);
2042 }
2043
2044 DEFUNSH(VTYSH_ALL, vtysh_quit_line_vty, vtysh_quit_line_vty_cmd, "quit",
2045 "Exit current mode and down to previous mode\n")
2046 {
2047 return vtysh_exit_line_vty(self, vty, argc, argv);
2048 }
2049
2050 DEFUNSH(VTYSH_INTERFACE, vtysh_interface, vtysh_interface_cmd,
2051 "interface IFNAME [vrf NAME]",
2052 "Select an interface to configure\n"
2053 "Interface's name\n" VRF_CMD_HELP_STR)
2054 {
2055 vty->node = INTERFACE_NODE;
2056 return CMD_SUCCESS;
2057 }
2058
2059 DEFUNSH(VTYSH_ZEBRA, vtysh_pseudowire, vtysh_pseudowire_cmd,
2060 "pseudowire IFNAME",
2061 "Static pseudowire configuration\n"
2062 "Pseudowire name\n")
2063 {
2064 vty->node = PW_NODE;
2065 return CMD_SUCCESS;
2066 }
2067
2068 DEFUNSH(VTYSH_ZEBRA, vtysh_logicalrouter, vtysh_logicalrouter_cmd,
2069 "logical-router (1-65535) ns NAME",
2070 "Enable a logical-router\n"
2071 "Specify the logical-router indentifier\n"
2072 "The Name Space\n"
2073 "The file name in " NS_RUN_DIR ", or a full pathname\n")
2074 {
2075 vty->node = LOGICALROUTER_NODE;
2076 return CMD_SUCCESS;
2077 }
2078
2079 DEFSH(VTYSH_ZEBRA, vtysh_no_logicalrouter_cmd,
2080 "no logical-router (1-65535) ns NAME", NO_STR
2081 "Enable a Logical-Router\n"
2082 "Specify the Logical-Router identifier\n"
2083 "The Name Space\n"
2084 "The file name in " NS_RUN_DIR ", or a full pathname\n")
2085
2086 DEFUNSH(VTYSH_PBRD, vtysh_nexthop_group, vtysh_nexthop_group_cmd,
2087 "nexthop-group NAME",
2088 "Nexthop Group configuration\n"
2089 "Name of the Nexthop Group\n")
2090 {
2091 vty->node = NH_GROUP_NODE;
2092 return CMD_SUCCESS;
2093 }
2094
2095 DEFSH(VTYSH_PBRD, vtysh_no_nexthop_group_cmd, "no nexthop-group NAME",
2096 NO_STR
2097 "Nexthop Group Configuration\n"
2098 "Name of the Nexthop Group\n")
2099
2100 DEFUNSH(VTYSH_VRF, vtysh_vrf, vtysh_vrf_cmd, "vrf NAME",
2101 "Select a VRF to configure\n"
2102 "VRF's name\n")
2103 {
2104 vty->node = VRF_NODE;
2105 return CMD_SUCCESS;
2106 }
2107
2108 DEFSH(VTYSH_ZEBRA, vtysh_vrf_netns_cmd,
2109 "netns NAME",
2110 "Attach VRF to a Namespace\n"
2111 "The file name in " NS_RUN_DIR ", or a full pathname\n")
2112
2113 DEFSH(VTYSH_ZEBRA, vtysh_no_vrf_netns_cmd,
2114 "no netns [NAME]",
2115 NO_STR
2116 "Detach VRF from a Namespace\n"
2117 "The file name in " NS_RUN_DIR ", or a full pathname\n")
2118
2119 DEFUNSH(VTYSH_NS, vtysh_exit_logicalrouter,
2120 vtysh_exit_logicalrouter_cmd, "exit",
2121 "Exit current mode and down to previous mode\n")
2122 {
2123 return vtysh_exit(vty);
2124 }
2125
2126 DEFUNSH(VTYSH_NS, vtysh_quit_logicalrouter,
2127 vtysh_quit_logicalrouter_cmd, "quit",
2128 "Exit current mode and down to previous mode\n")
2129 {
2130 return vtysh_exit_logicalrouter(self, vty, argc, argv);
2131 }
2132
2133 DEFUNSH(VTYSH_VRF, vtysh_exit_vrf, vtysh_exit_vrf_cmd, "exit",
2134 "Exit current mode and down to previous mode\n")
2135 {
2136 return vtysh_exit(vty);
2137 }
2138
2139 DEFUNSH(VTYSH_VRF, vtysh_quit_vrf, vtysh_quit_vrf_cmd, "quit",
2140 "Exit current mode and down to previous mode\n")
2141 {
2142 return vtysh_exit_vrf(self, vty, argc, argv);
2143 }
2144
2145 DEFUNSH(VTYSH_PBRD, vtysh_exit_nexthop_group, vtysh_exit_nexthop_group_cmd,
2146 "exit", "Exit current mode and down to previous mode\n")
2147 {
2148 return vtysh_exit(vty);
2149 }
2150
2151 DEFUNSH(VTYSH_VRF, vtysh_quit_nexthop_group, vtysh_quit_nexthop_group_cmd,
2152 "quit", "Exit current mode and down to previous mode\n")
2153 {
2154 return vtysh_exit_nexthop_group(self, vty, argc, argv);
2155 }
2156
2157 DEFUNSH(VTYSH_INTERFACE, vtysh_exit_interface, vtysh_exit_interface_cmd, "exit",
2158 "Exit current mode and down to previous mode\n")
2159 {
2160 return vtysh_exit(vty);
2161 }
2162
2163 DEFUNSH(VTYSH_INTERFACE, vtysh_quit_interface, vtysh_quit_interface_cmd, "quit",
2164 "Exit current mode and down to previous mode\n")
2165 {
2166 return vtysh_exit_interface(self, vty, argc, argv);
2167 }
2168
2169 DEFUN (vtysh_show_poll,
2170 vtysh_show_poll_cmd,
2171 "show thread poll",
2172 SHOW_STR
2173 "Thread information\n"
2174 "Thread Poll Information\n")
2175 {
2176 unsigned int i;
2177 int ret = CMD_SUCCESS;
2178 char line[100];
2179
2180 snprintf(line, sizeof(line), "do show thread poll\n");
2181 for (i = 0; i < array_size(vtysh_client); i++)
2182 if (vtysh_client[i].fd >= 0) {
2183 vty_out(vty, "Thread statistics for %s:\n",
2184 vtysh_client[i].name);
2185 ret = vtysh_client_execute(&vtysh_client[i], line);
2186 vty_out(vty, "\n");
2187 }
2188 return ret;
2189 }
2190
2191 DEFUN (vtysh_show_thread,
2192 vtysh_show_thread_cmd,
2193 "show thread cpu [FILTER]",
2194 SHOW_STR
2195 "Thread information\n"
2196 "Thread CPU usage\n"
2197 "Display filter (rwtexb)\n")
2198 {
2199 unsigned int i;
2200 int idx = 0;
2201 int ret = CMD_SUCCESS;
2202 char line[100];
2203
2204 const char *filter =
2205 argv_find(argv, argc, "FILTER", &idx) ? argv[idx]->arg : "";
2206
2207 snprintf(line, sizeof(line), "do show thread cpu %s\n", filter);
2208 for (i = 0; i < array_size(vtysh_client); i++)
2209 if (vtysh_client[i].fd >= 0) {
2210 vty_out(vty, "Thread statistics for %s:\n",
2211 vtysh_client[i].name);
2212 ret = vtysh_client_execute(&vtysh_client[i], line);
2213 vty_out(vty, "\n");
2214 }
2215 return ret;
2216 }
2217
2218 DEFUN (vtysh_show_work_queues,
2219 vtysh_show_work_queues_cmd,
2220 "show work-queues",
2221 SHOW_STR
2222 "Work Queue information\n")
2223 {
2224 unsigned int i;
2225 int ret = CMD_SUCCESS;
2226 char line[] = "do show work-queues\n";
2227
2228 for (i = 0; i < array_size(vtysh_client); i++)
2229 if (vtysh_client[i].fd >= 0) {
2230 vty_out(vty, "Work queue statistics for %s:\n",
2231 vtysh_client[i].name);
2232 ret = vtysh_client_execute(&vtysh_client[i], line);
2233 vty_out(vty, "\n");
2234 }
2235
2236 return ret;
2237 }
2238
2239 DEFUN (vtysh_show_work_queues_daemon,
2240 vtysh_show_work_queues_daemon_cmd,
2241 "show work-queues <zebra|ripd|ripngd|ospfd|ospf6d|bgpd|isisd|pbrd>",
2242 SHOW_STR
2243 "Work Queue information\n"
2244 "For the zebra daemon\n"
2245 "For the rip daemon\n"
2246 "For the ripng daemon\n"
2247 "For the ospf daemon\n"
2248 "For the ospfv6 daemon\n"
2249 "For the bgp daemon\n"
2250 "For the isis daemon\n"
2251 "For the pbr daemon\n")
2252 {
2253 int idx_protocol = 2;
2254 unsigned int i;
2255 int ret = CMD_SUCCESS;
2256
2257 for (i = 0; i < array_size(vtysh_client); i++) {
2258 if (strmatch(vtysh_client[i].name, argv[idx_protocol]->text))
2259 break;
2260 }
2261
2262 ret = vtysh_client_execute(&vtysh_client[i], "show work-queues\n");
2263
2264 return ret;
2265 }
2266
2267 DEFUNSH(VTYSH_ZEBRA, vtysh_link_params, vtysh_link_params_cmd, "link-params",
2268 LINK_PARAMS_STR)
2269 {
2270 vty->node = LINK_PARAMS_NODE;
2271 return CMD_SUCCESS;
2272 }
2273
2274 DEFUNSH(VTYSH_ZEBRA, exit_link_params, exit_link_params_cmd, "exit-link-params",
2275 "Exit from Link Params configuration node\n")
2276 {
2277 if (vty->node == LINK_PARAMS_NODE)
2278 vty->node = INTERFACE_NODE;
2279 return CMD_SUCCESS;
2280 }
2281
2282 static int show_per_daemon(const char *line, const char *headline)
2283 {
2284 unsigned int i;
2285 int ret = CMD_SUCCESS;
2286
2287 for (i = 0; i < array_size(vtysh_client); i++)
2288 if (vtysh_client[i].fd >= 0) {
2289 vty_out(vty, headline, vtysh_client[i].name);
2290 ret = vtysh_client_execute(&vtysh_client[i], line);
2291 vty_out(vty, "\n");
2292 }
2293
2294 return ret;
2295 }
2296
2297 DEFUNSH_HIDDEN (0x00,
2298 vtysh_debug_all,
2299 vtysh_debug_all_cmd,
2300 "[no] debug all",
2301 NO_STR
2302 DEBUG_STR
2303 "Toggle all debugs on or off\n")
2304 {
2305 return CMD_SUCCESS;
2306 }
2307
2308 DEFUN (vtysh_show_debugging,
2309 vtysh_show_debugging_cmd,
2310 "show debugging",
2311 SHOW_STR
2312 DEBUG_STR)
2313 {
2314 return show_per_daemon("do show debugging\n", "");
2315 }
2316
2317 DEFUN (vtysh_show_debugging_hashtable,
2318 vtysh_show_debugging_hashtable_cmd,
2319 "show debugging hashtable [statistics]",
2320 SHOW_STR
2321 DEBUG_STR
2322 "Statistics about hash tables\n"
2323 "Statistics about hash tables\n")
2324 {
2325 vty_out(vty, "\n");
2326 vty_out(vty,
2327 "Load factor (LF) - average number of elements across all buckets\n");
2328 vty_out(vty,
2329 "Full load factor (FLF) - average number of elements across full buckets\n\n");
2330 vty_out(vty,
2331 "Standard deviation (SD) is calculated for both the LF and FLF\n");
2332 vty_out(vty,
2333 "and indicates the typical deviation of bucket chain length\n");
2334 vty_out(vty, "from the value in the corresponding load factor.\n\n");
2335
2336 return show_per_daemon("do show debugging hashtable\n",
2337 "Hashtable statistics for %s:\n");
2338 }
2339
2340 DEFUN (vtysh_show_error_code,
2341 vtysh_show_error_code_cmd,
2342 "show error <(1-4294967296)|all> [json]",
2343 SHOW_STR
2344 "Information on errors\n"
2345 "Error code to get info about\n"
2346 "Information on all errors\n"
2347 JSON_STR)
2348 {
2349 char *fcmd = argv_concat(argv, argc, 0);
2350 char cmd[256];
2351 int rv;
2352
2353 snprintf(cmd, sizeof(cmd), "do %s", fcmd);
2354
2355 /* FIXME: Needs to determine which daemon to send to via code ranges */
2356 rv = show_per_daemon(cmd, "");
2357
2358 XFREE(MTYPE_TMP, fcmd);
2359 return rv;
2360 }
2361
2362 /* Memory */
2363 DEFUN (vtysh_show_memory,
2364 vtysh_show_memory_cmd,
2365 "show memory",
2366 SHOW_STR
2367 "Memory statistics\n")
2368 {
2369 return show_per_daemon("do show memory\n", "Memory statistics for %s:\n");
2370 }
2371
2372 DEFUN (vtysh_show_modules,
2373 vtysh_show_modules_cmd,
2374 "show modules",
2375 SHOW_STR
2376 "Loaded modules\n")
2377 {
2378 return show_per_daemon("do show modules\n",
2379 "Module information for %s:\n");
2380 }
2381
2382 /* Logging commands. */
2383 DEFUN (vtysh_show_logging,
2384 vtysh_show_logging_cmd,
2385 "show logging",
2386 SHOW_STR
2387 "Show current logging configuration\n")
2388 {
2389 return show_per_daemon("do show logging\n",
2390 "Logging configuration for %s:\n");
2391 }
2392
2393 DEFUNSH(VTYSH_ALL, vtysh_log_stdout, vtysh_log_stdout_cmd, "log stdout",
2394 "Logging control\n"
2395 "Set stdout logging level\n")
2396 {
2397 return CMD_SUCCESS;
2398 }
2399
2400 DEFUNSH(VTYSH_ALL, vtysh_log_stdout_level, vtysh_log_stdout_level_cmd,
2401 "log stdout <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>",
2402 "Logging control\n"
2403 "Set stdout logging level\n" LOG_LEVEL_DESC)
2404 {
2405 return CMD_SUCCESS;
2406 }
2407
2408 DEFUNSH(VTYSH_ALL, no_vtysh_log_stdout, no_vtysh_log_stdout_cmd,
2409 "no log stdout [LEVEL]", NO_STR
2410 "Logging control\n"
2411 "Cancel logging to stdout\n"
2412 "Logging level\n")
2413 {
2414 return CMD_SUCCESS;
2415 }
2416
2417 DEFUNSH(VTYSH_ALL, vtysh_log_file, vtysh_log_file_cmd, "log file FILENAME",
2418 "Logging control\n"
2419 "Logging to file\n"
2420 "Logging filename\n")
2421 {
2422 return CMD_SUCCESS;
2423 }
2424
2425 DEFUNSH(VTYSH_ALL, vtysh_log_file_level, vtysh_log_file_level_cmd,
2426 "log file FILENAME <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>",
2427 "Logging control\n"
2428 "Logging to file\n"
2429 "Logging filename\n" LOG_LEVEL_DESC)
2430 {
2431 return CMD_SUCCESS;
2432 }
2433
2434 DEFUNSH(VTYSH_ALL, no_vtysh_log_file, no_vtysh_log_file_cmd,
2435 "no log file [FILENAME [LEVEL]]", NO_STR
2436 "Logging control\n"
2437 "Cancel logging to file\n"
2438 "Logging file name\n"
2439 "Logging level\n")
2440 {
2441 return CMD_SUCCESS;
2442 }
2443
2444 DEFUNSH(VTYSH_ALL, vtysh_log_monitor, vtysh_log_monitor_cmd,
2445 "log monitor [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2446 "Logging control\n"
2447 "Set terminal line (monitor) logging level\n" LOG_LEVEL_DESC)
2448 {
2449 return CMD_SUCCESS;
2450 }
2451
2452 DEFUNSH(VTYSH_ALL, no_vtysh_log_monitor, no_vtysh_log_monitor_cmd,
2453 "no log monitor [LEVEL]", NO_STR
2454 "Logging control\n"
2455 "Disable terminal line (monitor) logging\n"
2456 "Logging level\n")
2457 {
2458 return CMD_SUCCESS;
2459 }
2460
2461 DEFUNSH(VTYSH_ALL, vtysh_log_syslog, vtysh_log_syslog_cmd,
2462 "log syslog [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2463 "Logging control\n"
2464 "Set syslog logging level\n" LOG_LEVEL_DESC)
2465 {
2466 return CMD_SUCCESS;
2467 }
2468
2469 DEFUNSH(VTYSH_ALL, no_vtysh_log_syslog, no_vtysh_log_syslog_cmd,
2470 "no log syslog [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2471 NO_STR
2472 "Logging control\n"
2473 "Cancel logging to syslog\n"
2474 LOG_LEVEL_DESC)
2475 {
2476 return CMD_SUCCESS;
2477 }
2478
2479 DEFUNSH(VTYSH_ALL, vtysh_log_facility, vtysh_log_facility_cmd,
2480 "log facility <kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7>",
2481 "Logging control\n"
2482 "Facility parameter for syslog messages\n" LOG_FACILITY_DESC)
2483 {
2484 return CMD_SUCCESS;
2485 }
2486
2487 DEFUNSH(VTYSH_ALL, no_vtysh_log_facility, no_vtysh_log_facility_cmd,
2488 "no log facility [FACILITY]", NO_STR
2489 "Logging control\n"
2490 "Reset syslog facility to default (daemon)\n"
2491 "Syslog facility\n")
2492 {
2493 return CMD_SUCCESS;
2494 }
2495
2496 DEFUNSH(VTYSH_ALL, vtysh_log_record_priority, vtysh_log_record_priority_cmd,
2497 "log record-priority",
2498 "Logging control\n"
2499 "Log the priority of the message within the message\n")
2500 {
2501 return CMD_SUCCESS;
2502 }
2503
2504 DEFUNSH(VTYSH_ALL, no_vtysh_log_record_priority,
2505 no_vtysh_log_record_priority_cmd, "no log record-priority", NO_STR
2506 "Logging control\n"
2507 "Do not log the priority of the message within the message\n")
2508 {
2509 return CMD_SUCCESS;
2510 }
2511
2512 DEFUNSH(VTYSH_ALL, vtysh_log_timestamp_precision,
2513 vtysh_log_timestamp_precision_cmd, "log timestamp precision (0-6)",
2514 "Logging control\n"
2515 "Timestamp configuration\n"
2516 "Set the timestamp precision\n"
2517 "Number of subsecond digits\n")
2518 {
2519 return CMD_SUCCESS;
2520 }
2521
2522 DEFUNSH(VTYSH_ALL, no_vtysh_log_timestamp_precision,
2523 no_vtysh_log_timestamp_precision_cmd, "no log timestamp precision",
2524 NO_STR
2525 "Logging control\n"
2526 "Timestamp configuration\n"
2527 "Reset the timestamp precision to the default value of 0\n")
2528 {
2529 return CMD_SUCCESS;
2530 }
2531
2532 DEFUNSH(VTYSH_ALL, vtysh_service_password_encrypt,
2533 vtysh_service_password_encrypt_cmd, "service password-encryption",
2534 "Set up miscellaneous service\n"
2535 "Enable encrypted passwords\n")
2536 {
2537 return CMD_SUCCESS;
2538 }
2539
2540 DEFUNSH(VTYSH_ALL, no_vtysh_service_password_encrypt,
2541 no_vtysh_service_password_encrypt_cmd, "no service password-encryption",
2542 NO_STR
2543 "Set up miscellaneous service\n"
2544 "Enable encrypted passwords\n")
2545 {
2546 return CMD_SUCCESS;
2547 }
2548
2549 DEFUNSH(VTYSH_ALL, vtysh_config_password, vtysh_password_cmd,
2550 "password [(8-8)] LINE",
2551 "Modify the terminal connection password\n"
2552 "Specifies a HIDDEN password will follow\n"
2553 "The password string\n")
2554 {
2555 return CMD_SUCCESS;
2556 }
2557
2558 DEFUNSH(VTYSH_ALL, no_vtysh_config_password, no_vtysh_password_cmd,
2559 "no password", NO_STR
2560 "Modify the terminal connection password\n")
2561 {
2562 vty_out(vty, NO_PASSWD_CMD_WARNING);
2563
2564 return CMD_SUCCESS;
2565 }
2566
2567 DEFUNSH(VTYSH_ALL, vtysh_config_enable_password, vtysh_enable_password_cmd,
2568 "enable password [(8-8)] LINE",
2569 "Modify enable password parameters\n"
2570 "Assign the privileged level password\n"
2571 "Specifies a HIDDEN password will follow\n"
2572 "The 'enable' password string\n")
2573 {
2574 return CMD_SUCCESS;
2575 }
2576
2577 DEFUNSH(VTYSH_ALL, no_vtysh_config_enable_password,
2578 no_vtysh_enable_password_cmd, "no enable password", NO_STR
2579 "Modify enable password parameters\n"
2580 "Assign the privileged level password\n")
2581 {
2582 vty_out(vty, NO_PASSWD_CMD_WARNING);
2583
2584 return CMD_SUCCESS;
2585 }
2586
2587 DEFUN (vtysh_write_terminal,
2588 vtysh_write_terminal_cmd,
2589 "write terminal [<zebra|ripd|ripngd|ospfd|ospf6d|ldpd|bgpd|isisd|pimd>]",
2590 "Write running configuration to memory, network, or terminal\n"
2591 "Write to terminal\n"
2592 "For the zebra daemon\n"
2593 "For the rip daemon\n"
2594 "For the ripng daemon\n"
2595 "For the ospf daemon\n"
2596 "For the ospfv6 daemon\n"
2597 "For the ldpd daemon\n"
2598 "For the bgp daemon\n"
2599 "For the isis daemon\n"
2600 "For the pim daemon\n")
2601 {
2602 unsigned int i;
2603 char line[] = "do write terminal\n";
2604
2605 vty_out(vty, "Building configuration...\n");
2606 vty_out(vty, "\nCurrent configuration:\n");
2607 vty_out(vty, "!\n");
2608
2609 for (i = 0; i < array_size(vtysh_client); i++)
2610 if ((argc < 3)
2611 || (strmatch(vtysh_client[i].name, argv[2]->text)))
2612 vtysh_client_config(&vtysh_client[i], line);
2613
2614 /* Integrate vtysh specific configuration. */
2615 vty_open_pager(vty);
2616 vtysh_config_write();
2617 vtysh_config_dump();
2618 vty_close_pager(vty);
2619 vty_out(vty, "end\n");
2620
2621 return CMD_SUCCESS;
2622 }
2623
2624 DEFUN (vtysh_show_running_config,
2625 vtysh_show_running_config_cmd,
2626 "show running-config [<zebra|ripd|ripngd|ospfd|ospf6d|ldpd|bgpd|isisd|pimd>]",
2627 SHOW_STR
2628 "Current operating configuration\n"
2629 "For the zebra daemon\n"
2630 "For the rip daemon\n"
2631 "For the ripng daemon\n"
2632 "For the ospf daemon\n"
2633 "For the ospfv6 daemon\n"
2634 "For the ldp daemon\n"
2635 "For the bgp daemon\n"
2636 "For the isis daemon\n"
2637 "For the pim daemon\n")
2638 {
2639 return vtysh_write_terminal(self, vty, argc, argv);
2640 }
2641
2642 DEFUN (vtysh_integrated_config,
2643 vtysh_integrated_config_cmd,
2644 "service integrated-vtysh-config",
2645 "Set up miscellaneous service\n"
2646 "Write configuration into integrated file\n")
2647 {
2648 vtysh_write_integrated = WRITE_INTEGRATED_YES;
2649 return CMD_SUCCESS;
2650 }
2651
2652 DEFUN (no_vtysh_integrated_config,
2653 no_vtysh_integrated_config_cmd,
2654 "no service integrated-vtysh-config",
2655 NO_STR
2656 "Set up miscellaneous service\n"
2657 "Write configuration into integrated file\n")
2658 {
2659 vtysh_write_integrated = WRITE_INTEGRATED_NO;
2660 return CMD_SUCCESS;
2661 }
2662
2663 static void backup_config_file(const char *fbackup)
2664 {
2665 char *integrate_sav = NULL;
2666
2667 integrate_sav = malloc(strlen(fbackup) + strlen(CONF_BACKUP_EXT) + 1);
2668 strcpy(integrate_sav, fbackup);
2669 strcat(integrate_sav, CONF_BACKUP_EXT);
2670
2671 /* Move current configuration file to backup config file. */
2672 if (unlink(integrate_sav) != 0) {
2673 vty_out(vty, "Warning: %s unlink failed\n", integrate_sav);
2674 }
2675 if (rename(fbackup, integrate_sav) != 0) {
2676 vty_out(vty, "Error renaming %s to %s\n", fbackup,
2677 integrate_sav);
2678 }
2679 free(integrate_sav);
2680 }
2681
2682 int vtysh_write_config_integrated(void)
2683 {
2684 unsigned int i;
2685 char line[] = "do write terminal\n";
2686 FILE *fp;
2687 int fd;
2688 #ifdef FRR_USER
2689 struct passwd *pwentry;
2690 #endif
2691 #ifdef FRR_GROUP
2692 struct group *grentry;
2693 #endif
2694 uid_t uid = -1;
2695 gid_t gid = -1;
2696 struct stat st;
2697 int err = 0;
2698
2699 vty_out(vty, "Building Configuration...\n");
2700
2701 backup_config_file(frr_config);
2702 fp = fopen(frr_config, "w");
2703 if (fp == NULL) {
2704 vty_out(vty,
2705 "%% Error: failed to open configuration file %s: %s\n",
2706 frr_config, safe_strerror(errno));
2707 return CMD_WARNING_CONFIG_FAILED;
2708 }
2709 fd = fileno(fp);
2710
2711 for (i = 0; i < array_size(vtysh_client); i++)
2712 vtysh_client_config(&vtysh_client[i], line);
2713
2714 vtysh_config_write();
2715 vty->of_saved = vty->of;
2716 vty->of = fp;
2717 vtysh_config_dump();
2718 vty->of = vty->of_saved;
2719
2720 if (fchmod(fd, CONFIGFILE_MASK) != 0) {
2721 printf("%% Warning: can't chmod configuration file %s: %s\n",
2722 frr_config, safe_strerror(errno));
2723 err++;
2724 }
2725
2726 #ifdef FRR_USER
2727 pwentry = getpwnam(FRR_USER);
2728 if (pwentry)
2729 uid = pwentry->pw_uid;
2730 else {
2731 printf("%% Warning: could not look up user \"%s\"\n", FRR_USER);
2732 err++;
2733 }
2734 #endif
2735 #ifdef FRR_GROUP
2736 grentry = getgrnam(FRR_GROUP);
2737 if (grentry)
2738 gid = grentry->gr_gid;
2739 else {
2740 printf("%% Warning: could not look up group \"%s\"\n",
2741 FRR_GROUP);
2742 err++;
2743 }
2744 #endif
2745
2746 if (!fstat(fd, &st)) {
2747 if (st.st_uid == uid)
2748 uid = -1;
2749 if (st.st_gid == gid)
2750 gid = -1;
2751 if ((uid != (uid_t)-1 || gid != (gid_t)-1)
2752 && fchown(fd, uid, gid)) {
2753 printf("%% Warning: can't chown configuration file %s: %s\n",
2754 frr_config, safe_strerror(errno));
2755 err++;
2756 }
2757 } else {
2758 printf("%% Warning: stat() failed on %s: %s\n", frr_config,
2759 safe_strerror(errno));
2760 err++;
2761 }
2762
2763 fclose(fp);
2764
2765 printf("Integrated configuration saved to %s\n", frr_config);
2766 if (err)
2767 return CMD_WARNING;
2768
2769 printf("[OK]\n");
2770 return CMD_SUCCESS;
2771 }
2772
2773 static bool want_config_integrated(void)
2774 {
2775 struct stat s;
2776
2777 switch (vtysh_write_integrated) {
2778 case WRITE_INTEGRATED_UNSPECIFIED:
2779 if (stat(frr_config, &s) && errno == ENOENT)
2780 return false;
2781 return true;
2782 case WRITE_INTEGRATED_NO:
2783 return false;
2784 case WRITE_INTEGRATED_YES:
2785 return true;
2786 }
2787 return true;
2788 }
2789
2790 DEFUN (vtysh_write_memory,
2791 vtysh_write_memory_cmd,
2792 "write [<memory|file>]",
2793 "Write running configuration to memory, network, or terminal\n"
2794 "Write configuration to the file (same as write file)\n"
2795 "Write configuration to the file (same as write memory)\n")
2796 {
2797 int ret = CMD_SUCCESS;
2798 char line[] = "do write memory\n";
2799 unsigned int i;
2800
2801 vty_out(vty, "Note: this version of vtysh never writes vtysh.conf\n");
2802
2803 /* If integrated frr.conf explicitely set. */
2804 if (want_config_integrated()) {
2805 ret = CMD_WARNING_CONFIG_FAILED;
2806
2807 /* first attempt to use watchfrr if it's available */
2808 bool used_watchfrr = false;
2809
2810 for (i = 0; i < array_size(vtysh_client); i++)
2811 if (vtysh_client[i].flag == VTYSH_WATCHFRR)
2812 break;
2813 if (i < array_size(vtysh_client) && vtysh_client[i].fd != -1) {
2814 used_watchfrr = true;
2815 ret = vtysh_client_execute(&vtysh_client[i],
2816 "do write integrated");
2817 }
2818
2819 /*
2820 * If we didn't use watchfrr, fallback to writing the config
2821 * ourselves
2822 */
2823 if (!used_watchfrr) {
2824 printf("\nWarning: attempting direct configuration write without "
2825 "watchfrr.\nFile permissions and ownership may be "
2826 "incorrect, or write may fail.\n\n");
2827 ret = vtysh_write_config_integrated();
2828 }
2829 return ret;
2830 }
2831
2832 vty_out(vty, "Building Configuration...\n");
2833
2834 for (i = 0; i < array_size(vtysh_client); i++)
2835 ret = vtysh_client_execute(&vtysh_client[i], line);
2836
2837 return ret;
2838 }
2839
2840 DEFUN (vtysh_copy_running_config,
2841 vtysh_copy_running_config_cmd,
2842 "copy running-config startup-config",
2843 "Copy from one file to another\n"
2844 "Copy from current system configuration\n"
2845 "Copy to startup configuration\n")
2846 {
2847 return vtysh_write_memory(self, vty, argc, argv);
2848 }
2849
2850 DEFUN (vtysh_terminal_paginate,
2851 vtysh_terminal_paginate_cmd,
2852 "[no] terminal paginate",
2853 NO_STR
2854 "Set terminal line parameters\n"
2855 "Use pager for output scrolling\n")
2856 {
2857 free(vtysh_pager_name);
2858 vtysh_pager_name = NULL;
2859
2860 if (strcmp(argv[0]->text, "no"))
2861 vtysh_pager_envdef(true);
2862 return CMD_SUCCESS;
2863 }
2864
2865 DEFUN (vtysh_terminal_length,
2866 vtysh_terminal_length_cmd,
2867 "[no] terminal length (0-4294967295)",
2868 NO_STR
2869 "Set terminal line parameters\n"
2870 "Set number of lines on a screen\n"
2871 "Number of lines on screen (0 for no pausing, nonzero to use pager)\n")
2872 {
2873 int idx_number = 2;
2874 unsigned long lines;
2875
2876 free(vtysh_pager_name);
2877 vtysh_pager_name = NULL;
2878
2879 if (!strcmp(argv[0]->text, "no") || !strcmp(argv[1]->text, "no")) {
2880 /* "terminal no length" = use VTYSH_PAGER */
2881 vtysh_pager_envdef(true);
2882 return CMD_SUCCESS;
2883 }
2884
2885 lines = strtoul(argv[idx_number]->arg, NULL, 10);
2886 if (lines != 0) {
2887 vty_out(vty,
2888 "%% The \"terminal length\" command is deprecated and its value is ignored.\n"
2889 "%% Please use \"terminal paginate\" instead with OS TTY length handling.\n");
2890 vtysh_pager_envdef(true);
2891 }
2892
2893 return CMD_SUCCESS;
2894 }
2895
2896 ALIAS_DEPRECATED(vtysh_terminal_length,
2897 vtysh_terminal_no_length_cmd,
2898 "terminal no length",
2899 "Set terminal line parameters\n"
2900 NO_STR
2901 "Set number of lines on a screen\n")
2902
2903 DEFUN (vtysh_show_daemons,
2904 vtysh_show_daemons_cmd,
2905 "show daemons",
2906 SHOW_STR
2907 "Show list of running daemons\n")
2908 {
2909 unsigned int i;
2910
2911 for (i = 0; i < array_size(vtysh_client); i++)
2912 if (vtysh_client[i].fd >= 0)
2913 vty_out(vty, " %s", vtysh_client[i].name);
2914 vty_out(vty, "\n");
2915
2916 return CMD_SUCCESS;
2917 }
2918
2919 /* Execute command in child process. */
2920 static void execute_command(const char *command, int argc, const char *arg1,
2921 const char *arg2)
2922 {
2923 pid_t pid;
2924 int status;
2925
2926 /* Call fork(). */
2927 pid = fork();
2928
2929 if (pid < 0) {
2930 /* Failure of fork(). */
2931 fprintf(stderr, "Can't fork: %s\n", safe_strerror(errno));
2932 exit(1);
2933 } else if (pid == 0) {
2934 /* This is child process. */
2935 switch (argc) {
2936 case 0:
2937 execlp(command, command, (const char *)NULL);
2938 break;
2939 case 1:
2940 execlp(command, command, arg1, (const char *)NULL);
2941 break;
2942 case 2:
2943 execlp(command, command, arg1, arg2,
2944 (const char *)NULL);
2945 break;
2946 }
2947
2948 /* When execlp suceed, this part is not executed. */
2949 fprintf(stderr, "Can't execute %s: %s\n", command,
2950 safe_strerror(errno));
2951 exit(1);
2952 } else {
2953 /* This is parent. */
2954 execute_flag = 1;
2955 wait4(pid, &status, 0, NULL);
2956 execute_flag = 0;
2957 }
2958 }
2959
2960 DEFUN (vtysh_ping,
2961 vtysh_ping_cmd,
2962 "ping WORD",
2963 "Send echo messages\n"
2964 "Ping destination address or hostname\n")
2965 {
2966 int idx = 1;
2967
2968 argv_find(argv, argc, "WORD", &idx);
2969 execute_command("ping", 1, argv[idx]->arg, NULL);
2970 return CMD_SUCCESS;
2971 }
2972
2973 ALIAS(vtysh_ping, vtysh_ping_ip_cmd, "ping ip WORD",
2974 "Send echo messages\n"
2975 "IP echo\n"
2976 "Ping destination address or hostname\n")
2977
2978 DEFUN (vtysh_traceroute,
2979 vtysh_traceroute_cmd,
2980 "traceroute WORD",
2981 "Trace route to destination\n"
2982 "Trace route to destination address or hostname\n")
2983 {
2984 int idx = 1;
2985
2986 argv_find(argv, argc, "WORD", &idx);
2987 execute_command("traceroute", 1, argv[idx]->arg, NULL);
2988 return CMD_SUCCESS;
2989 }
2990
2991 ALIAS(vtysh_traceroute, vtysh_traceroute_ip_cmd, "traceroute ip WORD",
2992 "Trace route to destination\n"
2993 "IP trace\n"
2994 "Trace route to destination address or hostname\n")
2995
2996 DEFUN (vtysh_mtrace,
2997 vtysh_mtrace_cmd,
2998 "mtrace WORD [WORD]",
2999 "Multicast trace route to multicast source\n"
3000 "Multicast trace route to multicast source address\n"
3001 "Multicast trace route for multicast group address\n")
3002 {
3003 if (argc == 2)
3004 execute_command("mtracebis", 1, argv[1]->arg, NULL);
3005 else
3006 execute_command("mtracebis", 2, argv[1]->arg, argv[2]->arg);
3007 return CMD_SUCCESS;
3008 }
3009
3010 DEFUN (vtysh_ping6,
3011 vtysh_ping6_cmd,
3012 "ping ipv6 WORD",
3013 "Send echo messages\n"
3014 "IPv6 echo\n"
3015 "Ping destination address or hostname\n")
3016 {
3017 execute_command("ping6", 1, argv[2]->arg, NULL);
3018 return CMD_SUCCESS;
3019 }
3020
3021 DEFUN (vtysh_traceroute6,
3022 vtysh_traceroute6_cmd,
3023 "traceroute ipv6 WORD",
3024 "Trace route to destination\n"
3025 "IPv6 trace\n"
3026 "Trace route to destination address or hostname\n")
3027 {
3028 execute_command("traceroute6", 1, argv[2]->arg, NULL);
3029 return CMD_SUCCESS;
3030 }
3031
3032 #if defined(HAVE_SHELL_ACCESS)
3033 DEFUN (vtysh_telnet,
3034 vtysh_telnet_cmd,
3035 "telnet WORD",
3036 "Open a telnet connection\n"
3037 "IP address or hostname of a remote system\n")
3038 {
3039 execute_command("telnet", 1, argv[1]->arg, NULL);
3040 return CMD_SUCCESS;
3041 }
3042
3043 DEFUN (vtysh_telnet_port,
3044 vtysh_telnet_port_cmd,
3045 "telnet WORD PORT",
3046 "Open a telnet connection\n"
3047 "IP address or hostname of a remote system\n"
3048 "TCP Port number\n")
3049 {
3050 execute_command("telnet", 2, argv[1]->arg, argv[2]->arg);
3051 return CMD_SUCCESS;
3052 }
3053
3054 DEFUN (vtysh_ssh,
3055 vtysh_ssh_cmd,
3056 "ssh WORD",
3057 "Open an ssh connection\n"
3058 "[user@]host\n")
3059 {
3060 execute_command("ssh", 1, argv[1]->arg, NULL);
3061 return CMD_SUCCESS;
3062 }
3063
3064 DEFUN (vtysh_start_shell,
3065 vtysh_start_shell_cmd,
3066 "start-shell",
3067 "Start UNIX shell\n")
3068 {
3069 execute_command("sh", 0, NULL, NULL);
3070 return CMD_SUCCESS;
3071 }
3072
3073 DEFUN (vtysh_start_bash,
3074 vtysh_start_bash_cmd,
3075 "start-shell bash",
3076 "Start UNIX shell\n"
3077 "Start bash\n")
3078 {
3079 execute_command("bash", 0, NULL, NULL);
3080 return CMD_SUCCESS;
3081 }
3082
3083 DEFUN (vtysh_start_zsh,
3084 vtysh_start_zsh_cmd,
3085 "start-shell zsh",
3086 "Start UNIX shell\n"
3087 "Start Z shell\n")
3088 {
3089 execute_command("zsh", 0, NULL, NULL);
3090 return CMD_SUCCESS;
3091 }
3092 #endif
3093
3094 DEFUN (config_list,
3095 config_list_cmd,
3096 "list [permutations]",
3097 "Print command list\n"
3098 "Print all possible command permutations\n")
3099 {
3100 return cmd_list_cmds(vty, argc == 2);
3101 }
3102
3103 DEFUN (vtysh_output_file,
3104 vtysh_output_file_cmd,
3105 "output file FILE",
3106 "Direct vtysh output to file\n"
3107 "Direct vtysh output to file\n"
3108 "Path to dump output to\n")
3109 {
3110 const char *path = argv[argc - 1]->arg;
3111 vty->of = fopen(path, "a");
3112 if (!vty->of) {
3113 vty_out(vty, "Failed to open file '%s': %s\n", path,
3114 safe_strerror(errno));
3115 vty->of = stdout;
3116 }
3117 return CMD_SUCCESS;
3118 }
3119
3120 DEFUN (no_vtysh_output_file,
3121 no_vtysh_output_file_cmd,
3122 "no output file [FILE]",
3123 NO_STR
3124 "Direct vtysh output to file\n"
3125 "Direct vtysh output to file\n"
3126 "Path to dump output to\n")
3127 {
3128 if (vty->of != stdout) {
3129 fclose(vty->of);
3130 vty->of = stdout;
3131 }
3132 return CMD_SUCCESS;
3133 }
3134
3135 DEFUN(find,
3136 find_cmd,
3137 "find COMMAND...",
3138 "Find CLI command containing text\n"
3139 "Text to search for\n")
3140 {
3141 char *text = argv_concat(argv, argc, 1);
3142 const struct cmd_node *node;
3143 const struct cmd_element *cli;
3144 vector clis;
3145
3146 for (unsigned int i = 0; i < vector_active(cmdvec); i++) {
3147 node = vector_slot(cmdvec, i);
3148 if (!node)
3149 continue;
3150 clis = node->cmd_vector;
3151 for (unsigned int j = 0; j < vector_active(clis); j++) {
3152 cli = vector_slot(clis, j);
3153 if (strcasestr(cli->string, text))
3154 vty_out(vty, " (%s) %s\n",
3155 node_names[node->node], cli->string);
3156 }
3157 }
3158
3159 XFREE(MTYPE_TMP, text);
3160
3161 return CMD_SUCCESS;
3162 }
3163
3164 DEFUN_HIDDEN(show_cli_graph_vtysh,
3165 show_cli_graph_vtysh_cmd,
3166 "show cli graph",
3167 SHOW_STR
3168 "CLI reflection\n"
3169 "Dump current command space as DOT graph\n")
3170 {
3171 struct cmd_node *cn = vector_slot(cmdvec, vty->node);
3172 char *dot = cmd_graph_dump_dot(cn->cmdgraph);
3173
3174 vty_out(vty, "%s\n", dot);
3175 XFREE(MTYPE_TMP, dot);
3176 return CMD_SUCCESS;
3177 }
3178
3179 static void vtysh_install_default(enum node_type node)
3180 {
3181 install_element(node, &config_list_cmd);
3182 install_element(node, &find_cmd);
3183 install_element(node, &show_cli_graph_vtysh_cmd);
3184 install_element(node, &vtysh_output_file_cmd);
3185 install_element(node, &no_vtysh_output_file_cmd);
3186 }
3187
3188 /* Making connection to protocol daemon. */
3189 static int vtysh_connect(struct vtysh_client *vclient)
3190 {
3191 int ret;
3192 int sock, len;
3193 struct sockaddr_un addr;
3194 struct stat s_stat;
3195 const char *path;
3196
3197 if (!vclient->path[0])
3198 snprintf(vclient->path, sizeof(vclient->path), "%s/%s.vty",
3199 vtydir, vclient->name);
3200 path = vclient->path;
3201
3202 /* Stat socket to see if we have permission to access it. */
3203 ret = stat(path, &s_stat);
3204 if (ret < 0 && errno != ENOENT) {
3205 fprintf(stderr, "vtysh_connect(%s): stat = %s\n", path,
3206 safe_strerror(errno));
3207 exit(1);
3208 }
3209
3210 if (ret >= 0) {
3211 if (!S_ISSOCK(s_stat.st_mode)) {
3212 fprintf(stderr, "vtysh_connect(%s): Not a socket\n",
3213 path);
3214 exit(1);
3215 }
3216 }
3217
3218 sock = socket(AF_UNIX, SOCK_STREAM, 0);
3219 if (sock < 0) {
3220 #ifdef DEBUG
3221 fprintf(stderr, "vtysh_connect(%s): socket = %s\n", path,
3222 safe_strerror(errno));
3223 #endif /* DEBUG */
3224 return -1;
3225 }
3226
3227 memset(&addr, 0, sizeof(struct sockaddr_un));
3228 addr.sun_family = AF_UNIX;
3229 strlcpy(addr.sun_path, path, sizeof(addr.sun_path));
3230 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
3231 len = addr.sun_len = SUN_LEN(&addr);
3232 #else
3233 len = sizeof(addr.sun_family) + strlen(addr.sun_path);
3234 #endif /* HAVE_STRUCT_SOCKADDR_UN_SUN_LEN */
3235
3236 ret = connect(sock, (struct sockaddr *)&addr, len);
3237 if (ret < 0) {
3238 #ifdef DEBUG
3239 fprintf(stderr, "vtysh_connect(%s): connect = %s\n", path,
3240 safe_strerror(errno));
3241 #endif /* DEBUG */
3242 close(sock);
3243 return -1;
3244 }
3245 vclient->fd = sock;
3246
3247 return 0;
3248 }
3249
3250 static int vtysh_reconnect(struct vtysh_client *vclient)
3251 {
3252 int ret;
3253
3254 fprintf(stderr, "Warning: connecting to %s...", vclient->name);
3255 ret = vtysh_connect(vclient);
3256 if (ret < 0) {
3257 fprintf(stderr, "failed!\n");
3258 return ret;
3259 }
3260 fprintf(stderr, "success!\n");
3261 if (vtysh_client_execute(vclient, "enable") < 0)
3262 return -1;
3263 return vtysh_execute_no_pager("end");
3264 }
3265
3266 /* Return true if str ends with suffix, else return false */
3267 static int ends_with(const char *str, const char *suffix)
3268 {
3269 if (!str || !suffix)
3270 return 0;
3271 size_t lenstr = strlen(str);
3272 size_t lensuffix = strlen(suffix);
3273 if (lensuffix > lenstr)
3274 return 0;
3275 return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
3276 }
3277
3278 static void vtysh_client_sorted_insert(struct vtysh_client *head_client,
3279 struct vtysh_client *client)
3280 {
3281 struct vtysh_client *prev_node, *current_node;
3282
3283 prev_node = head_client;
3284 current_node = head_client->next;
3285 while (current_node) {
3286 if (strcmp(current_node->path, client->path) > 0)
3287 break;
3288
3289 prev_node = current_node;
3290 current_node = current_node->next;
3291 }
3292 client->next = current_node;
3293 prev_node->next = client;
3294 }
3295
3296 #define MAXIMUM_INSTANCES 10
3297
3298 static void vtysh_update_all_insances(struct vtysh_client *head_client)
3299 {
3300 struct vtysh_client *client;
3301 DIR *dir;
3302 struct dirent *file;
3303 int n = 0;
3304
3305 if (head_client->flag != VTYSH_OSPFD)
3306 return;
3307
3308 /* ls vty_sock_dir and look for all files ending in .vty */
3309 dir = opendir(vtydir);
3310 if (dir) {
3311 while ((file = readdir(dir)) != NULL) {
3312 if (begins_with(file->d_name, "ospfd-")
3313 && ends_with(file->d_name, ".vty")) {
3314 if (n == MAXIMUM_INSTANCES) {
3315 fprintf(stderr,
3316 "Parsing %s, client limit(%d) reached!\n",
3317 vtydir, n);
3318 break;
3319 }
3320 client = (struct vtysh_client *)malloc(
3321 sizeof(struct vtysh_client));
3322 client->fd = -1;
3323 client->name = "ospfd";
3324 client->flag = VTYSH_OSPFD;
3325 snprintf(client->path, sizeof(client->path),
3326 "%s/%s", vtydir, file->d_name);
3327 client->next = NULL;
3328 vtysh_client_sorted_insert(head_client, client);
3329 n++;
3330 }
3331 }
3332 closedir(dir);
3333 }
3334 }
3335
3336 static int vtysh_connect_all_instances(struct vtysh_client *head_client)
3337 {
3338 struct vtysh_client *client;
3339 int rc = 0;
3340
3341 vtysh_update_all_insances(head_client);
3342
3343 client = head_client->next;
3344 while (client) {
3345 if (vtysh_connect(client) == 0)
3346 rc++;
3347 client = client->next;
3348 }
3349
3350 return rc;
3351 }
3352
3353 int vtysh_connect_all(const char *daemon_name)
3354 {
3355 unsigned int i;
3356 int rc = 0;
3357 int matches = 0;
3358
3359 for (i = 0; i < array_size(vtysh_client); i++) {
3360 if (!daemon_name
3361 || !strcmp(daemon_name, vtysh_client[i].name)) {
3362 matches++;
3363 if (vtysh_connect(&vtysh_client[i]) == 0)
3364 rc++;
3365
3366 rc += vtysh_connect_all_instances(&vtysh_client[i]);
3367 }
3368 }
3369 if (!matches)
3370 fprintf(stderr, "Error: no daemons match name %s!\n",
3371 daemon_name);
3372 return rc;
3373 }
3374
3375 /* To disable readline's filename completion. */
3376 static char *vtysh_completion_entry_function(const char *ignore,
3377 int invoking_key)
3378 {
3379 return NULL;
3380 }
3381
3382 void vtysh_readline_init(void)
3383 {
3384 /* readline related settings. */
3385 rl_initialize();
3386 rl_bind_key('?', (rl_command_func_t *)vtysh_rl_describe);
3387 rl_completion_entry_function = vtysh_completion_entry_function;
3388 rl_attempted_completion_function =
3389 (rl_completion_func_t *)new_completion;
3390 }
3391
3392 char *vtysh_prompt(void)
3393 {
3394 static char buf[100];
3395
3396 snprintf(buf, sizeof buf, cmd_prompt(vty->node), cmd_hostname_get());
3397 return buf;
3398 }
3399
3400 static void vtysh_ac_line(void *arg, const char *line)
3401 {
3402 vector comps = arg;
3403 size_t i;
3404 for (i = 0; i < vector_active(comps); i++)
3405 if (!strcmp(line, (char *)vector_slot(comps, i)))
3406 return;
3407 vector_set(comps, XSTRDUP(MTYPE_COMPLETION, line));
3408 }
3409
3410 static void vtysh_autocomplete(vector comps, struct cmd_token *token)
3411 {
3412 char accmd[256];
3413 size_t i;
3414
3415 snprintf(accmd, sizeof(accmd), "autocomplete %d %s %s", token->type,
3416 token->text, token->varname ? token->varname : "-");
3417
3418 vty->of_saved = vty->of;
3419 vty->of = NULL;
3420 for (i = 0; i < array_size(vtysh_client); i++)
3421 vtysh_client_run_all(&vtysh_client[i], accmd, 1, vtysh_ac_line,
3422 comps);
3423 vty->of = vty->of_saved;
3424 }
3425
3426 static const struct cmd_variable_handler vtysh_var_handler[] = {
3427 {/* match all */
3428 .tokenname = NULL,
3429 .varname = NULL,
3430 .completions = vtysh_autocomplete},
3431 {.completions = NULL}};
3432
3433 void vtysh_uninit()
3434 {
3435 if (vty->of != stdout)
3436 fclose(vty->of);
3437 }
3438
3439 void vtysh_init_vty(void)
3440 {
3441 /* Make vty structure. */
3442 vty = vty_new();
3443 vty->type = VTY_SHELL;
3444 vty->node = VIEW_NODE;
3445
3446 /* set default output */
3447 vty->of = stdout;
3448 vtysh_pager_envdef(false);
3449
3450 /* Initialize commands. */
3451 cmd_init(0);
3452 cmd_variable_handler_register(vtysh_var_handler);
3453
3454 /* Install nodes. */
3455 install_node(&bgp_node, NULL);
3456 install_node(&rip_node, NULL);
3457 install_node(&interface_node, NULL);
3458 install_node(&pw_node, NULL);
3459 install_node(&link_params_node, NULL);
3460 install_node(&logicalrouter_node, NULL);
3461 install_node(&vrf_node, NULL);
3462 install_node(&nh_group_node, NULL);
3463 install_node(&rmap_node, NULL);
3464 install_node(&pbr_map_node, NULL);
3465 install_node(&zebra_node, NULL);
3466 install_node(&bgp_vpnv4_node, NULL);
3467 install_node(&bgp_vpnv6_node, NULL);
3468 install_node(&bgp_flowspecv4_node, NULL);
3469 install_node(&bgp_flowspecv6_node, NULL);
3470 install_node(&bgp_ipv4_node, NULL);
3471 install_node(&bgp_ipv4m_node, NULL);
3472 install_node(&bgp_ipv4l_node, NULL);
3473 install_node(&bgp_ipv6_node, NULL);
3474 install_node(&bgp_ipv6m_node, NULL);
3475 install_node(&bgp_ipv6l_node, NULL);
3476 install_node(&bgp_vrf_policy_node, NULL);
3477 install_node(&bgp_evpn_node, NULL);
3478 install_node(&bgp_evpn_vni_node, NULL);
3479 install_node(&bgp_vnc_defaults_node, NULL);
3480 install_node(&bgp_vnc_nve_group_node, NULL);
3481 install_node(&bgp_vnc_l2_group_node, NULL);
3482 install_node(&ospf_node, NULL);
3483 install_node(&eigrp_node, NULL);
3484 install_node(&babel_node, NULL);
3485 install_node(&ripng_node, NULL);
3486 install_node(&ospf6_node, NULL);
3487 install_node(&ldp_node, NULL);
3488 install_node(&ldp_ipv4_node, NULL);
3489 install_node(&ldp_ipv6_node, NULL);
3490 install_node(&ldp_ipv4_iface_node, NULL);
3491 install_node(&ldp_ipv6_iface_node, NULL);
3492 install_node(&ldp_l2vpn_node, NULL);
3493 install_node(&ldp_pseudowire_node, NULL);
3494 install_node(&keychain_node, NULL);
3495 install_node(&keychain_key_node, NULL);
3496 install_node(&isis_node, NULL);
3497 install_node(&vty_node, NULL);
3498 install_node(&rpki_node, NULL);
3499 #if HAVE_BFDD > 0
3500 install_node(&bfd_node, NULL);
3501 install_node(&bfd_peer_node, NULL);
3502 #endif /* HAVE_BFDD */
3503
3504 struct cmd_node *node;
3505 for (unsigned int i = 0; i < vector_active(cmdvec); i++) {
3506 node = vector_slot(cmdvec, i);
3507 if (!node || node->node == VIEW_NODE)
3508 continue;
3509 vtysh_install_default(node->node);
3510 }
3511
3512 install_element(VIEW_NODE, &vtysh_enable_cmd);
3513 install_element(ENABLE_NODE, &vtysh_config_terminal_cmd);
3514 install_element(ENABLE_NODE, &vtysh_disable_cmd);
3515
3516 /* "exit" command. */
3517 install_element(VIEW_NODE, &vtysh_exit_all_cmd);
3518 install_element(CONFIG_NODE, &vtysh_exit_all_cmd);
3519 install_element(VIEW_NODE, &vtysh_quit_all_cmd);
3520 install_element(CONFIG_NODE, &vtysh_quit_all_cmd);
3521 install_element(RIP_NODE, &vtysh_exit_ripd_cmd);
3522 install_element(RIP_NODE, &vtysh_quit_ripd_cmd);
3523 install_element(RIPNG_NODE, &vtysh_exit_ripngd_cmd);
3524 install_element(RIPNG_NODE, &vtysh_quit_ripngd_cmd);
3525 install_element(OSPF_NODE, &vtysh_exit_ospfd_cmd);
3526 install_element(OSPF_NODE, &vtysh_quit_ospfd_cmd);
3527 install_element(EIGRP_NODE, &vtysh_exit_eigrpd_cmd);
3528 install_element(EIGRP_NODE, &vtysh_quit_eigrpd_cmd);
3529 install_element(BABEL_NODE, &vtysh_exit_babeld_cmd);
3530 install_element(BABEL_NODE, &vtysh_quit_babeld_cmd);
3531 install_element(OSPF6_NODE, &vtysh_exit_ospf6d_cmd);
3532 install_element(OSPF6_NODE, &vtysh_quit_ospf6d_cmd);
3533 #if defined(HAVE_LDPD)
3534 install_element(LDP_NODE, &vtysh_exit_ldpd_cmd);
3535 install_element(LDP_NODE, &vtysh_quit_ldpd_cmd);
3536 install_element(LDP_IPV4_NODE, &vtysh_exit_ldpd_cmd);
3537 install_element(LDP_IPV4_NODE, &vtysh_quit_ldpd_cmd);
3538 install_element(LDP_IPV4_NODE, &ldp_exit_address_family_cmd);
3539 install_element(LDP_IPV6_NODE, &vtysh_exit_ldpd_cmd);
3540 install_element(LDP_IPV6_NODE, &vtysh_quit_ldpd_cmd);
3541 install_element(LDP_IPV6_NODE, &ldp_exit_address_family_cmd);
3542 install_element(LDP_IPV4_IFACE_NODE, &vtysh_exit_ldpd_cmd);
3543 install_element(LDP_IPV4_IFACE_NODE, &vtysh_quit_ldpd_cmd);
3544 install_element(LDP_IPV6_IFACE_NODE, &vtysh_exit_ldpd_cmd);
3545 install_element(LDP_IPV6_IFACE_NODE, &vtysh_quit_ldpd_cmd);
3546 install_element(LDP_L2VPN_NODE, &vtysh_exit_ldpd_cmd);
3547 install_element(LDP_L2VPN_NODE, &vtysh_quit_ldpd_cmd);
3548 install_element(LDP_PSEUDOWIRE_NODE, &vtysh_exit_ldpd_cmd);
3549 install_element(LDP_PSEUDOWIRE_NODE, &vtysh_quit_ldpd_cmd);
3550 #endif
3551 install_element(BGP_NODE, &vtysh_exit_bgpd_cmd);
3552 install_element(BGP_NODE, &vtysh_quit_bgpd_cmd);
3553 install_element(BGP_VPNV4_NODE, &vtysh_exit_bgpd_cmd);
3554 install_element(BGP_VPNV4_NODE, &vtysh_quit_bgpd_cmd);
3555 install_element(BGP_VPNV6_NODE, &vtysh_exit_bgpd_cmd);
3556 install_element(BGP_VPNV6_NODE, &vtysh_quit_bgpd_cmd);
3557 install_element(BGP_FLOWSPECV4_NODE, &vtysh_exit_bgpd_cmd);
3558 install_element(BGP_FLOWSPECV4_NODE, &vtysh_quit_bgpd_cmd);
3559 install_element(BGP_FLOWSPECV6_NODE, &vtysh_exit_bgpd_cmd);
3560 install_element(BGP_FLOWSPECV6_NODE, &vtysh_quit_bgpd_cmd);
3561 install_element(BGP_IPV4_NODE, &vtysh_exit_bgpd_cmd);
3562 install_element(BGP_IPV4_NODE, &vtysh_quit_bgpd_cmd);
3563 install_element(BGP_IPV4M_NODE, &vtysh_exit_bgpd_cmd);
3564 install_element(BGP_IPV4M_NODE, &vtysh_quit_bgpd_cmd);
3565 install_element(BGP_IPV4L_NODE, &vtysh_exit_bgpd_cmd);
3566 install_element(BGP_IPV4L_NODE, &vtysh_quit_bgpd_cmd);
3567 install_element(BGP_IPV6_NODE, &vtysh_exit_bgpd_cmd);
3568 install_element(BGP_IPV6_NODE, &vtysh_quit_bgpd_cmd);
3569 install_element(BGP_IPV6M_NODE, &vtysh_exit_bgpd_cmd);
3570 install_element(BGP_IPV6M_NODE, &vtysh_quit_bgpd_cmd);
3571 install_element(BGP_EVPN_NODE, &vtysh_quit_bgpd_cmd);
3572 install_element(BGP_EVPN_NODE, &vtysh_exit_bgpd_cmd);
3573 install_element(BGP_EVPN_VNI_NODE, &vtysh_exit_bgpd_cmd);
3574 install_element(BGP_EVPN_VNI_NODE, &vtysh_quit_bgpd_cmd);
3575 install_element(BGP_IPV6L_NODE, &vtysh_exit_bgpd_cmd);
3576 install_element(BGP_IPV6L_NODE, &vtysh_quit_bgpd_cmd);
3577 #if defined(ENABLE_BGP_VNC)
3578 install_element(BGP_VRF_POLICY_NODE, &vtysh_exit_bgpd_cmd);
3579 install_element(BGP_VRF_POLICY_NODE, &vtysh_quit_bgpd_cmd);
3580 install_element(BGP_VNC_DEFAULTS_NODE, &vtysh_exit_bgpd_cmd);
3581 install_element(BGP_VNC_DEFAULTS_NODE, &vtysh_quit_bgpd_cmd);
3582 install_element(BGP_VNC_NVE_GROUP_NODE, &vtysh_exit_bgpd_cmd);
3583 install_element(BGP_VNC_NVE_GROUP_NODE, &vtysh_quit_bgpd_cmd);
3584 install_element(BGP_VNC_L2_GROUP_NODE, &vtysh_exit_bgpd_cmd);
3585 install_element(BGP_VNC_L2_GROUP_NODE, &vtysh_quit_bgpd_cmd);
3586 #endif
3587 install_element(ISIS_NODE, &vtysh_exit_isisd_cmd);
3588 install_element(ISIS_NODE, &vtysh_quit_isisd_cmd);
3589 install_element(KEYCHAIN_NODE, &vtysh_exit_ripd_cmd);
3590 install_element(KEYCHAIN_NODE, &vtysh_quit_ripd_cmd);
3591 install_element(KEYCHAIN_KEY_NODE, &vtysh_exit_ripd_cmd);
3592 install_element(KEYCHAIN_KEY_NODE, &vtysh_quit_ripd_cmd);
3593 install_element(RMAP_NODE, &vtysh_exit_rmap_cmd);
3594 install_element(RMAP_NODE, &vtysh_quit_rmap_cmd);
3595 install_element(PBRMAP_NODE, &vtysh_exit_pbr_map_cmd);
3596 install_element(PBRMAP_NODE, &vtysh_quit_pbr_map_cmd);
3597 #if HAVE_BFDD > 0
3598 /* Enter node. */
3599 install_element(CONFIG_NODE, &bfd_enter_cmd);
3600 install_element(BFD_NODE, &bfd_peer_enter_cmd);
3601
3602 /* Exit/quit node. */
3603 install_element(BFD_NODE, &vtysh_exit_bfdd_cmd);
3604 install_element(BFD_NODE, &vtysh_quit_bfdd_cmd);
3605 install_element(BFD_PEER_NODE, &vtysh_exit_bfdd_cmd);
3606 install_element(BFD_PEER_NODE, &vtysh_quit_bfdd_cmd);
3607
3608 /* End/exit all. */
3609 install_element(BFD_NODE, &vtysh_end_all_cmd);
3610 install_element(BFD_PEER_NODE, &vtysh_end_all_cmd);
3611 #endif /* HAVE_BFDD */
3612 install_element(VTY_NODE, &vtysh_exit_line_vty_cmd);
3613 install_element(VTY_NODE, &vtysh_quit_line_vty_cmd);
3614
3615 /* "end" command. */
3616 install_element(CONFIG_NODE, &vtysh_end_all_cmd);
3617 install_element(ENABLE_NODE, &vtysh_end_all_cmd);
3618 install_element(RIP_NODE, &vtysh_end_all_cmd);
3619 install_element(RIPNG_NODE, &vtysh_end_all_cmd);
3620 install_element(OSPF_NODE, &vtysh_end_all_cmd);
3621 install_element(EIGRP_NODE, &vtysh_end_all_cmd);
3622 install_element(BABEL_NODE, &vtysh_end_all_cmd);
3623 install_element(OSPF6_NODE, &vtysh_end_all_cmd);
3624 install_element(LDP_NODE, &vtysh_end_all_cmd);
3625 install_element(LDP_IPV4_NODE, &vtysh_end_all_cmd);
3626 install_element(LDP_IPV6_NODE, &vtysh_end_all_cmd);
3627 install_element(LDP_IPV4_IFACE_NODE, &vtysh_end_all_cmd);
3628 install_element(LDP_IPV6_IFACE_NODE, &vtysh_end_all_cmd);
3629 install_element(LDP_L2VPN_NODE, &vtysh_end_all_cmd);
3630 install_element(LDP_PSEUDOWIRE_NODE, &vtysh_end_all_cmd);
3631 install_element(BGP_NODE, &vtysh_end_all_cmd);
3632 install_element(BGP_IPV4_NODE, &vtysh_end_all_cmd);
3633 install_element(BGP_IPV4M_NODE, &vtysh_end_all_cmd);
3634 install_element(BGP_IPV4L_NODE, &vtysh_end_all_cmd);
3635 install_element(BGP_VPNV4_NODE, &vtysh_end_all_cmd);
3636 install_element(BGP_VPNV6_NODE, &vtysh_end_all_cmd);
3637 install_element(BGP_FLOWSPECV4_NODE, &vtysh_end_all_cmd);
3638 install_element(BGP_FLOWSPECV6_NODE, &vtysh_end_all_cmd);
3639 install_element(BGP_IPV6_NODE, &vtysh_end_all_cmd);
3640 install_element(BGP_IPV6M_NODE, &vtysh_end_all_cmd);
3641 install_element(BGP_IPV6L_NODE, &vtysh_end_all_cmd);
3642 install_element(BGP_VRF_POLICY_NODE, &vtysh_end_all_cmd);
3643 install_element(BGP_EVPN_NODE, &vtysh_end_all_cmd);
3644 install_element(BGP_EVPN_VNI_NODE, &vtysh_end_all_cmd);
3645 install_element(BGP_VNC_DEFAULTS_NODE, &vtysh_end_all_cmd);
3646 install_element(BGP_VNC_NVE_GROUP_NODE, &vtysh_end_all_cmd);
3647 install_element(BGP_VNC_L2_GROUP_NODE, &vtysh_end_all_cmd);
3648 install_element(ISIS_NODE, &vtysh_end_all_cmd);
3649 install_element(KEYCHAIN_NODE, &vtysh_end_all_cmd);
3650 install_element(KEYCHAIN_KEY_NODE, &vtysh_end_all_cmd);
3651 install_element(RMAP_NODE, &vtysh_end_all_cmd);
3652 install_element(PBRMAP_NODE, &vtysh_end_all_cmd);
3653 install_element(VTY_NODE, &vtysh_end_all_cmd);
3654
3655 install_element(INTERFACE_NODE, &vtysh_end_all_cmd);
3656 install_element(INTERFACE_NODE, &vtysh_exit_interface_cmd);
3657 install_element(LINK_PARAMS_NODE, &exit_link_params_cmd);
3658 install_element(LINK_PARAMS_NODE, &vtysh_end_all_cmd);
3659 install_element(LINK_PARAMS_NODE, &vtysh_exit_interface_cmd);
3660 install_element(INTERFACE_NODE, &vtysh_quit_interface_cmd);
3661
3662 install_element(PW_NODE, &vtysh_end_all_cmd);
3663 install_element(PW_NODE, &vtysh_exit_interface_cmd);
3664 install_element(PW_NODE, &vtysh_quit_interface_cmd);
3665
3666 install_element(LOGICALROUTER_NODE, &vtysh_end_all_cmd);
3667
3668 install_element(CONFIG_NODE, &vtysh_logicalrouter_cmd);
3669 install_element(CONFIG_NODE, &vtysh_no_logicalrouter_cmd);
3670 install_element(LOGICALROUTER_NODE, &vtysh_exit_logicalrouter_cmd);
3671 install_element(LOGICALROUTER_NODE, &vtysh_quit_logicalrouter_cmd);
3672
3673 install_element(CONFIG_NODE, &vtysh_nexthop_group_cmd);
3674 install_element(NH_GROUP_NODE, &vtysh_end_all_cmd);
3675 install_element(NH_GROUP_NODE, &vtysh_exit_nexthop_group_cmd);
3676 install_element(NH_GROUP_NODE, &vtysh_quit_nexthop_group_cmd);
3677
3678 install_element(VRF_NODE, &vtysh_end_all_cmd);
3679 install_element(VRF_NODE, &vtysh_exit_vrf_cmd);
3680 install_element(VRF_NODE, &vtysh_quit_vrf_cmd);
3681
3682 install_element(CONFIG_NODE, &router_eigrp_cmd);
3683 install_element(CONFIG_NODE, &router_babel_cmd);
3684 install_element(CONFIG_NODE, &router_rip_cmd);
3685 install_element(CONFIG_NODE, &router_ripng_cmd);
3686 install_element(CONFIG_NODE, &router_ospf_cmd);
3687 install_element(CONFIG_NODE, &router_ospf6_cmd);
3688 #if defined(HAVE_LDPD)
3689 install_element(CONFIG_NODE, &ldp_mpls_ldp_cmd);
3690 install_element(LDP_NODE, &ldp_address_family_ipv4_cmd);
3691 install_element(LDP_NODE, &ldp_address_family_ipv6_cmd);
3692 install_element(LDP_IPV4_NODE, &ldp_interface_ifname_cmd);
3693 install_element(LDP_IPV6_NODE, &ldp_interface_ifname_cmd);
3694 install_element(CONFIG_NODE, &ldp_l2vpn_word_type_vpls_cmd);
3695 install_element(LDP_L2VPN_NODE, &ldp_member_pseudowire_ifname_cmd);
3696 #endif
3697 install_element(CONFIG_NODE, &router_isis_cmd);
3698 install_element(CONFIG_NODE, &router_bgp_cmd);
3699 install_element(BGP_NODE, &address_family_vpnv4_cmd);
3700 install_element(BGP_NODE, &address_family_vpnv6_cmd);
3701 #if defined(ENABLE_BGP_VNC)
3702 install_element(BGP_NODE, &vnc_vrf_policy_cmd);
3703 install_element(BGP_NODE, &vnc_defaults_cmd);
3704 install_element(BGP_NODE, &vnc_nve_group_cmd);
3705 install_element(BGP_NODE, &vnc_l2_group_cmd);
3706 #endif
3707 install_element(BGP_NODE, &address_family_ipv4_cmd);
3708 install_element(BGP_NODE, &address_family_ipv4_multicast_cmd);
3709 install_element(BGP_NODE, &address_family_ipv4_vpn_cmd);
3710 install_element(BGP_NODE, &address_family_ipv4_labeled_unicast_cmd);
3711 install_element(BGP_NODE, &address_family_ipv6_cmd);
3712 install_element(BGP_NODE, &address_family_ipv6_multicast_cmd);
3713 install_element(BGP_NODE, &address_family_ipv6_vpn_cmd);
3714 install_element(BGP_NODE, &address_family_ipv6_labeled_unicast_cmd);
3715 install_element(BGP_NODE, &address_family_evpn_cmd);
3716 install_element(BGP_NODE, &address_family_flowspecv4_cmd);
3717 install_element(BGP_NODE, &address_family_flowspecv6_cmd);
3718 #if defined(HAVE_CUMULUS)
3719 install_element(BGP_NODE, &address_family_evpn2_cmd);
3720 #endif
3721 install_element(BGP_VPNV4_NODE, &exit_address_family_cmd);
3722 install_element(BGP_VPNV6_NODE, &exit_address_family_cmd);
3723 install_element(BGP_IPV4_NODE, &exit_address_family_cmd);
3724 install_element(BGP_IPV4M_NODE, &exit_address_family_cmd);
3725 install_element(BGP_IPV4L_NODE, &exit_address_family_cmd);
3726 install_element(BGP_IPV6_NODE, &exit_address_family_cmd);
3727 install_element(BGP_IPV6M_NODE, &exit_address_family_cmd);
3728 install_element(BGP_EVPN_NODE, &exit_address_family_cmd);
3729 install_element(BGP_IPV6L_NODE, &exit_address_family_cmd);
3730 install_element(BGP_FLOWSPECV4_NODE, &exit_address_family_cmd);
3731 install_element(BGP_FLOWSPECV6_NODE, &exit_address_family_cmd);
3732
3733 install_element(CONFIG_NODE, &rpki_cmd);
3734 install_element(RPKI_NODE, &rpki_exit_cmd);
3735 install_element(RPKI_NODE, &rpki_quit_cmd);
3736 install_element(RPKI_NODE, &vtysh_end_all_cmd);
3737
3738 /* EVPN commands */
3739 install_element(BGP_EVPN_NODE, &bgp_evpn_vni_cmd);
3740 install_element(BGP_EVPN_VNI_NODE, &exit_vni_cmd);
3741
3742 install_element(BGP_VRF_POLICY_NODE, &exit_vrf_policy_cmd);
3743 install_element(BGP_VNC_DEFAULTS_NODE, &exit_vnc_config_cmd);
3744 install_element(BGP_VNC_NVE_GROUP_NODE, &exit_vnc_config_cmd);
3745 install_element(BGP_VNC_L2_GROUP_NODE, &exit_vnc_config_cmd);
3746
3747 install_element(CONFIG_NODE, &key_chain_cmd);
3748 install_element(CONFIG_NODE, &vtysh_route_map_cmd);
3749 install_element(CONFIG_NODE, &vtysh_pbr_map_cmd);
3750 install_element(CONFIG_NODE, &vtysh_no_pbr_map_cmd);
3751 install_element(CONFIG_NODE, &vtysh_line_vty_cmd);
3752 install_element(KEYCHAIN_NODE, &key_cmd);
3753 install_element(KEYCHAIN_NODE, &key_chain_cmd);
3754 install_element(KEYCHAIN_KEY_NODE, &key_chain_cmd);
3755 install_element(CONFIG_NODE, &vtysh_interface_cmd);
3756 install_element(CONFIG_NODE, &vtysh_pseudowire_cmd);
3757 install_element(INTERFACE_NODE, &vtysh_link_params_cmd);
3758 install_element(ENABLE_NODE, &vtysh_show_running_config_cmd);
3759 install_element(ENABLE_NODE, &vtysh_copy_running_config_cmd);
3760
3761 install_element(CONFIG_NODE, &vtysh_vrf_cmd);
3762 install_element(VRF_NODE, &vtysh_vrf_netns_cmd);
3763 install_element(VRF_NODE, &vtysh_no_vrf_netns_cmd);
3764 install_element(VRF_NODE, &exit_vrf_config_cmd);
3765
3766 install_element(CONFIG_NODE, &vtysh_no_nexthop_group_cmd);
3767
3768 /* "write terminal" command. */
3769 install_element(ENABLE_NODE, &vtysh_write_terminal_cmd);
3770
3771 install_element(CONFIG_NODE, &vtysh_integrated_config_cmd);
3772 install_element(CONFIG_NODE, &no_vtysh_integrated_config_cmd);
3773
3774 /* "write memory" command. */
3775 install_element(ENABLE_NODE, &vtysh_write_memory_cmd);
3776
3777 install_element(CONFIG_NODE, &vtysh_terminal_paginate_cmd);
3778 install_element(VIEW_NODE, &vtysh_terminal_paginate_cmd);
3779 install_element(VIEW_NODE, &vtysh_terminal_length_cmd);
3780 install_element(VIEW_NODE, &vtysh_terminal_no_length_cmd);
3781 install_element(VIEW_NODE, &vtysh_show_daemons_cmd);
3782
3783 install_element(VIEW_NODE, &vtysh_ping_cmd);
3784 install_element(VIEW_NODE, &vtysh_ping_ip_cmd);
3785 install_element(VIEW_NODE, &vtysh_traceroute_cmd);
3786 install_element(VIEW_NODE, &vtysh_traceroute_ip_cmd);
3787 install_element(VIEW_NODE, &vtysh_mtrace_cmd);
3788 install_element(VIEW_NODE, &vtysh_ping6_cmd);
3789 install_element(VIEW_NODE, &vtysh_traceroute6_cmd);
3790 #if defined(HAVE_SHELL_ACCESS)
3791 install_element(VIEW_NODE, &vtysh_telnet_cmd);
3792 install_element(VIEW_NODE, &vtysh_telnet_port_cmd);
3793 install_element(VIEW_NODE, &vtysh_ssh_cmd);
3794 #endif
3795 #if defined(HAVE_SHELL_ACCESS)
3796 install_element(ENABLE_NODE, &vtysh_start_shell_cmd);
3797 install_element(ENABLE_NODE, &vtysh_start_bash_cmd);
3798 install_element(ENABLE_NODE, &vtysh_start_zsh_cmd);
3799 #endif
3800
3801 /* debugging */
3802 install_element(VIEW_NODE, &vtysh_show_debugging_cmd);
3803 install_element(VIEW_NODE, &vtysh_show_error_code_cmd);
3804 install_element(VIEW_NODE, &vtysh_show_debugging_hashtable_cmd);
3805 install_element(ENABLE_NODE, &vtysh_debug_all_cmd);
3806 install_element(CONFIG_NODE, &vtysh_debug_all_cmd);
3807
3808 /* misc lib show commands */
3809 install_element(VIEW_NODE, &vtysh_show_memory_cmd);
3810 install_element(VIEW_NODE, &vtysh_show_modules_cmd);
3811 install_element(VIEW_NODE, &vtysh_show_work_queues_cmd);
3812 install_element(VIEW_NODE, &vtysh_show_work_queues_daemon_cmd);
3813 install_element(VIEW_NODE, &vtysh_show_thread_cmd);
3814 install_element(VIEW_NODE, &vtysh_show_poll_cmd);
3815
3816 /* Logging */
3817 install_element(VIEW_NODE, &vtysh_show_logging_cmd);
3818 install_element(CONFIG_NODE, &vtysh_log_stdout_cmd);
3819 install_element(CONFIG_NODE, &vtysh_log_stdout_level_cmd);
3820 install_element(CONFIG_NODE, &no_vtysh_log_stdout_cmd);
3821 install_element(CONFIG_NODE, &vtysh_log_file_cmd);
3822 install_element(CONFIG_NODE, &vtysh_log_file_level_cmd);
3823 install_element(CONFIG_NODE, &no_vtysh_log_file_cmd);
3824 install_element(CONFIG_NODE, &vtysh_log_monitor_cmd);
3825 install_element(CONFIG_NODE, &no_vtysh_log_monitor_cmd);
3826 install_element(CONFIG_NODE, &vtysh_log_syslog_cmd);
3827 install_element(CONFIG_NODE, &no_vtysh_log_syslog_cmd);
3828 install_element(CONFIG_NODE, &vtysh_log_facility_cmd);
3829 install_element(CONFIG_NODE, &no_vtysh_log_facility_cmd);
3830 install_element(CONFIG_NODE, &vtysh_log_record_priority_cmd);
3831 install_element(CONFIG_NODE, &no_vtysh_log_record_priority_cmd);
3832 install_element(CONFIG_NODE, &vtysh_log_timestamp_precision_cmd);
3833 install_element(CONFIG_NODE, &no_vtysh_log_timestamp_precision_cmd);
3834
3835 install_element(CONFIG_NODE, &vtysh_service_password_encrypt_cmd);
3836 install_element(CONFIG_NODE, &no_vtysh_service_password_encrypt_cmd);
3837
3838 install_element(CONFIG_NODE, &vtysh_password_cmd);
3839 install_element(CONFIG_NODE, &no_vtysh_password_cmd);
3840 install_element(CONFIG_NODE, &vtysh_enable_password_cmd);
3841 install_element(CONFIG_NODE, &no_vtysh_enable_password_cmd);
3842 }
FRRouting mirror