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 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 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 \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       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 \f
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 }