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