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