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

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

网络

开发平台：

Unix_Linux

command.c：源码内容
  1. /* Command interpreter routine for virtual terminal [aka TeletYpe]
  2.    Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
  4. This file is part of GNU Zebra.
  5.  
  6. GNU Zebra is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published
  8. by the Free Software Foundation; either version 2, or (at your
  9. option) any later version.
  11. GNU Zebra is distributed in the hope that it will be useful, but
  12. WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14. General Public License for more details.
  16. You should have received a copy of the GNU General Public License
  17. along with GNU Zebra; see the file COPYING.  If not, write to the
  18. Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19. Boston, MA 02111-1307, USA.  */
  21. #include <zebra.h>
  23. #include "command.h"
  24. #include "memory.h"
  25. #include "log.h"
  26. #include "version.h"
  28. /* Command vector which includes some level of command lists. Normally
  29.    each daemon maintains each own cmdvec. */
  30. vector cmdvec;
  32. /* Host information structure. */
  33. struct host host;
  35. /* Default motd string. */
  36. char *default_motd = 
  37. "rn
  38. Hello, this is zebra (version " ZEBRA_VERSION ").rn
  39. Copyright 1996-2004 Kunihiro Ishiguro.rn
  40. rn";
  42. /* Standard command node structures. */
  43. struct cmd_node auth_node =
  44. {
  45.   AUTH_NODE,
  46.   "Password: ",
  47. };
  49. struct cmd_node view_node =
  50. {
  51.   VIEW_NODE,
  52.   "%s> ",
  53. };
  55. struct cmd_node auth_enable_node =
  56. {
  57.   AUTH_ENABLE_NODE,
  58.   "Password: ",
  59. };
  61. struct cmd_node enable_node =
  62. {
  63.   ENABLE_NODE,
  64.   "%s# ",
  65. };
  67. struct cmd_node config_node =
  68. {
  69.   CONFIG_NODE,
  70.   "%s(config)# ",
  71.   1
  72. };
  74. /* Utility function to concatenate argv argument into a single string
  75.    with inserting ' ' character between each argument.  */
  76. char *
  77. argv_concat (char **argv, int argc, int shift)
  78. {
  79.   int i;
  80.   int len;
  81.   int index;
  82.   char *str;
  84.   str = NULL;
  85.   index = 0;
  87.   for (i = shift; i < argc; i++)
  88.     {
  89.       len = strlen (argv[i]);
  91.       if (i == shift)
  92. {
  93.   str = XSTRDUP (MTYPE_TMP, argv[i]);
  94.   index = len;
  95. }
  96.       else
  97. {
  98.   str = XREALLOC (MTYPE_TMP, str, (index + len + 2));
  99.   str[index++] = ' ';
  100.   memcpy (str + index, argv[i], len);
  101.   index += len;
  102.   str[index] = '';
  103. }
  104.     }
  105.   return str;
  106. }
  108. /* Install top node of command vector. */
  109. void
  110. install_node (struct cmd_node *node, 
  111.       int (*func) (struct vty *))
  112. {
  113.   vector_set_index (cmdvec, node->node, node);
  114.   node->func = func;
  115.   node->cmd_vector = vector_init (VECTOR_MIN_SIZE);
  116. }
  118. /* Compare two command's string.  Used in sort_node (). */
  119. int
  120. cmp_node (const void *p, const void *q)
  121. {
  122.   struct cmd_element *a = *(struct cmd_element **)p;
  123.   struct cmd_element *b = *(struct cmd_element **)q;
  125.   return strcmp (a->string, b->string);
  126. }
  128. int
  129. cmp_desc (const void *p, const void *q)
  130. {
  131.   struct desc *a = *(struct desc **)p;
  132.   struct desc *b = *(struct desc **)q;
  134.   return strcmp (a->cmd, b->cmd);
  135. }
  137. /* Sort each node's command element according to command string. */
  138. void
  139. sort_node ()
  140. {
  141.   int i, j;
  142.   struct cmd_node *cnode;
  143.   vector descvec;
  144.   struct cmd_element *cmd_element;
  146.   for (i = 0; i < vector_max (cmdvec); i++) 
  147.     if ((cnode = vector_slot (cmdvec, i)) != NULL)
  148.       {
  149. vector cmd_vector = cnode->cmd_vector;
  150. qsort (cmd_vector->index, cmd_vector->max, sizeof (void *), cmp_node);
  152. for (j = 0; j < vector_max (cmd_vector); j++)
  153.   if ((cmd_element = vector_slot (cmd_vector, j)) != NULL)
  154.     {
  155.       descvec = vector_slot (cmd_element->strvec,
  156.      vector_max (cmd_element->strvec) - 1);
  157.       qsort (descvec->index, descvec->max, sizeof (void *), cmp_desc);
  158.     }
  159.       }
  160. }
  162. /* Breaking up string into each command piece. I assume given
  163.    character is separated by a space character. Return value is a
  164.    vector which includes char ** data element. */
  165. vector
  166. cmd_make_strvec (char *string)
  167. {
  168.   char *cp, *start, *token;
  169.   int strlen;
  170.   vector strvec;
  171.   
  172.   if (string == NULL)
  173.     return NULL;
  174.   
  175.   cp = string;
  177.   /* Skip white spaces. */
  178.   while (isspace ((int) *cp) && *cp != '')
  179.     cp++;
  181.   /* Return if there is only white spaces */
  182.   if (*cp == '')
  183.     return NULL;
  185.   if (*cp == '!' || *cp == '#')
  186.     return NULL;
  188.   /* Prepare return vector. */
  189.   strvec = vector_init (VECTOR_MIN_SIZE);
  191.   /* Copy each command piece and set into vector. */
  192.   while (1) 
  193.     {
  194.       start = cp;
  195.       while (!(isspace ((int) *cp) || *cp == 'r' || *cp == 'n') &&
  196.      *cp != '')
  197. cp++;
  198.       strlen = cp - start;
  199.       token = XMALLOC (MTYPE_STRVEC, strlen + 1);
  200.       memcpy (token, start, strlen);
  201.       *(token + strlen) = '';
  202.       vector_set (strvec, token);
  204.       while ((isspace ((int) *cp) || *cp == 'n' || *cp == 'r') &&
  205.      *cp != '')
  206. cp++;
  208.       if (*cp == '')
  209. return strvec;
  210.     }
  211. }
  213. /* Free allocated string vector. */
  214. void
  215. cmd_free_strvec (vector v)
  216. {
  217.   int i;
  218.   char *cp;
  220.   if (!v)
  221.     return;
  223.   for (i = 0; i < vector_max (v); i++)
  224.     if ((cp = vector_slot (v, i)) != NULL)
  225.       XFREE (MTYPE_STRVEC, cp);
  227.   vector_free (v);
  228. }
  230. /* Fetch next description.  Used in cmd_make_descvec(). */
  231. char *
  232. cmd_desc_str (char **string)
  233. {
  234.   char *cp, *start, *token;
  235.   int strlen;
  236.   
  237.   cp = *string;
  239.   if (cp == NULL)
  240.     return NULL;
  242.   /* Skip white spaces. */
  243.   while (isspace ((int) *cp) && *cp != '')
  244.     cp++;
  246.   /* Return if there is only white spaces */
  247.   if (*cp == '')
  248.     return NULL;
  250.   start = cp;
  252.   while (!(*cp == 'r' || *cp == 'n') && *cp != '')
  253.     cp++;
  255.   strlen = cp - start;
  256.   token = XMALLOC (MTYPE_STRVEC, strlen + 1);
  257.   memcpy (token, start, strlen);
  258.   *(token + strlen) = '';
  260.   *string = cp;
  262.   return token;
  263. }
  265. /* New string vector. */
  266. vector
  267. cmd_make_descvec (char *string, char *descstr)
  268. {
  269.   int multiple = 0;
  270.   char *sp;
  271.   char *token;
  272.   int len;
  273.   char *cp;
  274.   char *dp;
  275.   vector allvec;
  276.   vector strvec = NULL;
  277.   struct desc *desc;
  279.   cp = string;
  280.   dp = descstr;
  282.   if (cp == NULL)
  283.     return NULL;
  285.   allvec = vector_init (VECTOR_MIN_SIZE);
  287.   while (1)
  288.     {
  289.       while (isspace ((int) *cp) && *cp != '')
  290. cp++;
  292.       if (*cp == '(')
  293. {
  294.   multiple = 1;
  295.   cp++;
  296. }
  297.       if (*cp == ')')
  298. {
  299.   multiple = 0;
  300.   cp++;
  301. }
  302.       if (*cp == '|')
  303. {
  304.   if (! multiple)
  305.     {
  306.       fprintf (stderr, "Command parse error!: %sn", string);
  307.       exit (1);
  308.     }
  309.   cp++;
  310. }
  311.       
  312.       while (isspace ((int) *cp) && *cp != '')
  313. cp++;
  315.       if (*cp == '(')
  316. {
  317.   multiple = 1;
  318.   cp++;
  319. }
  321.       if (*cp == '') 
  322. return allvec;
  324.       sp = cp;
  326.       while (! (isspace ((int) *cp) || *cp == 'r' || *cp == 'n' || *cp == ')' || *cp == '|') && *cp != '')
  327. cp++;
  329.       len = cp - sp;
  331.       token = XMALLOC (MTYPE_STRVEC, len + 1);
  332.       memcpy (token, sp, len);
  333.       *(token + len) = '';
  335.       desc = XCALLOC (MTYPE_DESC, sizeof (struct desc));
  336.       desc->cmd = token;
  337.       desc->str = cmd_desc_str (&dp);
  339.       if (multiple)
  340. {
  341.   if (multiple == 1)
  342.     {
  343.       strvec = vector_init (VECTOR_MIN_SIZE);
  344.       vector_set (allvec, strvec);
  345.     }
  346.   multiple++;
  347. }
  348.       else
  349. {
  350.   strvec = vector_init (VECTOR_MIN_SIZE);
  351.   vector_set (allvec, strvec);
  352. }
  353.       vector_set (strvec, desc);
  354.     }
  355. }
  357. /* Count mandantory string vector size.  This is to determine inputed
  358.    command has enough command length. */
  359. int
  360. cmd_cmdsize (vector strvec)
  361. {
  362.   int i;
  363.   char *str;
  364.   int size = 0;
  365.   vector descvec;
  367.   for (i = 0; i < vector_max (strvec); i++)
  368.     {
  369.       descvec = vector_slot (strvec, i);
  371.       if (vector_max (descvec) == 1)
  372. {
  373.   struct desc *desc = vector_slot (descvec, 0);
  375.   str = desc->cmd;
  376.   
  377.   if (str == NULL || CMD_OPTION (str))
  378.     return size;
  379.   else
  380.     size++;
  381. }
  382.       else
  383. size++;
  384.     }
  385.   return size;
  386. }
  388. /* Return prompt character of specified node. */
  389. char *
  390. cmd_prompt (enum node_type node)
  391. {
  392.   struct cmd_node *cnode;
  394.   cnode = vector_slot (cmdvec, node);
  395.   return cnode->prompt;
  396. }
  398. /* Install a command into a node. */
  399. void
  400. install_element (enum node_type ntype, struct cmd_element *cmd)
  401. {
  402.   struct cmd_node *cnode;
  404.   cnode = vector_slot (cmdvec, ntype);
  406.   if (cnode == NULL) 
  407.     {
  408.       fprintf (stderr, "Command node %d doesn't exist, please check itn",
  409.        ntype);
  410.       exit (1);
  411.     }
  413.   vector_set (cnode->cmd_vector, cmd);
  415.   cmd->strvec = cmd_make_descvec (cmd->string, cmd->doc);
  416.   cmd->cmdsize = cmd_cmdsize (cmd->strvec);
  417. }
  419. static unsigned char itoa64[] =
  420. "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  422. void
  423. to64(char *s, long v, int n)
  424. {
  425.   while (--n >= 0) 
  426.     {
  427.       *s++ = itoa64[v&0x3f];
  428.       v >>= 6;
  429.     }
  430. }
  432. char *zencrypt (char *passwd)
  433. {
  434.   char salt[6];
  435.   struct timeval tv;
  436.   char *crypt (const char *, const char *);
  438.   gettimeofday(&tv,0);
  439.   
  440.   to64(&salt[0], random(), 3);
  441.   to64(&salt[3], tv.tv_usec, 3);
  442.   salt[5] = '';
  444.   return crypt (passwd, salt);
  445. }
  447. char *
  448. syslog_facility_print (int facility)
  449. {
  450.   switch (facility)
  451.     {
  452.       case LOG_KERN:
  453. return "kern";
  454. break;
  455.       case LOG_USER:
  456. return "user";
  457. break;
  458.       case LOG_MAIL:
  459. return "mail";
  460. break;
  461.       case LOG_DAEMON:
  462. return "daemon";
  463. break;
  464.       case LOG_AUTH:
  465. return "auth";
  466. break;
  467.       case LOG_SYSLOG:
  468. return "syslog";
  469. break;
  470.       case LOG_LPR:
  471. return "lpr";
  472. break;
  473.       case LOG_NEWS:
  474. return "news";
  475. break;
  476.       case LOG_UUCP:
  477. return "uucp";
  478. break;
  479.       case LOG_CRON:
  480. return "cron";
  481. break;
  482.       case LOG_LOCAL0:
  483. return "local0";
  484. break;
  485.       case LOG_LOCAL1:
  486. return "local1";
  487. break;
  488.       case LOG_LOCAL2:
  489. return "local2";
  490. break;
  491.       case LOG_LOCAL3:
  492. return "local3";
  493. break;
  494.       case LOG_LOCAL4:
  495. return "local4";
  496. break;
  497.       case LOG_LOCAL5:
  498. return "local5";
  499. break;
  500.       case LOG_LOCAL6:
  501. return "local6";
  502. break;
  503.       case LOG_LOCAL7:
  504. return "local7";
  505. break;
  506.       default:
  507. break;
  508.     }
  509.   return "";
  510. }
  512. /* This function write configuration of this host. */
  513. int
  514. config_write_host (struct vty *vty)
  515. {
  516.   if (host.name)
  517.     vty_out (vty, "hostname %s%s", host.name, VTY_NEWLINE);
  519.   if (host.encrypt)
  520.     {
  521.       if (host.password_encrypt)
  522.         vty_out (vty, "password 8 %s%s", host.password_encrypt, VTY_NEWLINE); 
  523.       if (host.enable_encrypt)
  524.         vty_out (vty, "enable password 8 %s%s", host.enable_encrypt, VTY_NEWLINE); 
  525.     }
  526.   else
  527.     {
  528.       if (host.password)
  529.         vty_out (vty, "password %s%s", host.password, VTY_NEWLINE);
  530.       else if (host.password_encrypt)
  531.         vty_out (vty, "password 8 %s%s", host.password_encrypt, VTY_NEWLINE); 
  533.       if (host.enable)
  534.         vty_out (vty, "enable password %s%s", host.enable, VTY_NEWLINE);
  535.       else if (host.enable_encrypt)
  536.         vty_out (vty, "enable password 8 %s%s", host.enable_encrypt, VTY_NEWLINE); 
  537.     }
  539.   if (host.logfile)
  540.     vty_out (vty, "log file %s%s", host.logfile, VTY_NEWLINE);
  542.   if (host.log_stdout)
  543.     vty_out (vty, "log stdout%s", VTY_NEWLINE);
  545.   if (host.log_syslog)
  546.     {
  547.       vty_out (vty, "log syslog");
  548.       if (zlog_default->facility != LOG_DAEMON)
  549. vty_out (vty, " facility %s", syslog_facility_print (zlog_default->facility));
  550.       vty_out (vty, "%s", VTY_NEWLINE);
  551.     }
  552.   if (zlog_default->maskpri != LOG_DEBUG)
  553.     vty_out (vty, "log trap %s%s", zlog_priority[zlog_default->maskpri], VTY_NEWLINE);
  555.   if (zlog_default->record_priority == 1)
  556.     vty_out (vty, "log record-priority%s", VTY_NEWLINE);
  558.   if (host.advanced)
  559.     vty_out (vty, "service advanced-vty%s", VTY_NEWLINE);
  561.   if (host.encrypt)
  562.     vty_out (vty, "service password-encryption%s", VTY_NEWLINE);
  564.   if (host.lines >= 0)
  565.     vty_out (vty, "service terminal-length %d%s", host.lines,
  566.      VTY_NEWLINE);
  568.   if (! host.motd)
  569.     vty_out (vty, "no banner motd%s", VTY_NEWLINE);
  571.   return 1;
  572. }
  574. /* Utility function for getting command vector. */
  575. vector
  576. cmd_node_vector (vector v, enum node_type ntype)
  577. {
  578.   struct cmd_node *cnode = vector_slot (v, ntype);
  579.   return cnode->cmd_vector;
  580. }
  582. /* Filter command vector by symbol */
  583. int
  584. cmd_filter_by_symbol (char *command, char *symbol)
  585. {
  586.   int i, lim;
  588.   if (strcmp (symbol, "IPV4_ADDRESS") == 0)
  589.     {
  590.       i = 0;
  591.       lim = strlen (command);
  592.       while (i < lim)
  593. {
  594.   if (! (isdigit ((int) command[i]) || command[i] == '.' || command[i] == '/'))
  595.     return 1;
  596.   i++;
  597. }
  598.       return 0;
  599.     }
  600.   if (strcmp (symbol, "STRING") == 0)
  601.     {
  602.       i = 0;
  603.       lim = strlen (command);
  604.       while (i < lim)
  605. {
  606.   if (! (isalpha ((int) command[i]) || command[i] == '_' || command[i] == '-'))
  607.     return 1;
  608.   i++;
  609. }
  610.       return 0;
  611.     }
  612.   if (strcmp (symbol, "IFNAME") == 0)
  613.     {
  614.       i = 0;
  615.       lim = strlen (command);
  616.       while (i < lim)
  617. {
  618.   if (! isalnum ((int) command[i]))
  619.     return 1;
  620.   i++;
  621. }
  622.       return 0;
  623.     }
  624.   return 0;
  625. }
  627. /* Completion match types. */
  628. enum match_type 
  629. {
  630.   no_match,
  631.   extend_match,
  632.   ipv4_prefix_match,
  633.   ipv4_match,
  634.   ipv6_prefix_match,
  635.   ipv6_match,
  636.   range_match,
  637.   vararg_match,
  638.   partly_match,
  639.   exact_match 
  640. };
  642. enum match_type
  643. cmd_ipv4_match (char *str)
  644. {
  645.   char *sp;
  646.   int dots = 0, nums = 0;
  647.   char buf[4];
  649.   if (str == NULL)
  650.     return partly_match;
  652.   for (;;)
  653.     {
  654.       memset (buf, 0, sizeof (buf));
  655.       sp = str;
  656.       while (*str != '')
  657. {
  658.   if (*str == '.')
  659.     {
  660.       if (dots >= 3)
  661. return no_match;
  663.       if (*(str + 1) == '.')
  664. return no_match;
  666.       if (*(str + 1) == '')
  667. return partly_match;
  669.       dots++;
  670.       break;
  671.     }
  672.   if (!isdigit ((int) *str))
  673.     return no_match;
  675.   str++;
  676. }
  678.       if (str - sp > 3)
  679. return no_match;
  681.       strncpy (buf, sp, str - sp);
  682.       if (atoi (buf) > 255)
  683. return no_match;
  685.       nums++;
  687.       if (*str == '')
  688. break;
  690.       str++;
  691.     }
  693.   if (nums < 4)
  694.     return partly_match;
  696.   return exact_match;
  697. }
  699. enum match_type
  700. cmd_ipv4_prefix_match (char *str)
  701. {
  702.   char *sp;
  703.   int dots = 0;
  704.   char buf[4];
  706.   if (str == NULL)
  707.     return partly_match;
  709.   for (;;)
  710.     {
  711.       memset (buf, 0, sizeof (buf));
  712.       sp = str;
  713.       while (*str != '' && *str != '/')
  714. {
  715.   if (*str == '.')
  716.     {
  717.       if (dots == 3)
  718. return no_match;
  720.       if (*(str + 1) == '.' || *(str + 1) == '/')
  721. return no_match;
  723.       if (*(str + 1) == '')
  724. return partly_match;
  726.       dots++;
  727.       break;
  728.     }
  730.   if (!isdigit ((int) *str))
  731.     return no_match;
  733.   str++;
  734. }
  736.       if (str - sp > 3)
  737. return no_match;
  739.       strncpy (buf, sp, str - sp);
  740.       if (atoi (buf) > 255)
  741. return no_match;
  743.       if (dots == 3)
  744. {
  745.   if (*str == '/')
  746.     {
  747.       if (*(str + 1) == '')
  748. return partly_match;
  750.       str++;
  751.       break;
  752.     }
  753.   else if (*str == '')
  754.     return partly_match;
  755. }
  757.       if (*str == '')
  758. return partly_match;
  760.       str++;
  761.     }
  763.   sp = str;
  764.   while (*str != '')
  765.     {
  766.       if (!isdigit ((int) *str))
  767. return no_match;
  769.       str++;
  770.     }
  772.   if (atoi (sp) > 32)
  773.     return no_match;
  775.   return exact_match;
  776. }
  778. #define IPV6_ADDR_STR "0123456789abcdefABCDEF:.%"
  779. #define IPV6_PREFIX_STR "0123456789abcdefABCDEF:.%/"
  780. #define STATE_START 1
  781. #define STATE_COLON 2
  782. #define STATE_DOUBLE 3
  783. #define STATE_ADDR 4
  784. #define STATE_DOT               5
  785. #define STATE_SLASH 6
  786. #define STATE_MASK 7
  788. enum match_type
  789. cmd_ipv6_match (char *str)
  790. {
  791.   int state = STATE_START;
  792.   int colons = 0, nums = 0, double_colon = 0;
  793.   char *sp = NULL;
  795.   if (str == NULL)
  796.     return partly_match;
  798.   if (strspn (str, IPV6_ADDR_STR) != strlen (str))
  799.     return no_match;
  801.   while (*str != '')
  802.     {
  803.       switch (state)
  804. {
  805. case STATE_START:
  806.   if (*str == ':')
  807.     {
  808.       if (*(str + 1) != ':' && *(str + 1) != '')
  809. return no_match;
  810.             colons--;
  811.       state = STATE_COLON;
  812.     }
  813.   else
  814.     {
  815.       sp = str;
  816.       state = STATE_ADDR;
  817.     }
  819.   continue;
  820. case STATE_COLON:
  821.   colons++;
  822.   if (*(str + 1) == ':')
  823.     state = STATE_DOUBLE;
  824.   else
  825.     {
  826.       sp = str + 1;
  827.       state = STATE_ADDR;
  828.     }
  829.   break;
  830. case STATE_DOUBLE:
  831.   if (double_colon)
  832.     return no_match;
  834.   if (*(str + 1) == ':')
  835.     return no_match;
  836.   else
  837.     {
  838.       if (*(str + 1) != '')
  839. colons++;
  840.       sp = str + 1;
  841.       state = STATE_ADDR;
  842.     }
  844.   double_colon++;
  845.   nums++;
  846.   break;
  847. case STATE_ADDR:
  848.   if (*(str + 1) == ':' || *(str + 1) == '')
  849.     {
  850.       if (str - sp > 3)
  851. return no_match;
  853.       nums++;
  854.       state = STATE_COLON;
  855.     }
  856.   if (*(str + 1) == '.')
  857.     state = STATE_DOT;
  858.   break;
  859. case STATE_DOT:
  860.   state = STATE_ADDR;
  861.   break;
  862. default:
  863.   break;
  864. }
  866.       if (nums > 8)
  867. return no_match;
  869.       if (colons > 7)
  870. return no_match;
  872.       str++;
  873.     }
  875. #if 0
  876.   if (nums < 11)
  877.     return partly_match;
  878. #endif /* 0 */
  880.   return exact_match;
  881. }
  883. enum match_type
  884. cmd_ipv6_prefix_match (char *str)
  885. {
  886.   int state = STATE_START;
  887.   int colons = 0, nums = 0, double_colon = 0;
  888.   int mask;
  889.   char *sp = NULL;
  890.   char *endptr = NULL;
  892.   if (str == NULL)
  893.     return partly_match;
  895.   if (strspn (str, IPV6_PREFIX_STR) != strlen (str))
  896.     return no_match;
  898.   while (*str != '' && state != STATE_MASK)
  899.     {
  900.       switch (state)
  901. {
  902. case STATE_START:
  903.   if (*str == ':')
  904.     {
  905.       if (*(str + 1) != ':' && *(str + 1) != '')
  906. return no_match;
  907.       colons--;
  908.       state = STATE_COLON;
  909.     }
  910.   else
  911.     {
  912.       sp = str;
  913.       state = STATE_ADDR;
  914.     }
  916.   continue;
  917. case STATE_COLON:
  918.   colons++;
  919.   if (*(str + 1) == '/')
  920.     return no_match;
  921.   else if (*(str + 1) == ':')
  922.     state = STATE_DOUBLE;
  923.   else
  924.     {
  925.       sp = str + 1;
  926.       state = STATE_ADDR;
  927.     }
  928.   break;
  929. case STATE_DOUBLE:
  930.   if (double_colon)
  931.     return no_match;
  933.   if (*(str + 1) == ':')
  934.     return no_match;
  935.   else
  936.     {
  937.       if (*(str + 1) != '' && *(str + 1) != '/')
  938. colons++;
  939.       sp = str + 1;
  941.       if (*(str + 1) == '/')
  942. state = STATE_SLASH;
  943.       else
  944. state = STATE_ADDR;
  945.     }
  947.   double_colon++;
  948.   nums += 1;
  949.   break;
  950. case STATE_ADDR:
  951.   if (*(str + 1) == ':' || *(str + 1) == '.'
  952.       || *(str + 1) == '' || *(str + 1) == '/')
  953.     {
  954.       if (str - sp > 3)
  955. return no_match;
  957.       for (; sp <= str; sp++)
  958. if (*sp == '/')
  959.   return no_match;
  961.       nums++;
  963.       if (*(str + 1) == ':')
  964. state = STATE_COLON;
  965.       else if (*(str + 1) == '.')
  966. state = STATE_DOT;
  967.       else if (*(str + 1) == '/')
  968. state = STATE_SLASH;
  969.     }
  970.   break;
  971. case STATE_DOT:
  972.   state = STATE_ADDR;
  973.   break;
  974. case STATE_SLASH:
  975.   if (*(str + 1) == '')
  976.     return partly_match;
  978.   state = STATE_MASK;
  979.   break;
  980. default:
  981.   break;
  982. }
  984.       if (nums > 11)
  985. return no_match;
  987.       if (colons > 7)
  988. return no_match;
  990.       str++;
  991.     }
  993.   if (state < STATE_MASK)
  994.     return partly_match;
  996.   mask = strtol (str, &endptr, 10);
  997.   if (*endptr != '')
  998.     return no_match;
  1000.   if (mask < 0 || mask > 128)
  1001.     return no_match;
  1002.   
  1003. /* I don't know why mask < 13 makes command match partly.
  1004.    Forgive me to make this comments. I Want to set static default route
  1005.    because of lack of function to originate default in ospf6d; sorry
  1006.        yasu
  1007.   if (mask < 13)
  1008.     return partly_match;
  1009. */
  1011.   return exact_match;
  1012. }
  1014. #define DECIMAL_STRLEN_MAX 10
  1016. int
  1017. cmd_range_match (char *range, char *str)
  1018. {
  1019.   char *p;
  1020.   char buf[DECIMAL_STRLEN_MAX + 1];
  1021.   char *endptr = NULL;
  1022.   unsigned long min, max, val;
  1024.   if (str == NULL)
  1025.     return 1;
  1027.   val = strtoul (str, &endptr, 10);
  1028.   if (*endptr != '')
  1029.     return 0;
  1031.   range++;
  1032.   p = strchr (range, '-');
  1033.   if (p == NULL)
  1034.     return 0;
  1035.   if (p - range > DECIMAL_STRLEN_MAX)
  1036.     return 0;
  1037.   strncpy (buf, range, p - range);
  1038.   buf[p - range] = '';
  1039.   min = strtoul (buf, &endptr, 10);
  1040.   if (*endptr != '')
  1041.     return 0;
  1043.   range = p + 1;
  1044.   p = strchr (range, '>');
  1045.   if (p == NULL)
  1046.     return 0;
  1047.   if (p - range > DECIMAL_STRLEN_MAX)
  1048.     return 0;
  1049.   strncpy (buf, range, p - range);
  1050.   buf[p - range] = '';
  1051.   max = strtoul (buf, &endptr, 10);
  1052.   if (*endptr != '')
  1053.     return 0;
  1055.   if (val < min || val > max)
  1056.     return 0;
  1058.   return 1;
  1059. }
  1061. /* Make completion match and return match type flag. */
  1062. enum match_type
  1063. cmd_filter_by_completion (char *command, vector v, int index)
  1064. {
  1065.   int i;
  1066.   char *str;
  1067.   struct cmd_element *cmd_element;
  1068.   enum match_type match_type;
  1069.   vector descvec;
  1070.   struct desc *desc;
  1071.   
  1072.   match_type = no_match;
  1074.   /* If command and cmd_element string does not match set NULL to vector */
  1075.   for (i = 0; i < vector_max (v); i++) 
  1076.     if ((cmd_element = vector_slot (v, i)) != NULL)
  1077.       {
  1078. if (index >= vector_max (cmd_element->strvec))
  1079.   vector_slot (v, i) = NULL;
  1080. else
  1081.   {
  1082.     int j;
  1083.     int matched = 0;
  1085.     descvec = vector_slot (cmd_element->strvec, index);
  1086.     
  1087.     for (j = 0; j < vector_max (descvec); j++)
  1088.       {
  1089. desc = vector_slot (descvec, j);
  1090. str = desc->cmd;
  1092. if (CMD_VARARG (str))
  1093.   {
  1094.     if (match_type < vararg_match)
  1095.       match_type = vararg_match;
  1096.     matched++;
  1097.   }
  1098. else if (CMD_RANGE (str))
  1099.   {
  1100.     if (cmd_range_match (str, command))
  1101.       {
  1102. if (match_type < range_match)
  1103.   match_type = range_match;
  1105. matched++;
  1106.       }
  1107.   }
  1108. else if (CMD_IPV6 (str))
  1109.   {
  1110.     if (cmd_ipv6_match (command))
  1111.       {
  1112. if (match_type < ipv6_match)
  1113.   match_type = ipv6_match;
  1115. matched++;
  1116.       }
  1117.   }
  1118. else if (CMD_IPV6_PREFIX (str))
  1119.   {
  1120.     if (cmd_ipv6_prefix_match (command))
  1121.       {
  1122. if (match_type < ipv6_prefix_match)
  1123.   match_type = ipv6_prefix_match;
  1125. matched++;
  1126.       }
  1127.   }
  1128. else if (CMD_IPV4 (str))
  1129.   {
  1130.     if (cmd_ipv4_match (command))
  1131.       {
  1132. if (match_type < ipv4_match)
  1133.   match_type = ipv4_match;
  1135. matched++;
  1136.       }
  1137.   }
  1138. else if (CMD_IPV4_PREFIX (str))
  1139.   {
  1140.     if (cmd_ipv4_prefix_match (command))
  1141.       {
  1142. if (match_type < ipv4_prefix_match)
  1143.   match_type = ipv4_prefix_match;
  1144. matched++;
  1145.       }
  1146.   }
  1147. else
  1148. /* Check is this point's argument optional ? */
  1149. if (CMD_OPTION (str) || CMD_VARIABLE (str))
  1150.   {
  1151.     if (match_type < extend_match)
  1152.       match_type = extend_match;
  1153.     matched++;
  1154.   }
  1155. else if (strncmp (command, str, strlen (command)) == 0)
  1156.   {
  1157.     if (strcmp (command, str) == 0) 
  1158.       match_type = exact_match;
  1159.     else
  1160.       {
  1161. if (match_type < partly_match)
  1162.   match_type = partly_match;
  1163.       }
  1164.     matched++;
  1165.   }
  1166.       }
  1167.     if (! matched)
  1168.       vector_slot (v, i) = NULL;
  1169.   }
  1170.       }
  1171.   return match_type;
  1172. }
  1174. /* Filter vector by command character with index. */
  1175. enum match_type
  1176. cmd_filter_by_string (char *command, vector v, int index)
  1177. {
  1178.   int i;
  1179.   char *str;
  1180.   struct cmd_element *cmd_element;
  1181.   enum match_type match_type;
  1182.   vector descvec;
  1183.   struct desc *desc;
  1184.   
  1185.   match_type = no_match;
  1187.   /* If command and cmd_element string does not match set NULL to vector */
  1188.   for (i = 0; i < vector_max (v); i++) 
  1189.     if ((cmd_element = vector_slot (v, i)) != NULL)
  1190.       {
  1191. /* If given index is bigger than max string vector of command,
  1192.            set NULL*/
  1193. if (index >= vector_max (cmd_element->strvec))
  1194.   vector_slot (v, i) = NULL;
  1195. else 
  1196.   {
  1197.     int j;
  1198.     int matched = 0;
  1200.     descvec = vector_slot (cmd_element->strvec, index);
  1202.     for (j = 0; j < vector_max (descvec); j++)
  1203.       {
  1204. desc = vector_slot (descvec, j);
  1205. str = desc->cmd;
  1207. if (CMD_VARARG (str))
  1208.   {
  1209.     if (match_type < vararg_match)
  1210.       match_type = vararg_match;
  1211.     matched++;
  1212.   }
  1213. else if (CMD_RANGE (str))
  1214.   {
  1215.     if (cmd_range_match (str, command))
  1216.       {
  1217. if (match_type < range_match)
  1218.   match_type = range_match;
  1219. matched++;
  1220.       }
  1221.   }
  1222. else if (CMD_IPV6 (str))
  1223.   {
  1224.     if (cmd_ipv6_match (command) == exact_match)
  1225.       {
  1226. if (match_type < ipv6_match)
  1227.   match_type = ipv6_match;
  1228. matched++;
  1229.       }
  1230.   }
  1231. else if (CMD_IPV6_PREFIX (str))
  1232.   {
  1233.     if (cmd_ipv6_prefix_match (command) == exact_match)
  1234.       {
  1235. if (match_type < ipv6_prefix_match)
  1236.   match_type = ipv6_prefix_match;
  1237. matched++;
  1238.       }
  1239.   }
  1240. else if (CMD_IPV4 (str))
  1241.   {
  1242.     if (cmd_ipv4_match (command) == exact_match)
  1243.       {
  1244. if (match_type < ipv4_match)
  1245.   match_type = ipv4_match;
  1246. matched++;
  1247.       }
  1248.   }
  1249. else if (CMD_IPV4_PREFIX (str))
  1250.   {
  1251.     if (cmd_ipv4_prefix_match (command) == exact_match)
  1252.       {
  1253. if (match_type < ipv4_prefix_match)
  1254.   match_type = ipv4_prefix_match;
  1255. matched++;
  1256.       }
  1257.   }
  1258. else if (CMD_OPTION (str) || CMD_VARIABLE (str))
  1259.   {
  1260.     if (match_type < extend_match)
  1261.       match_type = extend_match;
  1262.     matched++;
  1263.   }
  1264. else
  1265.   {   
  1266.     if (strcmp (command, str) == 0)
  1267.       {
  1268. match_type = exact_match;
  1269. matched++;
  1270.       }
  1271.   }
  1272.       }
  1273.     if (! matched)
  1274.       vector_slot (v, i) = NULL;
  1275.   }
  1276.       }
  1277.   return match_type;
  1278. }
  1280. /* Check ambiguous match */
  1281. int
  1282. is_cmd_ambiguous (char *command, vector v, int index, enum match_type type)
  1283. {
  1284.   int i;
  1285.   int j;
  1286.   char *str = NULL;
  1287.   struct cmd_element *cmd_element;
  1288.   char *matched = NULL;
  1289.   vector descvec;
  1290.   struct desc *desc;
  1291.   
  1292.   for (i = 0; i < vector_max (v); i++) 
  1293.     if ((cmd_element = vector_slot (v, i)) != NULL)
  1294.       {
  1295. int match = 0;
  1297. descvec = vector_slot (cmd_element->strvec, index);
  1299. for (j = 0; j < vector_max (descvec); j++)
  1300.   {
  1301.     enum match_type ret;
  1303.     desc = vector_slot (descvec, j);
  1304.     str = desc->cmd;
  1306.     switch (type)
  1307.       {
  1308.       case exact_match:
  1309. if (! (CMD_OPTION (str) || CMD_VARIABLE (str))
  1310.     && strcmp (command, str) == 0)
  1311.   match++;
  1312. break;
  1313.       case partly_match:
  1314. if (! (CMD_OPTION (str) || CMD_VARIABLE (str))
  1315.     && strncmp (command, str, strlen (command)) == 0)
  1316.   {
  1317.     if (matched && strcmp (matched, str) != 0)
  1318.       return 1; /* There is ambiguous match. */
  1319.     else
  1320.       matched = str;
  1321.     match++;
  1322.   }
  1323. break;
  1324.       case range_match:
  1325. if (cmd_range_match (str, command))
  1326.   {
  1327.     if (matched && strcmp (matched, str) != 0)
  1328.       return 1;
  1329.     else
  1330.       matched = str;
  1331.     match++;
  1332.   }
  1333. break;
  1334.         case ipv6_match:
  1335. if (CMD_IPV6 (str))
  1336.   match++;
  1337. break;
  1338.       case ipv6_prefix_match:
  1339. if ((ret = cmd_ipv6_prefix_match (command)) != no_match)
  1340.   {
  1341.     if (ret == partly_match)
  1342.       return 2; /* There is incomplete match. */
  1344.     match++;
  1345.   }
  1346. break;
  1347.       case ipv4_match:
  1348. if (CMD_IPV4 (str))
  1349.   match++;
  1350. break;
  1351.       case ipv4_prefix_match:
  1352. if ((ret = cmd_ipv4_prefix_match (command)) != no_match)
  1353.   {
  1354.     if (ret == partly_match)
  1355.       return 2; /* There is incomplete match. */
  1357.     match++;
  1358.   }
  1359. break;
  1360.       case extend_match:
  1361. if (CMD_OPTION (str) || CMD_VARIABLE (str))
  1362.   match++;
  1363. break;
  1364.       case no_match:
  1365.       default:
  1366. break;
  1367.       }
  1368.   }
  1369. if (! match)
  1370.   vector_slot (v, i) = NULL;
  1371.       }
  1372.   return 0;
  1373. }
  1375. /* If src matches dst return dst string, otherwise return NULL */
  1376. char *
  1377. cmd_entry_function (char *src, char *dst)
  1378. {
  1379.   /* Skip variable arguments. */
  1380.   if (CMD_OPTION (dst) || CMD_VARIABLE (dst) || CMD_VARARG (dst) ||
  1381.       CMD_IPV4 (dst) || CMD_IPV4_PREFIX (dst) || CMD_RANGE (dst))
  1382.     return NULL;
  1384.   /* In case of 'command t', given src is NULL string. */
  1385.   if (src == NULL)
  1386.     return dst;
  1388.   /* Matched with input string. */
  1389.   if (strncmp (src, dst, strlen (src)) == 0)
  1390.     return dst;
  1392.   return NULL;
  1393. }
  1395. /* If src matches dst return dst string, otherwise return NULL */
  1396. /* This version will return the dst string always if it is
  1397.    CMD_VARIABLE for '?' key processing */
  1398. char *
  1399. cmd_entry_function_desc (char *src, char *dst)
  1400. {
  1401.   if (CMD_VARARG (dst))
  1402.     return dst;
  1404.   if (CMD_RANGE (dst))
  1405.     {
  1406.       if (cmd_range_match (dst, src))
  1407. return dst;
  1408.       else
  1409. return NULL;
  1410.     }
  1412.   if (CMD_IPV6 (dst))
  1413.     {
  1414.       if (cmd_ipv6_match (src))
  1415. return dst;
  1416.       else
  1417. return NULL;
  1418.     }
  1420.   if (CMD_IPV6_PREFIX (dst))
  1421.     {
  1422.       if (cmd_ipv6_prefix_match (src))
  1423. return dst;
  1424.       else
  1425. return NULL;
  1426.     }
  1428.   if (CMD_IPV4 (dst))
  1429.     {
  1430.       if (cmd_ipv4_match (src))
  1431. return dst;
  1432.       else
  1433. return NULL;
  1434.     }
  1436.   if (CMD_IPV4_PREFIX (dst))
  1437.     {
  1438.       if (cmd_ipv4_prefix_match (src))
  1439. return dst;
  1440.       else
  1441. return NULL;
  1442.     }
  1444.   /* Optional or variable commands always match on '?' */
  1445.   if (CMD_OPTION (dst) || CMD_VARIABLE (dst))
  1446.     return dst;
  1448.   /* In case of 'command t', given src is NULL string. */
  1449.   if (src == NULL)
  1450.     return dst;
  1452.   if (strncmp (src, dst, strlen (src)) == 0)
  1453.     return dst;
  1454.   else
  1455.     return NULL;
  1456. }
  1458. /* Check same string element existence.  If it isn't there return
  1459.     1. */
  1460. int
  1461. cmd_unique_string (vector v, char *str)
  1462. {
  1463.   int i;
  1464.   char *match;
  1466.   for (i = 0; i < vector_max (v); i++)
  1467.     if ((match = vector_slot (v, i)) != NULL)
  1468.       if (strcmp (match, str) == 0)
  1469. return 0;
  1470.   return 1;
  1471. }
  1473. /* Compare string to description vector.  If there is same string
  1474.    return 1 else return 0. */
  1475. int
  1476. desc_unique_string (vector v, char *str)
  1477. {
  1478.   int i;
  1479.   struct desc *desc;
  1481.   for (i = 0; i < vector_max (v); i++)
  1482.     if ((desc = vector_slot (v, i)) != NULL)
  1483.       if (strcmp (desc->cmd, str) == 0)
  1484. return 1;
  1485.   return 0;
  1486. }
  1488. /* '?' describe command support. */
  1489. vector
  1490. cmd_describe_command (vector vline, struct vty *vty, int *status)
  1491. {
  1492.   int i;
  1493.   vector cmd_vector;
  1494. #define INIT_MATCHVEC_SIZE 10
  1495.   vector matchvec;
  1496.   struct cmd_element *cmd_element;
  1497.   int index;
  1498.   int ret;
  1499.   enum match_type match;
  1500.   char *command;
  1501.   static struct desc desc_cr = { "<cr>", "" };
  1503.   /* Set index. */
  1504.   index = vector_max (vline) - 1;
  1506.   /* Make copy vector of current node's command vector. */
  1507.   cmd_vector = vector_copy (cmd_node_vector (cmdvec, vty->node));
  1509.   /* Prepare match vector */
  1510.   matchvec = vector_init (INIT_MATCHVEC_SIZE);
  1512.   /* Filter commands. */
  1513.   /* Only words precedes current word will be checked in this loop. */
  1514.   for (i = 0; i < index; i++)
  1515.     {
  1516.       command = vector_slot (vline, i);
  1517.       match = cmd_filter_by_completion (command, cmd_vector, i);
  1519.       if (match == vararg_match)
  1520. {
  1521.   struct cmd_element *cmd_element;
  1522.   vector descvec;
  1523.   int j, k;
  1525.   for (j = 0; j < vector_max (cmd_vector); j++)
  1526.     if ((cmd_element = vector_slot (cmd_vector, j)) != NULL)
  1527.       {
  1528. descvec = vector_slot (cmd_element->strvec,
  1529.        vector_max (cmd_element->strvec) - 1);
  1530. for (k = 0; k < vector_max (descvec); k++)
  1531.   {
  1532.     struct desc *desc = vector_slot (descvec, k);
  1533.     vector_set (matchvec, desc);
  1534.   }
  1535.       }
  1537.   vector_set (matchvec, &desc_cr);
  1538.   vector_free (cmd_vector);
  1540.   return matchvec;
  1541. }
  1543.       if ((ret = is_cmd_ambiguous (command, cmd_vector, i, match)) == 1)
  1544. {
  1545.   vector_free (cmd_vector);
  1546.   *status = CMD_ERR_AMBIGUOUS;
  1547.   return NULL;
  1548. }
  1549.       else if (ret == 2)
  1550. {
  1551.   vector_free (cmd_vector);
  1552.   *status = CMD_ERR_NO_MATCH;
  1553.   return NULL;
  1554. }
  1555.     }
  1557.   /* Prepare match vector */
  1558.   /*  matchvec = vector_init (INIT_MATCHVEC_SIZE); */
  1560.   /* Make sure that cmd_vector is filtered based on current word */
  1561.   command = vector_slot (vline, index);
  1562.   if (command)
  1563.     match = cmd_filter_by_completion (command, cmd_vector, index);
  1565.   /* Make description vector. */
  1566.   for (i = 0; i < vector_max (cmd_vector); i++)
  1567.     if ((cmd_element = vector_slot (cmd_vector, i)) != NULL)
  1568.       {
  1569. char *string = NULL;
  1570. vector strvec = cmd_element->strvec;
  1572.         /* if command is NULL, index may be equal to vector_max */
  1573. if (command && index >= vector_max (strvec))
  1574.   vector_slot (cmd_vector, i) = NULL;
  1575. else
  1576.   {
  1577.     /* Check if command is completed. */
  1578.             if (command == NULL && index == vector_max (strvec))
  1579.       {
  1580. string = "<cr>";
  1581. if (! desc_unique_string (matchvec, string))
  1582.   vector_set (matchvec, &desc_cr);
  1583.       }
  1584.     else
  1585.       {
  1586. int j;
  1587. vector descvec = vector_slot (strvec, index);
  1588. struct desc *desc;
  1590. for (j = 0; j < vector_max (descvec); j++)
  1591.   {
  1592.     desc = vector_slot (descvec, j);
  1593.     string = cmd_entry_function_desc (command, desc->cmd);
  1594.     if (string)
  1595.       {
  1596. /* Uniqueness check */
  1597. if (! desc_unique_string (matchvec, string))
  1598.   vector_set (matchvec, desc);
  1599.       }
  1600.   }
  1601.       }
  1602.   }
  1603.       }
  1604.   vector_free (cmd_vector);
  1606.   if (vector_slot (matchvec, 0) == NULL)
  1607.     {
  1608.       vector_free (matchvec);
  1609.       *status= CMD_ERR_NO_MATCH;
  1610.     }
  1611.   else
  1612.     *status = CMD_SUCCESS;
  1614.   return matchvec;
  1615. }
  1617. /* Check LCD of matched command. */
  1618. int
  1619. cmd_lcd (char **matched)
  1620. {
  1621.   int i;
  1622.   int j;
  1623.   int lcd = -1;
  1624.   char *s1, *s2;
  1625.   char c1, c2;
  1627.   if (matched[0] == NULL || matched[1] == NULL)
  1628.     return 0;
  1630.   for (i = 1; matched[i] != NULL; i++)
  1631.     {
  1632.       s1 = matched[i - 1];
  1633.       s2 = matched[i];
  1635.       for (j = 0; (c1 = s1[j]) && (c2 = s2[j]); j++)
  1636. if (c1 != c2)
  1637.   break;
  1639.       if (lcd < 0)
  1640. lcd = j;
  1641.       else
  1642. {
  1643.   if (lcd > j)
  1644.     lcd = j;
  1645. }
  1646.     }
  1647.   return lcd;
  1648. }
  1650. /* Command line completion support. */
  1651. char **
  1652. cmd_complete_command (vector vline, struct vty *vty, int *status)
  1653. {
  1654.   int i;
  1655.   vector cmd_vector = vector_copy (cmd_node_vector (cmdvec, vty->node));
  1656. #define INIT_MATCHVEC_SIZE 10
  1657.   vector matchvec;
  1658.   struct cmd_element *cmd_element;
  1659.   int index = vector_max (vline) - 1;
  1660.   char **match_str;
  1661.   struct desc *desc;
  1662.   vector descvec;
  1663.   char *command;
  1664.   int lcd;
  1666.   /* First, filter by preceeding command string */
  1667.   for (i = 0; i < index; i++)
  1668.     {
  1669.       enum match_type match;
  1670.       int ret;
  1672.       command = vector_slot (vline, i);
  1674.       /* First try completion match, if there is exactly match return 1 */
  1675.       match = cmd_filter_by_completion (command, cmd_vector, i);
  1677.       /* If there is exact match then filter ambiguous match else check
  1678.  ambiguousness. */
  1679.       if ((ret = is_cmd_ambiguous (command, cmd_vector, i, match)) == 1)
  1680. {
  1681.   vector_free (cmd_vector);
  1682.   *status = CMD_ERR_AMBIGUOUS;
  1683.   return NULL;
  1684. }
  1685.       /*
  1686. else if (ret == 2)
  1687. {
  1688.   vector_free (cmd_vector);
  1689.   *status = CMD_ERR_NO_MATCH;
  1690.   return NULL;
  1691. }
  1692.       */
  1693.     }
  1695.   /* Prepare match vector. */
  1696.   matchvec = vector_init (INIT_MATCHVEC_SIZE);
  1698.   /* Now we got into completion */
  1699.   for (i = 0; i < vector_max (cmd_vector); i++)
  1700.     if ((cmd_element = vector_slot (cmd_vector, i)) != NULL)
  1701.       {
  1702. char *string;
  1703. vector strvec = cmd_element->strvec;
  1705. /* Check field length */
  1706. if (index >= vector_max (strvec))
  1707.   vector_slot (cmd_vector, i) = NULL;
  1708. else 
  1709.   {
  1710.     int j;
  1712.     descvec = vector_slot (strvec, index);
  1713.     for (j = 0; j < vector_max (descvec); j++)
  1714.       {
  1715. desc = vector_slot (descvec, j);
  1717. if ((string = cmd_entry_function (vector_slot (vline, index),
  1718.   desc->cmd)))
  1719.   if (cmd_unique_string (matchvec, string))
  1720.     vector_set (matchvec, XSTRDUP (MTYPE_TMP, string));
  1721.       }
  1722.   }
  1723.       }
  1725.   /* We don't need cmd_vector any more. */
  1726.   vector_free (cmd_vector);
  1728.   /* No matched command */
  1729.   if (vector_slot (matchvec, 0) == NULL)
  1730.     {
  1731.       vector_free (matchvec);
  1733.       /* In case of 'command t' pattern.  Do you need '?' command at
  1734.          the end of the line. */
  1735.       if (vector_slot (vline, index) == '')
  1736. *status = CMD_ERR_NOTHING_TODO;
  1737.       else
  1738. *status = CMD_ERR_NO_MATCH;
  1739.       return NULL;
  1740.     }
  1742.   /* Only one matched */
  1743.   if (vector_slot (matchvec, 1) == NULL)
  1744.     {
  1745.       match_str = (char **) matchvec->index;
  1746.       vector_only_wrapper_free (matchvec);
  1747.       *status = CMD_COMPLETE_FULL_MATCH;
  1748.       return match_str;
  1749.     }
  1750.   /* Make it sure last element is NULL. */
  1751.   vector_set (matchvec, NULL);
  1753.   /* Check LCD of matched strings. */
  1754.   if (vector_slot (vline, index) != NULL)
  1755.     {
  1756.       lcd = cmd_lcd ((char **) matchvec->index);
  1758.       if (lcd)
  1759. {
  1760.   int len = strlen (vector_slot (vline, index));
  1761.   
  1762.   if (len < lcd)
  1763.     {
  1764.       char *lcdstr;
  1765.       
  1766.       lcdstr = XMALLOC (MTYPE_TMP, lcd + 1);
  1767.       memcpy (lcdstr, matchvec->index[0], lcd);
  1768.       lcdstr[lcd] = '';
  1770.       /* match_str = (char **) &lcdstr; */
  1772.       /* Free matchvec. */
  1773.       for (i = 0; i < vector_max (matchvec); i++)
  1774. {
  1775.   if (vector_slot (matchvec, i))
  1776.     XFREE (MTYPE_TMP, vector_slot (matchvec, i));
  1777. }
  1778.       vector_free (matchvec);
  1780.              /* Make new matchvec. */
  1781.       matchvec = vector_init (INIT_MATCHVEC_SIZE);
  1782.       vector_set (matchvec, lcdstr);
  1783.       match_str = (char **) matchvec->index;
  1784.       vector_only_wrapper_free (matchvec);
  1786.       *status = CMD_COMPLETE_MATCH;
  1787.       return match_str;
  1788.     }
  1789. }
  1790.     }
  1792.   match_str = (char **) matchvec->index;
  1793.   vector_only_wrapper_free (matchvec);
  1794.   *status = CMD_COMPLETE_LIST_MATCH;
  1795.   return match_str;
  1796. }
  1798. /* Execute command by argument vline vector. */
  1799. int
  1800. cmd_execute_command (vector vline, struct vty *vty, struct cmd_element **cmd)
  1801. {
  1802.   int i;
  1803.   int index;
  1804.   vector cmd_vector;
  1805.   struct cmd_element *cmd_element;
  1806.   struct cmd_element *matched_element;
  1807.   unsigned int matched_count, incomplete_count;
  1808.   int argc;
  1809.   char *argv[CMD_ARGC_MAX];
  1810.   enum match_type match = 0;
  1811.   int varflag;
  1812.   char *command;
  1814.   /* Make copy of command elements. */
  1815.   cmd_vector = vector_copy (cmd_node_vector (cmdvec, vty->node));
  1817.   for (index = 0; index < vector_max (vline); index++) 
  1818.     {
  1819.       int ret;
  1821.       command = vector_slot (vline, index);
  1823.       match = cmd_filter_by_completion (command, cmd_vector, index);
  1825.       if (match == vararg_match)
  1826. break;
  1828.       ret = is_cmd_ambiguous (command, cmd_vector, index, match);
  1830.       if (ret == 1)
  1831. {
  1832.   vector_free (cmd_vector);
  1833.   return CMD_ERR_AMBIGUOUS;
  1834. }
  1835.       else if (ret == 2)
  1836. {
  1837.   vector_free (cmd_vector);
  1838.   return CMD_ERR_NO_MATCH;
  1839. }
  1840.     }
  1842.   /* Check matched count. */
  1843.   matched_element = NULL;
  1844.   matched_count = 0;
  1845.   incomplete_count = 0;
  1847.   for (i = 0; i < vector_max (cmd_vector); i++) 
  1848.     if (vector_slot (cmd_vector,i) != NULL)
  1849.       {
  1850. cmd_element = vector_slot (cmd_vector,i);
  1852. if (match == vararg_match || index >= cmd_element->cmdsize)
  1853.   {
  1854.     matched_element = cmd_element;
  1855. #if 0
  1856.     printf ("DEBUG: %sn", cmd_element->string);
  1857. #endif
  1858.     matched_count++;
  1859.   }
  1860. else
  1861.   {
  1862.     incomplete_count++;
  1863.   }
  1864.       }
  1865.   
  1866.   /* Finish of using cmd_vector. */
  1867.   vector_free (cmd_vector);
  1869.   /* To execute command, matched_count must be 1.*/
  1870.   if (matched_count == 0) 
  1871.     {
  1872.       if (incomplete_count)
  1873. return CMD_ERR_INCOMPLETE;
  1874.       else
  1875. return CMD_ERR_NO_MATCH;
  1876.     }
  1878.   if (matched_count > 1) 
  1879.     return CMD_ERR_AMBIGUOUS;
  1881.   /* Argument treatment */
  1882.   varflag = 0;
  1883.   argc = 0;
  1885.   for (i = 0; i < vector_max (vline); i++)
  1886.     {
  1887.       if (varflag)
  1888. argv[argc++] = vector_slot (vline, i);
  1889.       else
  1890. {   
  1891.   vector descvec = vector_slot (matched_element->strvec, i);
  1893.   if (vector_max (descvec) == 1)
  1894.     {
  1895.       struct desc *desc = vector_slot (descvec, 0);
  1896.       char *str = desc->cmd;
  1898.       if (CMD_VARARG (str))
  1899. varflag = 1;
  1901.       if (varflag || CMD_VARIABLE (str) || CMD_OPTION (str))
  1902. argv[argc++] = vector_slot (vline, i);
  1903.     }
  1904.   else
  1905.     argv[argc++] = vector_slot (vline, i);
  1906. }
  1908.       if (argc >= CMD_ARGC_MAX)
  1909. return CMD_ERR_EXEED_ARGC_MAX;
  1910.     }
  1912.   /* For vtysh execution. */
  1913.   if (cmd)
  1914.     *cmd = matched_element;
  1916.   if (matched_element->daemon)
  1917.     return CMD_SUCCESS_DAEMON;
  1919.   /* Execute matched command. */
  1920.   return (*matched_element->func) (matched_element, vty, argc, argv);
  1921. }
  1923. /* Execute command by argument readline. */
  1924. int
  1925. cmd_execute_command_strict (vector vline, struct vty *vty, 
  1926.     struct cmd_element **cmd)
  1927. {
  1928.   int i;
  1929.   int index;
  1930.   vector cmd_vector;
  1931.   struct cmd_element *cmd_element;
  1932.   struct cmd_element *matched_element;
  1933.   unsigned int matched_count, incomplete_count;
  1934.   int argc;
  1935.   char *argv[CMD_ARGC_MAX];
  1936.   int varflag;
  1937.   enum match_type match = 0;
  1938.   char *command;
  1940.   /* Make copy of command element */
  1941.   cmd_vector = vector_copy (cmd_node_vector (cmdvec, vty->node));
  1943.   for (index = 0; index < vector_max (vline); index++) 
  1944.     {
  1945.       int ret;
  1947.       command = vector_slot (vline, index);
  1949.       match = cmd_filter_by_string (vector_slot (vline, index), 
  1950.     cmd_vector, index);
  1952.       /* If command meets '.VARARG' then finish matching. */
  1953.       if (match == vararg_match)
  1954. break;
  1956.       ret = is_cmd_ambiguous (command, cmd_vector, index, match);
  1957.       if (ret == 1)
  1958. {
  1959.   vector_free (cmd_vector);
  1960.   return CMD_ERR_AMBIGUOUS;
  1961. }
  1962.       if (ret == 2)
  1963. {
  1964.   vector_free (cmd_vector);
  1965.   return CMD_ERR_NO_MATCH;
  1966. }
  1967.     }
  1969.   /* Check matched count. */
  1970.   matched_element = NULL;
  1971.   matched_count = 0;
  1972.   incomplete_count = 0;
  1973.   for (i = 0; i < vector_max (cmd_vector); i++) 
  1974.     if (vector_slot (cmd_vector,i) != NULL)
  1975.       {
  1976. cmd_element = vector_slot (cmd_vector,i);
  1978. if (match == vararg_match || index >= cmd_element->cmdsize)
  1979.   {
  1980.     matched_element = cmd_element;
  1981.     matched_count++;
  1982.   }
  1983. else
  1984.   incomplete_count++;
  1985.       }
  1986.   
  1987.   /* Finish of using cmd_vector. */
  1988.   vector_free (cmd_vector);
  1990.   /* To execute command, matched_count must be 1.*/
  1991.   if (matched_count == 0) 
  1992.     {
  1993.       if (incomplete_count)
  1994. return CMD_ERR_INCOMPLETE;
  1995.       else
  1996. return CMD_ERR_NO_MATCH;
  1997.     }
  1999.   if (matched_count > 1) 
  2000.     return CMD_ERR_AMBIGUOUS;
  2002.   /* Argument treatment */
  2003.   varflag = 0;
  2004.   argc = 0;
  2006.   for (i = 0; i < vector_max (vline); i++)
  2007.     {
  2008.       if (varflag)
  2009. argv[argc++] = vector_slot (vline, i);
  2010.       else
  2011. {   
  2012.   vector descvec = vector_slot (matched_element->strvec, i);
  2014.   if (vector_max (descvec) == 1)
  2015.     {
  2016.       struct desc *desc = vector_slot (descvec, 0);
  2017.       char *str = desc->cmd;
  2019.       if (CMD_VARARG (str))
  2020. varflag = 1;
  2021.   
  2022.       if (varflag || CMD_VARIABLE (str) || CMD_OPTION (str))
  2023. argv[argc++] = vector_slot (vline, i);
  2024.     }
  2025.   else
  2026.     argv[argc++] = vector_slot (vline, i);
  2027. }
  2029.       if (argc >= CMD_ARGC_MAX)
  2030. return CMD_ERR_EXEED_ARGC_MAX;
  2031.     }
  2033.   /* For vtysh execution. */
  2034.   if (cmd)
  2035.     *cmd = matched_element;
  2037.   if (matched_element->daemon)
  2038.     return CMD_SUCCESS_DAEMON;
  2040.   /* Now execute matched command */
  2041.   return (*matched_element->func) (matched_element, vty, argc, argv);
  2042. }
  2044. /* Configration make from file. */
  2045. int
  2046. config_from_file (struct vty *vty, FILE *fp)
  2047. {
  2048.   int ret;
  2049.   vector vline;
  2051.   while (fgets (vty->buf, VTY_BUFSIZ, fp))
  2052.     {
  2053.       vline = cmd_make_strvec (vty->buf);
  2055.       /* In case of comment line */
  2056.       if (vline == NULL)
  2057. continue;
  2058.       /* Execute configuration command : this is strict match */
  2059.       ret = cmd_execute_command_strict (vline, vty, NULL);
  2061.       /* Try again with setting node to CONFIG_NODE */
  2062.       if (ret != CMD_SUCCESS && ret != CMD_WARNING)
  2063. {
  2064.   if (vty->node == KEYCHAIN_KEY_NODE)
  2065.     {
  2066.       vty->node = KEYCHAIN_NODE;
  2068.       ret = cmd_execute_command_strict (vline, vty, NULL);
  2070.       if (ret != CMD_SUCCESS && ret != CMD_WARNING)
  2071. {
  2072.   vty->node = CONFIG_NODE;
  2073.   ret = cmd_execute_command_strict (vline, vty, NULL);
  2074. }
  2075.     }
  2076.   else
  2077.     {
  2078.       vty->node = CONFIG_NODE;
  2079.       ret = cmd_execute_command_strict (vline, vty, NULL);
  2080.     }
  2081. }   
  2083.       cmd_free_strvec (vline);
  2085.       if (ret != CMD_SUCCESS && ret != CMD_WARNING)
  2086. return ret;
  2087.     }
  2088.   return CMD_SUCCESS;
  2089. }
  2091. /* Configration from terminal */
  2092. DEFUN (config_terminal,
  2093.        config_terminal_cmd,
  2094.        "configure terminal",
  2095.        "Configuration from vty interfacen"
  2096.        "Configuration terminaln")
  2097. {
  2098.   if (vty_config_lock (vty))
  2099.     vty->node = CONFIG_NODE;
  2100.   else
  2101.     {
  2102.       vty_out (vty, "VTY configuration is locked by other VTY%s", VTY_NEWLINE);
  2103.       return CMD_WARNING;
  2104.     }
  2105.   return CMD_SUCCESS;
  2106. }
  2108. /* Enable command */
  2109. DEFUN (enable, 
  2110.        config_enable_cmd,
  2111.        "enable",
  2112.        "Turn on privileged mode commandn")
  2113. {
  2114.   /* If enable password is NULL, change to ENABLE_NODE */
  2115.   if ((host.enable == NULL && host.enable_encrypt == NULL) ||
  2116.       vty->type == VTY_SHELL_SERV)
  2117.     vty->node = ENABLE_NODE;
  2118.   else
  2119.     vty->node = AUTH_ENABLE_NODE;
  2121.   return CMD_SUCCESS;
  2122. }
  2124. /* Disable command */
  2125. DEFUN (disable, 
  2126.        config_disable_cmd,
  2127.        "disable",
  2128.        "Turn off privileged mode commandn")
  2129. {
  2130.   if (vty->node == ENABLE_NODE)
  2131.     vty->node = VIEW_NODE;
  2132.   return CMD_SUCCESS;
  2133. }
  2135. /* Down vty node level. */
  2136. DEFUN (config_exit,
  2137.        config_exit_cmd,
  2138.        "exit",
  2139.        "Exit current mode and down to previous moden")
  2140. {
  2141.   switch (vty->node)
  2142.     {
  2143.     case VIEW_NODE:
  2144.     case ENABLE_NODE:
  2145.       if (vty_shell (vty))
  2146. exit (0);
  2147.       else
  2148. vty->status = VTY_CLOSE;
  2149.       break;
  2150.     case CONFIG_NODE:
  2151.       vty->node = ENABLE_NODE;
  2152.       vty_config_unlock (vty);
  2153.       break;
  2154.     case INTERFACE_NODE:
  2155.     case ZEBRA_NODE:
  2156.     case BGP_NODE:
  2157.     case RIP_NODE:
  2158.     case RIPNG_NODE:
  2159.     case OSPF_NODE:
  2160.     case OSPF6_NODE:
  2161.     case KEYCHAIN_NODE:
  2162.     case MASC_NODE:
  2163.     case RMAP_NODE:
  2164.     case VTY_NODE:
  2165.       vty->node = CONFIG_NODE;
  2166.       break;
  2167.     case BGP_VPNV4_NODE:
  2168.     case BGP_IPV4_NODE:
  2169.     case BGP_IPV4M_NODE:
  2170.     case BGP_IPV6_NODE:
  2171.       vty->node = BGP_NODE;
  2172.       break;
  2173.     case KEYCHAIN_KEY_NODE:
  2174.       vty->node = KEYCHAIN_NODE;
  2175.       break;
  2176.     default:
  2177.       break;
  2178.     }
  2179.   return CMD_SUCCESS;
  2180. }
  2182. /* quit is alias of exit. */
  2183. ALIAS (config_exit,
  2184.        config_quit_cmd,
  2185.        "quit",
  2186.        "Exit current mode and down to previous moden");
  2187.        
  2188. /* End of configuration. */
  2189. DEFUN (config_end,
  2190.        config_end_cmd,
  2191.        "end",
  2192.        "End current mode and change to enable mode.")
  2193. {
  2194.   switch (vty->node)
  2195.     {
  2196.     case VIEW_NODE:
  2197.     case ENABLE_NODE:
  2198.       /* Nothing to do. */
  2199.       break;
  2200.     case CONFIG_NODE:
  2201.     case INTERFACE_NODE:
  2202.     case ZEBRA_NODE:
  2203.     case RIP_NODE:
  2204.     case RIPNG_NODE:
  2205.     case BGP_NODE:
  2206.     case BGP_VPNV4_NODE:
  2207.     case BGP_IPV4_NODE:
  2208.     case BGP_IPV4M_NODE:
  2209.     case BGP_IPV6_NODE:
  2210.     case RMAP_NODE:
  2211.     case OSPF_NODE:
  2212.     case OSPF6_NODE:
  2213.     case KEYCHAIN_NODE:
  2214.     case KEYCHAIN_KEY_NODE:
  2215.     case MASC_NODE:
  2216.     case VTY_NODE:
  2217.       vty_config_unlock (vty);
  2218.       vty->node = ENABLE_NODE;
  2219.       break;
  2220.     default:
  2221.       break;
  2222.     }
  2223.   return CMD_SUCCESS;
  2224. }
  2226. /* Show version. */
  2227. DEFUN (show_version,
  2228.        show_version_cmd,
  2229.        "show version",
  2230.        SHOW_STR
  2231.        "Displays zebra versionn")
  2232. {
  2233.   vty_out (vty, "Zebra %s (%s).%s", ZEBRA_VERSION,
  2234.    host_name,
  2235.    VTY_NEWLINE);
  2236.   vty_out (vty, "Copyright 1996-2004, Kunihiro Ishiguro.%s", VTY_NEWLINE);
  2238.   return CMD_SUCCESS;
  2239. }
  2241. /* Help display function for all node. */
  2242. DEFUN (config_help,
  2243.        config_help_cmd,
  2244.        "help",
  2245.        "Description of the interactive help systemn")
  2246. {
  2247.   vty_out (vty, 
  2248.    "Zebra VTY provides advanced help feature.  When you need help,%s
  2249. anytime at the command line please press '?'.%s
  2250. %s
  2251. If nothing matches, the help list will be empty and you must backup%s
  2252.  until entering a '?' shows the available options.%s
  2253. Two styles of help are provided:%s
  2254. 1. Full help is available when you are ready to enter a%s
  2255. command argument (e.g. 'show ?') and describes each possible%s
  2256. argument.%s
  2257. 2. Partial help is provided when an abbreviated argument is entered%s
  2258.    and you want to know what arguments match the input%s
  2259.    (e.g. 'show me?'.)%s%s", VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE,
  2260.    VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE,
  2261.    VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE);
  2262.   return CMD_SUCCESS;
  2263. }
  2265. /* Help display function for all node. */
  2266. DEFUN (config_list,
  2267.        config_list_cmd,
  2268.        "list",
  2269.        "Print command listn")
  2270. {
  2271.   int i;
  2272.   struct cmd_node *cnode = vector_slot (cmdvec, vty->node);
  2273.   struct cmd_element *cmd;
  2275.   for (i = 0; i < vector_max (cnode->cmd_vector); i++)
  2276.     if ((cmd = vector_slot (cnode->cmd_vector, i)) != NULL)
  2277.       vty_out (vty, "  %s%s", cmd->string,
  2278.        VTY_NEWLINE);
  2279.   return CMD_SUCCESS;
  2280. }
  2282. /* Write current configuration into file. */
  2283. DEFUN (config_write_file, 
  2284.        config_write_file_cmd,
  2285.        "write file",  
  2286.        "Write running configuration to memory, network, or terminaln"
  2287.        "Write to configuration filen")
  2288. {
  2289.   int i;
  2290.   int fd;
  2291.   struct cmd_node *node;
  2292.   char *config_file;
  2293.   char *config_file_tmp = NULL;
  2294.   char *config_file_sav = NULL;
  2295.   struct vty *file_vty;
  2297.   /* Check and see if we are operating under vtysh configuration */
  2298.   if (host.config == NULL)
  2299.     {
  2300.       vty_out (vty, "Can't save to configuration file, using vtysh.%s",
  2301.        VTY_NEWLINE);
  2302.       return CMD_WARNING;
  2303.     }
  2305.   /* Get filename. */
  2306.   config_file = host.config;
  2307.   
  2308.   config_file_sav = malloc (strlen (config_file) + strlen (CONF_BACKUP_EXT) + 1);
  2309.   strcpy (config_file_sav, config_file);
  2310.   strcat (config_file_sav, CONF_BACKUP_EXT);
  2313.   config_file_tmp = malloc (strlen (config_file) + 8);
  2314.   sprintf (config_file_tmp, "%s.XXXXXX", config_file);
  2315.   
  2316.   /* Open file to configuration write. */
  2317.   fd = mkstemp (config_file_tmp);
  2318.   if (fd < 0)
  2319.     {
  2320.       vty_out (vty, "Can't open configuration file %s.%s", config_file_tmp,
  2321.        VTY_NEWLINE);
  2322.       free (config_file_tmp);
  2323.       free (config_file_sav);
  2324.       return CMD_WARNING;
  2325.     }
  2326.   
  2327.   /* Make vty for configuration file. */
  2328.   file_vty = vty_new ();
  2329.   file_vty->fd = fd;
  2330.   file_vty->type = VTY_FILE;
  2332.   /* Config file header print. */
  2333.   vty_out (file_vty, "!n! Zebra configuration saved from vtyn!   ");
  2334.   vty_time_print (file_vty, 1);
  2335.   vty_out (file_vty, "!n");
  2337.   for (i = 0; i < vector_max (cmdvec); i++)
  2338.     if ((node = vector_slot (cmdvec, i)) && node->func)
  2339.       {
  2340. if ((*node->func) (file_vty))
  2341.   vty_out (file_vty, "!n");
  2342.       }
  2343.   vty_close (file_vty);
  2345.   if (unlink (config_file_sav) != 0)
  2346.     if (errno != ENOENT)
  2347.       {
  2348. vty_out (vty, "Can't unlink backup configuration file %s.%s", config_file_sav,
  2349.  VTY_NEWLINE);
  2350. free (config_file_sav);
  2351. free (config_file_tmp);
  2352. unlink (config_file_tmp);
  2353. return CMD_WARNING;
  2354.       }
  2355.   if (link (config_file, config_file_sav) != 0)
  2356.     {
  2357.       vty_out (vty, "Can't backup old configuration file %s.%s", config_file_sav,
  2358.         VTY_NEWLINE);
  2359.       free (config_file_sav);
  2360.       free (config_file_tmp);
  2361.       unlink (config_file_tmp);
  2362.       return CMD_WARNING;
  2363.     }
  2364.   sync ();
  2365.   if (unlink (config_file) != 0)
  2366.     {
  2367.       vty_out (vty, "Can't unlink configuration file %s.%s", config_file,
  2368.         VTY_NEWLINE);
  2369.       free (config_file_sav);
  2370.       free (config_file_tmp);
  2371.       unlink (config_file_tmp);
  2372.       return CMD_WARNING;      
  2373.     }
  2374.   if (link (config_file_tmp, config_file) != 0)
  2375.     {
  2376.       vty_out (vty, "Can't save configuration file %s.%s", config_file,
  2377.        VTY_NEWLINE);
  2378.       free (config_file_sav);
  2379.       free (config_file_tmp);
  2380.       unlink (config_file_tmp);
  2381.       return CMD_WARNING;      
  2382.     }
  2383.   unlink (config_file_tmp);
  2384.   sync ();
  2385.   
  2386.   free (config_file_sav);
  2387.   free (config_file_tmp);
  2388.   vty_out (vty, "Configuration saved to %s%s", config_file,
  2389.    VTY_NEWLINE);
  2390.   return CMD_SUCCESS;
  2391. }
  2393. ALIAS (config_write_file, 
  2394.        config_write_cmd,
  2395.        "write",  
  2396.        "Write running configuration to memory, network, or terminaln");
  2398. ALIAS (config_write_file, 
  2399.        config_write_memory_cmd,
  2400.        "write memory",  
  2401.        "Write running configuration to memory, network, or terminaln"
  2402.        "Write configuration to the file (same as write file)n");
  2404. ALIAS (config_write_file, 
  2405.        copy_runningconfig_startupconfig_cmd,
  2406.        "copy running-config startup-config",  
  2407.        "Copy configurationn"
  2408.        "Copy running config to... n"
  2409.        "Copy running config to startup config (same as write file)n");
  2411. /* Write current configuration into the terminal. */
  2412. DEFUN (config_write_terminal,
  2413.        config_write_terminal_cmd,
  2414.        "write terminal",
  2415.        "Write running configuration to memory, network, or terminaln"
  2416.        "Write to terminaln")
  2417. {
  2418.   int i;
  2419.   struct cmd_node *node;
  2421.   if (vty->type == VTY_SHELL_SERV)
  2422.     {
  2423.       for (i = 0; i < vector_max (cmdvec); i++)
  2424. if ((node = vector_slot (cmdvec, i)) && node->func && node->vtysh)
  2425.   {
  2426.     if ((*node->func) (vty))
  2427.       vty_out (vty, "!%s", VTY_NEWLINE);
  2428.   }
  2429.     }
  2430.   else
  2431.     {
  2432.       vty_out (vty, "%sCurrent configuration:%s", VTY_NEWLINE,
  2433.        VTY_NEWLINE);
  2434.       vty_out (vty, "!%s", VTY_NEWLINE);
  2436.       for (i = 0; i < vector_max (cmdvec); i++)
  2437. if ((node = vector_slot (cmdvec, i)) && node->func)
  2438.   {
  2439.     if ((*node->func) (vty))
  2440.       vty_out (vty, "!%s", VTY_NEWLINE);
  2441.   }
  2442.       vty_out (vty, "end%s",VTY_NEWLINE);
  2443.     }
  2444.   return CMD_SUCCESS;
  2445. }
  2447. /* Write current configuration into the terminal. */
  2448. ALIAS (config_write_terminal,
  2449.        show_running_config_cmd,
  2450.        "show running-config",
  2451.        SHOW_STR
  2452.        "running configurationn");
  2454. /* Write startup configuration into the terminal. */
  2455. DEFUN (show_startup_config,
  2456.        show_startup_config_cmd,
  2457.        "show startup-config",
  2458.        SHOW_STR
  2459.        "Contentes of startup configurationn")
  2460. {
  2461.   char buf[BUFSIZ];
  2462.   FILE *confp;
  2464.   confp = fopen (host.config, "r");
  2465.   if (confp == NULL)
  2466.     {
  2467.       vty_out (vty, "Can't open configuration file [%s]%s",
  2468.        host.config, VTY_NEWLINE);
  2469.       return CMD_WARNING;
  2470.     }
  2472.   while (fgets (buf, BUFSIZ, confp))
  2473.     {
  2474.       char *cp = buf;
  2476.       while (*cp != 'r' && *cp != 'n' && *cp != '')
  2477. cp++;
  2478.       *cp = '';
  2480.       vty_out (vty, "%s%s", buf, VTY_NEWLINE);
  2481.     }
  2483.   fclose (confp);
  2485.   return CMD_SUCCESS;
  2486. }
  2488. /* Hostname configuration */
  2489. DEFUN (config_hostname, 
  2490.        hostname_cmd,
  2491.        "hostname WORD",
  2492.        "Set system's network namen"
  2493.        "This system's network namen")
  2494. {
  2495.   if (!isalpha((int) *argv[0]))
  2496.     {
  2497.       vty_out (vty, "Please specify string starting with alphabet%s", VTY_NEWLINE);
  2498.       return CMD_WARNING;
  2499.     }
  2501.   if (host.name)
  2502.     XFREE (0, host.name);
  2503.     
  2504.   host.name = strdup (argv[0]);
  2505.   return CMD_SUCCESS;
  2506. }
  2508. DEFUN (config_no_hostname, 
  2509.        no_hostname_cmd,
  2510.        "no hostname [HOSTNAME]",
  2511.        NO_STR
  2512.        "Reset system's network namen"
  2513.        "Host name of this routern")
  2514. {
  2515.   if (host.name)
  2516.     XFREE (0, host.name);
  2517.   host.name = NULL;
  2518.   return CMD_SUCCESS;
  2519. }
  2521. /* VTY interface password set. */
  2522. DEFUN (config_password, password_cmd,
  2523.        "password (8|) WORD",
  2524.        "Assign the terminal connection passwordn"
  2525.        "Specifies a HIDDEN password will follown"
  2526.        "dummy string n"
  2527.        "The HIDDEN line password stringn")
  2528. {
  2529.   /* Argument check. */
  2530.   if (argc == 0)
  2531.     {
  2532.       vty_out (vty, "Please specify password.%s", VTY_NEWLINE);
  2533.       return CMD_WARNING;
  2534.     }
  2536.   if (argc == 2)
  2537.     {
  2538.       if (*argv[0] == '8')
  2539. {
  2540.   if (host.password)
  2541.     XFREE (0, host.password);
  2542.   host.password = NULL;
  2543.   if (host.password_encrypt)
  2544.     XFREE (0, host.password_encrypt);
  2545.   host.password_encrypt = XSTRDUP (0, strdup (argv[1]));
  2546.   return CMD_SUCCESS;
  2547. }
  2548.       else
  2549. {
  2550.   vty_out (vty, "Unknown encryption type.%s", VTY_NEWLINE);
  2551.   return CMD_WARNING;
  2552. }
  2553.     }
  2555.   if (!isalnum ((int) *argv[0]))
  2556.     {
  2557.       vty_out (vty, 
  2558.        "Please specify string starting with alphanumeric%s", VTY_NEWLINE);
  2559.       return CMD_WARNING;
  2560.     }
  2562.   if (host.password)
  2563.     XFREE (0, host.password);
  2564.   host.password = NULL;
  2566.   if (host.password_encrypt)
  2567.     XFREE (0, host.password_encrypt);
  2568.   host.password_encrypt = NULL;
  2570.   if (host.encrypt)
  2571.     host.password_encrypt = XSTRDUP (0, zencrypt (argv[0]));
  2572.   else
  2573.     host.password = XSTRDUP (0, argv[0]);
  2575.   return CMD_SUCCESS;
  2576. }
  2578. ALIAS (config_password, password_text_cmd,
  2579.        "password LINE",
  2580.        "Assign the terminal connection passwordn"
  2581.        "The UNENCRYPTED (cleartext) line passwordn");
  2583. /* VTY enable password set. */
  2584. DEFUN (config_enable_password, enable_password_cmd,
  2585.        "enable password (8|) WORD",
  2586.        "Modify enable password parametersn"
  2587.        "Assign the privileged level passwordn"
  2588.        "Specifies a HIDDEN password will follown"
  2589.        "dummy string n"
  2590.        "The HIDDEN 'enable' password stringn")
  2591. {
  2592.   /* Argument check. */
  2593.   if (argc == 0)
  2594.     {
  2595.       vty_out (vty, "Please specify password.%s", VTY_NEWLINE);
  2596.       return CMD_WARNING;
  2597.     }
  2599.   /* Crypt type is specified. */
  2600.   if (argc == 2)
  2601.     {
  2602.       if (*argv[0] == '8')
  2603. {
  2604.   if (host.enable)
  2605.     XFREE (0, host.enable);
  2606.   host.enable = NULL;
  2608.   if (host.enable_encrypt)
  2609.     XFREE (0, host.enable_encrypt);
  2610.   host.enable_encrypt = XSTRDUP (0, argv[1]);
  2612.   return CMD_SUCCESS;
  2613. }
  2614.       else
  2615. {
  2616.   vty_out (vty, "Unknown encryption type.%s", VTY_NEWLINE);
  2617.   return CMD_WARNING;
  2618. }
  2619.     }
  2621.   if (!isalnum ((int) *argv[0]))
  2622.     {
  2623.       vty_out (vty, 
  2624.        "Please specify string starting with alphanumeric%s", VTY_NEWLINE);
  2625.       return CMD_WARNING;
  2626.     }
  2628.   if (host.enable)
  2629.     XFREE (0, host.enable);
  2630.   host.enable = NULL;
  2632.   if (host.enable_encrypt)
  2633.     XFREE (0, host.enable_encrypt);
  2634.   host.enable_encrypt = NULL;
  2636.   /* Plain password input. */
  2637.   if (host.encrypt)
  2638.     host.enable_encrypt = XSTRDUP (0, zencrypt (argv[0]));
  2639.   else
  2640.     host.enable = XSTRDUP (0, argv[0]);
  2642.   return CMD_SUCCESS;
  2643. }
  2645. ALIAS (config_enable_password,
  2646.        enable_password_text_cmd,
  2647.        "enable password LINE",
  2648.        "Modify enable password parametersn"
  2649.        "Assign the privileged level passwordn"
  2650.        "The UNENCRYPTED (cleartext) 'enable' passwordn");
  2652. /* VTY enable password delete. */
  2653. DEFUN (no_config_enable_password, no_enable_password_cmd,
  2654.        "no enable password",
  2655.        NO_STR
  2656.        "Modify enable password parametersn"
  2657.        "Assign the privileged level passwordn")
  2658. {
  2659.   if (host.enable)
  2660.     XFREE (0, host.enable);
  2661.   host.enable = NULL;
  2663.   if (host.enable_encrypt)
  2664.     XFREE (0, host.enable_encrypt);
  2665.   host.enable_encrypt = NULL;
  2667.   return CMD_SUCCESS;
  2668. }
  2670. DEFUN (service_password_encrypt,
  2671.        service_password_encrypt_cmd,
  2672.        "service password-encryption",
  2673.        "Set up miscellaneous servicen"
  2674.        "Enable encrypted passwordsn")
  2675. {
  2676.   if (host.encrypt)
  2677.     return CMD_SUCCESS;
  2679.   host.encrypt = 1;
  2681.   if (host.password)
  2682.     {
  2683.       if (host.password_encrypt)
  2684. XFREE (0, host.password_encrypt);
  2685.       host.password_encrypt = XSTRDUP (0, zencrypt (host.password));
  2686.     }
  2687.   if (host.enable)
  2688.     {
  2689.       if (host.enable_encrypt)
  2690. XFREE (0, host.enable_encrypt);
  2691.       host.enable_encrypt = XSTRDUP (0, zencrypt (host.enable));
  2692.     }
  2694.   return CMD_SUCCESS;
  2695. }
  2697. DEFUN (no_service_password_encrypt,
  2698.        no_service_password_encrypt_cmd,
  2699.        "no service password-encryption",
  2700.        NO_STR
  2701.        "Set up miscellaneous servicen"
  2702.        "Enable encrypted passwordsn")
  2703. {
  2704.   if (! host.encrypt)
  2705.     return CMD_SUCCESS;
  2707.   host.encrypt = 0;
  2709.   if (host.password)
  2710.     {
  2711.       if (host.password_encrypt)
  2712. XFREE (0, host.password_encrypt);
  2713.       host.password_encrypt = NULL;
  2714.     }
  2716.   if (host.enable)
  2717.     {
  2718.       if (host.enable_encrypt)
  2719. XFREE (0, host.enable_encrypt);
  2720.       host.enable_encrypt = NULL;
  2721.     }
  2723.   return CMD_SUCCESS;
  2724. }
  2726. DEFUN (config_terminal_length, config_terminal_length_cmd,
  2727.        "terminal length <0-512>",
  2728.        "Set terminal line parametersn"
  2729.        "Set number of lines on a screenn"
  2730.        "Number of lines on screen (0 for no pausing)n")
  2731. {
  2732.   int lines;
  2733.   char *endptr = NULL;
  2735.   lines = strtol (argv[0], &endptr, 10);
  2736.   if (lines < 0 || lines > 512 || *endptr != '')
  2737.     {
  2738.       vty_out (vty, "length is malformed%s", VTY_NEWLINE);
  2739.       return CMD_WARNING;
  2740.     }
  2741.   vty->lines = lines;
  2743.   return CMD_SUCCESS;
  2744. }
  2746. DEFUN (config_terminal_no_length, config_terminal_no_length_cmd,
  2747.        "terminal no length",
  2748.        "Set terminal line parametersn"
  2749.        NO_STR
  2750.        "Set number of lines on a screenn")
  2751. {
  2752.   vty->lines = -1;
  2753.   return CMD_SUCCESS;
  2754. }
  2756. DEFUN (service_terminal_length, service_terminal_length_cmd,
  2757.        "service terminal-length <0-512>",
  2758.        "Set up miscellaneous servicen"
  2759.        "System wide terminal length configurationn"
  2760.        "Number of lines of VTY (0 means no line control)n")
  2761. {
  2762.   int lines;
  2763.   char *endptr = NULL;
  2765.   lines = strtol (argv[0], &endptr, 10);
  2766.   if (lines < 0 || lines > 512 || *endptr != '')
  2767.     {
  2768.       vty_out (vty, "length is malformed%s", VTY_NEWLINE);
  2769.       return CMD_WARNING;
  2770.     }
  2771.   host.lines = lines;
  2773.   return CMD_SUCCESS;
  2774. }
  2776. DEFUN (no_service_terminal_length, no_service_terminal_length_cmd,
  2777.        "no service terminal-length [<0-512>]",
  2778.        NO_STR
  2779.        "Set up miscellaneous servicen"
  2780.        "System wide terminal length configurationn"
  2781.        "Number of lines of VTY (0 means no line control)n")
  2782. {
  2783.   host.lines = -1;
  2784.   return CMD_SUCCESS;
  2785. }
  2787. DEFUN (config_log_stdout,
  2788.        config_log_stdout_cmd,
  2789.        "log stdout",
  2790.        "Logging controln"
  2791.        "Logging goes to stdoutn")
  2792. {
  2793.   zlog_set_flag (NULL, ZLOG_STDOUT);
  2794.   host.log_stdout = 1;
  2795.   return CMD_SUCCESS;
  2796. }
  2798. DEFUN (no_config_log_stdout,
  2799.        no_config_log_stdout_cmd,
  2800.        "no log stdout",
  2801.        NO_STR
  2802.        "Logging controln"
  2803.        "Cancel logging to stdoutn")
  2804. {
  2805.   zlog_reset_flag (NULL, ZLOG_STDOUT);
  2806.   host.log_stdout = 0;
  2807.   return CMD_SUCCESS;
  2808. }
  2810. DEFUN (config_log_file,
  2811.        config_log_file_cmd,
  2812.        "log file FILENAME",
  2813.        "Logging controln"
  2814.        "Logging to filen"
  2815.        "Logging filenamen")
  2816. {
  2817.   int ret;
  2818.   char *cwd;
  2819.   char *fullpath;
  2821.   /* Path detection. */
  2822.   if (! IS_DIRECTORY_SEP (*argv[0]))
  2823.     {
  2824.       cwd = getcwd (NULL, MAXPATHLEN);
  2825.       fullpath = XMALLOC (MTYPE_TMP,
  2826.   strlen (cwd) + strlen (argv[0]) + 2);
  2827.       sprintf (fullpath, "%s/%s", cwd, argv[0]);
  2828.     }
  2829.   else
  2830.     fullpath = argv[0];
  2832.   ret = zlog_set_file (NULL, ZLOG_FILE, fullpath);
  2834.   if (!ret)
  2835.     {
  2836.       vty_out (vty, "can't open logfile %sn", argv[0]);
  2837.       return CMD_WARNING;
  2838.     }
  2840.   if (host.logfile)
  2841.     XFREE (MTYPE_TMP, host.logfile);
  2843.   host.logfile = strdup (argv[0]);
  2845.   return CMD_SUCCESS;
  2846. }
  2848. DEFUN (no_config_log_file,
  2849.        no_config_log_file_cmd,
  2850.        "no log file [FILENAME]",
  2851.        NO_STR
  2852.        "Logging controln"
  2853.        "Cancel logging to filen"
  2854.        "Logging file namen")
  2855. {
  2856.   zlog_reset_file (NULL);
  2858.   if (host.logfile)
  2859.     XFREE (MTYPE_TMP, host.logfile);
  2861.   host.logfile = NULL;
  2863.   return CMD_SUCCESS;
  2864. }
  2866. DEFUN (config_log_syslog,
  2867.        config_log_syslog_cmd,
  2868.        "log syslog",
  2869.        "Logging controln"
  2870.        "Logging goes to syslogn")
  2871. {
  2872.   zlog_set_flag (NULL, ZLOG_SYSLOG);
  2873.   host.log_syslog = 1;
  2874.   zlog_default->facility = LOG_DAEMON;
  2875.   return CMD_SUCCESS;
  2876. }
  2878. DEFUN (config_log_syslog_facility,
  2879.        config_log_syslog_facility_cmd,
  2880.        "log syslog facility (kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7)",
  2881.        "Logging controln"
  2882.        "Logging goes to syslogn"
  2883.        "Facility parameter for syslog messagesn"
  2884.        "Kerneln"
  2885.        "User processn"
  2886.        "Mail systemn"
  2887.        "System daemonsn"
  2888.        "Authorization systemn"
  2889.        "Syslog itselfn"
  2890.        "Line printer systemn"
  2891.        "USENET newsn"
  2892.        "Unix-to-Unix copy systemn"
  2893.        "Cron/at facilityn"
  2894.        "Local usen"
  2895.        "Local usen"
  2896.        "Local usen"
  2897.        "Local usen"
  2898.        "Local usen"
  2899.        "Local usen"
  2900.        "Local usen"
  2901.        "Local usen")
  2902. {
  2903.   int facility = LOG_DAEMON;
  2905.   zlog_set_flag (NULL, ZLOG_SYSLOG);
  2906.   host.log_syslog = 1;
  2908.   if (strncmp (argv[0], "kern", 1) == 0)
  2909.     facility = LOG_KERN;
  2910.   else if (strncmp (argv[0], "user", 2) == 0)
  2911.     facility = LOG_USER;
  2912.   else if (strncmp (argv[0], "mail", 1) == 0)
  2913.     facility = LOG_MAIL;
  2914.   else if (strncmp (argv[0], "daemon", 1) == 0)
  2915.     facility = LOG_DAEMON;
  2916.   else if (strncmp (argv[0], "auth", 1) == 0)
  2917.     facility = LOG_AUTH;
  2918.   else if (strncmp (argv[0], "syslog", 1) == 0)
  2919.     facility = LOG_SYSLOG;
  2920.   else if (strncmp (argv[0], "lpr", 2) == 0)
  2921.     facility = LOG_LPR;
  2922.   else if (strncmp (argv[0], "news", 1) == 0)
  2923.     facility = LOG_NEWS;
  2924.   else if (strncmp (argv[0], "uucp", 2) == 0)
  2925.     facility = LOG_UUCP;
  2926.   else if (strncmp (argv[0], "cron", 1) == 0)
  2927.     facility = LOG_CRON;
  2928.   else if (strncmp (argv[0], "local0", 6) == 0)
  2929.     facility = LOG_LOCAL0;
  2930.   else if (strncmp (argv[0], "local1", 6) == 0)
  2931.     facility = LOG_LOCAL1;
  2932.   else if (strncmp (argv[0], "local2", 6) == 0)
  2933.     facility = LOG_LOCAL2;
  2934.   else if (strncmp (argv[0], "local3", 6) == 0)
  2935.     facility = LOG_LOCAL3;
  2936.   else if (strncmp (argv[0], "local4", 6) == 0)
  2937.     facility = LOG_LOCAL4;
  2938.   else if (strncmp (argv[0], "local5", 6) == 0)
  2939.     facility = LOG_LOCAL5;
  2940.   else if (strncmp (argv[0], "local6", 6) == 0)
  2941.     facility = LOG_LOCAL6;
  2942.   else if (strncmp (argv[0], "local7", 6) == 0)
  2943.     facility = LOG_LOCAL7;
  2945.   zlog_default->facility = facility;
  2947.   return CMD_SUCCESS;
  2948. }
  2950. DEFUN (no_config_log_syslog,
  2951.        no_config_log_syslog_cmd,
  2952.        "no log syslog",
  2953.        NO_STR
  2954.        "Logging controln"
  2955.        "Cancel logging to syslogn")
  2956. {
  2957.   zlog_reset_flag (NULL, ZLOG_SYSLOG);
  2958.   host.log_syslog = 0;
  2959.   zlog_default->facility = LOG_DAEMON;
  2960.   return CMD_SUCCESS;
  2961. }
  2963. ALIAS (no_config_log_syslog,
  2964.        no_config_log_syslog_facility_cmd,
  2965.        "no log syslog facility (kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7)",
  2966.        NO_STR
  2967.        "Logging controln"
  2968.        "Logging goes to syslogn"
  2969.        "Facility parameter for syslog messagesn"
  2970.        "Kerneln"
  2971.        "User processn"
  2972.        "Mail systemn"
  2973.        "System daemonsn"
  2974.        "Authorization systemn"
  2975.        "Syslog itselfn"
  2976.        "Line printer systemn"
  2977.        "USENET newsn"
  2978.        "Unix-to-Unix copy systemn"
  2979.        "Cron/at facilityn"
  2980.        "Local usen"
  2981.        "Local usen"
  2982.        "Local usen"
  2983.        "Local usen"
  2984.        "Local usen"
  2985.        "Local usen"
  2986.        "Local usen"
  2987.        "Local usen");
  2989. DEFUN (config_log_trap,
  2990.        config_log_trap_cmd,
  2991.        "log trap (emergencies|alerts|critical|errors|warnings|notifications|informational|debugging)",
  2992.        "Logging controln"
  2993.        "Limit logging to specifed leveln")
  2994. {
  2995.   int new_level ;
  2996.   
  2997.   for ( new_level = 0 ; zlog_priority [new_level] != NULL ; new_level ++ )
  2998.     {
  2999.     if ( strcmp ( argv[0], zlog_priority [new_level] ) == 0 )
  3000.       /* found new logging level */
  3001.       {
  3002.       zlog_default->maskpri = new_level;
  3003.       return CMD_SUCCESS;
  3004.       }
  3005.     }
  3006.   return CMD_ERR_NO_MATCH;
  3007. }
  3009. DEFUN (no_config_log_trap,
  3010.        no_config_log_trap_cmd,
  3011.        "no log trap",
  3012.        NO_STR
  3013.        "Logging controln"
  3014.        "Permit all logging informationn")
  3015. {
  3016.   zlog_default->maskpri = LOG_DEBUG;
  3017.   return CMD_SUCCESS;
  3018. }
  3020. DEFUN (config_log_record_priority,
  3021.        config_log_record_priority_cmd,
  3022.        "log record-priority",
  3023.        "Logging controln"
  3024.        "Log the priority of the message within the messagen")
  3025. {
  3026.   zlog_default->record_priority = 1 ;
  3027.   return CMD_SUCCESS;
  3028. }
  3030. DEFUN (no_config_log_record_priority,
  3031.        no_config_log_record_priority_cmd,
  3032.        "no log record-priority",
  3033.        NO_STR
  3034.        "Logging controln"
  3035.        "Do not log the priority of the message within the messagen")
  3036. {
  3037.   zlog_default->record_priority = 0 ;
  3038.   return CMD_SUCCESS;
  3039. }
  3042. DEFUN (banner_motd_default,
  3043.        banner_motd_default_cmd,
  3044.        "banner motd default",
  3045.        "Set banner stringn"
  3046.        "Strings for motdn"
  3047.        "Default stringn")
  3048. {
  3049.   host.motd = default_motd;
  3050.   return CMD_SUCCESS;
  3051. }
  3053. DEFUN (no_banner_motd,
  3054.        no_banner_motd_cmd,
  3055.        "no banner motd",
  3056.        NO_STR
  3057.        "Set banner stringn"
  3058.        "Strings for motdn")
  3059. {
  3060.   host.motd = NULL;
  3061.   return CMD_SUCCESS;
  3062. }
  3064. /* Set config filename.  Called from vty.c */
  3065. void
  3066. host_config_set (char *filename)
  3067. {
  3068.   host.config = strdup (filename);
  3069. }
  3071. void
  3072. install_default (enum node_type node)
  3073. {
  3074.   install_element (node, &config_exit_cmd);
  3075.   install_element (node, &config_quit_cmd);
  3076.   install_element (node, &config_end_cmd);
  3077.   install_element (node, &config_help_cmd);
  3078.   install_element (node, &config_list_cmd);
  3080.   install_element (node, &config_write_terminal_cmd);
  3081.   install_element (node, &config_write_file_cmd);
  3082.   install_element (node, &config_write_memory_cmd);
  3083.   install_element (node, &config_write_cmd);
  3084.   install_element (node, &show_running_config_cmd);
  3085. }
  3087. /* Initialize command interface. Install basic nodes and commands. */
  3088. void
  3089. cmd_init (int terminal)
  3090. {
  3091.   /* Allocate initial top vector of commands. */
  3092.   cmdvec = vector_init (VECTOR_MIN_SIZE);
  3094.   /* Default host value settings. */
  3095.   host.name = NULL;
  3096.   host.password = NULL;
  3097.   host.enable = NULL;
  3098.   host.logfile = NULL;
  3099.   host.config = NULL;
  3100.   host.lines = -1;
  3101.   host.motd = default_motd;
  3103.   /* Install top nodes. */
  3104.   install_node (&view_node, NULL);
  3105.   install_node (&enable_node, NULL);
  3106.   install_node (&auth_node, NULL);
  3107.   install_node (&auth_enable_node, NULL);
  3108.   install_node (&config_node, config_write_host);
  3110.   /* Each node's basic commands. */
  3111.   install_element (VIEW_NODE, &show_version_cmd);
  3112.   if (terminal)
  3113.     {
  3114.       install_element (VIEW_NODE, &config_list_cmd);
  3115.       install_element (VIEW_NODE, &config_exit_cmd);
  3116.       install_element (VIEW_NODE, &config_quit_cmd);
  3117.       install_element (VIEW_NODE, &config_help_cmd);
  3118.       install_element (VIEW_NODE, &config_enable_cmd);
  3119.       install_element (VIEW_NODE, &config_terminal_length_cmd);
  3120.       install_element (VIEW_NODE, &config_terminal_no_length_cmd);
  3121.     }
  3123.   if (terminal)
  3124.     {
  3125.       install_default (ENABLE_NODE);
  3126.       install_element (ENABLE_NODE, &config_disable_cmd);
  3127.       install_element (ENABLE_NODE, &config_terminal_cmd);
  3128.       install_element (ENABLE_NODE, &copy_runningconfig_startupconfig_cmd);
  3129.     }
  3130.   install_element (ENABLE_NODE, &show_startup_config_cmd);
  3131.   install_element (ENABLE_NODE, &show_version_cmd);
  3132.   install_element (ENABLE_NODE, &config_terminal_length_cmd);
  3133.   install_element (ENABLE_NODE, &config_terminal_no_length_cmd);
  3135.   if (terminal)
  3136.     install_default (CONFIG_NODE);
  3137.   install_element (CONFIG_NODE, &hostname_cmd);
  3138.   install_element (CONFIG_NODE, &no_hostname_cmd);
  3139.   install_element (CONFIG_NODE, &password_cmd);
  3140.   install_element (CONFIG_NODE, &password_text_cmd);
  3141.   install_element (CONFIG_NODE, &enable_password_cmd);
  3142.   install_element (CONFIG_NODE, &enable_password_text_cmd);
  3143.   install_element (CONFIG_NODE, &no_enable_password_cmd);
  3144.   if (terminal)
  3145.     {
  3146.       install_element (CONFIG_NODE, &config_log_stdout_cmd);
  3147.       install_element (CONFIG_NODE, &no_config_log_stdout_cmd);
  3148.       install_element (CONFIG_NODE, &config_log_file_cmd);
  3149.       install_element (CONFIG_NODE, &no_config_log_file_cmd);
  3150.       install_element (CONFIG_NODE, &config_log_syslog_cmd);
  3151.       install_element (CONFIG_NODE, &config_log_syslog_facility_cmd);
  3152.       install_element (CONFIG_NODE, &no_config_log_syslog_cmd);
  3153.       install_element (CONFIG_NODE, &no_config_log_syslog_facility_cmd);
  3154.       install_element (CONFIG_NODE, &config_log_trap_cmd);
  3155.       install_element (CONFIG_NODE, &no_config_log_trap_cmd);
  3156.       install_element (CONFIG_NODE, &config_log_record_priority_cmd);
  3157.       install_element (CONFIG_NODE, &no_config_log_record_priority_cmd);
  3158.       install_element (CONFIG_NODE, &service_password_encrypt_cmd);
  3159.       install_element (CONFIG_NODE, &no_service_password_encrypt_cmd);
  3160.       install_element (CONFIG_NODE, &banner_motd_default_cmd);
  3161.       install_element (CONFIG_NODE, &no_banner_motd_cmd);
  3162.       install_element (CONFIG_NODE, &service_terminal_length_cmd);
  3163.       install_element (CONFIG_NODE, &no_service_terminal_length_cmd);
  3164.     }
  3166.   srand(time(NULL));
  3167. }