lib/vty.c

   1 /*
   2  * Virtual terminal [aka TeletYpe] interface routine.
   3  * Copyright (C) 1997, 98 Kunihiro Ishiguro
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  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 \f
  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 static 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 \f
  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 \f
 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 BABEL_NODE:
 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:
1111     case BABEL_NODE:
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   char buf[SU_ADDRSTRLEN];
1616   struct vty *vty;
1617
1618   sockunion2str(su, buf, SU_ADDRSTRLEN);
1619
1620   /* Allocate new vty structure and set up default values. */
1621   vty = vty_new ();
1622   vty->fd = vty_sock;
1623   vty->type = VTY_TERM;
1624   strcpy (vty->address, buf);
1625   if (no_password_check)
1626     {
1627       if (restricted_mode)
1628         vty->node = RESTRICTED_NODE;
1629       else if (host.advanced)
1630         vty->node = ENABLE_NODE;
1631       else
1632         vty->node = VIEW_NODE;
1633     }
1634   else
1635     vty->node = AUTH_NODE;
1636   vty->fail = 0;
1637   vty->cp = 0;
1638   vty_clear_buf (vty);
1639   vty->length = 0;
1640   memset (vty->hist, 0, sizeof (vty->hist));
1641   vty->hp = 0;
1642   vty->hindex = 0;
1643   vector_set_index (vtyvec, vty_sock, vty);
1644   vty->status = VTY_NORMAL;
1645   vty->v_timeout = vty_timeout_val;
1646   if (host.lines >= 0)
1647     vty->lines = host.lines;
1648   else
1649     vty->lines = -1;
1650   vty->iac = 0;
1651   vty->iac_sb_in_progress = 0;
1652   vty->sb_len = 0;
1653
1654   if (! no_password_check)
1655     {
1656       /* Vty is not available if password isn't set. */
1657       if (host.password == NULL && host.password_encrypt == NULL)
1658         {
1659           vty_out (vty, "Vty password is not set.%s", VTY_NEWLINE);
1660           vty->status = VTY_CLOSE;
1661           vty_close (vty);
1662           return NULL;
1663         }
1664     }
1665
1666   /* Say hello to the world. */
1667   vty_hello (vty);
1668   if (! no_password_check)
1669     vty_out (vty, "%sUser Access Verification%s%s", VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE);
1670
1671   /* Setting up terminal. */
1672   vty_will_echo (vty);
1673   vty_will_suppress_go_ahead (vty);
1674
1675   vty_dont_linemode (vty);
1676   vty_do_window_size (vty);
1677   /* vty_dont_lflow_ahead (vty); */
1678
1679   vty_prompt (vty);
1680
1681   /* Add read/write thread. */
1682   vty_event (VTY_WRITE, vty_sock, vty);
1683   vty_event (VTY_READ, vty_sock, vty);
1684
1685   return vty;
1686 }
1687
1688 /* Accept connection from the network. */
1689 static int
1690 vty_accept (struct thread *thread)
1691 {
1692   int vty_sock;
1693   union sockunion su;
1694   int ret;
1695   unsigned int on;
1696   int accept_sock;
1697   struct prefix *p = NULL;
1698   struct access_list *acl = NULL;
1699   char buf[SU_ADDRSTRLEN];
1700
1701   accept_sock = THREAD_FD (thread);
1702
1703   /* We continue hearing vty socket. */
1704   vty_event (VTY_SERV, accept_sock, NULL);
1705
1706   memset (&su, 0, sizeof (union sockunion));
1707
1708   /* We can handle IPv4 or IPv6 socket. */
1709   vty_sock = sockunion_accept (accept_sock, &su);
1710   if (vty_sock < 0)
1711     {
1712       zlog_warn ("can't accept vty socket : %s", safe_strerror (errno));
1713       return -1;
1714     }
1715   set_nonblocking(vty_sock);
1716
1717   p = sockunion2hostprefix (&su);
1718
1719   /* VTY's accesslist apply. */
1720   if (p->family == AF_INET && vty_accesslist_name)
1721     {
1722       if ((acl = access_list_lookup (AFI_IP, vty_accesslist_name)) &&
1723           (access_list_apply (acl, p) == FILTER_DENY))
1724         {
1725           zlog (NULL, LOG_INFO, "Vty connection refused from %s",
1726                 sockunion2str (&su, buf, SU_ADDRSTRLEN));
1727           close (vty_sock);
1728
1729           /* continue accepting connections */
1730           vty_event (VTY_SERV, accept_sock, NULL);
1731
1732           prefix_free (p);
1733
1734           return 0;
1735         }
1736     }
1737
1738 #ifdef HAVE_IPV6
1739   /* VTY's ipv6 accesslist apply. */
1740   if (p->family == AF_INET6 && vty_ipv6_accesslist_name)
1741     {
1742       if ((acl = access_list_lookup (AFI_IP6, vty_ipv6_accesslist_name)) &&
1743           (access_list_apply (acl, p) == FILTER_DENY))
1744         {
1745           zlog (NULL, LOG_INFO, "Vty connection refused from %s",
1746                 sockunion2str (&su, buf, SU_ADDRSTRLEN));
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         sockunion2str (&su, buf, SU_ADDRSTRLEN));
1770
1771   vty_create (vty_sock, &su);
1772
1773   return 0;
1774 }
1775
1776 #if defined(HAVE_IPV6) && !defined(NRL)
1777 static void
1778 vty_serv_sock_addrinfo (const char *hostname, unsigned short port)
1779 {
1780   int ret;
1781   struct addrinfo req;
1782   struct addrinfo *ainfo;
1783   struct addrinfo *ainfo_save;
1784   int sock;
1785   char port_str[BUFSIZ];
1786
1787   memset (&req, 0, sizeof (struct addrinfo));
1788   req.ai_flags = AI_PASSIVE;
1789   req.ai_family = AF_UNSPEC;
1790   req.ai_socktype = SOCK_STREAM;
1791   sprintf (port_str, "%d", port);
1792   port_str[sizeof (port_str) - 1] = '\0';
1793
1794   ret = getaddrinfo (hostname, port_str, &req, &ainfo);
1795
1796   if (ret != 0)
1797     {
1798       fprintf (stderr, "getaddrinfo failed: %s\n", gai_strerror (ret));
1799       exit (1);
1800     }
1801
1802   ainfo_save = ainfo;
1803
1804   do
1805     {
1806       if (ainfo->ai_family != AF_INET
1807 #ifdef HAVE_IPV6
1808           && ainfo->ai_family != AF_INET6
1809 #endif /* HAVE_IPV6 */
1810           )
1811         continue;
1812
1813       sock = socket (ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol);
1814       if (sock < 0)
1815         continue;
1816
1817       sockopt_v6only (ainfo->ai_family, sock);
1818       sockopt_reuseaddr (sock);
1819       sockopt_reuseport (sock);
1820
1821       ret = bind (sock, ainfo->ai_addr, ainfo->ai_addrlen);
1822       if (ret < 0)
1823         {
1824           close (sock); /* Avoid sd leak. */
1825         continue;
1826         }
1827
1828       ret = listen (sock, 3);
1829       if (ret < 0)
1830         {
1831           close (sock); /* Avoid sd leak. */
1832         continue;
1833         }
1834
1835       vty_event (VTY_SERV, sock, NULL);
1836     }
1837   while ((ainfo = ainfo->ai_next) != NULL);
1838
1839   freeaddrinfo (ainfo_save);
1840 }
1841 #else /* HAVE_IPV6 && ! NRL */
1842
1843 /* Make vty server socket. */
1844 static void
1845 vty_serv_sock_family (const char* addr, unsigned short port, int family)
1846 {
1847   int ret;
1848   union sockunion su;
1849   int accept_sock;
1850   void* naddr=NULL;
1851
1852   memset (&su, 0, sizeof (union sockunion));
1853   su.sa.sa_family = family;
1854   if(addr)
1855     switch(family)
1856     {
1857       case AF_INET:
1858         naddr=&su.sin.sin_addr;
1859         break;
1860 #ifdef HAVE_IPV6
1861       case AF_INET6:
1862         naddr=&su.sin6.sin6_addr;
1863         break;
1864 #endif
1865     }
1866
1867   if(naddr)
1868     switch(inet_pton(family,addr,naddr))
1869     {
1870       case -1:
1871         zlog_err("bad address %s",addr);
1872         naddr=NULL;
1873         break;
1874       case 0:
1875         zlog_err("error translating address %s: %s",addr,safe_strerror(errno));
1876         naddr=NULL;
1877     }
1878
1879   /* Make new socket. */
1880   accept_sock = sockunion_stream_socket (&su);
1881   if (accept_sock < 0)
1882     return;
1883
1884   /* This is server, so reuse address. */
1885   sockopt_reuseaddr (accept_sock);
1886   sockopt_reuseport (accept_sock);
1887
1888   /* Bind socket to universal address and given port. */
1889   ret = sockunion_bind (accept_sock, &su, port, naddr);
1890   if (ret < 0)
1891     {
1892       zlog_warn("can't bind socket");
1893       close (accept_sock);      /* Avoid sd leak. */
1894       return;
1895     }
1896
1897   /* Listen socket under queue 3. */
1898   ret = listen (accept_sock, 3);
1899   if (ret < 0)
1900     {
1901       zlog (NULL, LOG_WARNING, "can't listen socket");
1902       close (accept_sock);      /* Avoid sd leak. */
1903       return;
1904     }
1905
1906   /* Add vty server event. */
1907   vty_event (VTY_SERV, accept_sock, NULL);
1908 }
1909 #endif /* HAVE_IPV6 && ! NRL */
1910
1911 #ifdef VTYSH
1912 /* For sockaddr_un. */
1913 #include <sys/un.h>
1914
1915 /* VTY shell UNIX domain socket. */
1916 static void
1917 vty_serv_un (const char *path)
1918 {
1919   int ret;
1920   int sock, len;
1921   struct sockaddr_un serv;
1922   mode_t old_mask;
1923   struct zprivs_ids_t ids;
1924
1925   /* First of all, unlink existing socket */
1926   unlink (path);
1927
1928   /* Set umask */
1929   old_mask = umask (0007);
1930
1931   /* Make UNIX domain socket. */
1932   sock = socket (AF_UNIX, SOCK_STREAM, 0);
1933   if (sock < 0)
1934     {
1935       zlog_err("Cannot create unix stream socket: %s", safe_strerror(errno));
1936       return;
1937     }
1938
1939   /* Make server socket. */
1940   memset (&serv, 0, sizeof (struct sockaddr_un));
1941   serv.sun_family = AF_UNIX;
1942   strncpy (serv.sun_path, path, strlen (path));
1943 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
1944   len = serv.sun_len = SUN_LEN(&serv);
1945 #else
1946   len = sizeof (serv.sun_family) + strlen (serv.sun_path);
1947 #endif /* HAVE_STRUCT_SOCKADDR_UN_SUN_LEN */
1948
1949   ret = bind (sock, (struct sockaddr *) &serv, len);
1950   if (ret < 0)
1951     {
1952       zlog_err("Cannot bind path %s: %s", path, safe_strerror(errno));
1953       close (sock);     /* Avoid sd leak. */
1954       return;
1955     }
1956
1957   ret = listen (sock, 5);
1958   if (ret < 0)
1959     {
1960       zlog_err("listen(fd %d) failed: %s", sock, safe_strerror(errno));
1961       close (sock);     /* Avoid sd leak. */
1962       return;
1963     }
1964
1965   umask (old_mask);
1966
1967   zprivs_get_ids(&ids);
1968
1969   if (ids.gid_vty > 0)
1970     {
1971       /* set group of socket */
1972       if ( chown (path, -1, ids.gid_vty) )
1973         {
1974           zlog_err ("vty_serv_un: could chown socket, %s",
1975                      safe_strerror (errno) );
1976         }
1977     }
1978
1979   vty_event (VTYSH_SERV, sock, NULL);
1980 }
1981
1982 /* #define VTYSH_DEBUG 1 */
1983
1984 static int
1985 vtysh_accept (struct thread *thread)
1986 {
1987   int accept_sock;
1988   int sock;
1989   int client_len;
1990   struct sockaddr_un client;
1991   struct vty *vty;
1992
1993   accept_sock = THREAD_FD (thread);
1994
1995   vty_event (VTYSH_SERV, accept_sock, NULL);
1996
1997   memset (&client, 0, sizeof (struct sockaddr_un));
1998   client_len = sizeof (struct sockaddr_un);
1999
2000   sock = accept (accept_sock, (struct sockaddr *) &client,
2001                  (socklen_t *) &client_len);
2002
2003   if (sock < 0)
2004     {
2005       zlog_warn ("can't accept vty socket : %s", safe_strerror (errno));
2006       return -1;
2007     }
2008
2009   if (set_nonblocking(sock) < 0)
2010     {
2011       zlog_warn ("vtysh_accept: could not set vty socket %d to non-blocking,"
2012                  " %s, closing", sock, safe_strerror (errno));
2013       close (sock);
2014       return -1;
2015     }
2016
2017 #ifdef VTYSH_DEBUG
2018   printf ("VTY shell accept\n");
2019 #endif /* VTYSH_DEBUG */
2020
2021   vty = vty_new ();
2022   vty->fd = sock;
2023   vty->type = VTY_SHELL_SERV;
2024   vty->node = VIEW_NODE;
2025
2026   vty_event (VTYSH_READ, sock, vty);
2027
2028   return 0;
2029 }
2030
2031 static int
2032 vtysh_flush(struct vty *vty)
2033 {
2034   switch (buffer_flush_available(vty->obuf, vty->fd))
2035     {
2036     case BUFFER_PENDING:
2037       vty_event(VTYSH_WRITE, vty->fd, vty);
2038       break;
2039     case BUFFER_ERROR:
2040       vty->monitor = 0; /* disable monitoring to avoid infinite recursion */
2041       zlog_warn("%s: write error to fd %d, closing", __func__, vty->fd);
2042       buffer_reset(vty->obuf);
2043       vty_close(vty);
2044       return -1;
2045       break;
2046     case BUFFER_EMPTY:
2047       break;
2048     }
2049   return 0;
2050 }
2051
2052 static int
2053 vtysh_read (struct thread *thread)
2054 {
2055   int ret;
2056   int sock;
2057   int nbytes;
2058   struct vty *vty;
2059   unsigned char buf[VTY_READ_BUFSIZ];
2060   unsigned char *p;
2061   u_char header[4] = {0, 0, 0, 0};
2062
2063   sock = THREAD_FD (thread);
2064   vty = THREAD_ARG (thread);
2065   vty->t_read = NULL;
2066
2067   if ((nbytes = read (sock, buf, VTY_READ_BUFSIZ)) <= 0)
2068     {
2069       if (nbytes < 0)
2070         {
2071           if (ERRNO_IO_RETRY(errno))
2072             {
2073               vty_event (VTYSH_READ, sock, vty);
2074               return 0;
2075             }
2076           vty->monitor = 0; /* disable monitoring to avoid infinite recursion */
2077           zlog_warn("%s: read failed on vtysh client fd %d, closing: %s",
2078                     __func__, sock, safe_strerror(errno));
2079         }
2080       buffer_reset(vty->obuf);
2081       vty_close (vty);
2082 #ifdef VTYSH_DEBUG
2083       printf ("close vtysh\n");
2084 #endif /* VTYSH_DEBUG */
2085       return 0;
2086     }
2087
2088 #ifdef VTYSH_DEBUG
2089   printf ("line: %.*s\n", nbytes, buf);
2090 #endif /* VTYSH_DEBUG */
2091
2092   for (p = buf; p < buf+nbytes; p++)
2093     {
2094       vty_ensure(vty, vty->length+1);
2095       vty->buf[vty->length++] = *p;
2096       if (*p == '\0')
2097         {
2098           /* Pass this line to parser. */
2099           ret = vty_execute (vty);
2100           /* Note that vty_execute clears the command buffer and resets
2101              vty->length to 0. */
2102
2103           /* Return result. */
2104 #ifdef VTYSH_DEBUG
2105           printf ("result: %d\n", ret);
2106           printf ("vtysh node: %d\n", vty->node);
2107 #endif /* VTYSH_DEBUG */
2108
2109           header[3] = ret;
2110           buffer_put(vty->obuf, header, 4);
2111
2112           if (!vty->t_write && (vtysh_flush(vty) < 0))
2113             /* Try to flush results; exit if a write error occurs. */
2114             return 0;
2115         }
2116     }
2117
2118   vty_event (VTYSH_READ, sock, vty);
2119
2120   return 0;
2121 }
2122
2123 static int
2124 vtysh_write (struct thread *thread)
2125 {
2126   struct vty *vty = THREAD_ARG (thread);
2127
2128   vty->t_write = NULL;
2129   vtysh_flush(vty);
2130   return 0;
2131 }
2132
2133 #endif /* VTYSH */
2134
2135 /* Determine address family to bind. */
2136 void
2137 vty_serv_sock (const char *addr, unsigned short port, const char *path)
2138 {
2139   /* If port is set to 0, do not listen on TCP/IP at all! */
2140   if (port)
2141     {
2142
2143 #ifdef HAVE_IPV6
2144 #ifdef NRL
2145       vty_serv_sock_family (addr, port, AF_INET);
2146       vty_serv_sock_family (addr, port, AF_INET6);
2147 #else /* ! NRL */
2148       vty_serv_sock_addrinfo (addr, port);
2149 #endif /* NRL*/
2150 #else /* ! HAVE_IPV6 */
2151       vty_serv_sock_family (addr,port, AF_INET);
2152 #endif /* HAVE_IPV6 */
2153     }
2154
2155 #ifdef VTYSH
2156   vty_serv_un (path);
2157 #endif /* VTYSH */
2158 }
2159
2160 /* Close vty interface.  Warning: call this only from functions that
2161    will be careful not to access the vty afterwards (since it has
2162    now been freed).  This is safest from top-level functions (called
2163    directly by the thread dispatcher). */
2164 void
2165 vty_close (struct vty *vty)
2166 {
2167   int i;
2168
2169   /* Cancel threads.*/
2170   if (vty->t_read)
2171     thread_cancel (vty->t_read);
2172   if (vty->t_write)
2173     thread_cancel (vty->t_write);
2174   if (vty->t_timeout)
2175     thread_cancel (vty->t_timeout);
2176
2177   /* Flush buffer. */
2178   buffer_flush_all (vty->obuf, vty->fd);
2179
2180   /* Free input buffer. */
2181   buffer_free (vty->obuf);
2182
2183   /* Free command history. */
2184   for (i = 0; i < VTY_MAXHIST; i++)
2185     if (vty->hist[i])
2186       XFREE (MTYPE_VTY_HIST, vty->hist[i]);
2187
2188   /* Unset vector. */
2189   vector_unset (vtyvec, vty->fd);
2190
2191   /* Close socket. */
2192   if (vty->fd > 0)
2193     close (vty->fd);
2194
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 \f
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       vty_serv_thread = thread_add_read (master, vtysh_accept, vty, sock);
2515       vector_set_index (Vvty_serv_thread, sock, vty_serv_thread);
2516       break;
2517     case VTYSH_READ:
2518       vty->t_read = thread_add_read (master, vtysh_read, vty, sock);
2519       break;
2520     case VTYSH_WRITE:
2521       vty->t_write = thread_add_write (master, vtysh_write, vty, sock);
2522       break;
2523 #endif /* VTYSH */
2524     case VTY_READ:
2525       vty->t_read = thread_add_read (master, vty_read, vty, sock);
2526
2527       /* Time out treatment. */
2528       if (vty->v_timeout)
2529         {
2530           if (vty->t_timeout)
2531             thread_cancel (vty->t_timeout);
2532           vty->t_timeout =
2533             thread_add_timer (master, vty_timeout, vty, vty->v_timeout);
2534         }
2535       break;
2536     case VTY_WRITE:
2537       if (! vty->t_write)
2538         vty->t_write = thread_add_write (master, vty_flush, vty, sock);
2539       break;
2540     case VTY_TIMEOUT_RESET:
2541       if (vty->t_timeout)
2542         {
2543           thread_cancel (vty->t_timeout);
2544           vty->t_timeout = NULL;
2545         }
2546       if (vty->v_timeout)
2547         {
2548           vty->t_timeout =
2549             thread_add_timer (master, vty_timeout, vty, vty->v_timeout);
2550         }
2551       break;
2552     }
2553 }
2554 \f
2555 DEFUN (config_who,
2556        config_who_cmd,
2557        "who",
2558        "Display who is on vty\n")
2559 {
2560   unsigned int i;
2561   struct vty *v;
2562
2563   for (i = 0; i < vector_active (vtyvec); i++)
2564     if ((v = vector_slot (vtyvec, i)) != NULL)
2565       vty_out (vty, "%svty[%d] connected from %s.%s",
2566                v->config ? "*" : " ",
2567                i, v->address, VTY_NEWLINE);
2568   return CMD_SUCCESS;
2569 }
2570
2571 /* Move to vty configuration mode. */
2572 DEFUN (line_vty,
2573        line_vty_cmd,
2574        "line vty",
2575        "Configure a terminal line\n"
2576        "Virtual terminal\n")
2577 {
2578   vty->node = VTY_NODE;
2579   return CMD_SUCCESS;
2580 }
2581
2582 /* Set time out value. */
2583 static int
2584 exec_timeout (struct vty *vty, const char *min_str, const char *sec_str)
2585 {
2586   unsigned long timeout = 0;
2587
2588   /* min_str and sec_str are already checked by parser.  So it must be
2589      all digit string. */
2590   if (min_str)
2591     {
2592       timeout = strtol (min_str, NULL, 10);
2593       timeout *= 60;
2594     }
2595   if (sec_str)
2596     timeout += strtol (sec_str, NULL, 10);
2597
2598   vty_timeout_val = timeout;
2599   vty->v_timeout = timeout;
2600   vty_event (VTY_TIMEOUT_RESET, 0, vty);
2601
2602
2603   return CMD_SUCCESS;
2604 }
2605
2606 DEFUN (exec_timeout_min,
2607        exec_timeout_min_cmd,
2608        "exec-timeout <0-35791>",
2609        "Set timeout value\n"
2610        "Timeout value in minutes\n")
2611 {
2612   return exec_timeout (vty, argv[0], NULL);
2613 }
2614
2615 DEFUN (exec_timeout_sec,
2616        exec_timeout_sec_cmd,
2617        "exec-timeout <0-35791> <0-2147483>",
2618        "Set the EXEC timeout\n"
2619        "Timeout in minutes\n"
2620        "Timeout in seconds\n")
2621 {
2622   return exec_timeout (vty, argv[0], argv[1]);
2623 }
2624
2625 DEFUN (no_exec_timeout,
2626        no_exec_timeout_cmd,
2627        "no exec-timeout",
2628        NO_STR
2629        "Set the EXEC timeout\n")
2630 {
2631   return exec_timeout (vty, NULL, NULL);
2632 }
2633
2634 /* Set vty access class. */
2635 DEFUN (vty_access_class,
2636        vty_access_class_cmd,
2637        "access-class WORD",
2638        "Filter connections based on an IP access list\n"
2639        "IP access list\n")
2640 {
2641   if (vty_accesslist_name)
2642     XFREE(MTYPE_VTY, vty_accesslist_name);
2643
2644   vty_accesslist_name = XSTRDUP(MTYPE_VTY, argv[0]);
2645
2646   return CMD_SUCCESS;
2647 }
2648
2649 /* Clear vty access class. */
2650 DEFUN (no_vty_access_class,
2651        no_vty_access_class_cmd,
2652        "no access-class [WORD]",
2653        NO_STR
2654        "Filter connections based on an IP access list\n"
2655        "IP access list\n")
2656 {
2657   if (! vty_accesslist_name || (argc && strcmp(vty_accesslist_name, argv[0])))
2658     {
2659       vty_out (vty, "Access-class is not currently applied to vty%s",
2660                VTY_NEWLINE);
2661       return CMD_WARNING;
2662     }
2663
2664   XFREE(MTYPE_VTY, vty_accesslist_name);
2665
2666   vty_accesslist_name = NULL;
2667
2668   return CMD_SUCCESS;
2669 }
2670
2671 #ifdef HAVE_IPV6
2672 /* Set vty access class. */
2673 DEFUN (vty_ipv6_access_class,
2674        vty_ipv6_access_class_cmd,
2675        "ipv6 access-class WORD",
2676        IPV6_STR
2677        "Filter connections based on an IP access list\n"
2678        "IPv6 access list\n")
2679 {
2680   if (vty_ipv6_accesslist_name)
2681     XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
2682
2683   vty_ipv6_accesslist_name = XSTRDUP(MTYPE_VTY, argv[0]);
2684
2685   return CMD_SUCCESS;
2686 }
2687
2688 /* Clear vty access class. */
2689 DEFUN (no_vty_ipv6_access_class,
2690        no_vty_ipv6_access_class_cmd,
2691        "no ipv6 access-class [WORD]",
2692        NO_STR
2693        IPV6_STR
2694        "Filter connections based on an IP access list\n"
2695        "IPv6 access list\n")
2696 {
2697   if (! vty_ipv6_accesslist_name ||
2698       (argc && strcmp(vty_ipv6_accesslist_name, argv[0])))
2699     {
2700       vty_out (vty, "IPv6 access-class is not currently applied to vty%s",
2701                VTY_NEWLINE);
2702       return CMD_WARNING;
2703     }
2704
2705   XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
2706
2707   vty_ipv6_accesslist_name = NULL;
2708
2709   return CMD_SUCCESS;
2710 }
2711 #endif /* HAVE_IPV6 */
2712
2713 /* vty login. */
2714 DEFUN (vty_login,
2715        vty_login_cmd,
2716        "login",
2717        "Enable password checking\n")
2718 {
2719   no_password_check = 0;
2720   return CMD_SUCCESS;
2721 }
2722
2723 DEFUN (no_vty_login,
2724        no_vty_login_cmd,
2725        "no login",
2726        NO_STR
2727        "Enable password checking\n")
2728 {
2729   no_password_check = 1;
2730   return CMD_SUCCESS;
2731 }
2732
2733 /* initial mode. */
2734 DEFUN (vty_restricted_mode,
2735        vty_restricted_mode_cmd,
2736        "anonymous restricted",
2737        "Restrict view commands available in anonymous, unauthenticated vty\n")
2738 {
2739   restricted_mode = 1;
2740   return CMD_SUCCESS;
2741 }
2742
2743 DEFUN (vty_no_restricted_mode,
2744        vty_no_restricted_mode_cmd,
2745        "no anonymous restricted",
2746        NO_STR
2747        "Enable password checking\n")
2748 {
2749   restricted_mode = 0;
2750   return CMD_SUCCESS;
2751 }
2752
2753 DEFUN (service_advanced_vty,
2754        service_advanced_vty_cmd,
2755        "service advanced-vty",
2756        "Set up miscellaneous service\n"
2757        "Enable advanced mode vty interface\n")
2758 {
2759   host.advanced = 1;
2760   return CMD_SUCCESS;
2761 }
2762
2763 DEFUN (no_service_advanced_vty,
2764        no_service_advanced_vty_cmd,
2765        "no service advanced-vty",
2766        NO_STR
2767        "Set up miscellaneous service\n"
2768        "Enable advanced mode vty interface\n")
2769 {
2770   host.advanced = 0;
2771   return CMD_SUCCESS;
2772 }
2773
2774 DEFUN (terminal_monitor,
2775        terminal_monitor_cmd,
2776        "terminal monitor",
2777        "Set terminal line parameters\n"
2778        "Copy debug output to the current terminal line\n")
2779 {
2780   vty->monitor = 1;
2781   return CMD_SUCCESS;
2782 }
2783
2784 DEFUN (terminal_no_monitor,
2785        terminal_no_monitor_cmd,
2786        "terminal no monitor",
2787        "Set terminal line parameters\n"
2788        NO_STR
2789        "Copy debug output to the current terminal line\n")
2790 {
2791   vty->monitor = 0;
2792   return CMD_SUCCESS;
2793 }
2794
2795 ALIAS (terminal_no_monitor,
2796        no_terminal_monitor_cmd,
2797        "no terminal monitor",
2798        NO_STR
2799        "Set terminal line parameters\n"
2800        "Copy debug output to the current terminal line\n")
2801
2802 DEFUN (show_history,
2803        show_history_cmd,
2804        "show history",
2805        SHOW_STR
2806        "Display the session command history\n")
2807 {
2808   int index;
2809
2810   for (index = vty->hindex + 1; index != vty->hindex;)
2811     {
2812       if (index == VTY_MAXHIST)
2813         {
2814           index = 0;
2815           continue;
2816         }
2817
2818       if (vty->hist[index] != NULL)
2819         vty_out (vty, "  %s%s", vty->hist[index], VTY_NEWLINE);
2820
2821       index++;
2822     }
2823
2824   return CMD_SUCCESS;
2825 }
2826
2827 /* Display current configuration. */
2828 static int
2829 vty_config_write (struct vty *vty)
2830 {
2831   vty_out (vty, "line vty%s", VTY_NEWLINE);
2832
2833   if (vty_accesslist_name)
2834     vty_out (vty, " access-class %s%s",
2835              vty_accesslist_name, VTY_NEWLINE);
2836
2837   if (vty_ipv6_accesslist_name)
2838     vty_out (vty, " ipv6 access-class %s%s",
2839              vty_ipv6_accesslist_name, VTY_NEWLINE);
2840
2841   /* exec-timeout */
2842   if (vty_timeout_val != VTY_TIMEOUT_DEFAULT)
2843     vty_out (vty, " exec-timeout %ld %ld%s",
2844              vty_timeout_val / 60,
2845              vty_timeout_val % 60, VTY_NEWLINE);
2846
2847   /* login */
2848   if (no_password_check)
2849     vty_out (vty, " no login%s", VTY_NEWLINE);
2850
2851   if (restricted_mode != restricted_mode_default)
2852     {
2853       if (restricted_mode_default)
2854         vty_out (vty, " no anonymous restricted%s", VTY_NEWLINE);
2855       else
2856         vty_out (vty, " anonymous restricted%s", VTY_NEWLINE);
2857     }
2858
2859   vty_out (vty, "!%s", VTY_NEWLINE);
2860
2861   return CMD_SUCCESS;
2862 }
2863
2864 struct cmd_node vty_node =
2865 {
2866   VTY_NODE,
2867   "%s(config-line)# ",
2868   1,
2869 };
2870
2871 /* Reset all VTY status. */
2872 void
2873 vty_reset ()
2874 {
2875   unsigned int i;
2876   struct vty *vty;
2877   struct thread *vty_serv_thread;
2878
2879   for (i = 0; i < vector_active (vtyvec); i++)
2880     if ((vty = vector_slot (vtyvec, i)) != NULL)
2881       {
2882         buffer_reset (vty->obuf);
2883         vty->status = VTY_CLOSE;
2884         vty_close (vty);
2885       }
2886
2887   for (i = 0; i < vector_active (Vvty_serv_thread); i++)
2888     if ((vty_serv_thread = vector_slot (Vvty_serv_thread, i)) != NULL)
2889       {
2890         thread_cancel (vty_serv_thread);
2891         vector_slot (Vvty_serv_thread, i) = NULL;
2892         close (i);
2893       }
2894
2895   vty_timeout_val = VTY_TIMEOUT_DEFAULT;
2896
2897   if (vty_accesslist_name)
2898     {
2899       XFREE(MTYPE_VTY, vty_accesslist_name);
2900       vty_accesslist_name = NULL;
2901     }
2902
2903   if (vty_ipv6_accesslist_name)
2904     {
2905       XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
2906       vty_ipv6_accesslist_name = NULL;
2907     }
2908 }
2909
2910 static void
2911 vty_save_cwd (void)
2912 {
2913   char cwd[MAXPATHLEN];
2914   char *c;
2915
2916   c = getcwd (cwd, MAXPATHLEN);
2917
2918   if (!c)
2919     {
2920       chdir (SYSCONFDIR);
2921       getcwd (cwd, MAXPATHLEN);
2922     }
2923
2924   vty_cwd = XMALLOC (MTYPE_TMP, strlen (cwd) + 1);
2925   strcpy (vty_cwd, cwd);
2926 }
2927
2928 char *
2929 vty_get_cwd ()
2930 {
2931   return vty_cwd;
2932 }
2933
2934 int
2935 vty_shell (struct vty *vty)
2936 {
2937   return vty->type == VTY_SHELL ? 1 : 0;
2938 }
2939
2940 int
2941 vty_shell_serv (struct vty *vty)
2942 {
2943   return vty->type == VTY_SHELL_SERV ? 1 : 0;
2944 }
2945
2946 void
2947 vty_init_vtysh ()
2948 {
2949   vtyvec = vector_init (VECTOR_MIN_SIZE);
2950 }
2951
2952 /* Install vty's own commands like `who' command. */
2953 void
2954 vty_init (struct thread_master *master_thread)
2955 {
2956   /* For further configuration read, preserve current directory. */
2957   vty_save_cwd ();
2958
2959   vtyvec = vector_init (VECTOR_MIN_SIZE);
2960
2961   master = master_thread;
2962
2963   /* Initilize server thread vector. */
2964   Vvty_serv_thread = vector_init (VECTOR_MIN_SIZE);
2965
2966   /* Install bgp top node. */
2967   install_node (&vty_node, vty_config_write);
2968
2969   install_element (RESTRICTED_NODE, &config_who_cmd);
2970   install_element (RESTRICTED_NODE, &show_history_cmd);
2971   install_element (VIEW_NODE, &config_who_cmd);
2972   install_element (VIEW_NODE, &show_history_cmd);
2973   install_element (ENABLE_NODE, &config_who_cmd);
2974   install_element (CONFIG_NODE, &line_vty_cmd);
2975   install_element (CONFIG_NODE, &service_advanced_vty_cmd);
2976   install_element (CONFIG_NODE, &no_service_advanced_vty_cmd);
2977   install_element (CONFIG_NODE, &show_history_cmd);
2978   install_element (ENABLE_NODE, &terminal_monitor_cmd);
2979   install_element (ENABLE_NODE, &terminal_no_monitor_cmd);
2980   install_element (ENABLE_NODE, &no_terminal_monitor_cmd);
2981   install_element (ENABLE_NODE, &show_history_cmd);
2982
2983   install_default (VTY_NODE);
2984   install_element (VTY_NODE, &exec_timeout_min_cmd);
2985   install_element (VTY_NODE, &exec_timeout_sec_cmd);
2986   install_element (VTY_NODE, &no_exec_timeout_cmd);
2987   install_element (VTY_NODE, &vty_access_class_cmd);
2988   install_element (VTY_NODE, &no_vty_access_class_cmd);
2989   install_element (VTY_NODE, &vty_login_cmd);
2990   install_element (VTY_NODE, &no_vty_login_cmd);
2991   install_element (VTY_NODE, &vty_restricted_mode_cmd);
2992   install_element (VTY_NODE, &vty_no_restricted_mode_cmd);
2993 #ifdef HAVE_IPV6
2994   install_element (VTY_NODE, &vty_ipv6_access_class_cmd);
2995   install_element (VTY_NODE, &no_vty_ipv6_access_class_cmd);
2996 #endif /* HAVE_IPV6 */
2997 }
2998
2999 void
3000 vty_terminate (void)
3001 {
3002   if (vty_cwd)
3003     XFREE (MTYPE_TMP, vty_cwd);
3004
3005   if (vtyvec && Vvty_serv_thread)
3006     {
3007       vty_reset ();
3008       vector_free (vtyvec);
3009       vector_free (Vvty_serv_thread);
3010     }
3011 }