Annotation of embedaddon/quagga/lib/vty.c, revision 1.1
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:
! 702: case BGP_NODE:
! 703: case BGP_VPNV4_NODE:
! 704: case BGP_IPV4_NODE:
! 705: case BGP_IPV4M_NODE:
! 706: case BGP_IPV6_NODE:
! 707: case BGP_IPV6M_NODE:
! 708: case RMAP_NODE:
! 709: case OSPF_NODE:
! 710: case OSPF6_NODE:
! 711: case ISIS_NODE:
! 712: case KEYCHAIN_NODE:
! 713: case KEYCHAIN_KEY_NODE:
! 714: case MASC_NODE:
! 715: case VTY_NODE:
! 716: vty_config_unlock (vty);
! 717: vty->node = ENABLE_NODE;
! 718: break;
! 719: default:
! 720: /* Unknown node, we have to ignore it. */
! 721: break;
! 722: }
! 723:
! 724: vty_prompt (vty);
! 725: vty->cp = 0;
! 726: }
! 727:
! 728: /* Delete a charcter at the current point. */
! 729: static void
! 730: vty_delete_char (struct vty *vty)
! 731: {
! 732: int i;
! 733: int size;
! 734:
! 735: if (vty->length == 0)
! 736: {
! 737: vty_down_level (vty);
! 738: return;
! 739: }
! 740:
! 741: if (vty->cp == vty->length)
! 742: return; /* completion need here? */
! 743:
! 744: size = vty->length - vty->cp;
! 745:
! 746: vty->length--;
! 747: memmove (&vty->buf[vty->cp], &vty->buf[vty->cp + 1], size - 1);
! 748: vty->buf[vty->length] = '\0';
! 749:
! 750: if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
! 751: return;
! 752:
! 753: vty_write (vty, &vty->buf[vty->cp], size - 1);
! 754: vty_write (vty, &telnet_space_char, 1);
! 755:
! 756: for (i = 0; i < size; i++)
! 757: vty_write (vty, &telnet_backward_char, 1);
! 758: }
! 759:
! 760: /* Delete a character before the point. */
! 761: static void
! 762: vty_delete_backward_char (struct vty *vty)
! 763: {
! 764: if (vty->cp == 0)
! 765: return;
! 766:
! 767: vty_backward_char (vty);
! 768: vty_delete_char (vty);
! 769: }
! 770:
! 771: /* Kill rest of line from current point. */
! 772: static void
! 773: vty_kill_line (struct vty *vty)
! 774: {
! 775: int i;
! 776: int size;
! 777:
! 778: size = vty->length - vty->cp;
! 779:
! 780: if (size == 0)
! 781: return;
! 782:
! 783: for (i = 0; i < size; i++)
! 784: vty_write (vty, &telnet_space_char, 1);
! 785: for (i = 0; i < size; i++)
! 786: vty_write (vty, &telnet_backward_char, 1);
! 787:
! 788: memset (&vty->buf[vty->cp], 0, size);
! 789: vty->length = vty->cp;
! 790: }
! 791:
! 792: /* Kill line from the beginning. */
! 793: static void
! 794: vty_kill_line_from_beginning (struct vty *vty)
! 795: {
! 796: vty_beginning_of_line (vty);
! 797: vty_kill_line (vty);
! 798: }
! 799:
! 800: /* Delete a word before the point. */
! 801: static void
! 802: vty_forward_kill_word (struct vty *vty)
! 803: {
! 804: while (vty->cp != vty->length && vty->buf[vty->cp] == ' ')
! 805: vty_delete_char (vty);
! 806: while (vty->cp != vty->length && vty->buf[vty->cp] != ' ')
! 807: vty_delete_char (vty);
! 808: }
! 809:
! 810: /* Delete a word before the point. */
! 811: static void
! 812: vty_backward_kill_word (struct vty *vty)
! 813: {
! 814: while (vty->cp > 0 && vty->buf[vty->cp - 1] == ' ')
! 815: vty_delete_backward_char (vty);
! 816: while (vty->cp > 0 && vty->buf[vty->cp - 1] != ' ')
! 817: vty_delete_backward_char (vty);
! 818: }
! 819:
! 820: /* Transpose chars before or at the point. */
! 821: static void
! 822: vty_transpose_chars (struct vty *vty)
! 823: {
! 824: char c1, c2;
! 825:
! 826: /* If length is short or point is near by the beginning of line then
! 827: return. */
! 828: if (vty->length < 2 || vty->cp < 1)
! 829: return;
! 830:
! 831: /* In case of point is located at the end of the line. */
! 832: if (vty->cp == vty->length)
! 833: {
! 834: c1 = vty->buf[vty->cp - 1];
! 835: c2 = vty->buf[vty->cp - 2];
! 836:
! 837: vty_backward_char (vty);
! 838: vty_backward_char (vty);
! 839: vty_self_insert_overwrite (vty, c1);
! 840: vty_self_insert_overwrite (vty, c2);
! 841: }
! 842: else
! 843: {
! 844: c1 = vty->buf[vty->cp];
! 845: c2 = vty->buf[vty->cp - 1];
! 846:
! 847: vty_backward_char (vty);
! 848: vty_self_insert_overwrite (vty, c1);
! 849: vty_self_insert_overwrite (vty, c2);
! 850: }
! 851: }
! 852:
! 853: /* Do completion at vty interface. */
! 854: static void
! 855: vty_complete_command (struct vty *vty)
! 856: {
! 857: int i;
! 858: int ret;
! 859: char **matched = NULL;
! 860: vector vline;
! 861:
! 862: if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
! 863: return;
! 864:
! 865: vline = cmd_make_strvec (vty->buf);
! 866: if (vline == NULL)
! 867: return;
! 868:
! 869: /* In case of 'help \t'. */
! 870: if (isspace ((int) vty->buf[vty->length - 1]))
! 871: vector_set (vline, '\0');
! 872:
! 873: matched = cmd_complete_command (vline, vty, &ret);
! 874:
! 875: cmd_free_strvec (vline);
! 876:
! 877: vty_out (vty, "%s", VTY_NEWLINE);
! 878: switch (ret)
! 879: {
! 880: case CMD_ERR_AMBIGUOUS:
! 881: vty_out (vty, "%% Ambiguous command.%s", VTY_NEWLINE);
! 882: vty_prompt (vty);
! 883: vty_redraw_line (vty);
! 884: break;
! 885: case CMD_ERR_NO_MATCH:
! 886: /* vty_out (vty, "%% There is no matched command.%s", VTY_NEWLINE); */
! 887: vty_prompt (vty);
! 888: vty_redraw_line (vty);
! 889: break;
! 890: case CMD_COMPLETE_FULL_MATCH:
! 891: vty_prompt (vty);
! 892: vty_redraw_line (vty);
! 893: vty_backward_pure_word (vty);
! 894: vty_insert_word_overwrite (vty, matched[0]);
! 895: vty_self_insert (vty, ' ');
! 896: XFREE (MTYPE_TMP, matched[0]);
! 897: break;
! 898: case CMD_COMPLETE_MATCH:
! 899: vty_prompt (vty);
! 900: vty_redraw_line (vty);
! 901: vty_backward_pure_word (vty);
! 902: vty_insert_word_overwrite (vty, matched[0]);
! 903: XFREE (MTYPE_TMP, matched[0]);
! 904: vector_only_index_free (matched);
! 905: return;
! 906: break;
! 907: case CMD_COMPLETE_LIST_MATCH:
! 908: for (i = 0; matched[i] != NULL; i++)
! 909: {
! 910: if (i != 0 && ((i % 6) == 0))
! 911: vty_out (vty, "%s", VTY_NEWLINE);
! 912: vty_out (vty, "%-10s ", matched[i]);
! 913: XFREE (MTYPE_TMP, matched[i]);
! 914: }
! 915: vty_out (vty, "%s", VTY_NEWLINE);
! 916:
! 917: vty_prompt (vty);
! 918: vty_redraw_line (vty);
! 919: break;
! 920: case CMD_ERR_NOTHING_TODO:
! 921: vty_prompt (vty);
! 922: vty_redraw_line (vty);
! 923: break;
! 924: default:
! 925: break;
! 926: }
! 927: if (matched)
! 928: vector_only_index_free (matched);
! 929: }
! 930:
! 931: static void
! 932: vty_describe_fold (struct vty *vty, int cmd_width,
! 933: unsigned int desc_width, struct desc *desc)
! 934: {
! 935: char *buf;
! 936: const char *cmd, *p;
! 937: int pos;
! 938:
! 939: cmd = desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd;
! 940:
! 941: if (desc_width <= 0)
! 942: {
! 943: vty_out (vty, " %-*s %s%s", cmd_width, cmd, desc->str, VTY_NEWLINE);
! 944: return;
! 945: }
! 946:
! 947: buf = XCALLOC (MTYPE_TMP, strlen (desc->str) + 1);
! 948:
! 949: for (p = desc->str; strlen (p) > desc_width; p += pos + 1)
! 950: {
! 951: for (pos = desc_width; pos > 0; pos--)
! 952: if (*(p + pos) == ' ')
! 953: break;
! 954:
! 955: if (pos == 0)
! 956: break;
! 957:
! 958: strncpy (buf, p, pos);
! 959: buf[pos] = '\0';
! 960: vty_out (vty, " %-*s %s%s", cmd_width, cmd, buf, VTY_NEWLINE);
! 961:
! 962: cmd = "";
! 963: }
! 964:
! 965: vty_out (vty, " %-*s %s%s", cmd_width, cmd, p, VTY_NEWLINE);
! 966:
! 967: XFREE (MTYPE_TMP, buf);
! 968: }
! 969:
! 970: /* Describe matched command function. */
! 971: static void
! 972: vty_describe_command (struct vty *vty)
! 973: {
! 974: int ret;
! 975: vector vline;
! 976: vector describe;
! 977: unsigned int i, width, desc_width;
! 978: struct desc *desc, *desc_cr = NULL;
! 979:
! 980: vline = cmd_make_strvec (vty->buf);
! 981:
! 982: /* In case of '> ?'. */
! 983: if (vline == NULL)
! 984: {
! 985: vline = vector_init (1);
! 986: vector_set (vline, '\0');
! 987: }
! 988: else
! 989: if (isspace ((int) vty->buf[vty->length - 1]))
! 990: vector_set (vline, '\0');
! 991:
! 992: describe = cmd_describe_command (vline, vty, &ret);
! 993:
! 994: vty_out (vty, "%s", VTY_NEWLINE);
! 995:
! 996: /* Ambiguous error. */
! 997: switch (ret)
! 998: {
! 999: case CMD_ERR_AMBIGUOUS:
! 1000: vty_out (vty, "%% Ambiguous command.%s", VTY_NEWLINE);
! 1001: goto out;
! 1002: break;
! 1003: case CMD_ERR_NO_MATCH:
! 1004: vty_out (vty, "%% There is no matched command.%s", VTY_NEWLINE);
! 1005: goto out;
! 1006: break;
! 1007: }
! 1008:
! 1009: /* Get width of command string. */
! 1010: width = 0;
! 1011: for (i = 0; i < vector_active (describe); i++)
! 1012: if ((desc = vector_slot (describe, i)) != NULL)
! 1013: {
! 1014: unsigned int len;
! 1015:
! 1016: if (desc->cmd[0] == '\0')
! 1017: continue;
! 1018:
! 1019: len = strlen (desc->cmd);
! 1020: if (desc->cmd[0] == '.')
! 1021: len--;
! 1022:
! 1023: if (width < len)
! 1024: width = len;
! 1025: }
! 1026:
! 1027: /* Get width of description string. */
! 1028: desc_width = vty->width - (width + 6);
! 1029:
! 1030: /* Print out description. */
! 1031: for (i = 0; i < vector_active (describe); i++)
! 1032: if ((desc = vector_slot (describe, i)) != NULL)
! 1033: {
! 1034: if (desc->cmd[0] == '\0')
! 1035: continue;
! 1036:
! 1037: if (strcmp (desc->cmd, command_cr) == 0)
! 1038: {
! 1039: desc_cr = desc;
! 1040: continue;
! 1041: }
! 1042:
! 1043: if (!desc->str)
! 1044: vty_out (vty, " %-s%s",
! 1045: desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
! 1046: VTY_NEWLINE);
! 1047: else if (desc_width >= strlen (desc->str))
! 1048: vty_out (vty, " %-*s %s%s", width,
! 1049: desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
! 1050: desc->str, VTY_NEWLINE);
! 1051: else
! 1052: vty_describe_fold (vty, width, desc_width, desc);
! 1053:
! 1054: #if 0
! 1055: vty_out (vty, " %-*s %s%s", width
! 1056: desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
! 1057: desc->str ? desc->str : "", VTY_NEWLINE);
! 1058: #endif /* 0 */
! 1059: }
! 1060:
! 1061: if ((desc = desc_cr))
! 1062: {
! 1063: if (!desc->str)
! 1064: vty_out (vty, " %-s%s",
! 1065: desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
! 1066: VTY_NEWLINE);
! 1067: else if (desc_width >= strlen (desc->str))
! 1068: vty_out (vty, " %-*s %s%s", width,
! 1069: desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
! 1070: desc->str, VTY_NEWLINE);
! 1071: else
! 1072: vty_describe_fold (vty, width, desc_width, desc);
! 1073: }
! 1074:
! 1075: out:
! 1076: cmd_free_strvec (vline);
! 1077: if (describe)
! 1078: vector_free (describe);
! 1079:
! 1080: vty_prompt (vty);
! 1081: vty_redraw_line (vty);
! 1082: }
! 1083:
! 1084: static void
! 1085: vty_clear_buf (struct vty *vty)
! 1086: {
! 1087: memset (vty->buf, 0, vty->max);
! 1088: }
! 1089:
! 1090: /* ^C stop current input and do not add command line to the history. */
! 1091: static void
! 1092: vty_stop_input (struct vty *vty)
! 1093: {
! 1094: vty->cp = vty->length = 0;
! 1095: vty_clear_buf (vty);
! 1096: vty_out (vty, "%s", VTY_NEWLINE);
! 1097:
! 1098: switch (vty->node)
! 1099: {
! 1100: case VIEW_NODE:
! 1101: case ENABLE_NODE:
! 1102: case RESTRICTED_NODE:
! 1103: /* Nothing to do. */
! 1104: break;
! 1105: case CONFIG_NODE:
! 1106: case INTERFACE_NODE:
! 1107: case ZEBRA_NODE:
! 1108: case RIP_NODE:
! 1109: case RIPNG_NODE:
! 1110: case BGP_NODE:
! 1111: case RMAP_NODE:
! 1112: case OSPF_NODE:
! 1113: case OSPF6_NODE:
! 1114: case ISIS_NODE:
! 1115: case KEYCHAIN_NODE:
! 1116: case KEYCHAIN_KEY_NODE:
! 1117: case MASC_NODE:
! 1118: case VTY_NODE:
! 1119: vty_config_unlock (vty);
! 1120: vty->node = ENABLE_NODE;
! 1121: break;
! 1122: default:
! 1123: /* Unknown node, we have to ignore it. */
! 1124: break;
! 1125: }
! 1126: vty_prompt (vty);
! 1127:
! 1128: /* Set history pointer to the latest one. */
! 1129: vty->hp = vty->hindex;
! 1130: }
! 1131:
! 1132: /* Add current command line to the history buffer. */
! 1133: static void
! 1134: vty_hist_add (struct vty *vty)
! 1135: {
! 1136: int index;
! 1137:
! 1138: if (vty->length == 0)
! 1139: return;
! 1140:
! 1141: index = vty->hindex ? vty->hindex - 1 : VTY_MAXHIST - 1;
! 1142:
! 1143: /* Ignore the same string as previous one. */
! 1144: if (vty->hist[index])
! 1145: if (strcmp (vty->buf, vty->hist[index]) == 0)
! 1146: {
! 1147: vty->hp = vty->hindex;
! 1148: return;
! 1149: }
! 1150:
! 1151: /* Insert history entry. */
! 1152: if (vty->hist[vty->hindex])
! 1153: XFREE (MTYPE_VTY_HIST, vty->hist[vty->hindex]);
! 1154: vty->hist[vty->hindex] = XSTRDUP (MTYPE_VTY_HIST, vty->buf);
! 1155:
! 1156: /* History index rotation. */
! 1157: vty->hindex++;
! 1158: if (vty->hindex == VTY_MAXHIST)
! 1159: vty->hindex = 0;
! 1160:
! 1161: vty->hp = vty->hindex;
! 1162: }
! 1163:
! 1164: /* #define TELNET_OPTION_DEBUG */
! 1165:
! 1166: /* Get telnet window size. */
! 1167: static int
! 1168: vty_telnet_option (struct vty *vty, unsigned char *buf, int nbytes)
! 1169: {
! 1170: #ifdef TELNET_OPTION_DEBUG
! 1171: int i;
! 1172:
! 1173: for (i = 0; i < nbytes; i++)
! 1174: {
! 1175: switch (buf[i])
! 1176: {
! 1177: case IAC:
! 1178: vty_out (vty, "IAC ");
! 1179: break;
! 1180: case WILL:
! 1181: vty_out (vty, "WILL ");
! 1182: break;
! 1183: case WONT:
! 1184: vty_out (vty, "WONT ");
! 1185: break;
! 1186: case DO:
! 1187: vty_out (vty, "DO ");
! 1188: break;
! 1189: case DONT:
! 1190: vty_out (vty, "DONT ");
! 1191: break;
! 1192: case SB:
! 1193: vty_out (vty, "SB ");
! 1194: break;
! 1195: case SE:
! 1196: vty_out (vty, "SE ");
! 1197: break;
! 1198: case TELOPT_ECHO:
! 1199: vty_out (vty, "TELOPT_ECHO %s", VTY_NEWLINE);
! 1200: break;
! 1201: case TELOPT_SGA:
! 1202: vty_out (vty, "TELOPT_SGA %s", VTY_NEWLINE);
! 1203: break;
! 1204: case TELOPT_NAWS:
! 1205: vty_out (vty, "TELOPT_NAWS %s", VTY_NEWLINE);
! 1206: break;
! 1207: default:
! 1208: vty_out (vty, "%x ", buf[i]);
! 1209: break;
! 1210: }
! 1211: }
! 1212: vty_out (vty, "%s", VTY_NEWLINE);
! 1213:
! 1214: #endif /* TELNET_OPTION_DEBUG */
! 1215:
! 1216: switch (buf[0])
! 1217: {
! 1218: case SB:
! 1219: vty->sb_len = 0;
! 1220: vty->iac_sb_in_progress = 1;
! 1221: return 0;
! 1222: break;
! 1223: case SE:
! 1224: {
! 1225: if (!vty->iac_sb_in_progress)
! 1226: return 0;
! 1227:
! 1228: if ((vty->sb_len == 0) || (vty->sb_buf[0] == '\0'))
! 1229: {
! 1230: vty->iac_sb_in_progress = 0;
! 1231: return 0;
! 1232: }
! 1233: switch (vty->sb_buf[0])
! 1234: {
! 1235: case TELOPT_NAWS:
! 1236: if (vty->sb_len != TELNET_NAWS_SB_LEN)
! 1237: zlog_warn("RFC 1073 violation detected: telnet NAWS option "
! 1238: "should send %d characters, but we received %lu",
! 1239: TELNET_NAWS_SB_LEN, (u_long)vty->sb_len);
! 1240: else if (sizeof(vty->sb_buf) < TELNET_NAWS_SB_LEN)
! 1241: zlog_err("Bug detected: sizeof(vty->sb_buf) %lu < %d, "
! 1242: "too small to handle the telnet NAWS option",
! 1243: (u_long)sizeof(vty->sb_buf), TELNET_NAWS_SB_LEN);
! 1244: else
! 1245: {
! 1246: vty->width = ((vty->sb_buf[1] << 8)|vty->sb_buf[2]);
! 1247: vty->height = ((vty->sb_buf[3] << 8)|vty->sb_buf[4]);
! 1248: #ifdef TELNET_OPTION_DEBUG
! 1249: vty_out(vty, "TELNET NAWS window size negotiation completed: "
! 1250: "width %d, height %d%s",
! 1251: vty->width, vty->height, VTY_NEWLINE);
! 1252: #endif
! 1253: }
! 1254: break;
! 1255: }
! 1256: vty->iac_sb_in_progress = 0;
! 1257: return 0;
! 1258: break;
! 1259: }
! 1260: default:
! 1261: break;
! 1262: }
! 1263: return 1;
! 1264: }
! 1265:
! 1266: /* Execute current command line. */
! 1267: static int
! 1268: vty_execute (struct vty *vty)
! 1269: {
! 1270: int ret;
! 1271:
! 1272: ret = CMD_SUCCESS;
! 1273:
! 1274: switch (vty->node)
! 1275: {
! 1276: case AUTH_NODE:
! 1277: case AUTH_ENABLE_NODE:
! 1278: vty_auth (vty, vty->buf);
! 1279: break;
! 1280: default:
! 1281: ret = vty_command (vty, vty->buf);
! 1282: if (vty->type == VTY_TERM)
! 1283: vty_hist_add (vty);
! 1284: break;
! 1285: }
! 1286:
! 1287: /* Clear command line buffer. */
! 1288: vty->cp = vty->length = 0;
! 1289: vty_clear_buf (vty);
! 1290:
! 1291: if (vty->status != VTY_CLOSE )
! 1292: vty_prompt (vty);
! 1293:
! 1294: return ret;
! 1295: }
! 1296:
! 1297: #define CONTROL(X) ((X) - '@')
! 1298: #define VTY_NORMAL 0
! 1299: #define VTY_PRE_ESCAPE 1
! 1300: #define VTY_ESCAPE 2
! 1301:
! 1302: /* Escape character command map. */
! 1303: static void
! 1304: vty_escape_map (unsigned char c, struct vty *vty)
! 1305: {
! 1306: switch (c)
! 1307: {
! 1308: case ('A'):
! 1309: vty_previous_line (vty);
! 1310: break;
! 1311: case ('B'):
! 1312: vty_next_line (vty);
! 1313: break;
! 1314: case ('C'):
! 1315: vty_forward_char (vty);
! 1316: break;
! 1317: case ('D'):
! 1318: vty_backward_char (vty);
! 1319: break;
! 1320: default:
! 1321: break;
! 1322: }
! 1323:
! 1324: /* Go back to normal mode. */
! 1325: vty->escape = VTY_NORMAL;
! 1326: }
! 1327:
! 1328: /* Quit print out to the buffer. */
! 1329: static void
! 1330: vty_buffer_reset (struct vty *vty)
! 1331: {
! 1332: buffer_reset (vty->obuf);
! 1333: vty_prompt (vty);
! 1334: vty_redraw_line (vty);
! 1335: }
! 1336:
! 1337: /* Read data via vty socket. */
! 1338: static int
! 1339: vty_read (struct thread *thread)
! 1340: {
! 1341: int i;
! 1342: int nbytes;
! 1343: unsigned char buf[VTY_READ_BUFSIZ];
! 1344:
! 1345: int vty_sock = THREAD_FD (thread);
! 1346: struct vty *vty = THREAD_ARG (thread);
! 1347: vty->t_read = NULL;
! 1348:
! 1349: /* Read raw data from socket */
! 1350: if ((nbytes = read (vty->fd, buf, VTY_READ_BUFSIZ)) <= 0)
! 1351: {
! 1352: if (nbytes < 0)
! 1353: {
! 1354: if (ERRNO_IO_RETRY(errno))
! 1355: {
! 1356: vty_event (VTY_READ, vty_sock, vty);
! 1357: return 0;
! 1358: }
! 1359: vty->monitor = 0; /* disable monitoring to avoid infinite recursion */
! 1360: zlog_warn("%s: read error on vty client fd %d, closing: %s",
! 1361: __func__, vty->fd, safe_strerror(errno));
! 1362: }
! 1363: buffer_reset(vty->obuf);
! 1364: vty->status = VTY_CLOSE;
! 1365: }
! 1366:
! 1367: for (i = 0; i < nbytes; i++)
! 1368: {
! 1369: if (buf[i] == IAC)
! 1370: {
! 1371: if (!vty->iac)
! 1372: {
! 1373: vty->iac = 1;
! 1374: continue;
! 1375: }
! 1376: else
! 1377: {
! 1378: vty->iac = 0;
! 1379: }
! 1380: }
! 1381:
! 1382: if (vty->iac_sb_in_progress && !vty->iac)
! 1383: {
! 1384: if (vty->sb_len < sizeof(vty->sb_buf))
! 1385: vty->sb_buf[vty->sb_len] = buf[i];
! 1386: vty->sb_len++;
! 1387: continue;
! 1388: }
! 1389:
! 1390: if (vty->iac)
! 1391: {
! 1392: /* In case of telnet command */
! 1393: int ret = 0;
! 1394: ret = vty_telnet_option (vty, buf + i, nbytes - i);
! 1395: vty->iac = 0;
! 1396: i += ret;
! 1397: continue;
! 1398: }
! 1399:
! 1400:
! 1401: if (vty->status == VTY_MORE)
! 1402: {
! 1403: switch (buf[i])
! 1404: {
! 1405: case CONTROL('C'):
! 1406: case 'q':
! 1407: case 'Q':
! 1408: vty_buffer_reset (vty);
! 1409: break;
! 1410: #if 0 /* More line does not work for "show ip bgp". */
! 1411: case '\n':
! 1412: case '\r':
! 1413: vty->status = VTY_MORELINE;
! 1414: break;
! 1415: #endif
! 1416: default:
! 1417: break;
! 1418: }
! 1419: continue;
! 1420: }
! 1421:
! 1422: /* Escape character. */
! 1423: if (vty->escape == VTY_ESCAPE)
! 1424: {
! 1425: vty_escape_map (buf[i], vty);
! 1426: continue;
! 1427: }
! 1428:
! 1429: /* Pre-escape status. */
! 1430: if (vty->escape == VTY_PRE_ESCAPE)
! 1431: {
! 1432: switch (buf[i])
! 1433: {
! 1434: case '[':
! 1435: vty->escape = VTY_ESCAPE;
! 1436: break;
! 1437: case 'b':
! 1438: vty_backward_word (vty);
! 1439: vty->escape = VTY_NORMAL;
! 1440: break;
! 1441: case 'f':
! 1442: vty_forward_word (vty);
! 1443: vty->escape = VTY_NORMAL;
! 1444: break;
! 1445: case 'd':
! 1446: vty_forward_kill_word (vty);
! 1447: vty->escape = VTY_NORMAL;
! 1448: break;
! 1449: case CONTROL('H'):
! 1450: case 0x7f:
! 1451: vty_backward_kill_word (vty);
! 1452: vty->escape = VTY_NORMAL;
! 1453: break;
! 1454: default:
! 1455: vty->escape = VTY_NORMAL;
! 1456: break;
! 1457: }
! 1458: continue;
! 1459: }
! 1460:
! 1461: switch (buf[i])
! 1462: {
! 1463: case CONTROL('A'):
! 1464: vty_beginning_of_line (vty);
! 1465: break;
! 1466: case CONTROL('B'):
! 1467: vty_backward_char (vty);
! 1468: break;
! 1469: case CONTROL('C'):
! 1470: vty_stop_input (vty);
! 1471: break;
! 1472: case CONTROL('D'):
! 1473: vty_delete_char (vty);
! 1474: break;
! 1475: case CONTROL('E'):
! 1476: vty_end_of_line (vty);
! 1477: break;
! 1478: case CONTROL('F'):
! 1479: vty_forward_char (vty);
! 1480: break;
! 1481: case CONTROL('H'):
! 1482: case 0x7f:
! 1483: vty_delete_backward_char (vty);
! 1484: break;
! 1485: case CONTROL('K'):
! 1486: vty_kill_line (vty);
! 1487: break;
! 1488: case CONTROL('N'):
! 1489: vty_next_line (vty);
! 1490: break;
! 1491: case CONTROL('P'):
! 1492: vty_previous_line (vty);
! 1493: break;
! 1494: case CONTROL('T'):
! 1495: vty_transpose_chars (vty);
! 1496: break;
! 1497: case CONTROL('U'):
! 1498: vty_kill_line_from_beginning (vty);
! 1499: break;
! 1500: case CONTROL('W'):
! 1501: vty_backward_kill_word (vty);
! 1502: break;
! 1503: case CONTROL('Z'):
! 1504: vty_end_config (vty);
! 1505: break;
! 1506: case '\n':
! 1507: case '\r':
! 1508: vty_out (vty, "%s", VTY_NEWLINE);
! 1509: vty_execute (vty);
! 1510: break;
! 1511: case '\t':
! 1512: vty_complete_command (vty);
! 1513: break;
! 1514: case '?':
! 1515: if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
! 1516: vty_self_insert (vty, buf[i]);
! 1517: else
! 1518: vty_describe_command (vty);
! 1519: break;
! 1520: case '\033':
! 1521: if (i + 1 < nbytes && buf[i + 1] == '[')
! 1522: {
! 1523: vty->escape = VTY_ESCAPE;
! 1524: i++;
! 1525: }
! 1526: else
! 1527: vty->escape = VTY_PRE_ESCAPE;
! 1528: break;
! 1529: default:
! 1530: if (buf[i] > 31 && buf[i] < 127)
! 1531: vty_self_insert (vty, buf[i]);
! 1532: break;
! 1533: }
! 1534: }
! 1535:
! 1536: /* Check status. */
! 1537: if (vty->status == VTY_CLOSE)
! 1538: vty_close (vty);
! 1539: else
! 1540: {
! 1541: vty_event (VTY_WRITE, vty_sock, vty);
! 1542: vty_event (VTY_READ, vty_sock, vty);
! 1543: }
! 1544: return 0;
! 1545: }
! 1546:
! 1547: /* Flush buffer to the vty. */
! 1548: static int
! 1549: vty_flush (struct thread *thread)
! 1550: {
! 1551: int erase;
! 1552: buffer_status_t flushrc;
! 1553: int vty_sock = THREAD_FD (thread);
! 1554: struct vty *vty = THREAD_ARG (thread);
! 1555:
! 1556: vty->t_write = NULL;
! 1557:
! 1558: /* Tempolary disable read thread. */
! 1559: if ((vty->lines == 0) && vty->t_read)
! 1560: {
! 1561: thread_cancel (vty->t_read);
! 1562: vty->t_read = NULL;
! 1563: }
! 1564:
! 1565: /* Function execution continue. */
! 1566: erase = ((vty->status == VTY_MORE || vty->status == VTY_MORELINE));
! 1567:
! 1568: /* N.B. if width is 0, that means we don't know the window size. */
! 1569: if ((vty->lines == 0) || (vty->width == 0))
! 1570: flushrc = buffer_flush_available(vty->obuf, vty->fd);
! 1571: else if (vty->status == VTY_MORELINE)
! 1572: flushrc = buffer_flush_window(vty->obuf, vty->fd, vty->width,
! 1573: 1, erase, 0);
! 1574: else
! 1575: flushrc = buffer_flush_window(vty->obuf, vty->fd, vty->width,
! 1576: vty->lines >= 0 ? vty->lines :
! 1577: vty->height,
! 1578: erase, 0);
! 1579: switch (flushrc)
! 1580: {
! 1581: case BUFFER_ERROR:
! 1582: vty->monitor = 0; /* disable monitoring to avoid infinite recursion */
! 1583: zlog_warn("buffer_flush failed on vty client fd %d, closing",
! 1584: vty->fd);
! 1585: buffer_reset(vty->obuf);
! 1586: vty_close(vty);
! 1587: return 0;
! 1588: case BUFFER_EMPTY:
! 1589: if (vty->status == VTY_CLOSE)
! 1590: vty_close (vty);
! 1591: else
! 1592: {
! 1593: vty->status = VTY_NORMAL;
! 1594: if (vty->lines == 0)
! 1595: vty_event (VTY_READ, vty_sock, vty);
! 1596: }
! 1597: break;
! 1598: case BUFFER_PENDING:
! 1599: /* There is more data waiting to be written. */
! 1600: vty->status = VTY_MORE;
! 1601: if (vty->lines == 0)
! 1602: vty_event (VTY_WRITE, vty_sock, vty);
! 1603: break;
! 1604: }
! 1605:
! 1606: return 0;
! 1607: }
! 1608:
! 1609: /* Create new vty structure. */
! 1610: static struct vty *
! 1611: vty_create (int vty_sock, union sockunion *su)
! 1612: {
! 1613: struct vty *vty;
! 1614:
! 1615: /* Allocate new vty structure and set up default values. */
! 1616: vty = vty_new ();
! 1617: vty->fd = vty_sock;
! 1618: vty->type = VTY_TERM;
! 1619: vty->address = sockunion_su2str (su);
! 1620: if (no_password_check)
! 1621: {
! 1622: if (restricted_mode)
! 1623: vty->node = RESTRICTED_NODE;
! 1624: else if (host.advanced)
! 1625: vty->node = ENABLE_NODE;
! 1626: else
! 1627: vty->node = VIEW_NODE;
! 1628: }
! 1629: else
! 1630: vty->node = AUTH_NODE;
! 1631: vty->fail = 0;
! 1632: vty->cp = 0;
! 1633: vty_clear_buf (vty);
! 1634: vty->length = 0;
! 1635: memset (vty->hist, 0, sizeof (vty->hist));
! 1636: vty->hp = 0;
! 1637: vty->hindex = 0;
! 1638: vector_set_index (vtyvec, vty_sock, vty);
! 1639: vty->status = VTY_NORMAL;
! 1640: vty->v_timeout = vty_timeout_val;
! 1641: if (host.lines >= 0)
! 1642: vty->lines = host.lines;
! 1643: else
! 1644: vty->lines = -1;
! 1645: vty->iac = 0;
! 1646: vty->iac_sb_in_progress = 0;
! 1647: vty->sb_len = 0;
! 1648:
! 1649: if (! no_password_check)
! 1650: {
! 1651: /* Vty is not available if password isn't set. */
! 1652: if (host.password == NULL && host.password_encrypt == NULL)
! 1653: {
! 1654: vty_out (vty, "Vty password is not set.%s", VTY_NEWLINE);
! 1655: vty->status = VTY_CLOSE;
! 1656: vty_close (vty);
! 1657: return NULL;
! 1658: }
! 1659: }
! 1660:
! 1661: /* Say hello to the world. */
! 1662: vty_hello (vty);
! 1663: if (! no_password_check)
! 1664: vty_out (vty, "%sUser Access Verification%s%s", VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE);
! 1665:
! 1666: /* Setting up terminal. */
! 1667: vty_will_echo (vty);
! 1668: vty_will_suppress_go_ahead (vty);
! 1669:
! 1670: vty_dont_linemode (vty);
! 1671: vty_do_window_size (vty);
! 1672: /* vty_dont_lflow_ahead (vty); */
! 1673:
! 1674: vty_prompt (vty);
! 1675:
! 1676: /* Add read/write thread. */
! 1677: vty_event (VTY_WRITE, vty_sock, vty);
! 1678: vty_event (VTY_READ, vty_sock, vty);
! 1679:
! 1680: return vty;
! 1681: }
! 1682:
! 1683: /* Accept connection from the network. */
! 1684: static int
! 1685: vty_accept (struct thread *thread)
! 1686: {
! 1687: int vty_sock;
! 1688: struct vty *vty;
! 1689: union sockunion su;
! 1690: int ret;
! 1691: unsigned int on;
! 1692: int accept_sock;
! 1693: struct prefix *p = NULL;
! 1694: struct access_list *acl = NULL;
! 1695: char *bufp;
! 1696:
! 1697: accept_sock = THREAD_FD (thread);
! 1698:
! 1699: /* We continue hearing vty socket. */
! 1700: vty_event (VTY_SERV, accept_sock, NULL);
! 1701:
! 1702: memset (&su, 0, sizeof (union sockunion));
! 1703:
! 1704: /* We can handle IPv4 or IPv6 socket. */
! 1705: vty_sock = sockunion_accept (accept_sock, &su);
! 1706: if (vty_sock < 0)
! 1707: {
! 1708: zlog_warn ("can't accept vty socket : %s", safe_strerror (errno));
! 1709: return -1;
! 1710: }
! 1711: set_nonblocking(vty_sock);
! 1712:
! 1713: p = sockunion2hostprefix (&su);
! 1714:
! 1715: /* VTY's accesslist apply. */
! 1716: if (p->family == AF_INET && vty_accesslist_name)
! 1717: {
! 1718: if ((acl = access_list_lookup (AFI_IP, vty_accesslist_name)) &&
! 1719: (access_list_apply (acl, p) == FILTER_DENY))
! 1720: {
! 1721: char *buf;
! 1722: zlog (NULL, LOG_INFO, "Vty connection refused from %s",
! 1723: (buf = sockunion_su2str (&su)));
! 1724: free (buf);
! 1725: close (vty_sock);
! 1726:
! 1727: /* continue accepting connections */
! 1728: vty_event (VTY_SERV, accept_sock, NULL);
! 1729:
! 1730: prefix_free (p);
! 1731:
! 1732: return 0;
! 1733: }
! 1734: }
! 1735:
! 1736: #ifdef HAVE_IPV6
! 1737: /* VTY's ipv6 accesslist apply. */
! 1738: if (p->family == AF_INET6 && vty_ipv6_accesslist_name)
! 1739: {
! 1740: if ((acl = access_list_lookup (AFI_IP6, vty_ipv6_accesslist_name)) &&
! 1741: (access_list_apply (acl, p) == FILTER_DENY))
! 1742: {
! 1743: char *buf;
! 1744: zlog (NULL, LOG_INFO, "Vty connection refused from %s",
! 1745: (buf = sockunion_su2str (&su)));
! 1746: free (buf);
! 1747: close (vty_sock);
! 1748:
! 1749: /* continue accepting connections */
! 1750: vty_event (VTY_SERV, accept_sock, NULL);
! 1751:
! 1752: prefix_free (p);
! 1753:
! 1754: return 0;
! 1755: }
! 1756: }
! 1757: #endif /* HAVE_IPV6 */
! 1758:
! 1759: prefix_free (p);
! 1760:
! 1761: on = 1;
! 1762: ret = setsockopt (vty_sock, IPPROTO_TCP, TCP_NODELAY,
! 1763: (char *) &on, sizeof (on));
! 1764: if (ret < 0)
! 1765: zlog (NULL, LOG_INFO, "can't set sockopt to vty_sock : %s",
! 1766: safe_strerror (errno));
! 1767:
! 1768: zlog (NULL, LOG_INFO, "Vty connection from %s",
! 1769: (bufp = sockunion_su2str (&su)));
! 1770: if (bufp)
! 1771: XFREE (MTYPE_TMP, bufp);
! 1772:
! 1773: vty = vty_create (vty_sock, &su);
! 1774:
! 1775: return 0;
! 1776: }
! 1777:
! 1778: #if defined(HAVE_IPV6) && !defined(NRL)
! 1779: static void
! 1780: vty_serv_sock_addrinfo (const char *hostname, unsigned short port)
! 1781: {
! 1782: int ret;
! 1783: struct addrinfo req;
! 1784: struct addrinfo *ainfo;
! 1785: struct addrinfo *ainfo_save;
! 1786: int sock;
! 1787: char port_str[BUFSIZ];
! 1788:
! 1789: memset (&req, 0, sizeof (struct addrinfo));
! 1790: req.ai_flags = AI_PASSIVE;
! 1791: req.ai_family = AF_UNSPEC;
! 1792: req.ai_socktype = SOCK_STREAM;
! 1793: sprintf (port_str, "%d", port);
! 1794: port_str[sizeof (port_str) - 1] = '\0';
! 1795:
! 1796: ret = getaddrinfo (hostname, port_str, &req, &ainfo);
! 1797:
! 1798: if (ret != 0)
! 1799: {
! 1800: fprintf (stderr, "getaddrinfo failed: %s\n", gai_strerror (ret));
! 1801: exit (1);
! 1802: }
! 1803:
! 1804: ainfo_save = ainfo;
! 1805:
! 1806: do
! 1807: {
! 1808: if (ainfo->ai_family != AF_INET
! 1809: #ifdef HAVE_IPV6
! 1810: && ainfo->ai_family != AF_INET6
! 1811: #endif /* HAVE_IPV6 */
! 1812: )
! 1813: continue;
! 1814:
! 1815: sock = socket (ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol);
! 1816: if (sock < 0)
! 1817: continue;
! 1818:
! 1819: sockopt_reuseaddr (sock);
! 1820: sockopt_reuseport (sock);
! 1821:
! 1822: ret = bind (sock, ainfo->ai_addr, ainfo->ai_addrlen);
! 1823: if (ret < 0)
! 1824: {
! 1825: close (sock); /* Avoid sd leak. */
! 1826: continue;
! 1827: }
! 1828:
! 1829: ret = listen (sock, 3);
! 1830: if (ret < 0)
! 1831: {
! 1832: close (sock); /* Avoid sd leak. */
! 1833: continue;
! 1834: }
! 1835:
! 1836: vty_event (VTY_SERV, sock, NULL);
! 1837: }
! 1838: while ((ainfo = ainfo->ai_next) != NULL);
! 1839:
! 1840: freeaddrinfo (ainfo_save);
! 1841: }
! 1842: #endif /* HAVE_IPV6 && ! NRL */
! 1843:
! 1844: /* Make vty server socket. */
! 1845: static void
! 1846: vty_serv_sock_family (const char* addr, unsigned short port, int family)
! 1847: {
! 1848: int ret;
! 1849: union sockunion su;
! 1850: int accept_sock;
! 1851: void* naddr=NULL;
! 1852:
! 1853: memset (&su, 0, sizeof (union sockunion));
! 1854: su.sa.sa_family = family;
! 1855: if(addr)
! 1856: switch(family)
! 1857: {
! 1858: case AF_INET:
! 1859: naddr=&su.sin.sin_addr;
! 1860: #ifdef HAVE_IPV6
! 1861: case AF_INET6:
! 1862: naddr=&su.sin6.sin6_addr;
! 1863: #endif
! 1864: }
! 1865:
! 1866: if(naddr)
! 1867: switch(inet_pton(family,addr,naddr))
! 1868: {
! 1869: case -1:
! 1870: zlog_err("bad address %s",addr);
! 1871: naddr=NULL;
! 1872: break;
! 1873: case 0:
! 1874: zlog_err("error translating address %s: %s",addr,safe_strerror(errno));
! 1875: naddr=NULL;
! 1876: }
! 1877:
! 1878: /* Make new socket. */
! 1879: accept_sock = sockunion_stream_socket (&su);
! 1880: if (accept_sock < 0)
! 1881: return;
! 1882:
! 1883: /* This is server, so reuse address. */
! 1884: sockopt_reuseaddr (accept_sock);
! 1885: sockopt_reuseport (accept_sock);
! 1886:
! 1887: /* Bind socket to universal address and given port. */
! 1888: ret = sockunion_bind (accept_sock, &su, port, naddr);
! 1889: if (ret < 0)
! 1890: {
! 1891: zlog_warn("can't bind socket");
! 1892: close (accept_sock); /* Avoid sd leak. */
! 1893: return;
! 1894: }
! 1895:
! 1896: /* Listen socket under queue 3. */
! 1897: ret = listen (accept_sock, 3);
! 1898: if (ret < 0)
! 1899: {
! 1900: zlog (NULL, LOG_WARNING, "can't listen socket");
! 1901: close (accept_sock); /* Avoid sd leak. */
! 1902: return;
! 1903: }
! 1904:
! 1905: /* Add vty server event. */
! 1906: vty_event (VTY_SERV, accept_sock, NULL);
! 1907: }
! 1908:
! 1909: #ifdef VTYSH
! 1910: /* For sockaddr_un. */
! 1911: #include <sys/un.h>
! 1912:
! 1913: /* VTY shell UNIX domain socket. */
! 1914: static void
! 1915: vty_serv_un (const char *path)
! 1916: {
! 1917: int ret;
! 1918: int sock, len;
! 1919: struct sockaddr_un serv;
! 1920: mode_t old_mask;
! 1921: struct zprivs_ids_t ids;
! 1922:
! 1923: /* First of all, unlink existing socket */
! 1924: unlink (path);
! 1925:
! 1926: /* Set umask */
! 1927: old_mask = umask (0007);
! 1928:
! 1929: /* Make UNIX domain socket. */
! 1930: sock = socket (AF_UNIX, SOCK_STREAM, 0);
! 1931: if (sock < 0)
! 1932: {
! 1933: zlog_err("Cannot create unix stream socket: %s", safe_strerror(errno));
! 1934: return;
! 1935: }
! 1936:
! 1937: /* Make server socket. */
! 1938: memset (&serv, 0, sizeof (struct sockaddr_un));
! 1939: serv.sun_family = AF_UNIX;
! 1940: strncpy (serv.sun_path, path, strlen (path));
! 1941: #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
! 1942: len = serv.sun_len = SUN_LEN(&serv);
! 1943: #else
! 1944: len = sizeof (serv.sun_family) + strlen (serv.sun_path);
! 1945: #endif /* HAVE_STRUCT_SOCKADDR_UN_SUN_LEN */
! 1946:
! 1947: ret = bind (sock, (struct sockaddr *) &serv, len);
! 1948: if (ret < 0)
! 1949: {
! 1950: zlog_err("Cannot bind path %s: %s", path, safe_strerror(errno));
! 1951: close (sock); /* Avoid sd leak. */
! 1952: return;
! 1953: }
! 1954:
! 1955: ret = listen (sock, 5);
! 1956: if (ret < 0)
! 1957: {
! 1958: zlog_err("listen(fd %d) failed: %s", sock, safe_strerror(errno));
! 1959: close (sock); /* Avoid sd leak. */
! 1960: return;
! 1961: }
! 1962:
! 1963: umask (old_mask);
! 1964:
! 1965: zprivs_get_ids(&ids);
! 1966:
! 1967: if (ids.gid_vty > 0)
! 1968: {
! 1969: /* set group of socket */
! 1970: if ( chown (path, -1, ids.gid_vty) )
! 1971: {
! 1972: zlog_err ("vty_serv_un: could chown socket, %s",
! 1973: safe_strerror (errno) );
! 1974: }
! 1975: }
! 1976:
! 1977: vty_event (VTYSH_SERV, sock, NULL);
! 1978: }
! 1979:
! 1980: /* #define VTYSH_DEBUG 1 */
! 1981:
! 1982: static int
! 1983: vtysh_accept (struct thread *thread)
! 1984: {
! 1985: int accept_sock;
! 1986: int sock;
! 1987: int client_len;
! 1988: struct sockaddr_un client;
! 1989: struct vty *vty;
! 1990:
! 1991: accept_sock = THREAD_FD (thread);
! 1992:
! 1993: vty_event (VTYSH_SERV, accept_sock, NULL);
! 1994:
! 1995: memset (&client, 0, sizeof (struct sockaddr_un));
! 1996: client_len = sizeof (struct sockaddr_un);
! 1997:
! 1998: sock = accept (accept_sock, (struct sockaddr *) &client,
! 1999: (socklen_t *) &client_len);
! 2000:
! 2001: if (sock < 0)
! 2002: {
! 2003: zlog_warn ("can't accept vty socket : %s", safe_strerror (errno));
! 2004: return -1;
! 2005: }
! 2006:
! 2007: if (set_nonblocking(sock) < 0)
! 2008: {
! 2009: zlog_warn ("vtysh_accept: could not set vty socket %d to non-blocking,"
! 2010: " %s, closing", sock, safe_strerror (errno));
! 2011: close (sock);
! 2012: return -1;
! 2013: }
! 2014:
! 2015: #ifdef VTYSH_DEBUG
! 2016: printf ("VTY shell accept\n");
! 2017: #endif /* VTYSH_DEBUG */
! 2018:
! 2019: vty = vty_new ();
! 2020: vty->fd = sock;
! 2021: vty->type = VTY_SHELL_SERV;
! 2022: vty->node = VIEW_NODE;
! 2023:
! 2024: vty_event (VTYSH_READ, sock, vty);
! 2025:
! 2026: return 0;
! 2027: }
! 2028:
! 2029: static int
! 2030: vtysh_flush(struct vty *vty)
! 2031: {
! 2032: switch (buffer_flush_available(vty->obuf, vty->fd))
! 2033: {
! 2034: case BUFFER_PENDING:
! 2035: vty_event(VTYSH_WRITE, vty->fd, vty);
! 2036: break;
! 2037: case BUFFER_ERROR:
! 2038: vty->monitor = 0; /* disable monitoring to avoid infinite recursion */
! 2039: zlog_warn("%s: write error to fd %d, closing", __func__, vty->fd);
! 2040: buffer_reset(vty->obuf);
! 2041: vty_close(vty);
! 2042: return -1;
! 2043: break;
! 2044: case BUFFER_EMPTY:
! 2045: break;
! 2046: }
! 2047: return 0;
! 2048: }
! 2049:
! 2050: static int
! 2051: vtysh_read (struct thread *thread)
! 2052: {
! 2053: int ret;
! 2054: int sock;
! 2055: int nbytes;
! 2056: struct vty *vty;
! 2057: unsigned char buf[VTY_READ_BUFSIZ];
! 2058: unsigned char *p;
! 2059: u_char header[4] = {0, 0, 0, 0};
! 2060:
! 2061: sock = THREAD_FD (thread);
! 2062: vty = THREAD_ARG (thread);
! 2063: vty->t_read = NULL;
! 2064:
! 2065: if ((nbytes = read (sock, buf, VTY_READ_BUFSIZ)) <= 0)
! 2066: {
! 2067: if (nbytes < 0)
! 2068: {
! 2069: if (ERRNO_IO_RETRY(errno))
! 2070: {
! 2071: vty_event (VTYSH_READ, sock, vty);
! 2072: return 0;
! 2073: }
! 2074: vty->monitor = 0; /* disable monitoring to avoid infinite recursion */
! 2075: zlog_warn("%s: read failed on vtysh client fd %d, closing: %s",
! 2076: __func__, sock, safe_strerror(errno));
! 2077: }
! 2078: buffer_reset(vty->obuf);
! 2079: vty_close (vty);
! 2080: #ifdef VTYSH_DEBUG
! 2081: printf ("close vtysh\n");
! 2082: #endif /* VTYSH_DEBUG */
! 2083: return 0;
! 2084: }
! 2085:
! 2086: #ifdef VTYSH_DEBUG
! 2087: printf ("line: %.*s\n", nbytes, buf);
! 2088: #endif /* VTYSH_DEBUG */
! 2089:
! 2090: for (p = buf; p < buf+nbytes; p++)
! 2091: {
! 2092: vty_ensure(vty, vty->length+1);
! 2093: vty->buf[vty->length++] = *p;
! 2094: if (*p == '\0')
! 2095: {
! 2096: /* Pass this line to parser. */
! 2097: ret = vty_execute (vty);
! 2098: /* Note that vty_execute clears the command buffer and resets
! 2099: vty->length to 0. */
! 2100:
! 2101: /* Return result. */
! 2102: #ifdef VTYSH_DEBUG
! 2103: printf ("result: %d\n", ret);
! 2104: printf ("vtysh node: %d\n", vty->node);
! 2105: #endif /* VTYSH_DEBUG */
! 2106:
! 2107: header[3] = ret;
! 2108: buffer_put(vty->obuf, header, 4);
! 2109:
! 2110: if (!vty->t_write && (vtysh_flush(vty) < 0))
! 2111: /* Try to flush results; exit if a write error occurs. */
! 2112: return 0;
! 2113: }
! 2114: }
! 2115:
! 2116: vty_event (VTYSH_READ, sock, vty);
! 2117:
! 2118: return 0;
! 2119: }
! 2120:
! 2121: static int
! 2122: vtysh_write (struct thread *thread)
! 2123: {
! 2124: struct vty *vty = THREAD_ARG (thread);
! 2125:
! 2126: vty->t_write = NULL;
! 2127: vtysh_flush(vty);
! 2128: return 0;
! 2129: }
! 2130:
! 2131: #endif /* VTYSH */
! 2132:
! 2133: /* Determine address family to bind. */
! 2134: void
! 2135: vty_serv_sock (const char *addr, unsigned short port, const char *path)
! 2136: {
! 2137: /* If port is set to 0, do not listen on TCP/IP at all! */
! 2138: if (port)
! 2139: {
! 2140:
! 2141: #ifdef HAVE_IPV6
! 2142: #ifdef NRL
! 2143: vty_serv_sock_family (addr, port, AF_INET);
! 2144: vty_serv_sock_family (addr, port, AF_INET6);
! 2145: #else /* ! NRL */
! 2146: vty_serv_sock_addrinfo (addr, port);
! 2147: #endif /* NRL*/
! 2148: #else /* ! HAVE_IPV6 */
! 2149: vty_serv_sock_family (addr,port, AF_INET);
! 2150: #endif /* HAVE_IPV6 */
! 2151: }
! 2152:
! 2153: #ifdef VTYSH
! 2154: vty_serv_un (path);
! 2155: #endif /* VTYSH */
! 2156: }
! 2157:
! 2158: /* Close vty interface. Warning: call this only from functions that
! 2159: will be careful not to access the vty afterwards (since it has
! 2160: now been freed). This is safest from top-level functions (called
! 2161: directly by the thread dispatcher). */
! 2162: void
! 2163: vty_close (struct vty *vty)
! 2164: {
! 2165: int i;
! 2166:
! 2167: /* Cancel threads.*/
! 2168: if (vty->t_read)
! 2169: thread_cancel (vty->t_read);
! 2170: if (vty->t_write)
! 2171: thread_cancel (vty->t_write);
! 2172: if (vty->t_timeout)
! 2173: thread_cancel (vty->t_timeout);
! 2174:
! 2175: /* Flush buffer. */
! 2176: buffer_flush_all (vty->obuf, vty->fd);
! 2177:
! 2178: /* Free input buffer. */
! 2179: buffer_free (vty->obuf);
! 2180:
! 2181: /* Free command history. */
! 2182: for (i = 0; i < VTY_MAXHIST; i++)
! 2183: if (vty->hist[i])
! 2184: XFREE (MTYPE_VTY_HIST, vty->hist[i]);
! 2185:
! 2186: /* Unset vector. */
! 2187: vector_unset (vtyvec, vty->fd);
! 2188:
! 2189: /* Close socket. */
! 2190: if (vty->fd > 0)
! 2191: close (vty->fd);
! 2192:
! 2193: if (vty->address)
! 2194: XFREE (MTYPE_TMP, vty->address);
! 2195: if (vty->buf)
! 2196: XFREE (MTYPE_VTY, vty->buf);
! 2197:
! 2198: /* Check configure. */
! 2199: vty_config_unlock (vty);
! 2200:
! 2201: /* OK free vty. */
! 2202: XFREE (MTYPE_VTY, vty);
! 2203: }
! 2204:
! 2205: /* When time out occur output message then close connection. */
! 2206: static int
! 2207: vty_timeout (struct thread *thread)
! 2208: {
! 2209: struct vty *vty;
! 2210:
! 2211: vty = THREAD_ARG (thread);
! 2212: vty->t_timeout = NULL;
! 2213: vty->v_timeout = 0;
! 2214:
! 2215: /* Clear buffer*/
! 2216: buffer_reset (vty->obuf);
! 2217: vty_out (vty, "%sVty connection is timed out.%s", VTY_NEWLINE, VTY_NEWLINE);
! 2218:
! 2219: /* Close connection. */
! 2220: vty->status = VTY_CLOSE;
! 2221: vty_close (vty);
! 2222:
! 2223: return 0;
! 2224: }
! 2225:
! 2226: /* Read up configuration file from file_name. */
! 2227: static void
! 2228: vty_read_file (FILE *confp)
! 2229: {
! 2230: int ret;
! 2231: struct vty *vty;
! 2232:
! 2233: vty = vty_new ();
! 2234: vty->fd = 0; /* stdout */
! 2235: vty->type = VTY_TERM;
! 2236: vty->node = CONFIG_NODE;
! 2237:
! 2238: /* Execute configuration file */
! 2239: ret = config_from_file (vty, confp);
! 2240:
! 2241: if ( !((ret == CMD_SUCCESS) || (ret == CMD_ERR_NOTHING_TODO)) )
! 2242: {
! 2243: switch (ret)
! 2244: {
! 2245: case CMD_ERR_AMBIGUOUS:
! 2246: fprintf (stderr, "Ambiguous command.\n");
! 2247: break;
! 2248: case CMD_ERR_NO_MATCH:
! 2249: fprintf (stderr, "There is no such command.\n");
! 2250: break;
! 2251: }
! 2252: fprintf (stderr, "Error occured during reading below line.\n%s\n",
! 2253: vty->buf);
! 2254: vty_close (vty);
! 2255: exit (1);
! 2256: }
! 2257:
! 2258: vty_close (vty);
! 2259: }
! 2260:
! 2261: static FILE *
! 2262: vty_use_backup_config (char *fullpath)
! 2263: {
! 2264: char *fullpath_sav, *fullpath_tmp;
! 2265: FILE *ret = NULL;
! 2266: struct stat buf;
! 2267: int tmp, sav;
! 2268: int c;
! 2269: char buffer[512];
! 2270:
! 2271: fullpath_sav = malloc (strlen (fullpath) + strlen (CONF_BACKUP_EXT) + 1);
! 2272: strcpy (fullpath_sav, fullpath);
! 2273: strcat (fullpath_sav, CONF_BACKUP_EXT);
! 2274: if (stat (fullpath_sav, &buf) == -1)
! 2275: {
! 2276: free (fullpath_sav);
! 2277: return NULL;
! 2278: }
! 2279:
! 2280: fullpath_tmp = malloc (strlen (fullpath) + 8);
! 2281: sprintf (fullpath_tmp, "%s.XXXXXX", fullpath);
! 2282:
! 2283: /* Open file to configuration write. */
! 2284: tmp = mkstemp (fullpath_tmp);
! 2285: if (tmp < 0)
! 2286: {
! 2287: free (fullpath_sav);
! 2288: free (fullpath_tmp);
! 2289: return NULL;
! 2290: }
! 2291:
! 2292: sav = open (fullpath_sav, O_RDONLY);
! 2293: if (sav < 0)
! 2294: {
! 2295: unlink (fullpath_tmp);
! 2296: free (fullpath_sav);
! 2297: free (fullpath_tmp);
! 2298: return NULL;
! 2299: }
! 2300:
! 2301: while((c = read (sav, buffer, 512)) > 0)
! 2302: write (tmp, buffer, c);
! 2303:
! 2304: close (sav);
! 2305: close (tmp);
! 2306:
! 2307: if (chmod(fullpath_tmp, CONFIGFILE_MASK) != 0)
! 2308: {
! 2309: unlink (fullpath_tmp);
! 2310: free (fullpath_sav);
! 2311: free (fullpath_tmp);
! 2312: return NULL;
! 2313: }
! 2314:
! 2315: if (link (fullpath_tmp, fullpath) == 0)
! 2316: ret = fopen (fullpath, "r");
! 2317:
! 2318: unlink (fullpath_tmp);
! 2319:
! 2320: free (fullpath_sav);
! 2321: free (fullpath_tmp);
! 2322: return ret;
! 2323: }
! 2324:
! 2325: /* Read up configuration file from file_name. */
! 2326: void
! 2327: vty_read_config (char *config_file,
! 2328: char *config_default_dir)
! 2329: {
! 2330: char cwd[MAXPATHLEN];
! 2331: FILE *confp = NULL;
! 2332: char *fullpath;
! 2333: char *tmp = NULL;
! 2334:
! 2335: /* If -f flag specified. */
! 2336: if (config_file != NULL)
! 2337: {
! 2338: if (! IS_DIRECTORY_SEP (config_file[0]))
! 2339: {
! 2340: getcwd (cwd, MAXPATHLEN);
! 2341: tmp = XMALLOC (MTYPE_TMP,
! 2342: strlen (cwd) + strlen (config_file) + 2);
! 2343: sprintf (tmp, "%s/%s", cwd, config_file);
! 2344: fullpath = tmp;
! 2345: }
! 2346: else
! 2347: fullpath = config_file;
! 2348:
! 2349: confp = fopen (fullpath, "r");
! 2350:
! 2351: if (confp == NULL)
! 2352: {
! 2353: fprintf (stderr, "%s: failed to open configuration file %s: %s\n",
! 2354: __func__, fullpath, safe_strerror (errno));
! 2355:
! 2356: confp = vty_use_backup_config (fullpath);
! 2357: if (confp)
! 2358: fprintf (stderr, "WARNING: using backup configuration file!\n");
! 2359: else
! 2360: {
! 2361: fprintf (stderr, "can't open configuration file [%s]\n",
! 2362: config_file);
! 2363: exit(1);
! 2364: }
! 2365: }
! 2366: }
! 2367: else
! 2368: {
! 2369: #ifdef VTYSH
! 2370: int ret;
! 2371: struct stat conf_stat;
! 2372:
! 2373: /* !!!!PLEASE LEAVE!!!!
! 2374: * This is NEEDED for use with vtysh -b, or else you can get
! 2375: * a real configuration food fight with a lot garbage in the
! 2376: * merged configuration file it creates coming from the per
! 2377: * daemon configuration files. This also allows the daemons
! 2378: * to start if there default configuration file is not
! 2379: * present or ignore them, as needed when using vtysh -b to
! 2380: * configure the daemons at boot - MAG
! 2381: */
! 2382:
! 2383: /* Stat for vtysh Zebra.conf, if found startup and wait for
! 2384: * boot configuration
! 2385: */
! 2386:
! 2387: if ( strstr(config_default_dir, "vtysh") == NULL)
! 2388: {
! 2389: ret = stat (integrate_default, &conf_stat);
! 2390: if (ret >= 0)
! 2391: return;
! 2392: }
! 2393: #endif /* VTYSH */
! 2394:
! 2395: confp = fopen (config_default_dir, "r");
! 2396: if (confp == NULL)
! 2397: {
! 2398: fprintf (stderr, "%s: failed to open configuration file %s: %s\n",
! 2399: __func__, config_default_dir, safe_strerror (errno));
! 2400:
! 2401: confp = vty_use_backup_config (config_default_dir);
! 2402: if (confp)
! 2403: {
! 2404: fprintf (stderr, "WARNING: using backup configuration file!\n");
! 2405: fullpath = config_default_dir;
! 2406: }
! 2407: else
! 2408: {
! 2409: fprintf (stderr, "can't open configuration file [%s]\n",
! 2410: config_default_dir);
! 2411: exit (1);
! 2412: }
! 2413: }
! 2414: else
! 2415: fullpath = config_default_dir;
! 2416: }
! 2417:
! 2418: vty_read_file (confp);
! 2419:
! 2420: fclose (confp);
! 2421:
! 2422: host_config_set (fullpath);
! 2423:
! 2424: if (tmp)
! 2425: XFREE (MTYPE_TMP, fullpath);
! 2426: }
! 2427:
! 2428: /* Small utility function which output log to the VTY. */
! 2429: void
! 2430: vty_log (const char *level, const char *proto_str,
! 2431: const char *format, struct timestamp_control *ctl, va_list va)
! 2432: {
! 2433: unsigned int i;
! 2434: struct vty *vty;
! 2435:
! 2436: if (!vtyvec)
! 2437: return;
! 2438:
! 2439: for (i = 0; i < vector_active (vtyvec); i++)
! 2440: if ((vty = vector_slot (vtyvec, i)) != NULL)
! 2441: if (vty->monitor)
! 2442: {
! 2443: va_list ac;
! 2444: va_copy(ac, va);
! 2445: vty_log_out (vty, level, proto_str, format, ctl, ac);
! 2446: va_end(ac);
! 2447: }
! 2448: }
! 2449:
! 2450: /* Async-signal-safe version of vty_log for fixed strings. */
! 2451: void
! 2452: vty_log_fixed (const char *buf, size_t len)
! 2453: {
! 2454: unsigned int i;
! 2455: struct iovec iov[2];
! 2456:
! 2457: /* vty may not have been initialised */
! 2458: if (!vtyvec)
! 2459: return;
! 2460:
! 2461: iov[0].iov_base = (void *)buf;
! 2462: iov[0].iov_len = len;
! 2463: iov[1].iov_base = (void *)"\r\n";
! 2464: iov[1].iov_len = 2;
! 2465:
! 2466: for (i = 0; i < vector_active (vtyvec); i++)
! 2467: {
! 2468: struct vty *vty;
! 2469: if (((vty = vector_slot (vtyvec, i)) != NULL) && vty->monitor)
! 2470: /* N.B. We don't care about the return code, since process is
! 2471: most likely just about to die anyway. */
! 2472: writev(vty->fd, iov, 2);
! 2473: }
! 2474: }
! 2475:
! 2476: int
! 2477: vty_config_lock (struct vty *vty)
! 2478: {
! 2479: if (vty_config == 0)
! 2480: {
! 2481: vty->config = 1;
! 2482: vty_config = 1;
! 2483: }
! 2484: return vty->config;
! 2485: }
! 2486:
! 2487: int
! 2488: vty_config_unlock (struct vty *vty)
! 2489: {
! 2490: if (vty_config == 1 && vty->config == 1)
! 2491: {
! 2492: vty->config = 0;
! 2493: vty_config = 0;
! 2494: }
! 2495: return vty->config;
! 2496: }
! 2497:
! 2498: /* Master of the threads. */
! 2499: static struct thread_master *master;
! 2500:
! 2501: static void
! 2502: vty_event (enum event event, int sock, struct vty *vty)
! 2503: {
! 2504: struct thread *vty_serv_thread;
! 2505:
! 2506: switch (event)
! 2507: {
! 2508: case VTY_SERV:
! 2509: vty_serv_thread = thread_add_read (master, vty_accept, vty, sock);
! 2510: vector_set_index (Vvty_serv_thread, sock, vty_serv_thread);
! 2511: break;
! 2512: #ifdef VTYSH
! 2513: case VTYSH_SERV:
! 2514: thread_add_read (master, vtysh_accept, vty, sock);
! 2515: break;
! 2516: case VTYSH_READ:
! 2517: vty->t_read = thread_add_read (master, vtysh_read, vty, sock);
! 2518: break;
! 2519: case VTYSH_WRITE:
! 2520: vty->t_write = thread_add_write (master, vtysh_write, vty, sock);
! 2521: break;
! 2522: #endif /* VTYSH */
! 2523: case VTY_READ:
! 2524: vty->t_read = thread_add_read (master, vty_read, vty, sock);
! 2525:
! 2526: /* Time out treatment. */
! 2527: if (vty->v_timeout)
! 2528: {
! 2529: if (vty->t_timeout)
! 2530: thread_cancel (vty->t_timeout);
! 2531: vty->t_timeout =
! 2532: thread_add_timer (master, vty_timeout, vty, vty->v_timeout);
! 2533: }
! 2534: break;
! 2535: case VTY_WRITE:
! 2536: if (! vty->t_write)
! 2537: vty->t_write = thread_add_write (master, vty_flush, vty, sock);
! 2538: break;
! 2539: case VTY_TIMEOUT_RESET:
! 2540: if (vty->t_timeout)
! 2541: {
! 2542: thread_cancel (vty->t_timeout);
! 2543: vty->t_timeout = NULL;
! 2544: }
! 2545: if (vty->v_timeout)
! 2546: {
! 2547: vty->t_timeout =
! 2548: thread_add_timer (master, vty_timeout, vty, vty->v_timeout);
! 2549: }
! 2550: break;
! 2551: }
! 2552: }
! 2553:
! 2554: DEFUN (config_who,
! 2555: config_who_cmd,
! 2556: "who",
! 2557: "Display who is on vty\n")
! 2558: {
! 2559: unsigned int i;
! 2560: struct vty *v;
! 2561:
! 2562: for (i = 0; i < vector_active (vtyvec); i++)
! 2563: if ((v = vector_slot (vtyvec, i)) != NULL)
! 2564: vty_out (vty, "%svty[%d] connected from %s.%s",
! 2565: v->config ? "*" : " ",
! 2566: i, v->address, VTY_NEWLINE);
! 2567: return CMD_SUCCESS;
! 2568: }
! 2569:
! 2570: /* Move to vty configuration mode. */
! 2571: DEFUN (line_vty,
! 2572: line_vty_cmd,
! 2573: "line vty",
! 2574: "Configure a terminal line\n"
! 2575: "Virtual terminal\n")
! 2576: {
! 2577: vty->node = VTY_NODE;
! 2578: return CMD_SUCCESS;
! 2579: }
! 2580:
! 2581: /* Set time out value. */
! 2582: static int
! 2583: exec_timeout (struct vty *vty, const char *min_str, const char *sec_str)
! 2584: {
! 2585: unsigned long timeout = 0;
! 2586:
! 2587: /* min_str and sec_str are already checked by parser. So it must be
! 2588: all digit string. */
! 2589: if (min_str)
! 2590: {
! 2591: timeout = strtol (min_str, NULL, 10);
! 2592: timeout *= 60;
! 2593: }
! 2594: if (sec_str)
! 2595: timeout += strtol (sec_str, NULL, 10);
! 2596:
! 2597: vty_timeout_val = timeout;
! 2598: vty->v_timeout = timeout;
! 2599: vty_event (VTY_TIMEOUT_RESET, 0, vty);
! 2600:
! 2601:
! 2602: return CMD_SUCCESS;
! 2603: }
! 2604:
! 2605: DEFUN (exec_timeout_min,
! 2606: exec_timeout_min_cmd,
! 2607: "exec-timeout <0-35791>",
! 2608: "Set timeout value\n"
! 2609: "Timeout value in minutes\n")
! 2610: {
! 2611: return exec_timeout (vty, argv[0], NULL);
! 2612: }
! 2613:
! 2614: DEFUN (exec_timeout_sec,
! 2615: exec_timeout_sec_cmd,
! 2616: "exec-timeout <0-35791> <0-2147483>",
! 2617: "Set the EXEC timeout\n"
! 2618: "Timeout in minutes\n"
! 2619: "Timeout in seconds\n")
! 2620: {
! 2621: return exec_timeout (vty, argv[0], argv[1]);
! 2622: }
! 2623:
! 2624: DEFUN (no_exec_timeout,
! 2625: no_exec_timeout_cmd,
! 2626: "no exec-timeout",
! 2627: NO_STR
! 2628: "Set the EXEC timeout\n")
! 2629: {
! 2630: return exec_timeout (vty, NULL, NULL);
! 2631: }
! 2632:
! 2633: /* Set vty access class. */
! 2634: DEFUN (vty_access_class,
! 2635: vty_access_class_cmd,
! 2636: "access-class WORD",
! 2637: "Filter connections based on an IP access list\n"
! 2638: "IP access list\n")
! 2639: {
! 2640: if (vty_accesslist_name)
! 2641: XFREE(MTYPE_VTY, vty_accesslist_name);
! 2642:
! 2643: vty_accesslist_name = XSTRDUP(MTYPE_VTY, argv[0]);
! 2644:
! 2645: return CMD_SUCCESS;
! 2646: }
! 2647:
! 2648: /* Clear vty access class. */
! 2649: DEFUN (no_vty_access_class,
! 2650: no_vty_access_class_cmd,
! 2651: "no access-class [WORD]",
! 2652: NO_STR
! 2653: "Filter connections based on an IP access list\n"
! 2654: "IP access list\n")
! 2655: {
! 2656: if (! vty_accesslist_name || (argc && strcmp(vty_accesslist_name, argv[0])))
! 2657: {
! 2658: vty_out (vty, "Access-class is not currently applied to vty%s",
! 2659: VTY_NEWLINE);
! 2660: return CMD_WARNING;
! 2661: }
! 2662:
! 2663: XFREE(MTYPE_VTY, vty_accesslist_name);
! 2664:
! 2665: vty_accesslist_name = NULL;
! 2666:
! 2667: return CMD_SUCCESS;
! 2668: }
! 2669:
! 2670: #ifdef HAVE_IPV6
! 2671: /* Set vty access class. */
! 2672: DEFUN (vty_ipv6_access_class,
! 2673: vty_ipv6_access_class_cmd,
! 2674: "ipv6 access-class WORD",
! 2675: IPV6_STR
! 2676: "Filter connections based on an IP access list\n"
! 2677: "IPv6 access list\n")
! 2678: {
! 2679: if (vty_ipv6_accesslist_name)
! 2680: XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
! 2681:
! 2682: vty_ipv6_accesslist_name = XSTRDUP(MTYPE_VTY, argv[0]);
! 2683:
! 2684: return CMD_SUCCESS;
! 2685: }
! 2686:
! 2687: /* Clear vty access class. */
! 2688: DEFUN (no_vty_ipv6_access_class,
! 2689: no_vty_ipv6_access_class_cmd,
! 2690: "no ipv6 access-class [WORD]",
! 2691: NO_STR
! 2692: IPV6_STR
! 2693: "Filter connections based on an IP access list\n"
! 2694: "IPv6 access list\n")
! 2695: {
! 2696: if (! vty_ipv6_accesslist_name ||
! 2697: (argc && strcmp(vty_ipv6_accesslist_name, argv[0])))
! 2698: {
! 2699: vty_out (vty, "IPv6 access-class is not currently applied to vty%s",
! 2700: VTY_NEWLINE);
! 2701: return CMD_WARNING;
! 2702: }
! 2703:
! 2704: XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
! 2705:
! 2706: vty_ipv6_accesslist_name = NULL;
! 2707:
! 2708: return CMD_SUCCESS;
! 2709: }
! 2710: #endif /* HAVE_IPV6 */
! 2711:
! 2712: /* vty login. */
! 2713: DEFUN (vty_login,
! 2714: vty_login_cmd,
! 2715: "login",
! 2716: "Enable password checking\n")
! 2717: {
! 2718: no_password_check = 0;
! 2719: return CMD_SUCCESS;
! 2720: }
! 2721:
! 2722: DEFUN (no_vty_login,
! 2723: no_vty_login_cmd,
! 2724: "no login",
! 2725: NO_STR
! 2726: "Enable password checking\n")
! 2727: {
! 2728: no_password_check = 1;
! 2729: return CMD_SUCCESS;
! 2730: }
! 2731:
! 2732: /* initial mode. */
! 2733: DEFUN (vty_restricted_mode,
! 2734: vty_restricted_mode_cmd,
! 2735: "anonymous restricted",
! 2736: "Restrict view commands available in anonymous, unauthenticated vty\n")
! 2737: {
! 2738: restricted_mode = 1;
! 2739: return CMD_SUCCESS;
! 2740: }
! 2741:
! 2742: DEFUN (vty_no_restricted_mode,
! 2743: vty_no_restricted_mode_cmd,
! 2744: "no anonymous restricted",
! 2745: NO_STR
! 2746: "Enable password checking\n")
! 2747: {
! 2748: restricted_mode = 0;
! 2749: return CMD_SUCCESS;
! 2750: }
! 2751:
! 2752: DEFUN (service_advanced_vty,
! 2753: service_advanced_vty_cmd,
! 2754: "service advanced-vty",
! 2755: "Set up miscellaneous service\n"
! 2756: "Enable advanced mode vty interface\n")
! 2757: {
! 2758: host.advanced = 1;
! 2759: return CMD_SUCCESS;
! 2760: }
! 2761:
! 2762: DEFUN (no_service_advanced_vty,
! 2763: no_service_advanced_vty_cmd,
! 2764: "no service advanced-vty",
! 2765: NO_STR
! 2766: "Set up miscellaneous service\n"
! 2767: "Enable advanced mode vty interface\n")
! 2768: {
! 2769: host.advanced = 0;
! 2770: return CMD_SUCCESS;
! 2771: }
! 2772:
! 2773: DEFUN (terminal_monitor,
! 2774: terminal_monitor_cmd,
! 2775: "terminal monitor",
! 2776: "Set terminal line parameters\n"
! 2777: "Copy debug output to the current terminal line\n")
! 2778: {
! 2779: vty->monitor = 1;
! 2780: return CMD_SUCCESS;
! 2781: }
! 2782:
! 2783: DEFUN (terminal_no_monitor,
! 2784: terminal_no_monitor_cmd,
! 2785: "terminal no monitor",
! 2786: "Set terminal line parameters\n"
! 2787: NO_STR
! 2788: "Copy debug output to the current terminal line\n")
! 2789: {
! 2790: vty->monitor = 0;
! 2791: return CMD_SUCCESS;
! 2792: }
! 2793:
! 2794: ALIAS (terminal_no_monitor,
! 2795: no_terminal_monitor_cmd,
! 2796: "no terminal monitor",
! 2797: NO_STR
! 2798: "Set terminal line parameters\n"
! 2799: "Copy debug output to the current terminal line\n")
! 2800:
! 2801: DEFUN (show_history,
! 2802: show_history_cmd,
! 2803: "show history",
! 2804: SHOW_STR
! 2805: "Display the session command history\n")
! 2806: {
! 2807: int index;
! 2808:
! 2809: for (index = vty->hindex + 1; index != vty->hindex;)
! 2810: {
! 2811: if (index == VTY_MAXHIST)
! 2812: {
! 2813: index = 0;
! 2814: continue;
! 2815: }
! 2816:
! 2817: if (vty->hist[index] != NULL)
! 2818: vty_out (vty, " %s%s", vty->hist[index], VTY_NEWLINE);
! 2819:
! 2820: index++;
! 2821: }
! 2822:
! 2823: return CMD_SUCCESS;
! 2824: }
! 2825:
! 2826: /* Display current configuration. */
! 2827: static int
! 2828: vty_config_write (struct vty *vty)
! 2829: {
! 2830: vty_out (vty, "line vty%s", VTY_NEWLINE);
! 2831:
! 2832: if (vty_accesslist_name)
! 2833: vty_out (vty, " access-class %s%s",
! 2834: vty_accesslist_name, VTY_NEWLINE);
! 2835:
! 2836: if (vty_ipv6_accesslist_name)
! 2837: vty_out (vty, " ipv6 access-class %s%s",
! 2838: vty_ipv6_accesslist_name, VTY_NEWLINE);
! 2839:
! 2840: /* exec-timeout */
! 2841: if (vty_timeout_val != VTY_TIMEOUT_DEFAULT)
! 2842: vty_out (vty, " exec-timeout %ld %ld%s",
! 2843: vty_timeout_val / 60,
! 2844: vty_timeout_val % 60, VTY_NEWLINE);
! 2845:
! 2846: /* login */
! 2847: if (no_password_check)
! 2848: vty_out (vty, " no login%s", VTY_NEWLINE);
! 2849:
! 2850: if (restricted_mode != restricted_mode_default)
! 2851: {
! 2852: if (restricted_mode_default)
! 2853: vty_out (vty, " no anonymous restricted%s", VTY_NEWLINE);
! 2854: else
! 2855: vty_out (vty, " anonymous restricted%s", VTY_NEWLINE);
! 2856: }
! 2857:
! 2858: vty_out (vty, "!%s", VTY_NEWLINE);
! 2859:
! 2860: return CMD_SUCCESS;
! 2861: }
! 2862:
! 2863: struct cmd_node vty_node =
! 2864: {
! 2865: VTY_NODE,
! 2866: "%s(config-line)# ",
! 2867: 1,
! 2868: };
! 2869:
! 2870: /* Reset all VTY status. */
! 2871: void
! 2872: vty_reset ()
! 2873: {
! 2874: unsigned int i;
! 2875: struct vty *vty;
! 2876: struct thread *vty_serv_thread;
! 2877:
! 2878: for (i = 0; i < vector_active (vtyvec); i++)
! 2879: if ((vty = vector_slot (vtyvec, i)) != NULL)
! 2880: {
! 2881: buffer_reset (vty->obuf);
! 2882: vty->status = VTY_CLOSE;
! 2883: vty_close (vty);
! 2884: }
! 2885:
! 2886: for (i = 0; i < vector_active (Vvty_serv_thread); i++)
! 2887: if ((vty_serv_thread = vector_slot (Vvty_serv_thread, i)) != NULL)
! 2888: {
! 2889: thread_cancel (vty_serv_thread);
! 2890: vector_slot (Vvty_serv_thread, i) = NULL;
! 2891: close (i);
! 2892: }
! 2893:
! 2894: vty_timeout_val = VTY_TIMEOUT_DEFAULT;
! 2895:
! 2896: if (vty_accesslist_name)
! 2897: {
! 2898: XFREE(MTYPE_VTY, vty_accesslist_name);
! 2899: vty_accesslist_name = NULL;
! 2900: }
! 2901:
! 2902: if (vty_ipv6_accesslist_name)
! 2903: {
! 2904: XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
! 2905: vty_ipv6_accesslist_name = NULL;
! 2906: }
! 2907: }
! 2908:
! 2909: static void
! 2910: vty_save_cwd (void)
! 2911: {
! 2912: char cwd[MAXPATHLEN];
! 2913: char *c;
! 2914:
! 2915: c = getcwd (cwd, MAXPATHLEN);
! 2916:
! 2917: if (!c)
! 2918: {
! 2919: chdir (SYSCONFDIR);
! 2920: getcwd (cwd, MAXPATHLEN);
! 2921: }
! 2922:
! 2923: vty_cwd = XMALLOC (MTYPE_TMP, strlen (cwd) + 1);
! 2924: strcpy (vty_cwd, cwd);
! 2925: }
! 2926:
! 2927: char *
! 2928: vty_get_cwd ()
! 2929: {
! 2930: return vty_cwd;
! 2931: }
! 2932:
! 2933: int
! 2934: vty_shell (struct vty *vty)
! 2935: {
! 2936: return vty->type == VTY_SHELL ? 1 : 0;
! 2937: }
! 2938:
! 2939: int
! 2940: vty_shell_serv (struct vty *vty)
! 2941: {
! 2942: return vty->type == VTY_SHELL_SERV ? 1 : 0;
! 2943: }
! 2944:
! 2945: void
! 2946: vty_init_vtysh ()
! 2947: {
! 2948: vtyvec = vector_init (VECTOR_MIN_SIZE);
! 2949: }
! 2950:
! 2951: /* Install vty's own commands like `who' command. */
! 2952: void
! 2953: vty_init (struct thread_master *master_thread)
! 2954: {
! 2955: /* For further configuration read, preserve current directory. */
! 2956: vty_save_cwd ();
! 2957:
! 2958: vtyvec = vector_init (VECTOR_MIN_SIZE);
! 2959:
! 2960: master = master_thread;
! 2961:
! 2962: /* Initilize server thread vector. */
! 2963: Vvty_serv_thread = vector_init (VECTOR_MIN_SIZE);
! 2964:
! 2965: /* Install bgp top node. */
! 2966: install_node (&vty_node, vty_config_write);
! 2967:
! 2968: install_element (RESTRICTED_NODE, &config_who_cmd);
! 2969: install_element (RESTRICTED_NODE, &show_history_cmd);
! 2970: install_element (VIEW_NODE, &config_who_cmd);
! 2971: install_element (VIEW_NODE, &show_history_cmd);
! 2972: install_element (ENABLE_NODE, &config_who_cmd);
! 2973: install_element (CONFIG_NODE, &line_vty_cmd);
! 2974: install_element (CONFIG_NODE, &service_advanced_vty_cmd);
! 2975: install_element (CONFIG_NODE, &no_service_advanced_vty_cmd);
! 2976: install_element (CONFIG_NODE, &show_history_cmd);
! 2977: install_element (ENABLE_NODE, &terminal_monitor_cmd);
! 2978: install_element (ENABLE_NODE, &terminal_no_monitor_cmd);
! 2979: install_element (ENABLE_NODE, &no_terminal_monitor_cmd);
! 2980: install_element (ENABLE_NODE, &show_history_cmd);
! 2981:
! 2982: install_default (VTY_NODE);
! 2983: install_element (VTY_NODE, &exec_timeout_min_cmd);
! 2984: install_element (VTY_NODE, &exec_timeout_sec_cmd);
! 2985: install_element (VTY_NODE, &no_exec_timeout_cmd);
! 2986: install_element (VTY_NODE, &vty_access_class_cmd);
! 2987: install_element (VTY_NODE, &no_vty_access_class_cmd);
! 2988: install_element (VTY_NODE, &vty_login_cmd);
! 2989: install_element (VTY_NODE, &no_vty_login_cmd);
! 2990: install_element (VTY_NODE, &vty_restricted_mode_cmd);
! 2991: install_element (VTY_NODE, &vty_no_restricted_mode_cmd);
! 2992: #ifdef HAVE_IPV6
! 2993: install_element (VTY_NODE, &vty_ipv6_access_class_cmd);
! 2994: install_element (VTY_NODE, &no_vty_ipv6_access_class_cmd);
! 2995: #endif /* HAVE_IPV6 */
! 2996: }
! 2997:
! 2998: void
! 2999: vty_terminate (void)
! 3000: {
! 3001: if (vty_cwd)
! 3002: XFREE (MTYPE_TMP, vty_cwd);
! 3003:
! 3004: if (vtyvec && Vvty_serv_thread)
! 3005: {
! 3006: vty_reset ();
! 3007: vector_free (vtyvec);
! 3008: vector_free (Vvty_serv_thread);
! 3009: }
! 3010: }
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