]> git.proxmox.com Git - mirror_frr.git/blob - lib/vty.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #11284 from ordex/prefixlen_count
[mirror_frr.git] / lib / vty.c
1 /*
2 * Virtual terminal [aka TeletYpe] interface routine.
3 * Copyright (C) 1997, 98 Kunihiro Ishiguro
4 *
5 * This file is part of GNU Zebra.
6 *
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23
24 #include <lib/version.h>
25 #include <sys/types.h>
26 #include <sys/types.h>
27 #ifdef HAVE_LIBPCREPOSIX
28 #include <pcreposix.h>
29 #else
30 #include <regex.h>
31 #endif /* HAVE_LIBPCREPOSIX */
32 #include <stdio.h>
33
34 #include "linklist.h"
35 #include "thread.h"
36 #include "buffer.h"
37 #include "command.h"
38 #include "sockunion.h"
39 #include "memory.h"
40 #include "log.h"
41 #include "prefix.h"
42 #include "filter.h"
43 #include "vty.h"
44 #include "privs.h"
45 #include "network.h"
46 #include "libfrr.h"
47 #include "frrstr.h"
48 #include "lib_errors.h"
49 #include "northbound_cli.h"
50 #include "printfrr.h"
51 #include "json.h"
52
53 #include <arpa/telnet.h>
54 #include <termios.h>
55
56 #ifndef VTYSH_EXTRACT_PL
57 #include "lib/vty_clippy.c"
58 #endif
59
60 DEFINE_MTYPE_STATIC(LIB, VTY, "VTY");
61 DEFINE_MTYPE_STATIC(LIB, VTY_SERV, "VTY server");
62 DEFINE_MTYPE_STATIC(LIB, VTY_OUT_BUF, "VTY output buffer");
63 DEFINE_MTYPE_STATIC(LIB, VTY_HIST, "VTY history");
64
65 DECLARE_DLIST(vtys, struct vty, itm);
66
67 /* Vty events */
68 enum vty_event {
69 VTY_SERV,
70 VTY_READ,
71 VTY_WRITE,
72 VTY_TIMEOUT_RESET,
73 #ifdef VTYSH
74 VTYSH_SERV,
75 VTYSH_READ,
76 VTYSH_WRITE
77 #endif /* VTYSH */
78 };
79
80 PREDECL_DLIST(vtyservs);
81
82 struct vty_serv {
83 struct vtyservs_item itm;
84
85 int sock;
86 bool vtysh;
87
88 struct thread *t_accept;
89 };
90
91 DECLARE_DLIST(vtyservs, struct vty_serv, itm);
92
93 static void vty_event_serv(enum vty_event event, struct vty_serv *);
94 static void vty_event(enum vty_event, struct vty *);
95
96 /* Extern host structure from command.c */
97 extern struct host host;
98
99 /* active listeners */
100 static struct vtyservs_head vty_servs[1] = {INIT_DLIST(vty_servs[0])};
101
102 /* active connections */
103 static struct vtys_head vty_sessions[1] = {INIT_DLIST(vty_sessions[0])};
104 static struct vtys_head vtysh_sessions[1] = {INIT_DLIST(vtysh_sessions[0])};
105
106 /* Vty timeout value. */
107 static unsigned long vty_timeout_val = VTY_TIMEOUT_DEFAULT;
108
109 /* Vty access-class command */
110 static char *vty_accesslist_name = NULL;
111
112 /* Vty access-calss for IPv6. */
113 static char *vty_ipv6_accesslist_name = NULL;
114
115 /* Current directory. */
116 static char vty_cwd[MAXPATHLEN];
117
118 /* Login password check. */
119 static int no_password_check = 0;
120
121 /* Integrated configuration file path */
122 static char integrate_default[] = SYSCONFDIR INTEGRATE_DEFAULT_CONFIG;
123
124 static bool do_log_commands;
125 static bool do_log_commands_perm;
126
127 void vty_frame(struct vty *vty, const char *format, ...)
128 {
129 va_list args;
130
131 va_start(args, format);
132 vsnprintfrr(vty->frame + vty->frame_pos,
133 sizeof(vty->frame) - vty->frame_pos, format, args);
134 vty->frame_pos = strlen(vty->frame);
135 va_end(args);
136 }
137
138 void vty_endframe(struct vty *vty, const char *endtext)
139 {
140 if (vty->frame_pos == 0 && endtext)
141 vty_out(vty, "%s", endtext);
142 vty->frame_pos = 0;
143 }
144
145 bool vty_set_include(struct vty *vty, const char *regexp)
146 {
147 int errcode;
148 bool ret = true;
149 char errbuf[256];
150
151 if (!regexp) {
152 if (vty->filter) {
153 regfree(&vty->include);
154 vty->filter = false;
155 }
156 return true;
157 }
158
159 errcode = regcomp(&vty->include, regexp,
160 REG_EXTENDED | REG_NEWLINE | REG_NOSUB);
161 if (errcode) {
162 ret = false;
163 regerror(errcode, &vty->include, errbuf, sizeof(errbuf));
164 vty_out(vty, "%% Regex compilation error: %s\n", errbuf);
165 } else {
166 vty->filter = true;
167 }
168
169 return ret;
170 }
171
172 /* VTY standard output function. */
173 int vty_out(struct vty *vty, const char *format, ...)
174 {
175 va_list args;
176 ssize_t len;
177 char buf[1024];
178 char *p = NULL;
179 char *filtered;
180 /* format string may contain %m, keep errno intact for printfrr */
181 int saved_errno = errno;
182
183 if (vty->frame_pos) {
184 vty->frame_pos = 0;
185 vty_out(vty, "%s", vty->frame);
186 }
187
188 va_start(args, format);
189 errno = saved_errno;
190 p = vasnprintfrr(MTYPE_VTY_OUT_BUF, buf, sizeof(buf), format, args);
191 va_end(args);
192
193 len = strlen(p);
194
195 /* filter buffer */
196 if (vty->filter) {
197 vector lines = frrstr_split_vec(p, "\n");
198
199 /* Place first value in the cache */
200 char *firstline = vector_slot(lines, 0);
201 buffer_put(vty->lbuf, (uint8_t *) firstline, strlen(firstline));
202
203 /* If our split returned more than one entry, time to filter */
204 if (vector_active(lines) > 1) {
205 /*
206 * returned string is MTYPE_TMP so it matches the MTYPE
207 * of everything else in the vector
208 */
209 char *bstr = buffer_getstr(vty->lbuf);
210 buffer_reset(vty->lbuf);
211 XFREE(MTYPE_TMP, lines->index[0]);
212 vector_set_index(lines, 0, bstr);
213 frrstr_filter_vec(lines, &vty->include);
214 vector_compact(lines);
215 /*
216 * Consider the string "foo\n". If the regex is an empty string
217 * and the line ended with a newline, then the vector will look
218 * like:
219 *
220 * [0]: 'foo'
221 * [1]: ''
222 *
223 * If the regex isn't empty, the vector will look like:
224 *
225 * [0]: 'foo'
226 *
227 * In this case we'd like to preserve the newline, so we add
228 * the empty string [1] as in the first example.
229 */
230 if (p[strlen(p) - 1] == '\n' && vector_active(lines) > 0
231 && strlen(vector_slot(lines, vector_active(lines) - 1)))
232 vector_set(lines, XSTRDUP(MTYPE_TMP, ""));
233
234 filtered = frrstr_join_vec(lines, "\n");
235 }
236 else {
237 filtered = NULL;
238 }
239
240 frrstr_strvec_free(lines);
241
242 } else {
243 filtered = p;
244 }
245
246 if (!filtered)
247 goto done;
248
249 switch (vty->type) {
250 case VTY_TERM:
251 /* print with crlf replacement */
252 buffer_put_crlf(vty->obuf, (uint8_t *)filtered,
253 strlen(filtered));
254 break;
255 case VTY_SHELL:
256 if (vty->of) {
257 fprintf(vty->of, "%s", filtered);
258 fflush(vty->of);
259 } else if (vty->of_saved) {
260 fprintf(vty->of_saved, "%s", filtered);
261 fflush(vty->of_saved);
262 }
263 break;
264 case VTY_SHELL_SERV:
265 case VTY_FILE:
266 default:
267 /* print without crlf replacement */
268 buffer_put(vty->obuf, (uint8_t *)filtered, strlen(filtered));
269 break;
270 }
271
272 done:
273
274 if (vty->filter && filtered)
275 XFREE(MTYPE_TMP, filtered);
276
277 /* If p is not different with buf, it is allocated buffer. */
278 if (p != buf)
279 XFREE(MTYPE_VTY_OUT_BUF, p);
280
281 return len;
282 }
283
284 int vty_json(struct vty *vty, struct json_object *json)
285 {
286 const char *text;
287
288 if (!json)
289 return CMD_SUCCESS;
290
291 text = json_object_to_json_string_ext(
292 json, JSON_C_TO_STRING_PRETTY | JSON_C_TO_STRING_NOSLASHESCAPE);
293 vty_out(vty, "%s\n", text);
294 json_object_free(json);
295
296 return CMD_SUCCESS;
297 }
298
299 /* Output current time to the vty. */
300 void vty_time_print(struct vty *vty, int cr)
301 {
302 char buf[FRR_TIMESTAMP_LEN];
303
304 if (frr_timestamp(0, buf, sizeof(buf)) == 0) {
305 zlog_info("frr_timestamp error");
306 return;
307 }
308 if (cr)
309 vty_out(vty, "%s\n", buf);
310 else
311 vty_out(vty, "%s ", buf);
312
313 return;
314 }
315
316 /* Say hello to vty interface. */
317 void vty_hello(struct vty *vty)
318 {
319 if (host.motdfile) {
320 FILE *f;
321 char buf[4096];
322
323 f = fopen(host.motdfile, "r");
324 if (f) {
325 while (fgets(buf, sizeof(buf), f)) {
326 char *s;
327 /* work backwards to ignore trailling isspace()
328 */
329 for (s = buf + strlen(buf);
330 (s > buf) && isspace((unsigned char)s[-1]);
331 s--)
332 ;
333 *s = '\0';
334 vty_out(vty, "%s\n", buf);
335 }
336 fclose(f);
337 } else
338 vty_out(vty, "MOTD file not found\n");
339 } else if (host.motd)
340 vty_out(vty, "%s", host.motd);
341 }
342
343 /* Put out prompt and wait input from user. */
344 static void vty_prompt(struct vty *vty)
345 {
346 if (vty->type == VTY_TERM) {
347 vty_out(vty, cmd_prompt(vty->node), cmd_hostname_get());
348 }
349 }
350
351 /* Send WILL TELOPT_ECHO to remote server. */
352 static void vty_will_echo(struct vty *vty)
353 {
354 unsigned char cmd[] = {IAC, WILL, TELOPT_ECHO, '\0'};
355 vty_out(vty, "%s", cmd);
356 }
357
358 /* Make suppress Go-Ahead telnet option. */
359 static void vty_will_suppress_go_ahead(struct vty *vty)
360 {
361 unsigned char cmd[] = {IAC, WILL, TELOPT_SGA, '\0'};
362 vty_out(vty, "%s", cmd);
363 }
364
365 /* Make don't use linemode over telnet. */
366 static void vty_dont_linemode(struct vty *vty)
367 {
368 unsigned char cmd[] = {IAC, DONT, TELOPT_LINEMODE, '\0'};
369 vty_out(vty, "%s", cmd);
370 }
371
372 /* Use window size. */
373 static void vty_do_window_size(struct vty *vty)
374 {
375 unsigned char cmd[] = {IAC, DO, TELOPT_NAWS, '\0'};
376 vty_out(vty, "%s", cmd);
377 }
378
379 /* Authentication of vty */
380 static void vty_auth(struct vty *vty, char *buf)
381 {
382 char *passwd = NULL;
383 enum node_type next_node = 0;
384 int fail;
385
386 switch (vty->node) {
387 case AUTH_NODE:
388 if (host.encrypt)
389 passwd = host.password_encrypt;
390 else
391 passwd = host.password;
392 if (host.advanced)
393 next_node = host.enable ? VIEW_NODE : ENABLE_NODE;
394 else
395 next_node = VIEW_NODE;
396 break;
397 case AUTH_ENABLE_NODE:
398 if (host.encrypt)
399 passwd = host.enable_encrypt;
400 else
401 passwd = host.enable;
402 next_node = ENABLE_NODE;
403 break;
404 }
405
406 if (passwd) {
407 if (host.encrypt)
408 fail = strcmp(crypt(buf, passwd), passwd);
409 else
410 fail = strcmp(buf, passwd);
411 } else
412 fail = 1;
413
414 if (!fail) {
415 vty->fail = 0;
416 vty->node = next_node; /* Success ! */
417 } else {
418 vty->fail++;
419 if (vty->fail >= 3) {
420 if (vty->node == AUTH_NODE) {
421 vty_out(vty,
422 "%% Bad passwords, too many failures!\n");
423 vty->status = VTY_CLOSE;
424 } else {
425 /* AUTH_ENABLE_NODE */
426 vty->fail = 0;
427 vty_out(vty,
428 "%% Bad enable passwords, too many failures!\n");
429 vty->status = VTY_CLOSE;
430 }
431 }
432 }
433 }
434
435 /* Command execution over the vty interface. */
436 static int vty_command(struct vty *vty, char *buf)
437 {
438 int ret;
439 const char *protocolname;
440 char *cp = NULL;
441
442 assert(vty);
443
444 /*
445 * Log non empty command lines
446 */
447 if (do_log_commands)
448 cp = buf;
449 if (cp != NULL) {
450 /* Skip white spaces. */
451 while (isspace((unsigned char)*cp) && *cp != '\0')
452 cp++;
453 }
454 if (cp != NULL && *cp != '\0') {
455 char vty_str[VTY_BUFSIZ];
456 char prompt_str[VTY_BUFSIZ];
457
458 /* format the base vty info */
459 snprintf(vty_str, sizeof(vty_str), "vty[%d]@%s", vty->fd,
460 vty->address);
461
462 /* format the prompt */
463 snprintf(prompt_str, sizeof(prompt_str), cmd_prompt(vty->node),
464 vty_str);
465
466 /* now log the command */
467 zlog_notice("%s%s", prompt_str, buf);
468 }
469
470 RUSAGE_T before;
471 RUSAGE_T after;
472 unsigned long walltime, cputime;
473
474 /* cmd_execute() may change cputime_enabled if we're executing the
475 * "service cputime-stats" command, which can result in nonsensical
476 * and very confusing warnings
477 */
478 bool cputime_enabled_here = cputime_enabled;
479
480 GETRUSAGE(&before);
481
482 ret = cmd_execute(vty, buf, NULL, 0);
483
484 GETRUSAGE(&after);
485
486 walltime = thread_consumed_time(&after, &before, &cputime);
487
488 if (cputime_enabled_here && cputime_enabled && cputime_threshold
489 && cputime > cputime_threshold)
490 /* Warn about CPU hog that must be fixed. */
491 flog_warn(EC_LIB_SLOW_THREAD_CPU,
492 "CPU HOG: command took %lums (cpu time %lums): %s",
493 walltime / 1000, cputime / 1000, buf);
494 else if (walltime_threshold && walltime > walltime_threshold)
495 flog_warn(EC_LIB_SLOW_THREAD_WALL,
496 "STARVATION: command took %lums (cpu time %lums): %s",
497 walltime / 1000, cputime / 1000, buf);
498
499 /* Get the name of the protocol if any */
500 protocolname = frr_protoname;
501
502 if (ret != CMD_SUCCESS)
503 switch (ret) {
504 case CMD_WARNING:
505 if (vty->type == VTY_FILE)
506 vty_out(vty, "Warning...\n");
507 break;
508 case CMD_ERR_AMBIGUOUS:
509 vty_out(vty, "%% Ambiguous command.\n");
510 break;
511 case CMD_ERR_NO_MATCH:
512 vty_out(vty, "%% [%s] Unknown command: %s\n",
513 protocolname, buf);
514 break;
515 case CMD_ERR_INCOMPLETE:
516 vty_out(vty, "%% Command incomplete.\n");
517 break;
518 }
519
520 return ret;
521 }
522
523 static const char telnet_backward_char = 0x08;
524 static const char telnet_space_char = ' ';
525
526 /* Basic function to write buffer to vty. */
527 static void vty_write(struct vty *vty, const char *buf, size_t nbytes)
528 {
529 if ((vty->node == AUTH_NODE) || (vty->node == AUTH_ENABLE_NODE))
530 return;
531
532 /* Should we do buffering here ? And make vty_flush (vty) ? */
533 buffer_put(vty->obuf, buf, nbytes);
534 }
535
536 /* Basic function to insert character into vty. */
537 static void vty_self_insert(struct vty *vty, char c)
538 {
539 int i;
540 int length;
541
542 if (vty->length + 1 >= VTY_BUFSIZ)
543 return;
544
545 length = vty->length - vty->cp;
546 memmove(&vty->buf[vty->cp + 1], &vty->buf[vty->cp], length);
547 vty->buf[vty->cp] = c;
548
549 vty_write(vty, &vty->buf[vty->cp], length + 1);
550 for (i = 0; i < length; i++)
551 vty_write(vty, &telnet_backward_char, 1);
552
553 vty->cp++;
554 vty->length++;
555
556 vty->buf[vty->length] = '\0';
557 }
558
559 /* Self insert character 'c' in overwrite mode. */
560 static void vty_self_insert_overwrite(struct vty *vty, char c)
561 {
562 if (vty->cp == vty->length) {
563 vty_self_insert(vty, c);
564 return;
565 }
566
567 vty->buf[vty->cp++] = c;
568 vty_write(vty, &c, 1);
569 }
570
571 /**
572 * Insert a string into vty->buf at the current cursor position.
573 *
574 * If the resultant string would be larger than VTY_BUFSIZ it is
575 * truncated to fit.
576 */
577 static void vty_insert_word_overwrite(struct vty *vty, char *str)
578 {
579 if (vty->cp == VTY_BUFSIZ)
580 return;
581
582 size_t nwrite = MIN((int)strlen(str), VTY_BUFSIZ - vty->cp - 1);
583 memcpy(&vty->buf[vty->cp], str, nwrite);
584 vty->cp += nwrite;
585 vty->length = MAX(vty->cp, vty->length);
586 vty->buf[vty->length] = '\0';
587 vty_write(vty, str, nwrite);
588 }
589
590 /* Forward character. */
591 static void vty_forward_char(struct vty *vty)
592 {
593 if (vty->cp < vty->length) {
594 vty_write(vty, &vty->buf[vty->cp], 1);
595 vty->cp++;
596 }
597 }
598
599 /* Backward character. */
600 static void vty_backward_char(struct vty *vty)
601 {
602 if (vty->cp > 0) {
603 vty->cp--;
604 vty_write(vty, &telnet_backward_char, 1);
605 }
606 }
607
608 /* Move to the beginning of the line. */
609 static void vty_beginning_of_line(struct vty *vty)
610 {
611 while (vty->cp)
612 vty_backward_char(vty);
613 }
614
615 /* Move to the end of the line. */
616 static void vty_end_of_line(struct vty *vty)
617 {
618 while (vty->cp < vty->length)
619 vty_forward_char(vty);
620 }
621
622 static void vty_kill_line_from_beginning(struct vty *);
623 static void vty_redraw_line(struct vty *);
624
625 /* Print command line history. This function is called from
626 vty_next_line and vty_previous_line. */
627 static void vty_history_print(struct vty *vty)
628 {
629 int length;
630
631 vty_kill_line_from_beginning(vty);
632
633 /* Get previous line from history buffer */
634 length = strlen(vty->hist[vty->hp]);
635 memcpy(vty->buf, vty->hist[vty->hp], length);
636 vty->cp = vty->length = length;
637 vty->buf[vty->length] = '\0';
638
639 /* Redraw current line */
640 vty_redraw_line(vty);
641 }
642
643 /* Show next command line history. */
644 static void vty_next_line(struct vty *vty)
645 {
646 int try_index;
647
648 if (vty->hp == vty->hindex)
649 return;
650
651 /* Try is there history exist or not. */
652 try_index = vty->hp;
653 if (try_index == (VTY_MAXHIST - 1))
654 try_index = 0;
655 else
656 try_index++;
657
658 /* If there is not history return. */
659 if (vty->hist[try_index] == NULL)
660 return;
661 else
662 vty->hp = try_index;
663
664 vty_history_print(vty);
665 }
666
667 /* Show previous command line history. */
668 static void vty_previous_line(struct vty *vty)
669 {
670 int try_index;
671
672 try_index = vty->hp;
673 if (try_index == 0)
674 try_index = VTY_MAXHIST - 1;
675 else
676 try_index--;
677
678 if (vty->hist[try_index] == NULL)
679 return;
680 else
681 vty->hp = try_index;
682
683 vty_history_print(vty);
684 }
685
686 /* This function redraw all of the command line character. */
687 static void vty_redraw_line(struct vty *vty)
688 {
689 vty_write(vty, vty->buf, vty->length);
690 vty->cp = vty->length;
691 }
692
693 /* Forward word. */
694 static void vty_forward_word(struct vty *vty)
695 {
696 while (vty->cp != vty->length && vty->buf[vty->cp] != ' ')
697 vty_forward_char(vty);
698
699 while (vty->cp != vty->length && vty->buf[vty->cp] == ' ')
700 vty_forward_char(vty);
701 }
702
703 /* Backward word without skipping training space. */
704 static void vty_backward_pure_word(struct vty *vty)
705 {
706 while (vty->cp > 0 && vty->buf[vty->cp - 1] != ' ')
707 vty_backward_char(vty);
708 }
709
710 /* Backward word. */
711 static void vty_backward_word(struct vty *vty)
712 {
713 while (vty->cp > 0 && vty->buf[vty->cp - 1] == ' ')
714 vty_backward_char(vty);
715
716 while (vty->cp > 0 && vty->buf[vty->cp - 1] != ' ')
717 vty_backward_char(vty);
718 }
719
720 /* When '^D' is typed at the beginning of the line we move to the down
721 level. */
722 static void vty_down_level(struct vty *vty)
723 {
724 vty_out(vty, "\n");
725 cmd_exit(vty);
726 vty_prompt(vty);
727 vty->cp = 0;
728 }
729
730 /* When '^Z' is received from vty, move down to the enable mode. */
731 static void vty_end_config(struct vty *vty)
732 {
733 vty_out(vty, "\n");
734
735 if (vty->config) {
736 vty_config_exit(vty);
737 vty->node = ENABLE_NODE;
738 }
739
740 vty_prompt(vty);
741 vty->cp = 0;
742 }
743
744 /* Delete a character at the current point. */
745 static void vty_delete_char(struct vty *vty)
746 {
747 int i;
748 int size;
749
750 if (vty->length == 0) {
751 vty_down_level(vty);
752 return;
753 }
754
755 if (vty->cp == vty->length)
756 return; /* completion need here? */
757
758 size = vty->length - vty->cp;
759
760 vty->length--;
761 memmove(&vty->buf[vty->cp], &vty->buf[vty->cp + 1], size - 1);
762 vty->buf[vty->length] = '\0';
763
764 if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
765 return;
766
767 vty_write(vty, &vty->buf[vty->cp], size - 1);
768 vty_write(vty, &telnet_space_char, 1);
769
770 for (i = 0; i < size; i++)
771 vty_write(vty, &telnet_backward_char, 1);
772 }
773
774 /* Delete a character before the point. */
775 static void vty_delete_backward_char(struct vty *vty)
776 {
777 if (vty->cp == 0)
778 return;
779
780 vty_backward_char(vty);
781 vty_delete_char(vty);
782 }
783
784 /* Kill rest of line from current point. */
785 static void vty_kill_line(struct vty *vty)
786 {
787 int i;
788 int size;
789
790 size = vty->length - vty->cp;
791
792 if (size == 0)
793 return;
794
795 for (i = 0; i < size; i++)
796 vty_write(vty, &telnet_space_char, 1);
797 for (i = 0; i < size; i++)
798 vty_write(vty, &telnet_backward_char, 1);
799
800 memset(&vty->buf[vty->cp], 0, size);
801 vty->length = vty->cp;
802 }
803
804 /* Kill line from the beginning. */
805 static void vty_kill_line_from_beginning(struct vty *vty)
806 {
807 vty_beginning_of_line(vty);
808 vty_kill_line(vty);
809 }
810
811 /* Delete a word before the point. */
812 static void vty_forward_kill_word(struct vty *vty)
813 {
814 while (vty->cp != vty->length && vty->buf[vty->cp] == ' ')
815 vty_delete_char(vty);
816 while (vty->cp != vty->length && vty->buf[vty->cp] != ' ')
817 vty_delete_char(vty);
818 }
819
820 /* Delete a word before the point. */
821 static void vty_backward_kill_word(struct vty *vty)
822 {
823 while (vty->cp > 0 && vty->buf[vty->cp - 1] == ' ')
824 vty_delete_backward_char(vty);
825 while (vty->cp > 0 && vty->buf[vty->cp - 1] != ' ')
826 vty_delete_backward_char(vty);
827 }
828
829 /* Transpose chars before or at the point. */
830 static void vty_transpose_chars(struct vty *vty)
831 {
832 char c1, c2;
833
834 /* If length is short or point is near by the beginning of line then
835 return. */
836 if (vty->length < 2 || vty->cp < 1)
837 return;
838
839 /* In case of point is located at the end of the line. */
840 if (vty->cp == vty->length) {
841 c1 = vty->buf[vty->cp - 1];
842 c2 = vty->buf[vty->cp - 2];
843
844 vty_backward_char(vty);
845 vty_backward_char(vty);
846 vty_self_insert_overwrite(vty, c1);
847 vty_self_insert_overwrite(vty, c2);
848 } else {
849 c1 = vty->buf[vty->cp];
850 c2 = vty->buf[vty->cp - 1];
851
852 vty_backward_char(vty);
853 vty_self_insert_overwrite(vty, c1);
854 vty_self_insert_overwrite(vty, c2);
855 }
856 }
857
858 /* Do completion at vty interface. */
859 static void vty_complete_command(struct vty *vty)
860 {
861 int i;
862 int ret;
863 char **matched = NULL;
864 vector vline;
865
866 if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
867 return;
868
869 vline = cmd_make_strvec(vty->buf);
870 if (vline == NULL)
871 return;
872
873 /* In case of 'help \t'. */
874 if (isspace((unsigned char)vty->buf[vty->length - 1]))
875 vector_set(vline, NULL);
876
877 matched = cmd_complete_command(vline, vty, &ret);
878
879 cmd_free_strvec(vline);
880
881 vty_out(vty, "\n");
882 switch (ret) {
883 case CMD_ERR_AMBIGUOUS:
884 vty_out(vty, "%% Ambiguous command.\n");
885 vty_prompt(vty);
886 vty_redraw_line(vty);
887 break;
888 case CMD_ERR_NO_MATCH:
889 /* vty_out (vty, "%% There is no matched command.\n"); */
890 vty_prompt(vty);
891 vty_redraw_line(vty);
892 break;
893 case CMD_COMPLETE_FULL_MATCH:
894 if (!matched[0]) {
895 /* 2016-11-28 equinox -- need to debug, SEGV here */
896 vty_out(vty, "%% CLI BUG: FULL_MATCH with NULL str\n");
897 vty_prompt(vty);
898 vty_redraw_line(vty);
899 break;
900 }
901 vty_prompt(vty);
902 vty_redraw_line(vty);
903 vty_backward_pure_word(vty);
904 vty_insert_word_overwrite(vty, matched[0]);
905 vty_self_insert(vty, ' ');
906 XFREE(MTYPE_COMPLETION, matched[0]);
907 break;
908 case CMD_COMPLETE_MATCH:
909 vty_prompt(vty);
910 vty_redraw_line(vty);
911 vty_backward_pure_word(vty);
912 vty_insert_word_overwrite(vty, matched[0]);
913 XFREE(MTYPE_COMPLETION, matched[0]);
914 break;
915 case CMD_COMPLETE_LIST_MATCH:
916 for (i = 0; matched[i] != NULL; i++) {
917 if (i != 0 && ((i % 6) == 0))
918 vty_out(vty, "\n");
919 vty_out(vty, "%-10s ", matched[i]);
920 XFREE(MTYPE_COMPLETION, matched[i]);
921 }
922 vty_out(vty, "\n");
923
924 vty_prompt(vty);
925 vty_redraw_line(vty);
926 break;
927 case CMD_ERR_NOTHING_TODO:
928 vty_prompt(vty);
929 vty_redraw_line(vty);
930 break;
931 default:
932 break;
933 }
934 XFREE(MTYPE_TMP, matched);
935 }
936
937 static void vty_describe_fold(struct vty *vty, int cmd_width,
938 unsigned int desc_width, struct cmd_token *token)
939 {
940 char *buf;
941 const char *cmd, *p;
942 int pos;
943
944 cmd = token->text;
945
946 if (desc_width <= 0) {
947 vty_out(vty, " %-*s %s\n", cmd_width, cmd, token->desc);
948 return;
949 }
950
951 buf = XCALLOC(MTYPE_TMP, strlen(token->desc) + 1);
952
953 for (p = token->desc; strlen(p) > desc_width; p += pos + 1) {
954 for (pos = desc_width; pos > 0; pos--)
955 if (*(p + pos) == ' ')
956 break;
957
958 if (pos == 0)
959 break;
960
961 memcpy(buf, p, pos);
962 buf[pos] = '\0';
963 vty_out(vty, " %-*s %s\n", cmd_width, cmd, buf);
964
965 cmd = "";
966 }
967
968 vty_out(vty, " %-*s %s\n", cmd_width, cmd, p);
969
970 XFREE(MTYPE_TMP, buf);
971 }
972
973 /* Describe matched command function. */
974 static void vty_describe_command(struct vty *vty)
975 {
976 int ret;
977 vector vline;
978 vector describe;
979 unsigned int i, width, desc_width;
980 struct cmd_token *token, *token_cr = NULL;
981
982 vline = cmd_make_strvec(vty->buf);
983
984 /* In case of '> ?'. */
985 if (vline == NULL) {
986 vline = vector_init(1);
987 vector_set(vline, NULL);
988 } else if (isspace((unsigned char)vty->buf[vty->length - 1]))
989 vector_set(vline, NULL);
990
991 describe = cmd_describe_command(vline, vty, &ret);
992
993 vty_out(vty, "\n");
994
995 /* Ambiguous error. */
996 switch (ret) {
997 case CMD_ERR_AMBIGUOUS:
998 vty_out(vty, "%% Ambiguous command.\n");
999 goto out;
1000 break;
1001 case CMD_ERR_NO_MATCH:
1002 vty_out(vty, "%% There is no matched command.\n");
1003 goto out;
1004 break;
1005 }
1006
1007 /* Get width of command string. */
1008 width = 0;
1009 for (i = 0; i < vector_active(describe); i++)
1010 if ((token = vector_slot(describe, i)) != NULL) {
1011 unsigned int len;
1012
1013 if (token->text[0] == '\0')
1014 continue;
1015
1016 len = strlen(token->text);
1017
1018 if (width < len)
1019 width = len;
1020 }
1021
1022 /* Get width of description string. */
1023 desc_width = vty->width - (width + 6);
1024
1025 /* Print out description. */
1026 for (i = 0; i < vector_active(describe); i++)
1027 if ((token = vector_slot(describe, i)) != NULL) {
1028 if (token->text[0] == '\0')
1029 continue;
1030
1031 if (strcmp(token->text, CMD_CR_TEXT) == 0) {
1032 token_cr = token;
1033 continue;
1034 }
1035
1036 if (!token->desc)
1037 vty_out(vty, " %-s\n", token->text);
1038 else if (desc_width >= strlen(token->desc))
1039 vty_out(vty, " %-*s %s\n", width, token->text,
1040 token->desc);
1041 else
1042 vty_describe_fold(vty, width, desc_width,
1043 token);
1044
1045 if (IS_VARYING_TOKEN(token->type)) {
1046 const char *ref = vector_slot(
1047 vline, vector_active(vline) - 1);
1048
1049 vector varcomps = vector_init(VECTOR_MIN_SIZE);
1050 cmd_variable_complete(token, ref, varcomps);
1051
1052 if (vector_active(varcomps) > 0) {
1053 char *ac = cmd_variable_comp2str(
1054 varcomps, vty->width);
1055 vty_out(vty, "%s\n", ac);
1056 XFREE(MTYPE_TMP, ac);
1057 }
1058
1059 vector_free(varcomps);
1060 }
1061 }
1062
1063 if ((token = token_cr)) {
1064 if (!token->desc)
1065 vty_out(vty, " %-s\n", token->text);
1066 else if (desc_width >= strlen(token->desc))
1067 vty_out(vty, " %-*s %s\n", width, token->text,
1068 token->desc);
1069 else
1070 vty_describe_fold(vty, width, desc_width, token);
1071 }
1072
1073 out:
1074 cmd_free_strvec(vline);
1075 if (describe)
1076 vector_free(describe);
1077
1078 vty_prompt(vty);
1079 vty_redraw_line(vty);
1080 }
1081
1082 static void vty_clear_buf(struct vty *vty)
1083 {
1084 memset(vty->buf, 0, vty->max);
1085 }
1086
1087 /* ^C stop current input and do not add command line to the history. */
1088 static void vty_stop_input(struct vty *vty)
1089 {
1090 vty->cp = vty->length = 0;
1091 vty_clear_buf(vty);
1092 vty_out(vty, "\n");
1093
1094 if (vty->config) {
1095 vty_config_exit(vty);
1096 vty->node = ENABLE_NODE;
1097 }
1098
1099 vty_prompt(vty);
1100
1101 /* Set history pointer to the latest one. */
1102 vty->hp = vty->hindex;
1103 }
1104
1105 /* Add current command line to the history buffer. */
1106 static void vty_hist_add(struct vty *vty)
1107 {
1108 int index;
1109
1110 if (vty->length == 0)
1111 return;
1112
1113 index = vty->hindex ? vty->hindex - 1 : VTY_MAXHIST - 1;
1114
1115 /* Ignore the same string as previous one. */
1116 if (vty->hist[index])
1117 if (strcmp(vty->buf, vty->hist[index]) == 0) {
1118 vty->hp = vty->hindex;
1119 return;
1120 }
1121
1122 /* Insert history entry. */
1123 XFREE(MTYPE_VTY_HIST, vty->hist[vty->hindex]);
1124 vty->hist[vty->hindex] = XSTRDUP(MTYPE_VTY_HIST, vty->buf);
1125
1126 /* History index rotation. */
1127 vty->hindex++;
1128 if (vty->hindex == VTY_MAXHIST)
1129 vty->hindex = 0;
1130
1131 vty->hp = vty->hindex;
1132 }
1133
1134 /* #define TELNET_OPTION_DEBUG */
1135
1136 /* Get telnet window size. */
1137 static int vty_telnet_option(struct vty *vty, unsigned char *buf, int nbytes)
1138 {
1139 #ifdef TELNET_OPTION_DEBUG
1140 int i;
1141
1142 for (i = 0; i < nbytes; i++) {
1143 switch (buf[i]) {
1144 case IAC:
1145 vty_out(vty, "IAC ");
1146 break;
1147 case WILL:
1148 vty_out(vty, "WILL ");
1149 break;
1150 case WONT:
1151 vty_out(vty, "WONT ");
1152 break;
1153 case DO:
1154 vty_out(vty, "DO ");
1155 break;
1156 case DONT:
1157 vty_out(vty, "DONT ");
1158 break;
1159 case SB:
1160 vty_out(vty, "SB ");
1161 break;
1162 case SE:
1163 vty_out(vty, "SE ");
1164 break;
1165 case TELOPT_ECHO:
1166 vty_out(vty, "TELOPT_ECHO \n");
1167 break;
1168 case TELOPT_SGA:
1169 vty_out(vty, "TELOPT_SGA \n");
1170 break;
1171 case TELOPT_NAWS:
1172 vty_out(vty, "TELOPT_NAWS \n");
1173 break;
1174 default:
1175 vty_out(vty, "%x ", buf[i]);
1176 break;
1177 }
1178 }
1179 vty_out(vty, "\n");
1180
1181 #endif /* TELNET_OPTION_DEBUG */
1182
1183 switch (buf[0]) {
1184 case SB:
1185 vty->sb_len = 0;
1186 vty->iac_sb_in_progress = 1;
1187 return 0;
1188 case SE: {
1189 if (!vty->iac_sb_in_progress)
1190 return 0;
1191
1192 if ((vty->sb_len == 0) || (vty->sb_buf[0] == '\0')) {
1193 vty->iac_sb_in_progress = 0;
1194 return 0;
1195 }
1196 switch (vty->sb_buf[0]) {
1197 case TELOPT_NAWS:
1198 if (vty->sb_len != TELNET_NAWS_SB_LEN)
1199 flog_err(
1200 EC_LIB_SYSTEM_CALL,
1201 "RFC 1073 violation detected: telnet NAWS option should send %d characters, but we received %lu",
1202 TELNET_NAWS_SB_LEN,
1203 (unsigned long)vty->sb_len);
1204 else if (sizeof(vty->sb_buf) < TELNET_NAWS_SB_LEN)
1205 flog_err(
1206 EC_LIB_DEVELOPMENT,
1207 "Bug detected: sizeof(vty->sb_buf) %lu < %d, too small to handle the telnet NAWS option",
1208 (unsigned long)sizeof(vty->sb_buf),
1209 TELNET_NAWS_SB_LEN);
1210 else {
1211 vty->width = ((vty->sb_buf[1] << 8)
1212 | vty->sb_buf[2]);
1213 vty->height = ((vty->sb_buf[3] << 8)
1214 | vty->sb_buf[4]);
1215 #ifdef TELNET_OPTION_DEBUG
1216 vty_out(vty,
1217 "TELNET NAWS window size negotiation completed: width %d, height %d\n",
1218 vty->width, vty->height);
1219 #endif
1220 }
1221 break;
1222 }
1223 vty->iac_sb_in_progress = 0;
1224 return 0;
1225 }
1226 default:
1227 break;
1228 }
1229 return 1;
1230 }
1231
1232 /* Execute current command line. */
1233 static int vty_execute(struct vty *vty)
1234 {
1235 int ret;
1236
1237 ret = CMD_SUCCESS;
1238
1239 switch (vty->node) {
1240 case AUTH_NODE:
1241 case AUTH_ENABLE_NODE:
1242 vty_auth(vty, vty->buf);
1243 break;
1244 default:
1245 ret = vty_command(vty, vty->buf);
1246 if (vty->type == VTY_TERM)
1247 vty_hist_add(vty);
1248 break;
1249 }
1250
1251 /* Clear command line buffer. */
1252 vty->cp = vty->length = 0;
1253 vty_clear_buf(vty);
1254
1255 if (vty->status != VTY_CLOSE)
1256 vty_prompt(vty);
1257
1258 return ret;
1259 }
1260
1261 #define CONTROL(X) ((X) - '@')
1262 #define VTY_NORMAL 0
1263 #define VTY_PRE_ESCAPE 1
1264 #define VTY_ESCAPE 2
1265 #define VTY_CR 3
1266
1267 /* Escape character command map. */
1268 static void vty_escape_map(unsigned char c, struct vty *vty)
1269 {
1270 switch (c) {
1271 case ('A'):
1272 vty_previous_line(vty);
1273 break;
1274 case ('B'):
1275 vty_next_line(vty);
1276 break;
1277 case ('C'):
1278 vty_forward_char(vty);
1279 break;
1280 case ('D'):
1281 vty_backward_char(vty);
1282 break;
1283 default:
1284 break;
1285 }
1286
1287 /* Go back to normal mode. */
1288 vty->escape = VTY_NORMAL;
1289 }
1290
1291 /* Quit print out to the buffer. */
1292 static void vty_buffer_reset(struct vty *vty)
1293 {
1294 buffer_reset(vty->obuf);
1295 buffer_reset(vty->lbuf);
1296 vty_prompt(vty);
1297 vty_redraw_line(vty);
1298 }
1299
1300 /* Read data via vty socket. */
1301 static void vty_read(struct thread *thread)
1302 {
1303 int i;
1304 int nbytes;
1305 unsigned char buf[VTY_READ_BUFSIZ];
1306
1307 struct vty *vty = THREAD_ARG(thread);
1308
1309 /* Read raw data from socket */
1310 if ((nbytes = read(vty->fd, buf, VTY_READ_BUFSIZ)) <= 0) {
1311 if (nbytes < 0) {
1312 if (ERRNO_IO_RETRY(errno)) {
1313 vty_event(VTY_READ, vty);
1314 return;
1315 }
1316 flog_err(
1317 EC_LIB_SOCKET,
1318 "%s: read error on vty client fd %d, closing: %s",
1319 __func__, vty->fd, safe_strerror(errno));
1320 buffer_reset(vty->obuf);
1321 buffer_reset(vty->lbuf);
1322 }
1323 vty->status = VTY_CLOSE;
1324 }
1325
1326 for (i = 0; i < nbytes; i++) {
1327 if (buf[i] == IAC) {
1328 if (!vty->iac) {
1329 vty->iac = 1;
1330 continue;
1331 } else {
1332 vty->iac = 0;
1333 }
1334 }
1335
1336 if (vty->iac_sb_in_progress && !vty->iac) {
1337 if (vty->sb_len < sizeof(vty->sb_buf))
1338 vty->sb_buf[vty->sb_len] = buf[i];
1339 vty->sb_len++;
1340 continue;
1341 }
1342
1343 if (vty->iac) {
1344 /* In case of telnet command */
1345 int ret = 0;
1346 ret = vty_telnet_option(vty, buf + i, nbytes - i);
1347 vty->iac = 0;
1348 i += ret;
1349 continue;
1350 }
1351
1352
1353 if (vty->status == VTY_MORE) {
1354 switch (buf[i]) {
1355 case CONTROL('C'):
1356 case 'q':
1357 case 'Q':
1358 vty_buffer_reset(vty);
1359 break;
1360 default:
1361 break;
1362 }
1363 continue;
1364 }
1365
1366 /* Escape character. */
1367 if (vty->escape == VTY_ESCAPE) {
1368 vty_escape_map(buf[i], vty);
1369 continue;
1370 }
1371
1372 /* Pre-escape status. */
1373 if (vty->escape == VTY_PRE_ESCAPE) {
1374 switch (buf[i]) {
1375 case '[':
1376 vty->escape = VTY_ESCAPE;
1377 break;
1378 case 'b':
1379 vty_backward_word(vty);
1380 vty->escape = VTY_NORMAL;
1381 break;
1382 case 'f':
1383 vty_forward_word(vty);
1384 vty->escape = VTY_NORMAL;
1385 break;
1386 case 'd':
1387 vty_forward_kill_word(vty);
1388 vty->escape = VTY_NORMAL;
1389 break;
1390 case CONTROL('H'):
1391 case 0x7f:
1392 vty_backward_kill_word(vty);
1393 vty->escape = VTY_NORMAL;
1394 break;
1395 default:
1396 vty->escape = VTY_NORMAL;
1397 break;
1398 }
1399 continue;
1400 }
1401
1402 if (vty->escape == VTY_CR) {
1403 /* if we get CR+NL, the NL results in an extra empty
1404 * prompt line being printed without this; just drop
1405 * the NL if it immediately follows CR.
1406 */
1407 vty->escape = VTY_NORMAL;
1408
1409 if (buf[i] == '\n')
1410 continue;
1411 }
1412
1413 switch (buf[i]) {
1414 case CONTROL('A'):
1415 vty_beginning_of_line(vty);
1416 break;
1417 case CONTROL('B'):
1418 vty_backward_char(vty);
1419 break;
1420 case CONTROL('C'):
1421 vty_stop_input(vty);
1422 break;
1423 case CONTROL('D'):
1424 vty_delete_char(vty);
1425 break;
1426 case CONTROL('E'):
1427 vty_end_of_line(vty);
1428 break;
1429 case CONTROL('F'):
1430 vty_forward_char(vty);
1431 break;
1432 case CONTROL('H'):
1433 case 0x7f:
1434 vty_delete_backward_char(vty);
1435 break;
1436 case CONTROL('K'):
1437 vty_kill_line(vty);
1438 break;
1439 case CONTROL('N'):
1440 vty_next_line(vty);
1441 break;
1442 case CONTROL('P'):
1443 vty_previous_line(vty);
1444 break;
1445 case CONTROL('T'):
1446 vty_transpose_chars(vty);
1447 break;
1448 case CONTROL('U'):
1449 vty_kill_line_from_beginning(vty);
1450 break;
1451 case CONTROL('W'):
1452 vty_backward_kill_word(vty);
1453 break;
1454 case CONTROL('Z'):
1455 vty_end_config(vty);
1456 break;
1457 case '\r':
1458 vty->escape = VTY_CR;
1459 /* fallthru */
1460 case '\n':
1461 vty_out(vty, "\n");
1462 buffer_flush_available(vty->obuf, vty->wfd);
1463 vty_execute(vty);
1464
1465 if (vty->pass_fd != -1) {
1466 close(vty->pass_fd);
1467 vty->pass_fd = -1;
1468 }
1469 break;
1470 case '\t':
1471 vty_complete_command(vty);
1472 break;
1473 case '?':
1474 if (vty->node == AUTH_NODE
1475 || vty->node == AUTH_ENABLE_NODE)
1476 vty_self_insert(vty, buf[i]);
1477 else
1478 vty_describe_command(vty);
1479 break;
1480 case '\033':
1481 if (i + 1 < nbytes && buf[i + 1] == '[') {
1482 vty->escape = VTY_ESCAPE;
1483 i++;
1484 } else
1485 vty->escape = VTY_PRE_ESCAPE;
1486 break;
1487 default:
1488 if (buf[i] > 31 && buf[i] < 127)
1489 vty_self_insert(vty, buf[i]);
1490 break;
1491 }
1492 }
1493
1494 /* Check status. */
1495 if (vty->status == VTY_CLOSE)
1496 vty_close(vty);
1497 else {
1498 vty_event(VTY_WRITE, vty);
1499 vty_event(VTY_READ, vty);
1500 }
1501 }
1502
1503 /* Flush buffer to the vty. */
1504 static void vty_flush(struct thread *thread)
1505 {
1506 int erase;
1507 buffer_status_t flushrc;
1508 struct vty *vty = THREAD_ARG(thread);
1509
1510 /* Tempolary disable read thread. */
1511 if (vty->lines == 0)
1512 THREAD_OFF(vty->t_read);
1513
1514 /* Function execution continue. */
1515 erase = ((vty->status == VTY_MORE || vty->status == VTY_MORELINE));
1516
1517 /* N.B. if width is 0, that means we don't know the window size. */
1518 if ((vty->lines == 0) || (vty->width == 0) || (vty->height == 0))
1519 flushrc = buffer_flush_available(vty->obuf, vty->wfd);
1520 else if (vty->status == VTY_MORELINE)
1521 flushrc = buffer_flush_window(vty->obuf, vty->wfd, vty->width,
1522 1, erase, 0);
1523 else
1524 flushrc = buffer_flush_window(
1525 vty->obuf, vty->wfd, vty->width,
1526 vty->lines >= 0 ? vty->lines : vty->height, erase, 0);
1527 switch (flushrc) {
1528 case BUFFER_ERROR:
1529 zlog_info("buffer_flush failed on vty client fd %d/%d, closing",
1530 vty->fd, vty->wfd);
1531 buffer_reset(vty->lbuf);
1532 buffer_reset(vty->obuf);
1533 vty_close(vty);
1534 return;
1535 case BUFFER_EMPTY:
1536 if (vty->status == VTY_CLOSE)
1537 vty_close(vty);
1538 else {
1539 vty->status = VTY_NORMAL;
1540 if (vty->lines == 0)
1541 vty_event(VTY_READ, vty);
1542 }
1543 break;
1544 case BUFFER_PENDING:
1545 /* There is more data waiting to be written. */
1546 vty->status = VTY_MORE;
1547 if (vty->lines == 0)
1548 vty_event(VTY_WRITE, vty);
1549 break;
1550 }
1551 }
1552
1553 /* Allocate new vty struct. */
1554 struct vty *vty_new(void)
1555 {
1556 struct vty *new = XCALLOC(MTYPE_VTY, sizeof(struct vty));
1557
1558 new->fd = new->wfd = -1;
1559 new->of = stdout;
1560 new->lbuf = buffer_new(0);
1561 new->obuf = buffer_new(0); /* Use default buffer size. */
1562 new->buf = XCALLOC(MTYPE_VTY, VTY_BUFSIZ);
1563 new->max = VTY_BUFSIZ;
1564 new->pass_fd = -1;
1565
1566 return new;
1567 }
1568
1569
1570 /* allocate and initialise vty */
1571 static struct vty *vty_new_init(int vty_sock)
1572 {
1573 struct vty *vty;
1574
1575 vty = vty_new();
1576 vty->fd = vty_sock;
1577 vty->wfd = vty_sock;
1578 vty->type = VTY_TERM;
1579 vty->node = AUTH_NODE;
1580 vty->fail = 0;
1581 vty->cp = 0;
1582 vty_clear_buf(vty);
1583 vty->length = 0;
1584 memset(vty->hist, 0, sizeof(vty->hist));
1585 vty->hp = 0;
1586 vty->hindex = 0;
1587 vty->xpath_index = 0;
1588 memset(vty->xpath, 0, sizeof(vty->xpath));
1589 vty->private_config = false;
1590 vty->candidate_config = vty_shared_candidate_config;
1591 vty->status = VTY_NORMAL;
1592 vty->lines = -1;
1593 vty->iac = 0;
1594 vty->iac_sb_in_progress = 0;
1595 vty->sb_len = 0;
1596
1597 vtys_add_tail(vty_sessions, vty);
1598
1599 return vty;
1600 }
1601
1602 /* Create new vty structure. */
1603 static struct vty *vty_create(int vty_sock, union sockunion *su)
1604 {
1605 char buf[SU_ADDRSTRLEN];
1606 struct vty *vty;
1607
1608 sockunion2str(su, buf, SU_ADDRSTRLEN);
1609
1610 /* Allocate new vty structure and set up default values. */
1611 vty = vty_new_init(vty_sock);
1612
1613 /* configurable parameters not part of basic init */
1614 vty->v_timeout = vty_timeout_val;
1615 strlcpy(vty->address, buf, sizeof(vty->address));
1616 if (no_password_check) {
1617 if (host.advanced)
1618 vty->node = ENABLE_NODE;
1619 else
1620 vty->node = VIEW_NODE;
1621 }
1622 if (host.lines >= 0)
1623 vty->lines = host.lines;
1624
1625 if (!no_password_check) {
1626 /* Vty is not available if password isn't set. */
1627 if (host.password == NULL && host.password_encrypt == NULL) {
1628 vty_out(vty, "Vty password is not set.\n");
1629 vty->status = VTY_CLOSE;
1630 vty_close(vty);
1631 return NULL;
1632 }
1633 }
1634
1635 /* Say hello to the world. */
1636 vty_hello(vty);
1637 if (!no_password_check)
1638 vty_out(vty, "\nUser Access Verification\n\n");
1639
1640 /* Setting up terminal. */
1641 vty_will_echo(vty);
1642 vty_will_suppress_go_ahead(vty);
1643
1644 vty_dont_linemode(vty);
1645 vty_do_window_size(vty);
1646 /* vty_dont_lflow_ahead (vty); */
1647
1648 vty_prompt(vty);
1649
1650 /* Add read/write thread. */
1651 vty_event(VTY_WRITE, vty);
1652 vty_event(VTY_READ, vty);
1653
1654 return vty;
1655 }
1656
1657 /* create vty for stdio */
1658 static struct termios stdio_orig_termios;
1659 static struct vty *stdio_vty = NULL;
1660 static bool stdio_termios = false;
1661 static void (*stdio_vty_atclose)(int isexit);
1662
1663 static void vty_stdio_reset(int isexit)
1664 {
1665 if (stdio_vty) {
1666 if (stdio_termios)
1667 tcsetattr(0, TCSANOW, &stdio_orig_termios);
1668 stdio_termios = false;
1669
1670 stdio_vty = NULL;
1671
1672 if (stdio_vty_atclose)
1673 stdio_vty_atclose(isexit);
1674 stdio_vty_atclose = NULL;
1675 }
1676 }
1677
1678 static void vty_stdio_atexit(void)
1679 {
1680 vty_stdio_reset(1);
1681 }
1682
1683 void vty_stdio_suspend(void)
1684 {
1685 if (!stdio_vty)
1686 return;
1687
1688 THREAD_OFF(stdio_vty->t_write);
1689 THREAD_OFF(stdio_vty->t_read);
1690 THREAD_OFF(stdio_vty->t_timeout);
1691
1692 if (stdio_termios)
1693 tcsetattr(0, TCSANOW, &stdio_orig_termios);
1694 stdio_termios = false;
1695 }
1696
1697 void vty_stdio_resume(void)
1698 {
1699 if (!stdio_vty)
1700 return;
1701
1702 if (!tcgetattr(0, &stdio_orig_termios)) {
1703 struct termios termios;
1704
1705 termios = stdio_orig_termios;
1706 termios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR
1707 | IGNCR | ICRNL | IXON);
1708 termios.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);
1709 termios.c_cflag &= ~(CSIZE | PARENB);
1710 termios.c_cflag |= CS8;
1711 tcsetattr(0, TCSANOW, &termios);
1712 stdio_termios = true;
1713 }
1714
1715 vty_prompt(stdio_vty);
1716
1717 /* Add read/write thread. */
1718 vty_event(VTY_WRITE, stdio_vty);
1719 vty_event(VTY_READ, stdio_vty);
1720 }
1721
1722 void vty_stdio_close(void)
1723 {
1724 if (!stdio_vty)
1725 return;
1726 vty_close(stdio_vty);
1727 }
1728
1729 struct vty *vty_stdio(void (*atclose)(int isexit))
1730 {
1731 struct vty *vty;
1732
1733 /* refuse creating two vtys on stdio */
1734 if (stdio_vty)
1735 return NULL;
1736
1737 vty = stdio_vty = vty_new_init(0);
1738 stdio_vty_atclose = atclose;
1739 vty->wfd = 1;
1740
1741 /* always have stdio vty in a known _unchangeable_ state, don't want
1742 * config
1743 * to have any effect here to make sure scripting this works as intended
1744 */
1745 vty->node = ENABLE_NODE;
1746 vty->v_timeout = 0;
1747 strlcpy(vty->address, "console", sizeof(vty->address));
1748
1749 vty_stdio_resume();
1750 return vty;
1751 }
1752
1753 /* Accept connection from the network. */
1754 static void vty_accept(struct thread *thread)
1755 {
1756 struct vty_serv *vtyserv = THREAD_ARG(thread);
1757 int vty_sock;
1758 union sockunion su;
1759 int ret;
1760 unsigned int on;
1761 int accept_sock = vtyserv->sock;
1762 struct prefix p;
1763 struct access_list *acl = NULL;
1764
1765 /* We continue hearing vty socket. */
1766 vty_event_serv(VTY_SERV, vtyserv);
1767
1768 memset(&su, 0, sizeof(union sockunion));
1769
1770 /* We can handle IPv4 or IPv6 socket. */
1771 vty_sock = sockunion_accept(accept_sock, &su);
1772 if (vty_sock < 0) {
1773 flog_err(EC_LIB_SOCKET, "can't accept vty socket : %s",
1774 safe_strerror(errno));
1775 return;
1776 }
1777 set_nonblocking(vty_sock);
1778 set_cloexec(vty_sock);
1779
1780 if (!sockunion2hostprefix(&su, &p)) {
1781 close(vty_sock);
1782 zlog_info("Vty unable to convert prefix from sockunion %pSU",
1783 &su);
1784 return;
1785 }
1786
1787 /* VTY's accesslist apply. */
1788 if (p.family == AF_INET && vty_accesslist_name) {
1789 if ((acl = access_list_lookup(AFI_IP, vty_accesslist_name))
1790 && (access_list_apply(acl, &p) == FILTER_DENY)) {
1791 zlog_info("Vty connection refused from %pSU", &su);
1792 close(vty_sock);
1793 return;
1794 }
1795 }
1796
1797 /* VTY's ipv6 accesslist apply. */
1798 if (p.family == AF_INET6 && vty_ipv6_accesslist_name) {
1799 if ((acl = access_list_lookup(AFI_IP6,
1800 vty_ipv6_accesslist_name))
1801 && (access_list_apply(acl, &p) == FILTER_DENY)) {
1802 zlog_info("Vty connection refused from %pSU", &su);
1803 close(vty_sock);
1804 return;
1805 }
1806 }
1807
1808 on = 1;
1809 ret = setsockopt(vty_sock, IPPROTO_TCP, TCP_NODELAY, (char *)&on,
1810 sizeof(on));
1811 if (ret < 0)
1812 zlog_info("can't set sockopt to vty_sock : %s",
1813 safe_strerror(errno));
1814
1815 zlog_info("Vty connection from %pSU", &su);
1816
1817 vty_create(vty_sock, &su);
1818 }
1819
1820 static void vty_serv_sock_addrinfo(const char *hostname, unsigned short port)
1821 {
1822 int ret;
1823 struct addrinfo req;
1824 struct addrinfo *ainfo;
1825 struct addrinfo *ainfo_save;
1826 int sock;
1827 char port_str[BUFSIZ];
1828
1829 memset(&req, 0, sizeof(req));
1830 req.ai_flags = AI_PASSIVE;
1831 req.ai_family = AF_UNSPEC;
1832 req.ai_socktype = SOCK_STREAM;
1833 snprintf(port_str, sizeof(port_str), "%d", port);
1834 port_str[sizeof(port_str) - 1] = '\0';
1835
1836 ret = getaddrinfo(hostname, port_str, &req, &ainfo);
1837
1838 if (ret != 0) {
1839 flog_err_sys(EC_LIB_SYSTEM_CALL, "getaddrinfo failed: %s",
1840 gai_strerror(ret));
1841 exit(1);
1842 }
1843
1844 ainfo_save = ainfo;
1845
1846 do {
1847 struct vty_serv *vtyserv;
1848
1849 if (ainfo->ai_family != AF_INET && ainfo->ai_family != AF_INET6)
1850 continue;
1851
1852 sock = socket(ainfo->ai_family, ainfo->ai_socktype,
1853 ainfo->ai_protocol);
1854 if (sock < 0)
1855 continue;
1856
1857 sockopt_v6only(ainfo->ai_family, sock);
1858 sockopt_reuseaddr(sock);
1859 sockopt_reuseport(sock);
1860 set_cloexec(sock);
1861
1862 ret = bind(sock, ainfo->ai_addr, ainfo->ai_addrlen);
1863 if (ret < 0) {
1864 close(sock); /* Avoid sd leak. */
1865 continue;
1866 }
1867
1868 ret = listen(sock, 3);
1869 if (ret < 0) {
1870 close(sock); /* Avoid sd leak. */
1871 continue;
1872 }
1873
1874 vtyserv = XCALLOC(MTYPE_VTY_SERV, sizeof(*vtyserv));
1875 vtyserv->sock = sock;
1876 vtyservs_add_tail(vty_servs, vtyserv);
1877
1878 vty_event_serv(VTY_SERV, vtyserv);
1879 } while ((ainfo = ainfo->ai_next) != NULL);
1880
1881 freeaddrinfo(ainfo_save);
1882 }
1883
1884 #ifdef VTYSH
1885 /* For sockaddr_un. */
1886 #include <sys/un.h>
1887
1888 /* VTY shell UNIX domain socket. */
1889 static void vty_serv_un(const char *path)
1890 {
1891 struct vty_serv *vtyserv;
1892 int ret;
1893 int sock, len;
1894 struct sockaddr_un serv;
1895 mode_t old_mask;
1896 struct zprivs_ids_t ids;
1897
1898 /* First of all, unlink existing socket */
1899 unlink(path);
1900
1901 /* Set umask */
1902 old_mask = umask(0007);
1903
1904 /* Make UNIX domain socket. */
1905 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1906 if (sock < 0) {
1907 flog_err_sys(EC_LIB_SOCKET,
1908 "Cannot create unix stream socket: %s",
1909 safe_strerror(errno));
1910 return;
1911 }
1912
1913 /* Make server socket. */
1914 memset(&serv, 0, sizeof(serv));
1915 serv.sun_family = AF_UNIX;
1916 strlcpy(serv.sun_path, path, sizeof(serv.sun_path));
1917 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
1918 len = serv.sun_len = SUN_LEN(&serv);
1919 #else
1920 len = sizeof(serv.sun_family) + strlen(serv.sun_path);
1921 #endif /* HAVE_STRUCT_SOCKADDR_UN_SUN_LEN */
1922
1923 set_cloexec(sock);
1924
1925 ret = bind(sock, (struct sockaddr *)&serv, len);
1926 if (ret < 0) {
1927 flog_err_sys(EC_LIB_SOCKET, "Cannot bind path %s: %s", path,
1928 safe_strerror(errno));
1929 close(sock); /* Avoid sd leak. */
1930 return;
1931 }
1932
1933 ret = listen(sock, 5);
1934 if (ret < 0) {
1935 flog_err_sys(EC_LIB_SOCKET, "listen(fd %d) failed: %s", sock,
1936 safe_strerror(errno));
1937 close(sock); /* Avoid sd leak. */
1938 return;
1939 }
1940
1941 umask(old_mask);
1942
1943 zprivs_get_ids(&ids);
1944
1945 /* Hack: ids.gid_vty is actually a uint, but we stored -1 in it
1946 earlier for the case when we don't need to chown the file
1947 type casting it here to make a compare */
1948 if ((int)ids.gid_vty > 0) {
1949 /* set group of socket */
1950 if (chown(path, -1, ids.gid_vty)) {
1951 flog_err_sys(EC_LIB_SYSTEM_CALL,
1952 "vty_serv_un: could chown socket, %s",
1953 safe_strerror(errno));
1954 }
1955 }
1956
1957 vtyserv = XCALLOC(MTYPE_VTY_SERV, sizeof(*vtyserv));
1958 vtyserv->sock = sock;
1959 vtyserv->vtysh = true;
1960 vtyservs_add_tail(vty_servs, vtyserv);
1961
1962 vty_event_serv(VTYSH_SERV, vtyserv);
1963 }
1964
1965 /* #define VTYSH_DEBUG 1 */
1966
1967 static void vtysh_accept(struct thread *thread)
1968 {
1969 struct vty_serv *vtyserv = THREAD_ARG(thread);
1970 int accept_sock = vtyserv->sock;
1971 int sock;
1972 int client_len;
1973 struct sockaddr_un client;
1974 struct vty *vty;
1975
1976 vty_event_serv(VTYSH_SERV, vtyserv);
1977
1978 memset(&client, 0, sizeof(client));
1979 client_len = sizeof(struct sockaddr_un);
1980
1981 sock = accept(accept_sock, (struct sockaddr *)&client,
1982 (socklen_t *)&client_len);
1983
1984 if (sock < 0) {
1985 flog_err(EC_LIB_SOCKET, "can't accept vty socket : %s",
1986 safe_strerror(errno));
1987 return;
1988 }
1989
1990 if (set_nonblocking(sock) < 0) {
1991 flog_err(
1992 EC_LIB_SOCKET,
1993 "vtysh_accept: could not set vty socket %d to non-blocking, %s, closing",
1994 sock, safe_strerror(errno));
1995 close(sock);
1996 return;
1997 }
1998 set_cloexec(sock);
1999
2000 #ifdef VTYSH_DEBUG
2001 printf("VTY shell accept\n");
2002 #endif /* VTYSH_DEBUG */
2003
2004 vty = vty_new();
2005 vty->fd = sock;
2006 vty->wfd = sock;
2007 vty->type = VTY_SHELL_SERV;
2008 vty->node = VIEW_NODE;
2009 vtys_add_tail(vtysh_sessions, vty);
2010
2011 vty_event(VTYSH_READ, vty);
2012 }
2013
2014 static int vtysh_do_pass_fd(struct vty *vty)
2015 {
2016 struct iovec iov[1] = {
2017 {
2018 .iov_base = vty->pass_fd_status,
2019 .iov_len = sizeof(vty->pass_fd_status),
2020 },
2021 };
2022 union {
2023 uint8_t buf[CMSG_SPACE(sizeof(int))];
2024 struct cmsghdr align;
2025 } u;
2026 struct msghdr mh = {
2027 .msg_iov = iov,
2028 .msg_iovlen = array_size(iov),
2029 .msg_control = u.buf,
2030 .msg_controllen = sizeof(u.buf),
2031 };
2032 struct cmsghdr *cmh = CMSG_FIRSTHDR(&mh);
2033 ssize_t ret;
2034
2035 memset(&u.buf, 0, sizeof(u.buf));
2036 cmh->cmsg_level = SOL_SOCKET;
2037 cmh->cmsg_type = SCM_RIGHTS;
2038 cmh->cmsg_len = CMSG_LEN(sizeof(int));
2039 memcpy(CMSG_DATA(cmh), &vty->pass_fd, sizeof(int));
2040
2041 ret = sendmsg(vty->wfd, &mh, 0);
2042 if (ret < 0 && ERRNO_IO_RETRY(errno))
2043 return BUFFER_PENDING;
2044
2045 close(vty->pass_fd);
2046 vty->pass_fd = -1;
2047 vty->status = VTY_NORMAL;
2048
2049 if (ret <= 0)
2050 return BUFFER_ERROR;
2051
2052 /* resume accepting commands (suspended in vtysh_read) */
2053 vty_event(VTYSH_READ, vty);
2054
2055 if ((size_t)ret < sizeof(vty->pass_fd_status)) {
2056 size_t remains = sizeof(vty->pass_fd_status) - ret;
2057
2058 buffer_put(vty->obuf, vty->pass_fd_status + ret, remains);
2059 return BUFFER_PENDING;
2060 }
2061 return BUFFER_EMPTY;
2062 }
2063
2064 static int vtysh_flush(struct vty *vty)
2065 {
2066 int ret;
2067
2068 ret = buffer_flush_available(vty->obuf, vty->wfd);
2069 if (ret == BUFFER_EMPTY && vty->status == VTY_PASSFD)
2070 ret = vtysh_do_pass_fd(vty);
2071
2072 switch (ret) {
2073 case BUFFER_PENDING:
2074 vty_event(VTYSH_WRITE, vty);
2075 break;
2076 case BUFFER_ERROR:
2077 flog_err(EC_LIB_SOCKET, "%s: write error to fd %d, closing",
2078 __func__, vty->fd);
2079 buffer_reset(vty->lbuf);
2080 buffer_reset(vty->obuf);
2081 vty_close(vty);
2082 return -1;
2083 case BUFFER_EMPTY:
2084 break;
2085 }
2086 return 0;
2087 }
2088
2089 void vty_pass_fd(struct vty *vty, int fd)
2090 {
2091 if (vty->pass_fd != -1)
2092 close(vty->pass_fd);
2093
2094 vty->pass_fd = fd;
2095 }
2096
2097 static void vtysh_read(struct thread *thread)
2098 {
2099 int ret;
2100 int sock;
2101 int nbytes;
2102 struct vty *vty;
2103 unsigned char buf[VTY_READ_BUFSIZ];
2104 unsigned char *p;
2105 uint8_t header[4] = {0, 0, 0, 0};
2106
2107 sock = THREAD_FD(thread);
2108 vty = THREAD_ARG(thread);
2109
2110 if ((nbytes = read(sock, buf, VTY_READ_BUFSIZ)) <= 0) {
2111 if (nbytes < 0) {
2112 if (ERRNO_IO_RETRY(errno)) {
2113 vty_event(VTYSH_READ, vty);
2114 return;
2115 }
2116 flog_err(
2117 EC_LIB_SOCKET,
2118 "%s: read failed on vtysh client fd %d, closing: %s",
2119 __func__, sock, safe_strerror(errno));
2120 }
2121 buffer_reset(vty->lbuf);
2122 buffer_reset(vty->obuf);
2123 vty_close(vty);
2124 #ifdef VTYSH_DEBUG
2125 printf("close vtysh\n");
2126 #endif /* VTYSH_DEBUG */
2127 return;
2128 }
2129
2130 #ifdef VTYSH_DEBUG
2131 printf("line: %.*s\n", nbytes, buf);
2132 #endif /* VTYSH_DEBUG */
2133
2134 if (vty->length + nbytes >= VTY_BUFSIZ) {
2135 /* Clear command line buffer. */
2136 vty->cp = vty->length = 0;
2137 vty_clear_buf(vty);
2138 vty_out(vty, "%% Command is too long.\n");
2139 } else {
2140 for (p = buf; p < buf + nbytes; p++) {
2141 vty->buf[vty->length++] = *p;
2142 if (*p == '\0') {
2143 /* Pass this line to parser. */
2144 ret = vty_execute(vty);
2145 /* Note that vty_execute clears the command buffer and resets
2146 vty->length to 0. */
2147
2148 /* Return result. */
2149 #ifdef VTYSH_DEBUG
2150 printf("result: %d\n", ret);
2151 printf("vtysh node: %d\n", vty->node);
2152 #endif /* VTYSH_DEBUG */
2153
2154 if (vty->pass_fd != -1) {
2155 memset(vty->pass_fd_status, 0, 4);
2156 vty->pass_fd_status[3] = ret;
2157 vty->status = VTY_PASSFD;
2158
2159 if (!vty->t_write)
2160 vty_event(VTYSH_WRITE, vty);
2161
2162 /* this introduces a "sequence point"
2163 * command output is written normally,
2164 * read processing is suspended until
2165 * buffer is empty
2166 * then retcode + FD is written
2167 * then normal processing resumes
2168 *
2169 * => skip vty_event(VTYSH_READ, vty)!
2170 */
2171 return;
2172 }
2173
2174 /* hack for asynchronous "write integrated"
2175 * - other commands in "buf" will be ditched
2176 * - input during pending config-write is
2177 * "unsupported" */
2178 if (ret == CMD_SUSPEND)
2179 break;
2180
2181 /* warning: watchfrr hardcodes this result write
2182 */
2183 header[3] = ret;
2184 buffer_put(vty->obuf, header, 4);
2185
2186 if (!vty->t_write && (vtysh_flush(vty) < 0))
2187 /* Try to flush results; exit if a write
2188 * error occurs. */
2189 return;
2190 }
2191 }
2192 }
2193
2194 if (vty->status == VTY_CLOSE)
2195 vty_close(vty);
2196 else
2197 vty_event(VTYSH_READ, vty);
2198 }
2199
2200 static void vtysh_write(struct thread *thread)
2201 {
2202 struct vty *vty = THREAD_ARG(thread);
2203
2204 vtysh_flush(vty);
2205 }
2206
2207 #endif /* VTYSH */
2208
2209 /* Determine address family to bind. */
2210 void vty_serv_sock(const char *addr, unsigned short port, const char *path)
2211 {
2212 /* If port is set to 0, do not listen on TCP/IP at all! */
2213 if (port)
2214 vty_serv_sock_addrinfo(addr, port);
2215
2216 #ifdef VTYSH
2217 vty_serv_un(path);
2218 #endif /* VTYSH */
2219 }
2220
2221 static void vty_error_delete(void *arg)
2222 {
2223 struct vty_error *ve = arg;
2224
2225 XFREE(MTYPE_TMP, ve);
2226 }
2227
2228 /* Close vty interface. Warning: call this only from functions that
2229 will be careful not to access the vty afterwards (since it has
2230 now been freed). This is safest from top-level functions (called
2231 directly by the thread dispatcher). */
2232 void vty_close(struct vty *vty)
2233 {
2234 int i;
2235 bool was_stdio = false;
2236
2237 /* Drop out of configure / transaction if needed. */
2238 vty_config_exit(vty);
2239
2240 /* Cancel threads.*/
2241 THREAD_OFF(vty->t_read);
2242 THREAD_OFF(vty->t_write);
2243 THREAD_OFF(vty->t_timeout);
2244
2245 if (vty->pass_fd != -1) {
2246 close(vty->pass_fd);
2247 vty->pass_fd = -1;
2248 }
2249 zlog_live_close(&vty->live_log);
2250
2251 /* Flush buffer. */
2252 buffer_flush_all(vty->obuf, vty->wfd);
2253
2254 /* Free input buffer. */
2255 buffer_free(vty->obuf);
2256 buffer_free(vty->lbuf);
2257
2258 /* Free command history. */
2259 for (i = 0; i < VTY_MAXHIST; i++) {
2260 XFREE(MTYPE_VTY_HIST, vty->hist[i]);
2261 }
2262
2263 /* Unset vector. */
2264 if (vty->fd != -1) {
2265 if (vty->type == VTY_SHELL_SERV)
2266 vtys_del(vtysh_sessions, vty);
2267 else
2268 vtys_del(vty_sessions, vty);
2269 }
2270
2271 if (vty->wfd > 0 && vty->type == VTY_FILE)
2272 fsync(vty->wfd);
2273
2274 /* Close socket.
2275 * note check is for fd > STDERR_FILENO, not fd != -1.
2276 * We never close stdin/stdout/stderr here, because we may be
2277 * running in foreground mode with logging to stdout. Also,
2278 * additionally, we'd need to replace these fds with /dev/null. */
2279 if (vty->wfd > STDERR_FILENO && vty->wfd != vty->fd)
2280 close(vty->wfd);
2281 if (vty->fd > STDERR_FILENO)
2282 close(vty->fd);
2283 if (vty->fd == STDIN_FILENO)
2284 was_stdio = true;
2285
2286 XFREE(MTYPE_VTY, vty->buf);
2287
2288 if (vty->error) {
2289 vty->error->del = vty_error_delete;
2290 list_delete(&vty->error);
2291 }
2292
2293 /* OK free vty. */
2294 XFREE(MTYPE_VTY, vty);
2295
2296 if (was_stdio)
2297 vty_stdio_reset(0);
2298 }
2299
2300 /* When time out occur output message then close connection. */
2301 static void vty_timeout(struct thread *thread)
2302 {
2303 struct vty *vty;
2304
2305 vty = THREAD_ARG(thread);
2306 vty->v_timeout = 0;
2307
2308 /* Clear buffer*/
2309 buffer_reset(vty->lbuf);
2310 buffer_reset(vty->obuf);
2311 vty_out(vty, "\nVty connection is timed out.\n");
2312
2313 /* Close connection. */
2314 vty->status = VTY_CLOSE;
2315 vty_close(vty);
2316 }
2317
2318 /* Read up configuration file from file_name. */
2319 static void vty_read_file(struct nb_config *config, FILE *confp)
2320 {
2321 int ret;
2322 struct vty *vty;
2323 struct vty_error *ve;
2324 struct listnode *node;
2325 unsigned int line_num = 0;
2326
2327 vty = vty_new();
2328 /* vty_close won't close stderr; if some config command prints
2329 * something it'll end up there. (not ideal; it'd be better if output
2330 * from a file-load went to logging instead. Also note that if this
2331 * function is called after daemonizing, stderr will be /dev/null.)
2332 *
2333 * vty->fd will be -1 from vty_new()
2334 */
2335 vty->wfd = STDERR_FILENO;
2336 vty->type = VTY_FILE;
2337 vty->node = CONFIG_NODE;
2338 vty->config = true;
2339 if (config)
2340 vty->candidate_config = config;
2341 else {
2342 vty->private_config = true;
2343 vty->candidate_config = nb_config_new(NULL);
2344 }
2345
2346 /* Execute configuration file */
2347 ret = config_from_file(vty, confp, &line_num);
2348
2349 /* Flush any previous errors before printing messages below */
2350 buffer_flush_all(vty->obuf, vty->wfd);
2351
2352 if (!((ret == CMD_SUCCESS) || (ret == CMD_ERR_NOTHING_TODO))) {
2353 const char *message = NULL;
2354 char *nl;
2355
2356 switch (ret) {
2357 case CMD_ERR_AMBIGUOUS:
2358 message = "Ambiguous command";
2359 break;
2360 case CMD_ERR_NO_MATCH:
2361 message = "No such command";
2362 break;
2363 case CMD_WARNING:
2364 message = "Command returned Warning";
2365 break;
2366 case CMD_WARNING_CONFIG_FAILED:
2367 message = "Command returned Warning Config Failed";
2368 break;
2369 case CMD_ERR_INCOMPLETE:
2370 message = "Command returned Incomplete";
2371 break;
2372 case CMD_ERR_EXEED_ARGC_MAX:
2373 message =
2374 "Command exceeded maximum number of Arguments";
2375 break;
2376 default:
2377 message = "Command returned unhandled error message";
2378 break;
2379 }
2380
2381 for (ALL_LIST_ELEMENTS_RO(vty->error, node, ve)) {
2382 nl = strchr(ve->error_buf, '\n');
2383 if (nl)
2384 *nl = '\0';
2385 flog_err(EC_LIB_VTY, "%s on config line %u: %s",
2386 message, ve->line_num, ve->error_buf);
2387 }
2388 }
2389
2390 /*
2391 * Automatically commit the candidate configuration after
2392 * reading the configuration file.
2393 */
2394 if (config == NULL) {
2395 struct nb_context context = {};
2396 char errmsg[BUFSIZ] = {0};
2397
2398 context.client = NB_CLIENT_CLI;
2399 context.user = vty;
2400 ret = nb_candidate_commit(&context, vty->candidate_config, true,
2401 "Read configuration file", NULL,
2402 errmsg, sizeof(errmsg));
2403 if (ret != NB_OK && ret != NB_ERR_NO_CHANGES)
2404 zlog_err(
2405 "%s: failed to read configuration file: %s (%s)",
2406 __func__, nb_err_name(ret), errmsg);
2407 }
2408
2409 vty_close(vty);
2410 }
2411
2412 static FILE *vty_use_backup_config(const char *fullpath)
2413 {
2414 char *fullpath_sav, *fullpath_tmp;
2415 FILE *ret = NULL;
2416 int tmp, sav;
2417 int c;
2418 char buffer[512];
2419
2420 size_t fullpath_sav_sz = strlen(fullpath) + strlen(CONF_BACKUP_EXT) + 1;
2421 fullpath_sav = malloc(fullpath_sav_sz);
2422 strlcpy(fullpath_sav, fullpath, fullpath_sav_sz);
2423 strlcat(fullpath_sav, CONF_BACKUP_EXT, fullpath_sav_sz);
2424
2425 sav = open(fullpath_sav, O_RDONLY);
2426 if (sav < 0) {
2427 free(fullpath_sav);
2428 return NULL;
2429 }
2430
2431 fullpath_tmp = malloc(strlen(fullpath) + 8);
2432 snprintf(fullpath_tmp, strlen(fullpath) + 8, "%s.XXXXXX", fullpath);
2433
2434 /* Open file to configuration write. */
2435 tmp = mkstemp(fullpath_tmp);
2436 if (tmp < 0)
2437 goto out_close_sav;
2438
2439 if (fchmod(tmp, CONFIGFILE_MASK) != 0)
2440 goto out_close;
2441
2442 while ((c = read(sav, buffer, 512)) > 0) {
2443 if (write(tmp, buffer, c) <= 0)
2444 goto out_close;
2445 }
2446 close(sav);
2447 close(tmp);
2448
2449 if (rename(fullpath_tmp, fullpath) == 0)
2450 ret = fopen(fullpath, "r");
2451 else
2452 unlink(fullpath_tmp);
2453
2454 if (0) {
2455 out_close:
2456 close(tmp);
2457 unlink(fullpath_tmp);
2458 out_close_sav:
2459 close(sav);
2460 }
2461
2462 free(fullpath_sav);
2463 free(fullpath_tmp);
2464 return ret;
2465 }
2466
2467 /* Read up configuration file from file_name. */
2468 bool vty_read_config(struct nb_config *config, const char *config_file,
2469 char *config_default_dir)
2470 {
2471 char cwd[MAXPATHLEN];
2472 FILE *confp = NULL;
2473 const char *fullpath;
2474 char *tmp = NULL;
2475 bool read_success = false;
2476
2477 /* If -f flag specified. */
2478 if (config_file != NULL) {
2479 if (!IS_DIRECTORY_SEP(config_file[0])) {
2480 if (getcwd(cwd, MAXPATHLEN) == NULL) {
2481 flog_err_sys(
2482 EC_LIB_SYSTEM_CALL,
2483 "%s: failure to determine Current Working Directory %d!",
2484 __func__, errno);
2485 goto tmp_free_and_out;
2486 }
2487 size_t tmp_len = strlen(cwd) + strlen(config_file) + 2;
2488 tmp = XMALLOC(MTYPE_TMP, tmp_len);
2489 snprintf(tmp, tmp_len, "%s/%s", cwd, config_file);
2490 fullpath = tmp;
2491 } else
2492 fullpath = config_file;
2493
2494 confp = fopen(fullpath, "r");
2495
2496 if (confp == NULL) {
2497 flog_warn(
2498 EC_LIB_BACKUP_CONFIG,
2499 "%s: failed to open configuration file %s: %s, checking backup",
2500 __func__, fullpath, safe_strerror(errno));
2501
2502 confp = vty_use_backup_config(fullpath);
2503 if (confp)
2504 flog_warn(EC_LIB_BACKUP_CONFIG,
2505 "using backup configuration file!");
2506 else {
2507 flog_err(
2508 EC_LIB_VTY,
2509 "%s: can't open configuration file [%s]",
2510 __func__, config_file);
2511 goto tmp_free_and_out;
2512 }
2513 }
2514 } else {
2515
2516 host_config_set(config_default_dir);
2517
2518 #ifdef VTYSH
2519 int ret;
2520 struct stat conf_stat;
2521
2522 /* !!!!PLEASE LEAVE!!!!
2523 * This is NEEDED for use with vtysh -b, or else you can get
2524 * a real configuration food fight with a lot garbage in the
2525 * merged configuration file it creates coming from the per
2526 * daemon configuration files. This also allows the daemons
2527 * to start if there default configuration file is not
2528 * present or ignore them, as needed when using vtysh -b to
2529 * configure the daemons at boot - MAG
2530 */
2531
2532 /* Stat for vtysh Zebra.conf, if found startup and wait for
2533 * boot configuration
2534 */
2535
2536 if (strstr(config_default_dir, "vtysh") == NULL) {
2537 ret = stat(integrate_default, &conf_stat);
2538 if (ret >= 0) {
2539 read_success = true;
2540 goto tmp_free_and_out;
2541 }
2542 }
2543 #endif /* VTYSH */
2544 confp = fopen(config_default_dir, "r");
2545 if (confp == NULL) {
2546 flog_err(
2547 EC_LIB_SYSTEM_CALL,
2548 "%s: failed to open configuration file %s: %s, checking backup",
2549 __func__, config_default_dir,
2550 safe_strerror(errno));
2551
2552 confp = vty_use_backup_config(config_default_dir);
2553 if (confp) {
2554 flog_warn(EC_LIB_BACKUP_CONFIG,
2555 "using backup configuration file!");
2556 fullpath = config_default_dir;
2557 } else {
2558 flog_err(EC_LIB_VTY,
2559 "can't open configuration file [%s]",
2560 config_default_dir);
2561 goto tmp_free_and_out;
2562 }
2563 } else
2564 fullpath = config_default_dir;
2565 }
2566
2567 vty_read_file(config, confp);
2568 read_success = true;
2569
2570 fclose(confp);
2571
2572 host_config_set(fullpath);
2573
2574 tmp_free_and_out:
2575 XFREE(MTYPE_TMP, tmp);
2576
2577 return read_success;
2578 }
2579
2580 static void update_xpath(struct vty *vty, const char *oldpath,
2581 const char *newpath)
2582 {
2583 int i;
2584
2585 for (i = 0; i < vty->xpath_index; i++) {
2586 if (!frrstr_startswith(vty->xpath[i], oldpath))
2587 break;
2588
2589 char *tmp = frrstr_replace(vty->xpath[i], oldpath, newpath);
2590 strlcpy(vty->xpath[i], tmp, sizeof(vty->xpath[0]));
2591 XFREE(MTYPE_TMP, tmp);
2592 }
2593 }
2594
2595 void vty_update_xpath(const char *oldpath, const char *newpath)
2596 {
2597 struct vty *vty;
2598
2599 frr_each (vtys, vtysh_sessions, vty)
2600 update_xpath(vty, oldpath, newpath);
2601 frr_each (vtys, vty_sessions, vty)
2602 update_xpath(vty, oldpath, newpath);
2603 }
2604
2605 int vty_config_enter(struct vty *vty, bool private_config, bool exclusive)
2606 {
2607 if (exclusive && nb_running_lock(NB_CLIENT_CLI, vty)) {
2608 vty_out(vty, "%% Configuration is locked by other client\n");
2609 return CMD_WARNING;
2610 }
2611
2612 vty->node = CONFIG_NODE;
2613 vty->config = true;
2614 vty->private_config = private_config;
2615 vty->xpath_index = 0;
2616
2617 if (private_config) {
2618 vty->candidate_config = nb_config_dup(running_config);
2619 vty->candidate_config_base = nb_config_dup(running_config);
2620 vty_out(vty,
2621 "Warning: uncommitted changes will be discarded on exit.\n\n");
2622 } else {
2623 vty->candidate_config = vty_shared_candidate_config;
2624 if (frr_get_cli_mode() == FRR_CLI_TRANSACTIONAL)
2625 vty->candidate_config_base =
2626 nb_config_dup(running_config);
2627 }
2628
2629 return CMD_SUCCESS;
2630 }
2631
2632 void vty_config_exit(struct vty *vty)
2633 {
2634 enum node_type node = vty->node;
2635 struct cmd_node *cnode;
2636
2637 /* unlock and jump up to ENABLE_NODE if -and only if- we're
2638 * somewhere below CONFIG_NODE */
2639 while (node && node != CONFIG_NODE) {
2640 cnode = vector_lookup(cmdvec, node);
2641 node = cnode->parent_node;
2642 }
2643 if (node != CONFIG_NODE)
2644 /* called outside config, e.g. vty_close() in ENABLE_NODE */
2645 return;
2646
2647 while (vty->node != ENABLE_NODE)
2648 /* will call vty_config_node_exit() below */
2649 cmd_exit(vty);
2650 }
2651
2652 int vty_config_node_exit(struct vty *vty)
2653 {
2654 vty->xpath_index = 0;
2655
2656 /* Perform any pending commits. */
2657 (void)nb_cli_pending_commit_check(vty);
2658
2659 /* Check if there's a pending confirmed commit. */
2660 if (vty->t_confirmed_commit_timeout) {
2661 vty_out(vty,
2662 "exiting with a pending confirmed commit. Rolling back to previous configuration.\n\n");
2663 nb_cli_confirmed_commit_rollback(vty);
2664 nb_cli_confirmed_commit_clean(vty);
2665 }
2666
2667 (void)nb_running_unlock(NB_CLIENT_CLI, vty);
2668
2669 if (vty->candidate_config) {
2670 if (vty->private_config)
2671 nb_config_free(vty->candidate_config);
2672 vty->candidate_config = NULL;
2673 }
2674 if (vty->candidate_config_base) {
2675 nb_config_free(vty->candidate_config_base);
2676 vty->candidate_config_base = NULL;
2677 }
2678
2679 vty->config = false;
2680 return 1;
2681 }
2682
2683 /* Master of the threads. */
2684 static struct thread_master *vty_master;
2685
2686 static void vty_event_serv(enum vty_event event, struct vty_serv *vty_serv)
2687 {
2688 switch (event) {
2689 case VTY_SERV:
2690 thread_add_read(vty_master, vty_accept, vty_serv,
2691 vty_serv->sock, &vty_serv->t_accept);
2692 break;
2693 #ifdef VTYSH
2694 case VTYSH_SERV:
2695 thread_add_read(vty_master, vtysh_accept, vty_serv,
2696 vty_serv->sock, &vty_serv->t_accept);
2697 break;
2698 #endif /* VTYSH */
2699 default:
2700 assert(!"vty_event_serv() called incorrectly");
2701 }
2702 }
2703
2704 static void vty_event(enum vty_event event, struct vty *vty)
2705 {
2706 switch (event) {
2707 #ifdef VTYSH
2708 case VTYSH_READ:
2709 thread_add_read(vty_master, vtysh_read, vty, vty->fd,
2710 &vty->t_read);
2711 break;
2712 case VTYSH_WRITE:
2713 thread_add_write(vty_master, vtysh_write, vty, vty->wfd,
2714 &vty->t_write);
2715 break;
2716 #endif /* VTYSH */
2717 case VTY_READ:
2718 thread_add_read(vty_master, vty_read, vty, vty->fd,
2719 &vty->t_read);
2720
2721 /* Time out treatment. */
2722 if (vty->v_timeout) {
2723 THREAD_OFF(vty->t_timeout);
2724 thread_add_timer(vty_master, vty_timeout, vty,
2725 vty->v_timeout, &vty->t_timeout);
2726 }
2727 break;
2728 case VTY_WRITE:
2729 thread_add_write(vty_master, vty_flush, vty, vty->wfd,
2730 &vty->t_write);
2731 break;
2732 case VTY_TIMEOUT_RESET:
2733 THREAD_OFF(vty->t_timeout);
2734 if (vty->v_timeout)
2735 thread_add_timer(vty_master, vty_timeout, vty,
2736 vty->v_timeout, &vty->t_timeout);
2737 break;
2738 default:
2739 assert(!"vty_event() called incorrectly");
2740 }
2741 }
2742
2743 DEFUN_NOSH (config_who,
2744 config_who_cmd,
2745 "who",
2746 "Display who is on vty\n")
2747 {
2748 struct vty *v;
2749
2750 frr_each (vtys, vty_sessions, v)
2751 vty_out(vty, "%svty[%d] connected from %s%s.\n",
2752 v->config ? "*" : " ", v->fd, v->address,
2753 zlog_live_is_null(&v->live_log) ? "" : ", live log");
2754 return CMD_SUCCESS;
2755 }
2756
2757 /* Move to vty configuration mode. */
2758 DEFUN_NOSH (line_vty,
2759 line_vty_cmd,
2760 "line vty",
2761 "Configure a terminal line\n"
2762 "Virtual terminal\n")
2763 {
2764 vty->node = VTY_NODE;
2765 return CMD_SUCCESS;
2766 }
2767
2768 /* Set time out value. */
2769 static int exec_timeout(struct vty *vty, const char *min_str,
2770 const char *sec_str)
2771 {
2772 unsigned long timeout = 0;
2773
2774 /* min_str and sec_str are already checked by parser. So it must be
2775 all digit string. */
2776 if (min_str) {
2777 timeout = strtol(min_str, NULL, 10);
2778 timeout *= 60;
2779 }
2780 if (sec_str)
2781 timeout += strtol(sec_str, NULL, 10);
2782
2783 vty_timeout_val = timeout;
2784 vty->v_timeout = timeout;
2785 vty_event(VTY_TIMEOUT_RESET, vty);
2786
2787
2788 return CMD_SUCCESS;
2789 }
2790
2791 DEFUN (exec_timeout_min,
2792 exec_timeout_min_cmd,
2793 "exec-timeout (0-35791)",
2794 "Set timeout value\n"
2795 "Timeout value in minutes\n")
2796 {
2797 int idx_number = 1;
2798 return exec_timeout(vty, argv[idx_number]->arg, NULL);
2799 }
2800
2801 DEFUN (exec_timeout_sec,
2802 exec_timeout_sec_cmd,
2803 "exec-timeout (0-35791) (0-2147483)",
2804 "Set the EXEC timeout\n"
2805 "Timeout in minutes\n"
2806 "Timeout in seconds\n")
2807 {
2808 int idx_number = 1;
2809 int idx_number_2 = 2;
2810 return exec_timeout(vty, argv[idx_number]->arg,
2811 argv[idx_number_2]->arg);
2812 }
2813
2814 DEFUN (no_exec_timeout,
2815 no_exec_timeout_cmd,
2816 "no exec-timeout",
2817 NO_STR
2818 "Set the EXEC timeout\n")
2819 {
2820 return exec_timeout(vty, NULL, NULL);
2821 }
2822
2823 /* Set vty access class. */
2824 DEFUN (vty_access_class,
2825 vty_access_class_cmd,
2826 "access-class WORD",
2827 "Filter connections based on an IP access list\n"
2828 "IP access list\n")
2829 {
2830 int idx_word = 1;
2831 if (vty_accesslist_name)
2832 XFREE(MTYPE_VTY, vty_accesslist_name);
2833
2834 vty_accesslist_name = XSTRDUP(MTYPE_VTY, argv[idx_word]->arg);
2835
2836 return CMD_SUCCESS;
2837 }
2838
2839 /* Clear vty access class. */
2840 DEFUN (no_vty_access_class,
2841 no_vty_access_class_cmd,
2842 "no access-class [WORD]",
2843 NO_STR
2844 "Filter connections based on an IP access list\n"
2845 "IP access list\n")
2846 {
2847 int idx_word = 2;
2848 const char *accesslist = (argc == 3) ? argv[idx_word]->arg : NULL;
2849 if (!vty_accesslist_name
2850 || (argc == 3 && strcmp(vty_accesslist_name, accesslist))) {
2851 vty_out(vty, "Access-class is not currently applied to vty\n");
2852 return CMD_WARNING_CONFIG_FAILED;
2853 }
2854
2855 XFREE(MTYPE_VTY, vty_accesslist_name);
2856
2857 vty_accesslist_name = NULL;
2858
2859 return CMD_SUCCESS;
2860 }
2861
2862 /* Set vty access class. */
2863 DEFUN (vty_ipv6_access_class,
2864 vty_ipv6_access_class_cmd,
2865 "ipv6 access-class WORD",
2866 IPV6_STR
2867 "Filter connections based on an IP access list\n"
2868 "IPv6 access list\n")
2869 {
2870 int idx_word = 2;
2871 if (vty_ipv6_accesslist_name)
2872 XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
2873
2874 vty_ipv6_accesslist_name = XSTRDUP(MTYPE_VTY, argv[idx_word]->arg);
2875
2876 return CMD_SUCCESS;
2877 }
2878
2879 /* Clear vty access class. */
2880 DEFUN (no_vty_ipv6_access_class,
2881 no_vty_ipv6_access_class_cmd,
2882 "no ipv6 access-class [WORD]",
2883 NO_STR
2884 IPV6_STR
2885 "Filter connections based on an IP access list\n"
2886 "IPv6 access list\n")
2887 {
2888 int idx_word = 3;
2889 const char *accesslist = (argc == 4) ? argv[idx_word]->arg : NULL;
2890
2891 if (!vty_ipv6_accesslist_name
2892 || (argc == 4 && strcmp(vty_ipv6_accesslist_name, accesslist))) {
2893 vty_out(vty,
2894 "IPv6 access-class is not currently applied to vty\n");
2895 return CMD_WARNING_CONFIG_FAILED;
2896 }
2897
2898 XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
2899
2900 vty_ipv6_accesslist_name = NULL;
2901
2902 return CMD_SUCCESS;
2903 }
2904
2905 /* vty login. */
2906 DEFUN (vty_login,
2907 vty_login_cmd,
2908 "login",
2909 "Enable password checking\n")
2910 {
2911 no_password_check = 0;
2912 return CMD_SUCCESS;
2913 }
2914
2915 DEFUN (no_vty_login,
2916 no_vty_login_cmd,
2917 "no login",
2918 NO_STR
2919 "Enable password checking\n")
2920 {
2921 no_password_check = 1;
2922 return CMD_SUCCESS;
2923 }
2924
2925 DEFUN (service_advanced_vty,
2926 service_advanced_vty_cmd,
2927 "service advanced-vty",
2928 "Set up miscellaneous service\n"
2929 "Enable advanced mode vty interface\n")
2930 {
2931 host.advanced = 1;
2932 return CMD_SUCCESS;
2933 }
2934
2935 DEFUN (no_service_advanced_vty,
2936 no_service_advanced_vty_cmd,
2937 "no service advanced-vty",
2938 NO_STR
2939 "Set up miscellaneous service\n"
2940 "Enable advanced mode vty interface\n")
2941 {
2942 host.advanced = 0;
2943 return CMD_SUCCESS;
2944 }
2945
2946 DEFUN_NOSH(terminal_monitor,
2947 terminal_monitor_cmd,
2948 "terminal monitor [detach]",
2949 "Set terminal line parameters\n"
2950 "Copy debug output to the current terminal line\n"
2951 "Keep logging feed open independent of VTY session\n")
2952 {
2953 int fd_ret = -1;
2954
2955 if (vty->type != VTY_SHELL_SERV) {
2956 vty_out(vty, "%% not supported\n");
2957 return CMD_WARNING;
2958 }
2959
2960 if (argc == 3) {
2961 struct zlog_live_cfg detach_log = {};
2962
2963 zlog_live_open(&detach_log, LOG_DEBUG, &fd_ret);
2964 zlog_live_disown(&detach_log);
2965 } else
2966 zlog_live_open(&vty->live_log, LOG_DEBUG, &fd_ret);
2967
2968 if (fd_ret == -1) {
2969 vty_out(vty, "%% error opening live log: %m\n");
2970 return CMD_WARNING;
2971 }
2972
2973 vty_pass_fd(vty, fd_ret);
2974 return CMD_SUCCESS;
2975 }
2976
2977 DEFUN_NOSH(no_terminal_monitor,
2978 no_terminal_monitor_cmd,
2979 "no terminal monitor",
2980 NO_STR
2981 "Set terminal line parameters\n"
2982 "Copy debug output to the current terminal line\n")
2983 {
2984 zlog_live_close(&vty->live_log);
2985 return CMD_SUCCESS;
2986 }
2987
2988 DEFUN_NOSH(terminal_no_monitor,
2989 terminal_no_monitor_cmd,
2990 "terminal no monitor",
2991 "Set terminal line parameters\n"
2992 NO_STR
2993 "Copy debug output to the current terminal line\n")
2994 {
2995 return no_terminal_monitor(self, vty, argc, argv);
2996 }
2997
2998
2999 DEFUN_NOSH (show_history,
3000 show_history_cmd,
3001 "show history",
3002 SHOW_STR
3003 "Display the session command history\n")
3004 {
3005 int index;
3006
3007 for (index = vty->hindex + 1; index != vty->hindex;) {
3008 if (index == VTY_MAXHIST) {
3009 index = 0;
3010 continue;
3011 }
3012
3013 if (vty->hist[index] != NULL)
3014 vty_out(vty, " %s\n", vty->hist[index]);
3015
3016 index++;
3017 }
3018
3019 return CMD_SUCCESS;
3020 }
3021
3022 /* vty login. */
3023 DEFPY (log_commands,
3024 log_commands_cmd,
3025 "[no] log commands",
3026 NO_STR
3027 "Logging control\n"
3028 "Log all commands\n")
3029 {
3030 if (no) {
3031 if (do_log_commands_perm) {
3032 vty_out(vty,
3033 "Daemon started with permanent logging turned on for commands, ignoring\n");
3034 return CMD_WARNING;
3035 }
3036
3037 do_log_commands = false;
3038 } else
3039 do_log_commands = true;
3040
3041 return CMD_SUCCESS;
3042 }
3043
3044 /* Display current configuration. */
3045 static int vty_config_write(struct vty *vty)
3046 {
3047 vty_frame(vty, "line vty\n");
3048
3049 if (vty_accesslist_name)
3050 vty_out(vty, " access-class %s\n", vty_accesslist_name);
3051
3052 if (vty_ipv6_accesslist_name)
3053 vty_out(vty, " ipv6 access-class %s\n",
3054 vty_ipv6_accesslist_name);
3055
3056 /* exec-timeout */
3057 if (vty_timeout_val != VTY_TIMEOUT_DEFAULT)
3058 vty_out(vty, " exec-timeout %ld %ld\n", vty_timeout_val / 60,
3059 vty_timeout_val % 60);
3060
3061 /* login */
3062 if (no_password_check)
3063 vty_out(vty, " no login\n");
3064
3065 vty_endframe(vty, "exit\n");
3066
3067 if (do_log_commands)
3068 vty_out(vty, "log commands\n");
3069
3070 vty_out(vty, "!\n");
3071
3072 return CMD_SUCCESS;
3073 }
3074
3075 static int vty_config_write(struct vty *vty);
3076 struct cmd_node vty_node = {
3077 .name = "vty",
3078 .node = VTY_NODE,
3079 .parent_node = CONFIG_NODE,
3080 .prompt = "%s(config-line)# ",
3081 .config_write = vty_config_write,
3082 };
3083
3084 /* Reset all VTY status. */
3085 void vty_reset(void)
3086 {
3087 struct vty *vty;
3088
3089 frr_each_safe (vtys, vty_sessions, vty) {
3090 buffer_reset(vty->lbuf);
3091 buffer_reset(vty->obuf);
3092 vty->status = VTY_CLOSE;
3093 vty_close(vty);
3094 }
3095
3096 vty_timeout_val = VTY_TIMEOUT_DEFAULT;
3097
3098 XFREE(MTYPE_VTY, vty_accesslist_name);
3099 XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
3100 }
3101
3102 static void vty_save_cwd(void)
3103 {
3104 char *c;
3105
3106 c = getcwd(vty_cwd, sizeof(vty_cwd));
3107
3108 if (!c) {
3109 /*
3110 * At this point if these go wrong, more than likely
3111 * the whole world is coming down around us
3112 * Hence not worrying about it too much.
3113 */
3114 if (chdir(SYSCONFDIR)) {
3115 flog_err_sys(EC_LIB_SYSTEM_CALL,
3116 "Failure to chdir to %s, errno: %d",
3117 SYSCONFDIR, errno);
3118 exit(-1);
3119 }
3120 if (getcwd(vty_cwd, sizeof(vty_cwd)) == NULL) {
3121 flog_err_sys(EC_LIB_SYSTEM_CALL,
3122 "Failure to getcwd, errno: %d", errno);
3123 exit(-1);
3124 }
3125 }
3126 }
3127
3128 char *vty_get_cwd(void)
3129 {
3130 return vty_cwd;
3131 }
3132
3133 int vty_shell(struct vty *vty)
3134 {
3135 return vty->type == VTY_SHELL ? 1 : 0;
3136 }
3137
3138 int vty_shell_serv(struct vty *vty)
3139 {
3140 return vty->type == VTY_SHELL_SERV ? 1 : 0;
3141 }
3142
3143 void vty_init_vtysh(void)
3144 {
3145 /* currently nothing to do, but likely to have future use */
3146 }
3147
3148 /* Install vty's own commands like `who' command. */
3149 void vty_init(struct thread_master *master_thread, bool do_command_logging)
3150 {
3151 /* For further configuration read, preserve current directory. */
3152 vty_save_cwd();
3153
3154 vty_master = master_thread;
3155
3156 atexit(vty_stdio_atexit);
3157
3158 /* Install bgp top node. */
3159 install_node(&vty_node);
3160
3161 install_element(VIEW_NODE, &config_who_cmd);
3162 install_element(VIEW_NODE, &show_history_cmd);
3163 install_element(CONFIG_NODE, &line_vty_cmd);
3164 install_element(CONFIG_NODE, &service_advanced_vty_cmd);
3165 install_element(CONFIG_NODE, &no_service_advanced_vty_cmd);
3166 install_element(CONFIG_NODE, &show_history_cmd);
3167 install_element(CONFIG_NODE, &log_commands_cmd);
3168
3169 if (do_command_logging) {
3170 do_log_commands = true;
3171 do_log_commands_perm = true;
3172 }
3173
3174 install_element(ENABLE_NODE, &terminal_monitor_cmd);
3175 install_element(ENABLE_NODE, &terminal_no_monitor_cmd);
3176 install_element(ENABLE_NODE, &no_terminal_monitor_cmd);
3177
3178 install_default(VTY_NODE);
3179 install_element(VTY_NODE, &exec_timeout_min_cmd);
3180 install_element(VTY_NODE, &exec_timeout_sec_cmd);
3181 install_element(VTY_NODE, &no_exec_timeout_cmd);
3182 install_element(VTY_NODE, &vty_access_class_cmd);
3183 install_element(VTY_NODE, &no_vty_access_class_cmd);
3184 install_element(VTY_NODE, &vty_login_cmd);
3185 install_element(VTY_NODE, &no_vty_login_cmd);
3186 install_element(VTY_NODE, &vty_ipv6_access_class_cmd);
3187 install_element(VTY_NODE, &no_vty_ipv6_access_class_cmd);
3188 }
3189
3190 void vty_terminate(void)
3191 {
3192 struct vty *vty;
3193 struct vty_serv *vtyserv;
3194
3195 memset(vty_cwd, 0x00, sizeof(vty_cwd));
3196
3197 vty_reset();
3198
3199 /* default state of vty_sessions is initialized & empty. */
3200 vtys_fini(vty_sessions);
3201 vtys_init(vty_sessions);
3202
3203 /* vty_reset() doesn't close vtysh sessions */
3204 frr_each_safe (vtys, vtysh_sessions, vty) {
3205 buffer_reset(vty->lbuf);
3206 buffer_reset(vty->obuf);
3207 vty->status = VTY_CLOSE;
3208 vty_close(vty);
3209 }
3210
3211 vtys_fini(vtysh_sessions);
3212 vtys_init(vtysh_sessions);
3213
3214 while ((vtyserv = vtyservs_pop(vty_servs))) {
3215 THREAD_OFF(vtyserv->t_accept);
3216 close(vtyserv->sock);
3217 XFREE(MTYPE_VTY_SERV, vtyserv);
3218 }
3219
3220 vtyservs_fini(vty_servs);
3221 vtyservs_init(vty_servs);
3222 }
FRRouting mirror