开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
vty.c
资源名称：zebra-0.95a.tar.gz　[点击查看]
上传用户：xiaozhuqw
上传日期：2009-11-15
资源大小：1338k
文件大小：58k
源码类别：

网络

开发平台：

Unix_Linux

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.  */
  23. #include <zebra.h>
  25. #include "linklist.h"
  26. #include "buffer.h"
  27. #include "version.h"
  28. #include "command.h"
  29. #include "sockunion.h"
  30. #include "thread.h"
  31. #include "memory.h"
  32. #include "str.h"
  33. #include "log.h"
  34. #include "prefix.h"
  35. #include "filter.h"
  37. /* Vty events */
  38. enum event 
  39.   {
  40.     VTY_SERV,
  41.     VTY_READ,
  42.     VTY_WRITE,
  43.     VTY_TIMEOUT_RESET,
  44. #ifdef VTYSH
  45.     VTYSH_SERV,
  46.     VTYSH_READ
  47. #endif /* VTYSH */
  48.   };
  50. static void vty_event (enum event, int, struct vty *);
  52. /* Extern host structure from command.c */
  53. extern struct host host;
  55. /* Vector which store each vty structure. */
  56. static vector vtyvec;
  58. /* Vty timeout value. */
  59. static unsigned long vty_timeout_val = VTY_TIMEOUT_DEFAULT;
  61. /* Vty access-class command */
  62. static char *vty_accesslist_name = NULL;
  64. /* Vty access-calss for IPv6. */
  65. static char *vty_ipv6_accesslist_name = NULL;
  67. /* VTY server thread. */
  68. vector Vvty_serv_thread;
  70. /* Current directory. */
  71. char *vty_cwd = NULL;
  73. /* Configure lock. */
  74. static int vty_config;
  76. /* Login password check. */
  77. static int no_password_check = 0;
  79. /* Integrated configuration file path */
  80. char integrate_default[] = SYSCONFDIR INTEGRATE_DEFAULT_CONFIG;
  83. /* VTY standard output function. */
  84. int
  85. vty_out (struct vty *vty, const char *format, ...)
  86. {
  87.   va_list args;
  88.   int len = 0;
  89.   int size = 1024;
  90.   char buf[1024];
  91.   char *p = NULL;
  92.   
  93.   va_start (args, format);
  95.   if (vty_shell (vty))
  96.     vprintf (format, args);
  97.   else
  98.     {
  99.       /* Try to write to initial buffer.  */
  100.       len = vsnprintf (buf, sizeof buf, format, args);
  102.       /* Initial buffer is not enough.  */
  103.       if (len < 0 || len >= size)
  104. {
  105.   while (1)
  106.     {
  107.       if (len > -1)
  108. size = len + 1;
  109.       else
  110. size = size * 2;
  112.       p = XREALLOC (MTYPE_VTY_OUT_BUF, p, size);
  113.       if (! p)
  114. return -1;
  116.       len = vsnprintf (p, size, format, args);
  118.       if (len > -1 && len < size)
  119. break;
  120.     }
  121. }
  123.       /* When initial buffer is enough to store all output.  */
  124.       if (! p)
  125. p = buf;
  127.       /* Pointer p must point out buffer. */
  128.       if (vty_shell_serv (vty))
  129. write (vty->fd, (u_char *) p, len);
  130.       else
  131. buffer_write (vty->obuf, (u_char *) p, len);
  133.       /* If p is not different with buf, it is allocated buffer.  */
  134.       if (p != buf)
  135. XFREE (MTYPE_VTY_OUT_BUF, p);
  136.     }
  138.   va_end (args);
  140.   return len;
  141. }
  143. #define TIME_BUF 27
  145. /* current time string. */
  146. int
  147. time_str (char *buf)
  148. {
  149.   time_t clock;
  150.   struct tm *tm;
  151.   int ret;
  153.   time (&clock);
  154.   tm = localtime (&clock);
  156.   ret = strftime (buf, TIME_BUF, "%Y/%m/%d %H:%M:%S", tm);
  158.   return ret;
  159. }
  161. int
  162. vty_log_out (struct vty *vty, const char *proto_str, const char *format,
  163.      va_list va)
  164. {
  165.   int len;
  166.   int ret;
  167.   char buf[1024];
  168.   char time_buf[TIME_BUF];
  170.   ret = time_str (time_buf);
  172.   if (ret != 0)
  173.     {
  174.       snprintf (buf, sizeof buf, "%s ", time_buf);
  175.       write (vty->fd, buf, strlen (time_buf) + 1);
  176.     }
  178.   snprintf (buf, sizeof buf, "%s: ", proto_str);
  179.   write (vty->fd, buf, strlen (proto_str) + 2);
  181.   len = vsnprintf (buf, sizeof buf, format, va);
  182.   if (len < 0)
  183.     return -1;
  184.   write (vty->fd, (u_char *)buf, len);
  186.   snprintf (buf, sizeof buf, "rn");
  187.   write (vty->fd, buf, 2);
  189.   return len;
  190. }
  192. /* Output current time to the vty. */
  193. void
  194. vty_time_print (struct vty *vty, int cr)
  195. {
  196.   int ret;
  197.   char buf [TIME_BUF];
  198.  
  199.   ret = time_str (buf);
  201.   if (ret == 0)
  202.     {
  203.       zlog (NULL, LOG_INFO, "strftime error");
  204.       return;
  205.     }
  207.   if (cr)
  208.     vty_out (vty, "%sn", buf);
  209.   else
  210.     vty_out (vty, "%s ", buf);
  212.   return;
  213. }
  215. /* Say hello to vty interface. */
  216. void
  217. vty_hello (struct vty *vty)
  218. {
  219.   if (host.motd)
  220.     vty_out (vty, host.motd);
  221. }
  223. /* Put out prompt and wait input from user. */
  224. static void
  225. vty_prompt (struct vty *vty)
  226. {
  227.   struct utsname names;
  228.   const char*hostname;
  230.   if (vty->type == VTY_TERM)
  231.     {
  232.       hostname = host.name;
  233.       if (!hostname)
  234. {
  235.   uname (&names);
  236.   hostname = names.nodename;
  237. }
  238.       vty_out (vty, cmd_prompt (vty->node), hostname);
  239.     }
  240. }
  242. /* Send WILL TELOPT_ECHO to remote server. */
  243. void
  244. vty_will_echo (struct vty *vty)
  245. {
  246.   char cmd[] = { IAC, WILL, TELOPT_ECHO, '' };
  247.   vty_out (vty, "%s", cmd);
  248. }
  250. /* Make suppress Go-Ahead telnet option. */
  251. static void
  252. vty_will_suppress_go_ahead (struct vty *vty)
  253. {
  254.   char cmd[] = { IAC, WILL, TELOPT_SGA, '' };
  255.   vty_out (vty, "%s", cmd);
  256. }
  258. /* Make don't use linemode over telnet. */
  259. static void
  260. vty_dont_linemode (struct vty *vty)
  261. {
  262.   char cmd[] = { IAC, DONT, TELOPT_LINEMODE, '' };
  263.   vty_out (vty, "%s", cmd);
  264. }
  266. /* Use window size. */
  267. static void
  268. vty_do_window_size (struct vty *vty)
  269. {
  270.   char cmd[] = { IAC, DO, TELOPT_NAWS, '' };
  271.   vty_out (vty, "%s", cmd);
  272. }
  274. #if 0 /* Currently not used. */
  275. /* Make don't use lflow vty interface. */
  276. static void
  277. vty_dont_lflow_ahead (struct vty *vty)
  278. {
  279.   char cmd[] = { IAC, DONT, TELOPT_LFLOW, '' };
  280.   vty_out (vty, "%s", cmd);
  281. }
  282. #endif /* 0 */
  284. /* Allocate new vty struct. */
  285. struct vty *
  286. vty_new ()
  287. {
  288.   struct vty *new = XCALLOC (MTYPE_VTY, sizeof (struct vty));
  290.   new->obuf = (struct buffer *) buffer_new (100);
  291.   new->buf = XCALLOC (MTYPE_VTY, VTY_BUFSIZ);
  292.   new->max = VTY_BUFSIZ;
  293.   new->sb_buffer = NULL;
  295.   return new;
  296. }
  298. /* Authentication of vty */
  299. static void
  300. vty_auth (struct vty *vty, char *buf)
  301. {
  302.   char *passwd = NULL;
  303.   enum node_type next_node = 0;
  304.   int fail;
  305.   char *crypt (const char *, const char *);
  307.   switch (vty->node)
  308.     {
  309.     case AUTH_NODE:
  310.       if (host.password_encrypt)
  311. passwd = host.password_encrypt;
  312.       else
  313. passwd = host.password;
  314.       if (host.advanced)
  315. next_node = host.enable ? VIEW_NODE : ENABLE_NODE;
  316.       else
  317. next_node = VIEW_NODE;
  318.       break;
  319.     case AUTH_ENABLE_NODE:
  320.       if (host.enable_encrypt)
  321. passwd = host.enable_encrypt;
  322.       else
  323. passwd = host.enable;
  324.       next_node = ENABLE_NODE;
  325.       break;
  326.     }
  328.   if (passwd)
  329.     {
  330.       if (strcmp (crypt(buf, passwd), passwd) == 0
  331.   || strcmp (buf, passwd) == 0)
  332. fail = 0;
  333.       else
  334. fail = 1;
  335.     }
  336.   else
  337.     fail = 1;
  339.   if (! fail)
  340.     {
  341.       vty->fail = 0;
  342.       vty->node = next_node; /* Success ! */
  343.     }
  344.   else
  345.     {
  346.       vty->fail++;
  347.       if (vty->fail >= 3)
  348. {
  349.   if (vty->node == AUTH_NODE)
  350.     {
  351.       vty_out (vty, "%% Bad passwords, too many failures!%s", VTY_NEWLINE);
  352.       vty->status = VTY_CLOSE;
  353.     }
  354.   else
  355.     {
  356.       /* AUTH_ENABLE_NODE */
  357.       vty->fail = 0;
  358.       vty_out (vty, "%% Bad enable passwords, too many failures!%s", VTY_NEWLINE);
  359.       vty->node = VIEW_NODE;
  360.     }
  361. }
  362.     }
  363. }
  365. /* Command execution over the vty interface. */
  366. int
  367. vty_command (struct vty *vty, char *buf)
  368. {
  369.   int ret;
  370.   vector vline;
  372.   /* Split readline string up into the vector */
  373.   vline = cmd_make_strvec (buf);
  375.   if (vline == NULL)
  376.     return CMD_SUCCESS;
  378.   ret = cmd_execute_command (vline, vty, NULL);
  380.   if (ret != CMD_SUCCESS)
  381.     switch (ret)
  382.       {
  383.       case CMD_WARNING:
  384. if (vty->type == VTY_FILE)
  385.   vty_out (vty, "Warning...%s", VTY_NEWLINE);
  386. break;
  387.       case CMD_ERR_AMBIGUOUS:
  388. vty_out (vty, "%% Ambiguous command.%s", VTY_NEWLINE);
  389. break;
  390.       case CMD_ERR_NO_MATCH:
  391. vty_out (vty, "%% Unknown command.%s", VTY_NEWLINE);
  392. break;
  393.       case CMD_ERR_INCOMPLETE:
  394. vty_out (vty, "%% Command incomplete.%s", VTY_NEWLINE);
  395. break;
  396.       }
  397.   cmd_free_strvec (vline);
  399.   return ret;
  400. }
  402. char telnet_backward_char = 0x08;
  403. char telnet_space_char = ' ';
  405. /* Basic function to write buffer to vty. */
  406. static void
  407. vty_write (struct vty *vty, char *buf, size_t nbytes)
  408. {
  409.   if ((vty->node == AUTH_NODE) || (vty->node == AUTH_ENABLE_NODE))
  410.     return;
  412.   /* Should we do buffering here ?  And make vty_flush (vty) ? */
  413.   buffer_write (vty->obuf, (u_char *)buf, nbytes);
  414. }
  416. /* Ensure length of input buffer.  Is buffer is short, double it. */
  417. static void
  418. vty_ensure (struct vty *vty, int length)
  419. {
  420.   if (vty->max <= length)
  421.     {
  422.       vty->max *= 2;
  423.       vty->buf = XREALLOC (MTYPE_VTY, vty->buf, vty->max);
  424.     }
  425. }
  427. /* Basic function to insert character into vty. */
  428. static void
  429. vty_self_insert (struct vty *vty, char c)
  430. {
  431.   int i;
  432.   int length;
  434.   vty_ensure (vty, vty->length + 1);
  435.   length = vty->length - vty->cp;
  436.   memmove (&vty->buf[vty->cp + 1], &vty->buf[vty->cp], length);
  437.   vty->buf[vty->cp] = c;
  439.   vty_write (vty, &vty->buf[vty->cp], length + 1);
  440.   for (i = 0; i < length; i++)
  441.     vty_write (vty, &telnet_backward_char, 1);
  443.   vty->cp++;
  444.   vty->length++;
  445. }
  447. /* Self insert character 'c' in overwrite mode. */
  448. static void
  449. vty_self_insert_overwrite (struct vty *vty, char c)
  450. {
  451.   vty_ensure (vty, vty->length + 1);
  452.   vty->buf[vty->cp++] = c;
  454.   if (vty->cp > vty->length)
  455.     vty->length++;
  457.   if ((vty->node == AUTH_NODE) || (vty->node == AUTH_ENABLE_NODE))
  458.     return;
  460.   vty_write (vty, &c, 1);
  461. }
  463. /* Insert a word into vty interface with overwrite mode. */
  464. static void
  465. vty_insert_word_overwrite (struct vty *vty, char *str)
  466. {
  467.   int len = strlen (str);
  468.   vty_write (vty, str, len);
  469.   strcpy (&vty->buf[vty->cp], str);
  470.   vty->cp += len;
  471.   vty->length = vty->cp;
  472. }
  474. /* Forward character. */
  475. static void
  476. vty_forward_char (struct vty *vty)
  477. {
  478.   if (vty->cp < vty->length)
  479.     {
  480.       vty_write (vty, &vty->buf[vty->cp], 1);
  481.       vty->cp++;
  482.     }
  483. }
  485. /* Backward character. */
  486. static void
  487. vty_backward_char (struct vty *vty)
  488. {
  489.   if (vty->cp > 0)
  490.     {
  491.       vty->cp--;
  492.       vty_write (vty, &telnet_backward_char, 1);
  493.     }
  494. }
  496. /* Move to the beginning of the line. */
  497. static void
  498. vty_beginning_of_line (struct vty *vty)
  499. {
  500.   while (vty->cp)
  501.     vty_backward_char (vty);
  502. }
  504. /* Move to the end of the line. */
  505. static void
  506. vty_end_of_line (struct vty *vty)
  507. {
  508.   while (vty->cp < vty->length)
  509.     vty_forward_char (vty);
  510. }
  512. static void vty_kill_line_from_beginning (struct vty *);
  513. static void vty_redraw_line (struct vty *);
  515. /* Print command line history.  This function is called from
  516.    vty_next_line and vty_previous_line. */
  517. static void
  518. vty_history_print (struct vty *vty)
  519. {
  520.   int length;
  522.   vty_kill_line_from_beginning (vty);
  524.   /* Get previous line from history buffer */
  525.   length = strlen (vty->hist[vty->hp]);
  526.   memcpy (vty->buf, vty->hist[vty->hp], length);
  527.   vty->cp = vty->length = length;
  529.   /* Redraw current line */
  530.   vty_redraw_line (vty);
  531. }
  533. /* Show next command line history. */
  534. void
  535. vty_next_line (struct vty *vty)
  536. {
  537.   int try_index;
  539.   if (vty->hp == vty->hindex)
  540.     return;
  542.   /* Try is there history exist or not. */
  543.   try_index = vty->hp;
  544.   if (try_index == (VTY_MAXHIST - 1))
  545.     try_index = 0;
  546.   else
  547.     try_index++;
  549.   /* If there is not history return. */
  550.   if (vty->hist[try_index] == NULL)
  551.     return;
  552.   else
  553.     vty->hp = try_index;
  555.   vty_history_print (vty);
  556. }
  558. /* Show previous command line history. */
  559. void
  560. vty_previous_line (struct vty *vty)
  561. {
  562.   int try_index;
  564.   try_index = vty->hp;
  565.   if (try_index == 0)
  566.     try_index = VTY_MAXHIST - 1;
  567.   else
  568.     try_index--;
  570.   if (vty->hist[try_index] == NULL)
  571.     return;
  572.   else
  573.     vty->hp = try_index;
  575.   vty_history_print (vty);
  576. }
  578. /* This function redraw all of the command line character. */
  579. static void
  580. vty_redraw_line (struct vty *vty)
  581. {
  582.   vty_write (vty, vty->buf, vty->length);
  583.   vty->cp = vty->length;
  584. }
  586. /* Forward word. */
  587. static void
  588. vty_forward_word (struct vty *vty)
  589. {
  590.   while (vty->cp != vty->length && vty->buf[vty->cp] != ' ')
  591.     vty_forward_char (vty);
  592.   
  593.   while (vty->cp != vty->length && vty->buf[vty->cp] == ' ')
  594.     vty_forward_char (vty);
  595. }
  597. /* Backward word without skipping training space. */
  598. static void
  599. vty_backward_pure_word (struct vty *vty)
  600. {
  601.   while (vty->cp > 0 && vty->buf[vty->cp - 1] != ' ')
  602.     vty_backward_char (vty);
  603. }
  605. /* Backward word. */
  606. static void
  607. vty_backward_word (struct vty *vty)
  608. {
  609.   while (vty->cp > 0 && vty->buf[vty->cp - 1] == ' ')
  610.     vty_backward_char (vty);
  612.   while (vty->cp > 0 && vty->buf[vty->cp - 1] != ' ')
  613.     vty_backward_char (vty);
  614. }
  616. /* When '^D' is typed at the beginning of the line we move to the down
  617.    level. */
  618. static void
  619. vty_down_level (struct vty *vty)
  620. {
  621.   vty_out (vty, "%s", VTY_NEWLINE);
  622.   config_exit (NULL, vty, 0, NULL);
  623.   vty_prompt (vty);
  624.   vty->cp = 0;
  625. }
  627. /* When '^Z' is received from vty, move down to the enable mode. */
  628. void
  629. vty_end_config (struct vty *vty)
  630. {
  631.   vty_out (vty, "%s", VTY_NEWLINE);
  633.   switch (vty->node)
  634.     {
  635.     case VIEW_NODE:
  636.     case ENABLE_NODE:
  637.       /* Nothing to do. */
  638.       break;
  639.     case CONFIG_NODE:
  640.     case INTERFACE_NODE:
  641.     case ZEBRA_NODE:
  642.     case RIP_NODE:
  643.     case RIPNG_NODE:
  644.     case BGP_NODE:
  645.     case BGP_VPNV4_NODE:
  646.     case BGP_IPV4_NODE:
  647.     case BGP_IPV4M_NODE:
  648.     case BGP_IPV6_NODE:
  649.     case RMAP_NODE:
  650.     case OSPF_NODE:
  651.     case OSPF6_NODE:
  652.     case KEYCHAIN_NODE:
  653.     case KEYCHAIN_KEY_NODE:
  654.     case MASC_NODE:
  655.     case VTY_NODE:
  656.       vty_config_unlock (vty);
  657.       vty->node = ENABLE_NODE;
  658.       break;
  659.     default:
  660.       /* Unknown node, we have to ignore it. */
  661.       break;
  662.     }
  664.   vty_prompt (vty);
  665.   vty->cp = 0;
  666. }
  668. /* Delete a charcter at the current point. */
  669. static void
  670. vty_delete_char (struct vty *vty)
  671. {
  672.   int i;
  673.   int size;
  675.   if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
  676.     return;
  678.   if (vty->length == 0)
  679.     {
  680.       vty_down_level (vty);
  681.       return;
  682.     }
  684.   if (vty->cp == vty->length)
  685.     return; /* completion need here? */
  687.   size = vty->length - vty->cp;
  689.   vty->length--;
  690.   memmove (&vty->buf[vty->cp], &vty->buf[vty->cp + 1], size - 1);
  691.   vty->buf[vty->length] = '';
  693.   vty_write (vty, &vty->buf[vty->cp], size - 1);
  694.   vty_write (vty, &telnet_space_char, 1);
  696.   for (i = 0; i < size; i++)
  697.     vty_write (vty, &telnet_backward_char, 1);
  698. }
  700. /* Delete a character before the point. */
  701. static void
  702. vty_delete_backward_char (struct vty *vty)
  703. {
  704.   if (vty->cp == 0)
  705.     return;
  707.   vty_backward_char (vty);
  708.   vty_delete_char (vty);
  709. }
  711. /* Kill rest of line from current point. */
  712. static void
  713. vty_kill_line (struct vty *vty)
  714. {
  715.   int i;
  716.   int size;
  718.   size = vty->length - vty->cp;
  719.   
  720.   if (size == 0)
  721.     return;
  723.   for (i = 0; i < size; i++)
  724.     vty_write (vty, &telnet_space_char, 1);
  725.   for (i = 0; i < size; i++)
  726.     vty_write (vty, &telnet_backward_char, 1);
  728.   memset (&vty->buf[vty->cp], 0, size);
  729.   vty->length = vty->cp;
  730. }
  732. /* Kill line from the beginning. */
  733. static void
  734. vty_kill_line_from_beginning (struct vty *vty)
  735. {
  736.   vty_beginning_of_line (vty);
  737.   vty_kill_line (vty);
  738. }
  740. /* Delete a word before the point. */
  741. static void
  742. vty_forward_kill_word (struct vty *vty)
  743. {
  744.   while (vty->cp != vty->length && vty->buf[vty->cp] == ' ')
  745.     vty_delete_char (vty);
  746.   while (vty->cp != vty->length && vty->buf[vty->cp] != ' ')
  747.     vty_delete_char (vty);
  748. }
  750. /* Delete a word before the point. */
  751. static void
  752. vty_backward_kill_word (struct vty *vty)
  753. {
  754.   while (vty->cp > 0 && vty->buf[vty->cp - 1] == ' ')
  755.     vty_delete_backward_char (vty);
  756.   while (vty->cp > 0 && vty->buf[vty->cp - 1] != ' ')
  757.     vty_delete_backward_char (vty);
  758. }
  760. /* Transpose chars before or at the point. */
  761. static void
  762. vty_transpose_chars (struct vty *vty)
  763. {
  764.   char c1, c2;
  766.   /* If length is short or point is near by the beginning of line then
  767.      return. */
  768.   if (vty->length < 2 || vty->cp < 1)
  769.     return;
  771.   /* In case of point is located at the end of the line. */
  772.   if (vty->cp == vty->length)
  773.     {
  774.       c1 = vty->buf[vty->cp - 1];
  775.       c2 = vty->buf[vty->cp - 2];
  777.       vty_backward_char (vty);
  778.       vty_backward_char (vty);
  779.       vty_self_insert_overwrite (vty, c1);
  780.       vty_self_insert_overwrite (vty, c2);
  781.     }
  782.   else
  783.     {
  784.       c1 = vty->buf[vty->cp];
  785.       c2 = vty->buf[vty->cp - 1];
  787.       vty_backward_char (vty);
  788.       vty_self_insert_overwrite (vty, c1);
  789.       vty_self_insert_overwrite (vty, c2);
  790.     }
  791. }
  793. /* Do completion at vty interface. */
  794. static void
  795. vty_complete_command (struct vty *vty)
  796. {
  797.   int i;
  798.   int ret;
  799.   char **matched = NULL;
  800.   vector vline;
  802.   if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
  803.     return;
  805.   vline = cmd_make_strvec (vty->buf);
  806.   if (vline == NULL)
  807.     return;
  809.   /* In case of 'help t'. */
  810.   if (isspace ((int) vty->buf[vty->length - 1]))
  811.     vector_set (vline, '');
  813.   matched = cmd_complete_command (vline, vty, &ret);
  814.   
  815.   cmd_free_strvec (vline);
  817.   vty_out (vty, "%s", VTY_NEWLINE);
  818.   switch (ret)
  819.     {
  820.     case CMD_ERR_AMBIGUOUS:
  821.       vty_out (vty, "%% Ambiguous command.%s", VTY_NEWLINE);
  822.       vty_prompt (vty);
  823.       vty_redraw_line (vty);
  824.       break;
  825.     case CMD_ERR_NO_MATCH:
  826.       /* vty_out (vty, "%% There is no matched command.%s", VTY_NEWLINE); */
  827.       vty_prompt (vty);
  828.       vty_redraw_line (vty);
  829.       break;
  830.     case CMD_COMPLETE_FULL_MATCH:
  831.       vty_prompt (vty);
  832.       vty_redraw_line (vty);
  833.       vty_backward_pure_word (vty);
  834.       vty_insert_word_overwrite (vty, matched[0]);
  835.       vty_self_insert (vty, ' ');
  836.       XFREE (MTYPE_TMP, matched[0]);
  837.       break;
  838.     case CMD_COMPLETE_MATCH:
  839.       vty_prompt (vty);
  840.       vty_redraw_line (vty);
  841.       vty_backward_pure_word (vty);
  842.       vty_insert_word_overwrite (vty, matched[0]);
  843.       XFREE (MTYPE_TMP, matched[0]);
  844.       vector_only_index_free (matched);
  845.       return;
  846.       break;
  847.     case CMD_COMPLETE_LIST_MATCH:
  848.       for (i = 0; matched[i] != NULL; i++)
  849. {
  850.   if (i != 0 && ((i % 6) == 0))
  851.     vty_out (vty, "%s", VTY_NEWLINE);
  852.   vty_out (vty, "%-10s ", matched[i]);
  853.   XFREE (MTYPE_TMP, matched[i]);
  854. }
  855.       vty_out (vty, "%s", VTY_NEWLINE);
  857.       vty_prompt (vty);
  858.       vty_redraw_line (vty);
  859.       break;
  860.     case CMD_ERR_NOTHING_TODO:
  861.       vty_prompt (vty);
  862.       vty_redraw_line (vty);
  863.       break;
  864.     default:
  865.       break;
  866.     }
  867.   if (matched)
  868.     vector_only_index_free (matched);
  869. }
  871. void
  872. vty_describe_fold (struct vty *vty, int cmd_width,
  873.    int desc_width, struct desc *desc)
  874. {
  875.   char *buf, *cmd, *p;
  876.   int pos;
  878.   cmd = desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd;
  880.   if (desc_width <= 0)
  881.     {
  882.       vty_out (vty, "  %-*s  %s%s", cmd_width, cmd, desc->str, VTY_NEWLINE);
  883.       return;
  884.     }
  886.   buf = XCALLOC (MTYPE_TMP, strlen (desc->str) + 1);
  888.   for (p = desc->str; strlen (p) > desc_width; p += pos + 1)
  889.     {
  890.       for (pos = desc_width; pos > 0; pos--)
  891. if (*(p + pos) == ' ')
  892.   break;
  894.       if (pos == 0)
  895. break;
  897.       strncpy (buf, p, pos);
  898.       buf[pos] = '';
  899.       vty_out (vty, "  %-*s  %s%s", cmd_width, cmd, buf, VTY_NEWLINE);
  901.       cmd = "";
  902.     }
  904.   vty_out (vty, "  %-*s  %s%s", cmd_width, cmd, p, VTY_NEWLINE);
  906.   XFREE (MTYPE_TMP, buf);
  907. }
  909. /* Describe matched command function. */
  910. static void
  911. vty_describe_command (struct vty *vty)
  912. {
  913.   int ret;
  914.   vector vline;
  915.   vector describe;
  916.   int i, width, desc_width;
  917.   struct desc *desc, *desc_cr = NULL;
  919.   vline = cmd_make_strvec (vty->buf);
  921.   /* In case of '> ?'. */
  922.   if (vline == NULL)
  923.     {
  924.       vline = vector_init (1);
  925.       vector_set (vline, '');
  926.     }
  927.   else 
  928.     if (isspace ((int) vty->buf[vty->length - 1]))
  929.       vector_set (vline, '');
  931.   describe = cmd_describe_command (vline, vty, &ret);
  933.   vty_out (vty, "%s", VTY_NEWLINE);
  935.   /* Ambiguous error. */
  936.   switch (ret)
  937.     {
  938.     case CMD_ERR_AMBIGUOUS:
  939.       cmd_free_strvec (vline);
  940.       vty_out (vty, "%% Ambiguous command.%s", VTY_NEWLINE);
  941.       vty_prompt (vty);
  942.       vty_redraw_line (vty);
  943.       return;
  944.       break;
  945.     case CMD_ERR_NO_MATCH:
  946.       cmd_free_strvec (vline);
  947.       vty_out (vty, "%% There is no matched command.%s", VTY_NEWLINE);
  948.       vty_prompt (vty);
  949.       vty_redraw_line (vty);
  950.       return;
  951.       break;
  952.     }  
  954.   /* Get width of command string. */
  955.   width = 0;
  956.   for (i = 0; i < vector_max (describe); i++)
  957.     if ((desc = vector_slot (describe, i)) != NULL)
  958.       {
  959. int len;
  961. if (desc->cmd[0] == '')
  962.   continue;
  964. len = strlen (desc->cmd);
  965. if (desc->cmd[0] == '.')
  966.   len--;
  968. if (width < len)
  969.   width = len;
  970.       }
  972.   /* Get width of description string. */
  973.   desc_width = vty->width - (width + 6);
  975.   /* Print out description. */
  976.   for (i = 0; i < vector_max (describe); i++)
  977.     if ((desc = vector_slot (describe, i)) != NULL)
  978.       {
  979. if (desc->cmd[0] == '')
  980.   continue;
  982. if (strcmp (desc->cmd, "<cr>") == 0)
  983.   {
  984.     desc_cr = desc;
  985.     continue;
  986.   }
  988. if (!desc->str)
  989.   vty_out (vty, "  %-s%s",
  990.    desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
  991.    VTY_NEWLINE);
  992. else if (desc_width >= strlen (desc->str))
  993.   vty_out (vty, "  %-*s  %s%s", width,
  994.    desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
  995.    desc->str, VTY_NEWLINE);
  996. else
  997.   vty_describe_fold (vty, width, desc_width, desc);
  999. #if 0
  1000. vty_out (vty, "  %-*s %s%s", width
  1001.  desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
  1002.  desc->str ? desc->str : "", VTY_NEWLINE);
  1003. #endif /* 0 */
  1004.       }
  1006.   if ((desc = desc_cr))
  1007.     {
  1008.       if (!desc->str)
  1009. vty_out (vty, "  %-s%s",
  1010.  desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
  1011.  VTY_NEWLINE);
  1012.       else if (desc_width >= strlen (desc->str))
  1013. vty_out (vty, "  %-*s  %s%s", width,
  1014.  desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd,
  1015.  desc->str, VTY_NEWLINE);
  1016.       else
  1017. vty_describe_fold (vty, width, desc_width, desc);
  1018.     }
  1020.   cmd_free_strvec (vline);
  1021.   vector_free (describe);
  1023.   vty_prompt (vty);
  1024.   vty_redraw_line (vty);
  1025. }
  1027. void
  1028. vty_clear_buf (struct vty *vty)
  1029. {
  1030.   memset (vty->buf, 0, vty->max);
  1031. }
  1033. /* ^C stop current input and do not add command line to the history. */
  1034. static void
  1035. vty_stop_input (struct vty *vty)
  1036. {
  1037.   vty->cp = vty->length = 0;
  1038.   vty_clear_buf (vty);
  1039.   vty_out (vty, "%s", VTY_NEWLINE);
  1041.   switch (vty->node)
  1042.     {
  1043.     case VIEW_NODE:
  1044.     case ENABLE_NODE:
  1045.       /* Nothing to do. */
  1046.       break;
  1047.     case CONFIG_NODE:
  1048.     case INTERFACE_NODE:
  1049.     case ZEBRA_NODE:
  1050.     case RIP_NODE:
  1051.     case RIPNG_NODE:
  1052.     case BGP_NODE:
  1053.     case RMAP_NODE:
  1054.     case OSPF_NODE:
  1055.     case OSPF6_NODE:
  1056.     case KEYCHAIN_NODE:
  1057.     case KEYCHAIN_KEY_NODE:
  1058.     case MASC_NODE:
  1059.     case VTY_NODE:
  1060.       vty_config_unlock (vty);
  1061.       vty->node = ENABLE_NODE;
  1062.       break;
  1063.     default:
  1064.       /* Unknown node, we have to ignore it. */
  1065.       break;
  1066.     }
  1067.   vty_prompt (vty);
  1069.   /* Set history pointer to the latest one. */
  1070.   vty->hp = vty->hindex;
  1071. }
  1073. /* Add current command line to the history buffer. */
  1074. static void
  1075. vty_hist_add (struct vty *vty)
  1076. {
  1077.   int index;
  1079.   if (vty->length == 0)
  1080.     return;
  1082.   index = vty->hindex ? vty->hindex - 1 : VTY_MAXHIST - 1;
  1084.   /* Ignore the same string as previous one. */
  1085.   if (vty->hist[index])
  1086.     if (strcmp (vty->buf, vty->hist[index]) == 0)
  1087.       {
  1088. vty->hp = vty->hindex;
  1089. return;
  1090.       }
  1092.   /* Insert history entry. */
  1093.   if (vty->hist[vty->hindex])
  1094.     XFREE (MTYPE_VTY_HIST, vty->hist[vty->hindex]);
  1095.   vty->hist[vty->hindex] = XSTRDUP (MTYPE_VTY_HIST, vty->buf);
  1097.   /* History index rotation. */
  1098.   vty->hindex++;
  1099.   if (vty->hindex == VTY_MAXHIST)
  1100.     vty->hindex = 0;
  1102.   vty->hp = vty->hindex;
  1103. }
  1105. /* #define TELNET_OPTION_DEBUG */
  1107. /* Get telnet window size. */
  1108. static int
  1109. vty_telnet_option (struct vty *vty, unsigned char *buf, int nbytes)
  1110. {
  1111. #ifdef TELNET_OPTION_DEBUG
  1112.   int i;
  1114.   for (i = 0; i < nbytes; i++)
  1115.     {
  1116.       switch (buf[i])
  1117. {
  1118. case IAC:
  1119.   vty_out (vty, "IAC ");
  1120.   break;
  1121. case WILL:
  1122.   vty_out (vty, "WILL ");
  1123.   break;
  1124. case WONT:
  1125.   vty_out (vty, "WONT ");
  1126.   break;
  1127. case DO:
  1128.   vty_out (vty, "DO ");
  1129.   break;
  1130. case DONT:
  1131.   vty_out (vty, "DONT ");
  1132.   break;
  1133. case SB:
  1134.   vty_out (vty, "SB ");
  1135.   break;
  1136. case SE:
  1137.   vty_out (vty, "SE ");
  1138.   break;
  1139. case TELOPT_ECHO:
  1140.   vty_out (vty, "TELOPT_ECHO %s", VTY_NEWLINE);
  1141.   break;
  1142. case TELOPT_SGA:
  1143.   vty_out (vty, "TELOPT_SGA %s", VTY_NEWLINE);
  1144.   break;
  1145. case TELOPT_NAWS:
  1146.   vty_out (vty, "TELOPT_NAWS %s", VTY_NEWLINE);
  1147.   break;
  1148. default:
  1149.   vty_out (vty, "%x ", buf[i]);
  1150.   break;
  1151. }
  1152.     }
  1153.   vty_out (vty, "%s", VTY_NEWLINE);
  1155. #endif /* TELNET_OPTION_DEBUG */
  1157.   switch (buf[0])
  1158.     {
  1159.     case SB:
  1160.       buffer_reset(vty->sb_buffer);
  1161.       vty->iac_sb_in_progress = 1;
  1162.       return 0;
  1163.       break;
  1164.     case SE: 
  1165.       {
  1166. char *buffer;
  1167. int length;
  1169. if (!vty->iac_sb_in_progress)
  1170.   return 0;
  1172. buffer = (char *)vty->sb_buffer->head->data;
  1173. length = vty->sb_buffer->length;
  1175. if (buffer == NULL)
  1176.   return 0;
  1178. if (buffer[0] == '')
  1179.   {
  1180.     vty->iac_sb_in_progress = 0;
  1181.     return 0;
  1182.   }
  1183. switch (buffer[0])
  1184.   {
  1185.   case TELOPT_NAWS:
  1186.     if (length < 5)
  1187.       break;
  1188.     vty->width = buffer[2];
  1189.     vty->height = vty->lines >= 0 ? vty->lines : buffer[4];
  1190.     break;
  1191.   }
  1192. vty->iac_sb_in_progress = 0;
  1193. return 0;
  1194. break;
  1195.       }
  1196.     default:
  1197.       break;
  1198.     }
  1199.   return 1;
  1200. }
  1202. /* Execute current command line. */
  1203. static int
  1204. vty_execute (struct vty *vty)
  1205. {
  1206.   int ret;
  1208.   ret = CMD_SUCCESS;
  1210.   switch (vty->node)
  1211.     {
  1212.     case AUTH_NODE:
  1213.     case AUTH_ENABLE_NODE:
  1214.       vty_auth (vty, vty->buf);
  1215.       break;
  1216.     default:
  1217.       ret = vty_command (vty, vty->buf);
  1218.       if (vty->type == VTY_TERM)
  1219. vty_hist_add (vty);
  1220.       break;
  1221.     }
  1223.   /* Clear command line buffer. */
  1224.   vty->cp = vty->length = 0;
  1225.   vty_clear_buf (vty);
  1227.   if (vty->status != VTY_CLOSE 
  1228.       && vty->status != VTY_START
  1229.       && vty->status != VTY_CONTINUE)
  1230.     vty_prompt (vty);
  1232.   return ret;
  1233. }
  1235. #define CONTROL(X)  ((X) - '@')
  1236. #define VTY_NORMAL     0
  1237. #define VTY_PRE_ESCAPE 1
  1238. #define VTY_ESCAPE     2
  1240. /* Escape character command map. */
  1241. static void
  1242. vty_escape_map (unsigned char c, struct vty *vty)
  1243. {
  1244.   switch (c)
  1245.     {
  1246.     case ('A'):
  1247.       vty_previous_line (vty);
  1248.       break;
  1249.     case ('B'):
  1250.       vty_next_line (vty);
  1251.       break;
  1252.     case ('C'):
  1253.       vty_forward_char (vty);
  1254.       break;
  1255.     case ('D'):
  1256.       vty_backward_char (vty);
  1257.       break;
  1258.     default:
  1259.       break;
  1260.     }
  1262.   /* Go back to normal mode. */
  1263.   vty->escape = VTY_NORMAL;
  1264. }
  1266. /* Quit print out to the buffer. */
  1267. static void
  1268. vty_buffer_reset (struct vty *vty)
  1269. {
  1270.   buffer_reset (vty->obuf);
  1271.   vty_prompt (vty);
  1272.   vty_redraw_line (vty);
  1273. }
  1275. /* Read data via vty socket. */
  1276. static int
  1277. vty_read (struct thread *thread)
  1278. {
  1279.   int i;
  1280.   int ret;
  1281.   int nbytes;
  1282.   unsigned char buf[VTY_READ_BUFSIZ];
  1284.   int vty_sock = THREAD_FD (thread);
  1285.   struct vty *vty = THREAD_ARG (thread);
  1286.   vty->t_read = NULL;
  1288.   /* Read raw data from socket */
  1289.   nbytes = read (vty->fd, buf, VTY_READ_BUFSIZ);
  1290.   if (nbytes <= 0)
  1291.     vty->status = VTY_CLOSE;
  1293.   for (i = 0; i < nbytes; i++) 
  1294.     {
  1295.       if (buf[i] == IAC)
  1296. {
  1297.   if (!vty->iac)
  1298.     {
  1299.       vty->iac = 1;
  1300.       continue;
  1301.     }
  1302.   else
  1303.     {
  1304.       vty->iac = 0;
  1305.     }
  1306. }
  1307.       
  1308.       if (vty->iac_sb_in_progress && !vty->iac)
  1309. {
  1310.   buffer_putc(vty->sb_buffer, buf[i]);
  1311.   continue;
  1312. }
  1314.       if (vty->iac)
  1315. {
  1316.   /* In case of telnet command */
  1317.   ret = vty_telnet_option (vty, buf + i, nbytes - i);
  1318.   vty->iac = 0;
  1319.   i += ret;
  1320.   continue;
  1321. }
  1323.       if (vty->status == VTY_MORE)
  1324. {
  1325.   switch (buf[i])
  1326.     {
  1327.     case CONTROL('C'):
  1328.     case 'q':
  1329.     case 'Q':
  1330.       if (vty->output_func)
  1331. (*vty->output_func) (vty, 1);
  1332.       vty_buffer_reset (vty);
  1333.       break;
  1334. #if 1 /* More line for "show ip bgp" is fixed */
  1335.     case 'n':
  1336.     case 'r':
  1337.       vty->status = VTY_MORELINE;
  1338.       if (vty->output_func)
  1339. (*vty->output_func) (vty, 0);
  1340.       break;
  1341. #endif
  1342.     default:
  1343.       if (vty->output_func)
  1344. (*vty->output_func) (vty, 0);
  1345.       break;
  1346.     }
  1347.   continue;
  1348. }
  1350.       /* Escape character. */
  1351.       if (vty->escape == VTY_ESCAPE)
  1352. {
  1353.   vty_escape_map (buf[i], vty);
  1354.   continue;
  1355. }
  1357.       /* Pre-escape status. */
  1358.       if (vty->escape == VTY_PRE_ESCAPE)
  1359. {
  1360.   switch (buf[i])
  1361.     {
  1362.     case '[':
  1363.       vty->escape = VTY_ESCAPE;
  1364.       break;
  1365.     case 'b':
  1366.       vty_backward_word (vty);
  1367.       vty->escape = VTY_NORMAL;
  1368.       break;
  1369.     case 'f':
  1370.       vty_forward_word (vty);
  1371.       vty->escape = VTY_NORMAL;
  1372.       break;
  1373.     case 'd':
  1374.       vty_forward_kill_word (vty);
  1375.       vty->escape = VTY_NORMAL;
  1376.       break;
  1377.     case CONTROL('H'):
  1378.     case 0x7f:
  1379.       vty_backward_kill_word (vty);
  1380.       vty->escape = VTY_NORMAL;
  1381.       break;
  1382.     default:
  1383.       vty->escape = VTY_NORMAL;
  1384.       break;
  1385.     }
  1386.   continue;
  1387. }
  1389.       switch (buf[i])
  1390. {
  1391. case CONTROL('A'):
  1392.   vty_beginning_of_line (vty);
  1393.   break;
  1394. case CONTROL('B'):
  1395.   vty_backward_char (vty);
  1396.   break;
  1397. case CONTROL('C'):
  1398.   vty_stop_input (vty);
  1399.   break;
  1400. case CONTROL('D'):
  1401.   vty_delete_char (vty);
  1402.   break;
  1403. case CONTROL('E'):
  1404.   vty_end_of_line (vty);
  1405.   break;
  1406. case CONTROL('F'):
  1407.   vty_forward_char (vty);
  1408.   break;
  1409. case CONTROL('H'):
  1410. case 0x7f:
  1411.   vty_delete_backward_char (vty);
  1412.   break;
  1413. case CONTROL('K'):
  1414.   vty_kill_line (vty);
  1415.   break;
  1416. case CONTROL('N'):
  1417.   vty_next_line (vty);
  1418.   break;
  1419. case CONTROL('P'):
  1420.   vty_previous_line (vty);
  1421.   break;
  1422. case CONTROL('T'):
  1423.   vty_transpose_chars (vty);
  1424.   break;
  1425. case CONTROL('U'):
  1426.   vty_kill_line_from_beginning (vty);
  1427.   break;
  1428. case CONTROL('W'):
  1429.   vty_backward_kill_word (vty);
  1430.   break;
  1431. case CONTROL('Z'):
  1432.   vty_end_config (vty);
  1433.   break;
  1434. case 'n':
  1435. case 'r':
  1436.   vty_out (vty, "%s", VTY_NEWLINE);
  1437.   vty_execute (vty);
  1438.   break;
  1439. case 't':
  1440.   vty_complete_command (vty);
  1441.   break;
  1442. case '?':
  1443.   if (vty->node == AUTH_NODE || vty->node == AUTH_ENABLE_NODE)
  1444.     vty_self_insert (vty, buf[i]);
  1445.   else
  1446.     vty_describe_command (vty);
  1447.   break;
  1448. case '33':
  1449.   if (i + 1 < nbytes && buf[i + 1] == '[')
  1450.     {
  1451.       vty->escape = VTY_ESCAPE;
  1452.       i++;
  1453.     }
  1454.   else
  1455.     vty->escape = VTY_PRE_ESCAPE;
  1456.   break;
  1457. default:
  1458.   if (buf[i] > 31 && buf[i] < 127)
  1459.     vty_self_insert (vty, buf[i]);
  1460.   break;
  1461. }
  1462.     }
  1464.   /* Check status. */
  1465.   if (vty->status == VTY_CLOSE)
  1466.     vty_close (vty);
  1467.   else
  1468.     {
  1469.       vty_event (VTY_WRITE, vty_sock, vty);
  1470.       vty_event (VTY_READ, vty_sock, vty);
  1471.     }
  1472.   return 0;
  1473. }
  1475. /* Flush buffer to the vty. */
  1476. static int
  1477. vty_flush (struct thread *thread)
  1478. {
  1479.   int erase;
  1480.   int dont_more;
  1481.   int vty_sock = THREAD_FD (thread);
  1482.   struct vty *vty = THREAD_ARG (thread);
  1483.   vty->t_write = NULL;
  1485.   /* Tempolary disable read thread. */
  1486.   if (vty->lines == 0)
  1487.     if (vty->t_read)
  1488.       {
  1489. thread_cancel (vty->t_read);
  1490. vty->t_read = NULL;
  1491.       }
  1493.   /* Function execution continue. */
  1494.   if (vty->status == VTY_START || vty->status == VTY_CONTINUE)
  1495.     {
  1496.       if (vty->status == VTY_CONTINUE && vty->output_func)
  1497. erase = 1;
  1498.       else
  1499. erase = 0;
  1501.       if (vty->output_func == NULL)
  1502. dont_more = 1;
  1503.       else
  1504. dont_more = 0;
  1506.       if (vty->lines == 0)
  1507. {
  1508.   erase = 0;
  1509.   dont_more = 1;
  1510. }
  1512.       buffer_flush_vty_all (vty->obuf, vty->fd, erase, dont_more);
  1514.       if (vty->status == VTY_CLOSE)
  1515. {
  1516.   vty_close (vty);
  1517.   return 0;
  1518. }
  1520.       if (vty->output_func == NULL)
  1521. {
  1522.   vty->status = VTY_NORMAL;
  1523.   vty_prompt (vty);
  1524.   vty_event (VTY_WRITE, vty_sock, vty);
  1525. }
  1526.       else
  1527. vty->status = VTY_MORE;
  1529.       if (vty->lines == 0)
  1530. {
  1531.   if (vty->output_func == NULL)
  1532.     vty_event (VTY_READ, vty_sock, vty);
  1533.   else
  1534.     {
  1535.       if (vty->output_func)
  1536. (*vty->output_func) (vty, 0);
  1537.       vty_event (VTY_WRITE, vty_sock, vty);
  1538.     }
  1539. }
  1540.     }
  1541.   else
  1542.     {
  1543.       if (vty->status == VTY_MORE || vty->status == VTY_MORELINE)
  1544. erase = 1;
  1545.       else
  1546. erase = 0;
  1548.       if (vty->lines == 0)
  1549. buffer_flush_window (vty->obuf, vty->fd, vty->width, 25, 0, 1);
  1550.       else if (vty->status == VTY_MORELINE)
  1551. buffer_flush_window (vty->obuf, vty->fd, vty->width, 1, erase, 0);
  1552.       else
  1553. buffer_flush_window (vty->obuf, vty->fd, vty->width,
  1554.      vty->lines >= 0 ? vty->lines : vty->height,
  1555.      erase, 0);
  1556.   
  1557.       if (buffer_empty (vty->obuf))
  1558. {
  1559.   if (vty->status == VTY_CLOSE)
  1560.     vty_close (vty);
  1561.   else
  1562.     {
  1563.       vty->status = VTY_NORMAL;
  1564.   
  1565.       if (vty->lines == 0)
  1566. vty_event (VTY_READ, vty_sock, vty);
  1567.     }
  1568. }
  1569.       else
  1570. {
  1571.   vty->status = VTY_MORE;
  1573.   if (vty->lines == 0)
  1574.     vty_event (VTY_WRITE, vty_sock, vty);
  1575. }
  1576.     }
  1578.   return 0;
  1579. }
  1581. /* Create new vty structure. */
  1582. struct vty *
  1583. vty_create (int vty_sock, union sockunion *su)
  1584. {
  1585.   struct vty *vty;
  1587.   /* Allocate new vty structure and set up default values. */
  1588.   vty = vty_new ();
  1589.   vty->fd = vty_sock;
  1590.   vty->type = VTY_TERM;
  1591.   vty->address = sockunion_su2str (su);
  1592.   if (no_password_check)
  1593.     {
  1594.       if (host.advanced)
  1595. vty->node = ENABLE_NODE;
  1596.       else
  1597. vty->node = VIEW_NODE;
  1598.     }
  1599.   else
  1600.     vty->node = AUTH_NODE;
  1601.   vty->fail = 0;
  1602.   vty->cp = 0;
  1603.   vty_clear_buf (vty);
  1604.   vty->length = 0;
  1605.   memset (vty->hist, 0, sizeof (vty->hist));
  1606.   vty->hp = 0;
  1607.   vty->hindex = 0;
  1608.   vector_set_index (vtyvec, vty_sock, vty);
  1609.   vty->status = VTY_NORMAL;
  1610.   vty->v_timeout = vty_timeout_val;
  1611.   if (host.lines >= 0)
  1612.     vty->lines = host.lines;
  1613.   else
  1614.     vty->lines = -1;
  1615.   vty->iac = 0;
  1616.   vty->iac_sb_in_progress = 0;
  1617.   vty->sb_buffer = buffer_new (1024);
  1619.   if (! no_password_check)
  1620.     {
  1621.       /* Vty is not available if password isn't set. */
  1622.       if (host.password == NULL && host.password_encrypt == NULL)
  1623. {
  1624.   vty_out (vty, "Vty password is not set.%s", VTY_NEWLINE);
  1625.   vty->status = VTY_CLOSE;
  1626.   vty_close (vty);
  1627.   return NULL;
  1628. }
  1629.     }
  1631.   /* Say hello to the world. */
  1632.   vty_hello (vty);
  1633.   if (! no_password_check)
  1634.     vty_out (vty, "%sUser Access Verification%s%s", VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE);
  1636.   /* Setting up terminal. */
  1637.   vty_will_echo (vty);
  1638.   vty_will_suppress_go_ahead (vty);
  1640.   vty_dont_linemode (vty);
  1641.   vty_do_window_size (vty);
  1642.   /* vty_dont_lflow_ahead (vty); */
  1644.   vty_prompt (vty);
  1646.   /* Add read/write thread. */
  1647.   vty_event (VTY_WRITE, vty_sock, vty);
  1648.   vty_event (VTY_READ, vty_sock, vty);
  1650.   return vty;
  1651. }
  1653. /* Accept connection from the network. */
  1654. static int
  1655. vty_accept (struct thread *thread)
  1656. {
  1657.   int vty_sock;
  1658.   struct vty *vty;
  1659.   union sockunion su;
  1660.   int ret;
  1661.   unsigned int on;
  1662.   int accept_sock;
  1663.   struct prefix *p = NULL;
  1664.   struct access_list *acl = NULL;
  1666.   accept_sock = THREAD_FD (thread);
  1668.   /* We continue hearing vty socket. */
  1669.   vty_event (VTY_SERV, accept_sock, NULL);
  1671.   memset (&su, 0, sizeof (union sockunion));
  1673.   /* We can handle IPv4 or IPv6 socket. */
  1674.   vty_sock = sockunion_accept (accept_sock, &su);
  1675.   if (vty_sock < 0)
  1676.     {
  1677.       zlog_warn ("can't accept vty socket : %s", strerror (errno));
  1678.       return -1;
  1679.     }
  1681.   p = sockunion2hostprefix (&su);
  1683.   /* VTY's accesslist apply. */
  1684.   if (p->family == AF_INET && vty_accesslist_name)
  1685.     {
  1686.       if ((acl = access_list_lookup (AFI_IP, vty_accesslist_name)) &&
  1687.   (access_list_apply (acl, p) == FILTER_DENY))
  1688. {
  1689.   char *buf;
  1690.   zlog (NULL, LOG_INFO, "Vty connection refused from %s",
  1691. (buf = sockunion_su2str (&su)));
  1692.   free (buf);
  1693.   close (vty_sock);
  1694.   
  1695.   /* continue accepting connections */
  1696.   vty_event (VTY_SERV, accept_sock, NULL);
  1697.   
  1698.   prefix_free (p);
  1700.   return 0;
  1701. }
  1702.     }
  1704. #ifdef HAVE_IPV6
  1705.   /* VTY's ipv6 accesslist apply. */
  1706.   if (p->family == AF_INET6 && vty_ipv6_accesslist_name)
  1707.     {
  1708.       if ((acl = access_list_lookup (AFI_IP6, vty_ipv6_accesslist_name)) &&
  1709.   (access_list_apply (acl, p) == FILTER_DENY))
  1710. {
  1711.   char *buf;
  1712.   zlog (NULL, LOG_INFO, "Vty connection refused from %s",
  1713. (buf = sockunion_su2str (&su)));
  1714.   free (buf);
  1715.   close (vty_sock);
  1716.   
  1717.   /* continue accepting connections */
  1718.   vty_event (VTY_SERV, accept_sock, NULL);
  1719.   
  1720.   prefix_free (p);
  1722.   return 0;
  1723. }
  1724.     }
  1725. #endif /* HAVE_IPV6 */
  1726.   
  1727.   prefix_free (p);
  1729.   on = 1;
  1730.   ret = setsockopt (vty_sock, IPPROTO_TCP, TCP_NODELAY, 
  1731.     (char *) &on, sizeof (on));
  1732.   if (ret < 0)
  1733.     zlog (NULL, LOG_INFO, "can't set sockopt to vty_sock : %s", 
  1734.   strerror (errno));
  1736.   vty = vty_create (vty_sock, &su);
  1738.   return 0;
  1739. }
  1741. #if defined(HAVE_IPV6) || defined(HAVE_GETADDRINFO)
  1742. void
  1743. vty_serv_sock_addrinfo (const char *hostname, unsigned short port)
  1744. {
  1745.   int ret;
  1746.   struct addrinfo req;
  1747.   struct addrinfo *ainfo;
  1748.   struct addrinfo *ainfo_save;
  1749.   int sock;
  1750.   char port_str[BUFSIZ];
  1752.   memset (&req, 0, sizeof (struct addrinfo));
  1753.   req.ai_flags = AI_PASSIVE;
  1754.   req.ai_family = AF_UNSPEC;
  1755.   req.ai_socktype = SOCK_STREAM;
  1756.   sprintf (port_str, "%d", port);
  1757.   port_str[sizeof (port_str) - 1] = '';
  1759.   ret = getaddrinfo (hostname, port_str, &req, &ainfo);
  1761.   if (ret != 0)
  1762.     {
  1763.       fprintf (stderr, "getaddrinfo failed: %sn", gai_strerror (ret));
  1764.       exit (1);
  1765.     }
  1767.   ainfo_save = ainfo;
  1769.   do
  1770.     {
  1771.       if (ainfo->ai_family != AF_INET
  1772. #ifdef HAVE_IPV6
  1773.   && ainfo->ai_family != AF_INET6
  1774. #endif /* HAVE_IPV6 */
  1775.   )
  1776. continue;
  1778.       sock = socket (ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol);
  1779.       if (sock < 0)
  1780. continue;
  1782.       sockopt_reuseaddr (sock);
  1783.       sockopt_reuseport (sock);
  1785.       ret = bind (sock, ainfo->ai_addr, ainfo->ai_addrlen);
  1786.       if (ret < 0)
  1787. {
  1788.   close (sock); /* Avoid sd leak. */
  1789.   continue;
  1790. }
  1792.       ret = listen (sock, 3);
  1793.       if (ret < 0) 
  1794. {
  1795.   close (sock); /* Avoid sd leak. */
  1796.   continue;
  1797. }
  1799.       vty_event (VTY_SERV, sock, NULL);
  1800.     }
  1801.   while ((ainfo = ainfo->ai_next) != NULL);
  1803.   freeaddrinfo (ainfo_save);
  1804. }
  1805. #endif /* ! (defined(HAVE_IPV6) || defined(HAVE_GETADDRINFO)) */
  1807. /* Make vty server socket. */
  1808. void
  1809. vty_serv_sock_family (unsigned short port, int family)
  1810. {
  1811.   int ret;
  1812.   union sockunion su;
  1813.   int accept_sock;
  1815.   memset (&su, 0, sizeof (union sockunion));
  1816.   su.sa.sa_family = family;
  1818.   /* Make new socket. */
  1819.   accept_sock = sockunion_stream_socket (&su);
  1820.   if (accept_sock < 0)
  1821.     return;
  1823.   /* This is server, so reuse address. */
  1824.   sockopt_reuseaddr (accept_sock);
  1825.   sockopt_reuseport (accept_sock);
  1827.   /* Bind socket to universal address and given port. */
  1828.   ret = sockunion_bind (accept_sock, &su, port, NULL);
  1829.   if (ret < 0)
  1830.     {
  1831.       close (accept_sock); /* Avoid sd leak. */
  1832.       return;
  1833.     }
  1835.   /* Listen socket under queue 3. */
  1836.   ret = listen (accept_sock, 3);
  1837.   if (ret < 0) 
  1838.     {
  1839.       zlog (NULL, LOG_WARNING, "can't listen socket");
  1840.       close (accept_sock); /* Avoid sd leak. */
  1841.       return;
  1842.     }
  1844.   /* Add vty server event. */
  1845.   vty_event (VTY_SERV, accept_sock, NULL);
  1846. }
  1848. #ifdef VTYSH
  1849. /* For sockaddr_un. */
  1850. #include <sys/un.h>
  1852. /* VTY shell UNIX domain socket. */
  1853. void
  1854. vty_serv_un (char *path)
  1855. {
  1856.   int ret;
  1857.   int sock, len;
  1858.   struct sockaddr_un serv;
  1859.   mode_t old_mask;
  1861.   /* First of all, unlink existing socket */
  1862.   unlink (path);
  1864.   /* Set umask */
  1865.   old_mask = umask (0077);
  1867.   /* Make UNIX domain socket. */
  1868.   sock = socket (AF_UNIX, SOCK_STREAM, 0);
  1869.   if (sock < 0)
  1870.     {
  1871.       perror ("sock");
  1872.       return;
  1873.     }
  1875.   /* Make server socket. */
  1876.   memset (&serv, 0, sizeof (struct sockaddr_un));
  1877.   serv.sun_family = AF_UNIX;
  1878.   strncpy (serv.sun_path, path, strlen (path));
  1879. #ifdef HAVE_SUN_LEN
  1880.   len = serv.sun_len = SUN_LEN(&serv);
  1881. #else
  1882.   len = sizeof (serv.sun_family) + strlen (serv.sun_path);
  1883. #endif /* HAVE_SUN_LEN */
  1885.   ret = bind (sock, (struct sockaddr *) &serv, len);
  1886.   if (ret < 0)
  1887.     {
  1888.       perror ("bind");
  1889.       close (sock); /* Avoid sd leak. */
  1890.       return;
  1891.     }
  1893.   ret = listen (sock, 5);
  1894.   if (ret < 0)
  1895.     {
  1896.       perror ("listen");
  1897.       close (sock); /* Avoid sd leak. */
  1898.       return;
  1899.     }
  1901.   umask (old_mask);
  1903.   vty_event (VTYSH_SERV, sock, NULL);
  1904. }
  1906. /* #define VTYSH_DEBUG 1 */
  1908. static int
  1909. vtysh_accept (struct thread *thread)
  1910. {
  1911.   int accept_sock;
  1912.   int sock;
  1913.   int client_len;
  1914.   struct sockaddr_un client;
  1915.   struct vty *vty;
  1916.   
  1917.   accept_sock = THREAD_FD (thread);
  1919.   vty_event (VTYSH_SERV, accept_sock, NULL);
  1921.   memset (&client, 0, sizeof (struct sockaddr_un));
  1922.   client_len = sizeof (struct sockaddr_un);
  1924.   sock = accept (accept_sock, (struct sockaddr *) &client, &client_len);
  1926.   if (sock < 0)
  1927.     {
  1928.       zlog_warn ("can't accept vty socket : %s", strerror (errno));
  1929.       return -1;
  1930.     }
  1932. #ifdef VTYSH_DEBUG
  1933.   printf ("VTY shell acceptn");
  1934. #endif /* VTYSH_DEBUG */
  1936.   vty = vty_new ();
  1937.   vty->fd = sock;
  1938.   vty->type = VTY_SHELL_SERV;
  1939.   vty->node = VIEW_NODE;
  1941.   vty_event (VTYSH_READ, sock, vty);
  1943.   return 0;
  1944. }
  1946. static int
  1947. vtysh_read (struct thread *thread)
  1948. {
  1949.   int ret;
  1950.   int sock;
  1951.   int nbytes;
  1952.   struct vty *vty;
  1953.   unsigned char buf[VTY_READ_BUFSIZ];
  1954.   u_char header[4] = {0, 0, 0, 0};
  1956.   sock = THREAD_FD (thread);
  1957.   vty = THREAD_ARG (thread);
  1958.   vty->t_read = NULL;
  1960.   nbytes = read (sock, buf, VTY_READ_BUFSIZ);
  1961.   if (nbytes <= 0)
  1962.     {
  1963.       vty_close (vty);
  1964. #ifdef VTYSH_DEBUG
  1965.       printf ("close vtyshn");
  1966. #endif /* VTYSH_DEBUG */
  1967.       return 0;
  1968.     }
  1970. #ifdef VTYSH_DEBUG
  1971.   printf ("line: %sn", buf);
  1972. #endif /* VTYSH_DEBUG */
  1974.   vty_ensure (vty, nbytes);
  1975.   memcpy (vty->buf, buf, nbytes);
  1976.   
  1977.   /* Pass this line to parser. */
  1978.   ret = vty_execute (vty);
  1980.   vty_clear_buf (vty);
  1982.   /* Return result. */
  1983. #ifdef VTYSH_DEBUG
  1984.   printf ("result: %dn", ret);
  1985.   printf ("vtysh node: %dn", vty->node);
  1986. #endif /* VTYSH_DEBUG */
  1988.   header[3] = ret;
  1989.   write (vty->fd, header, 4);
  1991.   vty_event (VTYSH_READ, sock, vty);
  1993.   return 0;
  1994. }
  1995. #endif /* VTYSH */
  1997. /* Determine address family to bind. */
  1998. void
  1999. vty_serv_sock (const char *hostname, unsigned short port, char *path)
  2000. {
  2001.   /* If port is set to 0, do not listen on TCP/IP at all! */
  2002.   if (port)
  2003.     {
  2005. #if defined(HAVE_IPV6) || defined(HAVE_GETADDRINFO)
  2006.       vty_serv_sock_addrinfo (hostname, port);
  2007. #else /* ! (defined(HAVE_IPV6) || defined(HAVE_GETADDRINFO)) */
  2008.       vty_serv_sock_family (port, AF_INET);
  2009. #endif /* HAVE_IPV6 */
  2010.     }
  2012. #ifdef VTYSH
  2013.   vty_serv_un (path);
  2014. #endif /* VTYSH */
  2015. }
  2017. /* Close vty interface. */
  2018. void
  2019. vty_close (struct vty *vty)
  2020. {
  2021.   int i;
  2023.   /* Cancel threads.*/
  2024.   if (vty->t_read)
  2025.     thread_cancel (vty->t_read);
  2026.   if (vty->t_write)
  2027.     thread_cancel (vty->t_write);
  2028.   if (vty->t_timeout)
  2029.     thread_cancel (vty->t_timeout);
  2030.   if (vty->t_output)
  2031.     thread_cancel (vty->t_output);
  2033.   /* Flush buffer. */
  2034.   if (! buffer_empty (vty->obuf))
  2035.     buffer_flush_all (vty->obuf, vty->fd);
  2037.   /* Free input buffer. */
  2038.   buffer_free (vty->obuf);
  2040.   /* Free SB buffer. */
  2041.   if (vty->sb_buffer)
  2042.     buffer_free (vty->sb_buffer);
  2044.   /* Free command history. */
  2045.   for (i = 0; i < VTY_MAXHIST; i++)
  2046.     if (vty->hist[i])
  2047.       XFREE (MTYPE_VTY_HIST, vty->hist[i]);
  2049.   /* Unset vector. */
  2050.   vector_unset (vtyvec, vty->fd);
  2052.   /* Close socket. */
  2053.   if (vty->fd > 0)
  2054.     close (vty->fd);
  2056.   if (vty->address)
  2057.     XFREE (0, vty->address);
  2058.   if (vty->buf)
  2059.     XFREE (MTYPE_VTY, vty->buf);
  2061.   /* Check configure. */
  2062.   vty_config_unlock (vty);
  2064.   /* OK free vty. */
  2065.   XFREE (MTYPE_VTY, vty);
  2066. }
  2068. /* When time out occur output message then close connection. */
  2069. static int
  2070. vty_timeout (struct thread *thread)
  2071. {
  2072.   struct vty *vty;
  2074.   vty = THREAD_ARG (thread);
  2075.   vty->t_timeout = NULL;
  2076.   vty->v_timeout = 0;
  2078.   /* Clear buffer*/
  2079.   buffer_reset (vty->obuf);
  2080.   vty_out (vty, "%sVty connection is timed out.%s", VTY_NEWLINE, VTY_NEWLINE);
  2082.   /* Close connection. */
  2083.   vty->status = VTY_CLOSE;
  2084.   vty_close (vty);
  2086.   return 0;
  2087. }
  2089. /* Read up configuration file from file_name. */
  2090. static void
  2091. vty_read_file (FILE *confp)
  2092. {
  2093.   int ret;
  2094.   struct vty *vty;
  2096.   vty = vty_new ();
  2097.   vty->fd = 0; /* stdout */
  2098.   vty->type = VTY_TERM;
  2099.   vty->node = CONFIG_NODE;
  2100.   
  2101.   /* Execute configuration file */
  2102.   ret = config_from_file (vty, confp);
  2104.   if (ret != CMD_SUCCESS) 
  2105.     {
  2106.       switch (ret)
  2107. {
  2108. case CMD_ERR_AMBIGUOUS:
  2109.   fprintf (stderr, "Ambiguous command.n");
  2110.   break;
  2111. case CMD_ERR_NO_MATCH:
  2112.   fprintf (stderr, "There is no such command.n");
  2113.   break;
  2114. }
  2115.       fprintf (stderr, "Error occured during reading below line.n%sn", 
  2116.        vty->buf);
  2117.       vty_close (vty);
  2118.       exit (1);
  2119.     }
  2121.   vty_close (vty);
  2122. }
  2124. FILE *
  2125. vty_use_backup_config (char *fullpath)
  2126. {
  2127.   char *fullpath_sav, *fullpath_tmp;
  2128.   FILE *ret = NULL;
  2129.   struct stat buf;
  2130.   int tmp, sav;
  2131.   int c;
  2132.   char buffer[512];
  2133.   
  2134.   fullpath_sav = malloc (strlen (fullpath) + strlen (CONF_BACKUP_EXT) + 1);
  2135.   strcpy (fullpath_sav, fullpath);
  2136.   strcat (fullpath_sav, CONF_BACKUP_EXT);
  2137.   if (stat (fullpath_sav, &buf) == -1)
  2138.     {
  2139.       free (fullpath_sav);
  2140.       return NULL;
  2141.     }
  2143.   fullpath_tmp = malloc (strlen (fullpath) + 8);
  2144.   sprintf (fullpath_tmp, "%s.XXXXXX", fullpath);
  2145.   
  2146.   /* Open file to configuration write. */
  2147.   tmp = mkstemp (fullpath_tmp);
  2148.   if (tmp < 0)
  2149.     {
  2150.       free (fullpath_sav);
  2151.       free (fullpath_tmp);
  2152.       return NULL;
  2153.     }
  2155.   sav = open (fullpath_sav, O_RDONLY);
  2156.   if (sav < 0)
  2157.     {
  2158.       free (fullpath_sav);
  2159.       free (fullpath_tmp);
  2160.       unlink (fullpath_tmp);
  2161.       return NULL;
  2162.     }
  2163.   
  2164.   while((c = read (sav, buffer, 512)) > 0)
  2165.     write (tmp, buffer, c);
  2166.   
  2167.   close (sav);
  2168.   close (tmp);
  2169.   
  2170.   if (link (fullpath_tmp, fullpath) == 0)
  2171.     ret = fopen (fullpath, "r");
  2173.   unlink (fullpath_tmp);
  2174.   
  2175.   free (fullpath_sav);
  2176.   free (fullpath_tmp);
  2177.   return fopen (fullpath, "r");
  2178. }
  2180. /* Read up configuration file from file_name. */
  2181. void
  2182. vty_read_config (char *config_file,
  2183.  char *config_current_dir,
  2184.  char *config_default_dir)
  2185. {
  2186.   char *cwd;
  2187.   FILE *confp = NULL;
  2188.   char *fullpath;
  2190.   /* If -f flag specified. */
  2191.   if (config_file != NULL)
  2192.     {
  2193.       if (! IS_DIRECTORY_SEP (config_file[0]))
  2194. {
  2195.   cwd = getcwd (NULL, MAXPATHLEN);
  2196.   fullpath = XMALLOC (MTYPE_TMP, 
  2197.       strlen (cwd) + strlen (config_file) + 2);
  2198.   sprintf (fullpath, "%s/%s", cwd, config_file);
  2199. }
  2200.       else
  2201. fullpath = config_file;
  2203.       confp = fopen (fullpath, "r");
  2205.       if (confp == NULL)
  2206. {
  2207.   confp = vty_use_backup_config (fullpath);
  2208.   if (confp)
  2209.     fprintf (stderr, "WARNING: using backup configuration file!n");
  2210.   else
  2211.     {
  2212.       fprintf (stderr, "can't open configuration file [%s]n", 
  2213.        config_file);
  2214.       exit(1);
  2215.     }
  2216. }
  2217.     }
  2218.   else
  2219.     {
  2220.       /* Relative path configuration file open. */
  2221.       if (config_current_dir)
  2222. {
  2223.   confp = fopen (config_current_dir, "r");
  2224.   if (confp == NULL)
  2225.     {
  2226.       confp = vty_use_backup_config (config_current_dir);
  2227.       if (confp)
  2228. fprintf (stderr, "WARNING: using backup configuration file!n");
  2229.     }
  2230. }
  2232.       /* If there is no relative path exists, open system default file. */
  2233.       if (confp == NULL)
  2234. {
  2235. #ifdef VTYSH
  2236.   int ret;
  2237.   struct stat conf_stat;
  2239.   /* !!!!PLEASE LEAVE!!!!
  2240.      This is NEEDED for use with vtysh -b, or else you can get
  2241.      a real configuration food fight with a lot garbage in the
  2242.      merged configuration file it creates coming from the per
  2243.      daemon configuration files.  This also allows the daemons
  2244.      to start if there default configuration file is not
  2245.      present or ignore them, as needed when using vtysh -b to
  2246.      configure the daemons at boot - MAG */
  2248.   /* Stat for vtysh Zebra.conf, if found startup and wait for
  2249.      boot configuration */
  2251.   if ( strstr(config_default_dir, "vtysh") == NULL)
  2252.     {
  2253.       ret = stat (integrate_default, &conf_stat);
  2254.       if (ret >= 0)
  2255. {
  2256.   return;
  2257. }
  2258.     }
  2259. #endif /* VTYSH */
  2261.   confp = fopen (config_default_dir, "r");
  2262.   if (confp == NULL)
  2263.     {
  2264.       confp = vty_use_backup_config (config_default_dir);
  2265.       if (confp)
  2266. {
  2267.   fprintf (stderr, "WARNING: using backup configuration file!n");
  2268.   fullpath = config_default_dir;
  2269. }
  2270.       else
  2271. {
  2272.   fprintf (stderr, "can't open configuration file [%s]n",
  2273.    config_default_dir);
  2274.   exit (1);
  2275. }
  2276.     }      
  2277.   else
  2278.     fullpath = config_default_dir;
  2279. }
  2280.       else
  2281. {
  2282.   /* Rleative path configuration file. */
  2283.   cwd = getcwd (NULL, MAXPATHLEN);
  2284.   fullpath = XMALLOC (MTYPE_TMP, 
  2285.       strlen (cwd) + strlen (config_current_dir) + 2);
  2286.   sprintf (fullpath, "%s/%s", cwd, config_current_dir);
  2287. }  
  2288.     }  
  2289.   vty_read_file (confp);
  2291.   fclose (confp);
  2293.   host_config_set (fullpath);
  2294. }
  2296. /* Small utility function which output log to the VTY. */
  2297. void
  2298. vty_log (const char *proto_str, const char *format, va_list va)
  2299. {
  2300.   int i;
  2301.   struct vty *vty;
  2303.   for (i = 0; i < vector_max (vtyvec); i++)
  2304.     if ((vty = vector_slot (vtyvec, i)) != NULL)
  2305.       if (vty->monitor)
  2306. vty_log_out (vty, proto_str, format, va);
  2307. }
  2309. int
  2310. vty_config_lock (struct vty *vty)
  2311. {
  2312.   if (vty_config == 0)
  2313.     {
  2314.       vty->config = 1;
  2315.       vty_config = 1;
  2316.     }
  2317.   return vty->config;
  2318. }
  2320. int
  2321. vty_config_unlock (struct vty *vty)
  2322. {
  2323.   if (vty_config == 1 && vty->config == 1)
  2324.     {
  2325.       vty->config = 0;
  2326.       vty_config = 0;
  2327.     }
  2328.   return vty->config;
  2329. }
  2331. /* Master of the threads. */
  2332. extern struct thread_master *master;
  2333. /* struct thread_master *master; */
  2335. static void
  2336. vty_event (enum event event, int sock, struct vty *vty)
  2337. {
  2338.   struct thread *vty_serv_thread;
  2340.   switch (event)
  2341.     {
  2342.     case VTY_SERV:
  2343.       vty_serv_thread = thread_add_read (master, vty_accept, vty, sock);
  2344.       vector_set_index (Vvty_serv_thread, sock, vty_serv_thread);
  2345.       break;
  2346. #ifdef VTYSH
  2347.     case VTYSH_SERV:
  2348.       thread_add_read (master, vtysh_accept, vty, sock);
  2349.       break;
  2350.     case VTYSH_READ:
  2351.       thread_add_read (master, vtysh_read, vty, sock);
  2352.       break;
  2353. #endif /* VTYSH */
  2354.     case VTY_READ:
  2355.       vty->t_read = thread_add_read (master, vty_read, vty, sock);
  2357.       /* Time out treatment. */
  2358.       if (vty->v_timeout)
  2359. {
  2360.   if (vty->t_timeout)
  2361.     thread_cancel (vty->t_timeout);
  2362.   vty->t_timeout = 
  2363.     thread_add_timer (master, vty_timeout, vty, vty->v_timeout);
  2364. }
  2365.       break;
  2366.     case VTY_WRITE:
  2367.       if (! vty->t_write)
  2368. vty->t_write = thread_add_write (master, vty_flush, vty, sock);
  2369.       break;
  2370.     case VTY_TIMEOUT_RESET:
  2371.       if (vty->t_timeout)
  2372. {
  2373.   thread_cancel (vty->t_timeout);
  2374.   vty->t_timeout = NULL;
  2375. }
  2376.       if (vty->v_timeout)
  2377. {
  2378.   vty->t_timeout = 
  2379.     thread_add_timer (master, vty_timeout, vty, vty->v_timeout);
  2380. }
  2381.       break;
  2382.     }
  2383. }
  2385. DEFUN (config_who,
  2386.        config_who_cmd,
  2387.        "who",
  2388.        "Display who is on vtyn")
  2389. {
  2390.   int i;
  2391.   struct vty *v;
  2393.   for (i = 0; i < vector_max (vtyvec); i++)
  2394.     if ((v = vector_slot (vtyvec, i)) != NULL)
  2395.       vty_out (vty, "%svty[%d] connected from %s.%s",
  2396.        v->config ? "*" : " ",
  2397.        i, v->address, VTY_NEWLINE);
  2398.   return CMD_SUCCESS;
  2399. }
  2401. /* Move to vty configuration mode. */
  2402. DEFUN (line_vty,
  2403.        line_vty_cmd,
  2404.        "line vty",
  2405.        "Configure a terminal linen"
  2406.        "Virtual terminaln")
  2407. {
  2408.   vty->node = VTY_NODE;
  2409.   return CMD_SUCCESS;
  2410. }
  2412. /* Set time out value. */
  2413. int
  2414. exec_timeout (struct vty *vty, char *min_str, char *sec_str)
  2415. {
  2416.   unsigned long timeout = 0;
  2418.   /* min_str and sec_str are already checked by parser.  So it must be
  2419.      all digit string. */
  2420.   if (min_str)
  2421.     {
  2422.       timeout = strtol (min_str, NULL, 10);
  2423.       timeout *= 60;
  2424.     }
  2425.   if (sec_str)
  2426.     timeout += strtol (sec_str, NULL, 10);
  2428.   vty_timeout_val = timeout;
  2429.   vty->v_timeout = timeout;
  2430.   vty_event (VTY_TIMEOUT_RESET, 0, vty);
  2433.   return CMD_SUCCESS;
  2434. }
  2436. DEFUN (exec_timeout_min,
  2437.        exec_timeout_min_cmd,
  2438.        "exec-timeout <0-35791>",
  2439.        "Set timeout valuen"
  2440.        "Timeout value in minutesn")
  2441. {
  2442.   return exec_timeout (vty, argv[0], NULL);
  2443. }
  2445. DEFUN (exec_timeout_sec,
  2446.        exec_timeout_sec_cmd,
  2447.        "exec-timeout <0-35791> <0-2147483>",
  2448.        "Set the EXEC timeoutn"
  2449.        "Timeout in minutesn"
  2450.        "Timeout in secondsn")
  2451. {
  2452.   return exec_timeout (vty, argv[0], argv[1]);
  2453. }
  2455. DEFUN (no_exec_timeout,
  2456.        no_exec_timeout_cmd,
  2457.        "no exec-timeout",
  2458.        NO_STR
  2459.        "Set the EXEC timeoutn")
  2460. {
  2461.   return exec_timeout (vty, NULL, NULL);
  2462. }
  2464. /* Set vty access class. */
  2465. DEFUN (vty_access_class,
  2466.        vty_access_class_cmd,
  2467.        "access-class WORD",
  2468.        "Filter connections based on an IP access listn"
  2469.        "IP access listn")
  2470. {
  2471.   if (vty_accesslist_name)
  2472.     XFREE(MTYPE_VTY, vty_accesslist_name);
  2474.   vty_accesslist_name = XSTRDUP(MTYPE_VTY, argv[0]);
  2476.   return CMD_SUCCESS;
  2477. }
  2479. /* Clear vty access class. */
  2480. DEFUN (no_vty_access_class,
  2481.        no_vty_access_class_cmd,
  2482.        "no access-class [WORD]",
  2483.        NO_STR
  2484.        "Filter connections based on an IP access listn"
  2485.        "IP access listn")
  2486. {
  2487.   if (! vty_accesslist_name || (argc && strcmp(vty_accesslist_name, argv[0])))
  2488.     {
  2489.       vty_out (vty, "Access-class is not currently applied to vty%s",
  2490.        VTY_NEWLINE);
  2491.       return CMD_WARNING;
  2492.     }
  2494.   XFREE(MTYPE_VTY, vty_accesslist_name);
  2496.   vty_accesslist_name = NULL;
  2498.   return CMD_SUCCESS;
  2499. }
  2501. #ifdef HAVE_IPV6
  2502. /* Set vty access class. */
  2503. DEFUN (vty_ipv6_access_class,
  2504.        vty_ipv6_access_class_cmd,
  2505.        "ipv6 access-class WORD",
  2506.        IPV6_STR
  2507.        "Filter connections based on an IP access listn"
  2508.        "IPv6 access listn")
  2509. {
  2510.   if (vty_ipv6_accesslist_name)
  2511.     XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
  2513.   vty_ipv6_accesslist_name = XSTRDUP(MTYPE_VTY, argv[0]);
  2515.   return CMD_SUCCESS;
  2516. }
  2518. /* Clear vty access class. */
  2519. DEFUN (no_vty_ipv6_access_class,
  2520.        no_vty_ipv6_access_class_cmd,
  2521.        "no ipv6 access-class [WORD]",
  2522.        NO_STR
  2523.        IPV6_STR
  2524.        "Filter connections based on an IP access listn"
  2525.        "IPv6 access listn")
  2526. {
  2527.   if (! vty_ipv6_accesslist_name ||
  2528.       (argc && strcmp(vty_ipv6_accesslist_name, argv[0])))
  2529.     {
  2530.       vty_out (vty, "IPv6 access-class is not currently applied to vty%s",
  2531.        VTY_NEWLINE);
  2532.       return CMD_WARNING;
  2533.     }
  2535.   XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
  2537.   vty_ipv6_accesslist_name = NULL;
  2539.   return CMD_SUCCESS;
  2540. }
  2541. #endif /* HAVE_IPV6 */
  2543. /* vty login. */
  2544. DEFUN (vty_login,
  2545.        vty_login_cmd,
  2546.        "login",
  2547.        "Enable password checkingn")
  2548. {
  2549.   no_password_check = 0;
  2550.   return CMD_SUCCESS;
  2551. }
  2553. DEFUN (no_vty_login,
  2554.        no_vty_login_cmd,
  2555.        "no login",
  2556.        NO_STR
  2557.        "Enable password checkingn")
  2558. {
  2559.   no_password_check = 1;
  2560.   return CMD_SUCCESS;
  2561. }
  2563. DEFUN (service_advanced_vty,
  2564.        service_advanced_vty_cmd,
  2565.        "service advanced-vty",
  2566.        "Set up miscellaneous servicen"
  2567.        "Enable advanced mode vty interfacen")
  2568. {
  2569.   host.advanced = 1;
  2570.   return CMD_SUCCESS;
  2571. }
  2573. DEFUN (no_service_advanced_vty,
  2574.        no_service_advanced_vty_cmd,
  2575.        "no service advanced-vty",
  2576.        NO_STR
  2577.        "Set up miscellaneous servicen"
  2578.        "Enable advanced mode vty interfacen")
  2579. {
  2580.   host.advanced = 0;
  2581.   return CMD_SUCCESS;
  2582. }
  2584. DEFUN (terminal_monitor,
  2585.        terminal_monitor_cmd,
  2586.        "terminal monitor",
  2587.        "Set terminal line parametersn"
  2588.        "Copy debug output to the current terminal linen")
  2589. {
  2590.   vty->monitor = 1;
  2591.   return CMD_SUCCESS;
  2592. }
  2594. DEFUN (terminal_no_monitor,
  2595.        terminal_no_monitor_cmd,
  2596.        "terminal no monitor",
  2597.        "Set terminal line parametersn"
  2598.        NO_STR
  2599.        "Copy debug output to the current terminal linen")
  2600. {
  2601.   vty->monitor = 0;
  2602.   return CMD_SUCCESS;
  2603. }
  2605. DEFUN (show_history,
  2606.        show_history_cmd,
  2607.        "show history",
  2608.        SHOW_STR
  2609.        "Display the session command historyn")
  2610. {
  2611.   int index;
  2613.   for (index = vty->hindex + 1; index != vty->hindex;)
  2614.     {
  2615.       if (index == VTY_MAXHIST)
  2616. {
  2617.   index = 0;
  2618.   continue;
  2619. }
  2621.       if (vty->hist[index] != NULL)
  2622. vty_out (vty, "  %s%s", vty->hist[index], VTY_NEWLINE);
  2624.       index++;
  2625.     }
  2627.   return CMD_SUCCESS;
  2628. }
  2630. /* Display current configuration. */
  2631. int
  2632. vty_config_write (struct vty *vty)
  2633. {
  2634.   vty_out (vty, "line vty%s", VTY_NEWLINE);
  2636.   if (vty_accesslist_name)
  2637.     vty_out (vty, " access-class %s%s",
  2638.      vty_accesslist_name, VTY_NEWLINE);
  2640.   if (vty_ipv6_accesslist_name)
  2641.     vty_out (vty, " ipv6 access-class %s%s",
  2642.      vty_ipv6_accesslist_name, VTY_NEWLINE);
  2644.   /* exec-timeout */
  2645.   if (vty_timeout_val != VTY_TIMEOUT_DEFAULT)
  2646.     vty_out (vty, " exec-timeout %ld %ld%s", 
  2647.      vty_timeout_val / 60,
  2648.      vty_timeout_val % 60, VTY_NEWLINE);
  2650.   /* login */
  2651.   if (no_password_check)
  2652.     vty_out (vty, " no login%s", VTY_NEWLINE);
  2654.   vty_out (vty, "!%s", VTY_NEWLINE);
  2656.   return CMD_SUCCESS;
  2657. }
  2659. struct cmd_node vty_node =
  2660.   {
  2661.     VTY_NODE,
  2662.     "%s(config-line)# ",
  2663.   };
  2665. /* Reset all VTY status. */
  2666. void
  2667. vty_reset ()
  2668. {
  2669.   int i;
  2670.   struct vty *vty;
  2671.   struct thread *vty_serv_thread;
  2673.   for (i = 0; i < vector_max (vtyvec); i++)
  2674.     if ((vty = vector_slot (vtyvec, i)) != NULL)
  2675.       {
  2676. buffer_reset (vty->obuf);
  2677. vty->status = VTY_CLOSE;
  2678. vty_close (vty);
  2679.       }
  2681.   for (i = 0; i < vector_max (Vvty_serv_thread); i++)
  2682.     if ((vty_serv_thread = vector_slot (Vvty_serv_thread, i)) != NULL)
  2683.       {
  2684. thread_cancel (vty_serv_thread);
  2685. vector_slot (Vvty_serv_thread, i) = NULL;
  2686.         close (i);
  2687.       }
  2689.   vty_timeout_val = VTY_TIMEOUT_DEFAULT;
  2691.   if (vty_accesslist_name)
  2692.     {
  2693.       XFREE(MTYPE_VTY, vty_accesslist_name);
  2694.       vty_accesslist_name = NULL;
  2695.     }
  2697.   if (vty_ipv6_accesslist_name)
  2698.     {
  2699.       XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
  2700.       vty_ipv6_accesslist_name = NULL;
  2701.     }
  2702. }
  2704. /* for ospf6d easy temprary reload function */
  2705. /* vty_reset + close accept socket */
  2706. void
  2707. vty_finish ()
  2708. {
  2709.   int i;
  2710.   struct vty *vty;
  2711.   struct thread *vty_serv_thread;
  2713.   for (i = 0; i < vector_max (vtyvec); i++)
  2714.     if ((vty = vector_slot (vtyvec, i)) != NULL)
  2715.       {
  2716. buffer_reset (vty->obuf);
  2717. vty->status = VTY_CLOSE;
  2718. vty_close (vty);
  2719.       }
  2721.   for (i = 0; i < vector_max (Vvty_serv_thread); i++)
  2722.     if ((vty_serv_thread = vector_slot (Vvty_serv_thread, i)) != NULL)
  2723.       {
  2724. thread_cancel (vty_serv_thread);
  2725. vector_slot (Vvty_serv_thread, i) = NULL;
  2726.         close (i);
  2727.       }
  2729.   vty_timeout_val = VTY_TIMEOUT_DEFAULT;
  2731.   if (vty_accesslist_name)
  2732.     {
  2733.       XFREE(MTYPE_VTY, vty_accesslist_name);
  2734.       vty_accesslist_name = NULL;
  2735.     }
  2737.   if (vty_ipv6_accesslist_name)
  2738.     {
  2739.       XFREE(MTYPE_VTY, vty_ipv6_accesslist_name);
  2740.       vty_ipv6_accesslist_name = NULL;
  2741.     }
  2742. }
  2744. void
  2745. vty_save_cwd ()
  2746. {
  2747.   char *cwd;
  2749.   cwd = getcwd (NULL, MAXPATHLEN);
  2751.   vty_cwd = XMALLOC (MTYPE_TMP, strlen (cwd) + 1);
  2752.   strcpy (vty_cwd, cwd);
  2753. }
  2755. char *
  2756. vty_get_cwd ()
  2757. {
  2758.   return vty_cwd;
  2759. }
  2761. int
  2762. vty_shell (struct vty *vty)
  2763. {
  2764.   return vty->type == VTY_SHELL ? 1 : 0;
  2765. }
  2767. int
  2768. vty_shell_serv (struct vty *vty)
  2769. {
  2770.   return vty->type == VTY_SHELL_SERV ? 1 : 0;
  2771. }
  2773. void
  2774. vty_init_vtysh ()
  2775. {
  2776.   vtyvec = vector_init (VECTOR_MIN_SIZE);
  2777. }
  2779. /* Install vty's own commands like `who' command. */
  2780. void
  2781. vty_init ()
  2782. {
  2783.   /* For further configuration read, preserve current directory. */
  2784.   vty_save_cwd ();
  2786.   vtyvec = vector_init (VECTOR_MIN_SIZE);
  2788.   /* Initilize server thread vector. */
  2789.   Vvty_serv_thread = vector_init (VECTOR_MIN_SIZE);
  2791.   /* Install bgp top node. */
  2792.   install_node (&vty_node, vty_config_write);
  2794.   install_element (VIEW_NODE, &config_who_cmd);
  2795.   install_element (VIEW_NODE, &show_history_cmd);
  2796.   install_element (ENABLE_NODE, &config_who_cmd);
  2797.   install_element (CONFIG_NODE, &line_vty_cmd);
  2798.   install_element (CONFIG_NODE, &service_advanced_vty_cmd);
  2799.   install_element (CONFIG_NODE, &no_service_advanced_vty_cmd);
  2800.   install_element (CONFIG_NODE, &show_history_cmd);
  2801.   install_element (ENABLE_NODE, &terminal_monitor_cmd);
  2802.   install_element (ENABLE_NODE, &terminal_no_monitor_cmd);
  2803.   install_element (ENABLE_NODE, &show_history_cmd);
  2805.   install_default (VTY_NODE);
  2806.   install_element (VTY_NODE, &exec_timeout_min_cmd);
  2807.   install_element (VTY_NODE, &exec_timeout_sec_cmd);
  2808.   install_element (VTY_NODE, &no_exec_timeout_cmd);
  2809.   install_element (VTY_NODE, &vty_access_class_cmd);
  2810.   install_element (VTY_NODE, &no_vty_access_class_cmd);
  2811.   install_element (VTY_NODE, &vty_login_cmd);
  2812.   install_element (VTY_NODE, &no_vty_login_cmd);
  2813. #ifdef HAVE_IPV6
  2814.   install_element (VTY_NODE, &vty_ipv6_access_class_cmd);
  2815.   install_element (VTY_NODE, &no_vty_ipv6_access_class_cmd);
  2816. #endif /* HAVE_IPV6 */
  2817. }