[BACK]Return to isisd.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / isisd

Diff for /embedaddon/quagga/isisd/isisd.c between versions 1.1 and 1.1.1.4

version 1.1, 2012/02/21 17:26:11 version 1.1.1.4, 2016/11/02 10:09:10
Line 27 Line 27
 #include "command.h"  #include "command.h"
 #include "log.h"  #include "log.h"
 #include "memory.h"  #include "memory.h"
   #include "time.h"
 #include "linklist.h"  #include "linklist.h"
 #include "if.h"  #include "if.h"
 #include "hash.h"  #include "hash.h"
Line 38 Line 39
 #include "isisd/include-netbsd/iso.h"  #include "isisd/include-netbsd/iso.h"
 #include "isisd/isis_constants.h"  #include "isisd/isis_constants.h"
 #include "isisd/isis_common.h"  #include "isisd/isis_common.h"
 #include "isisd/isis_circuit.h"  
 #include "isisd/isis_flags.h"  #include "isisd/isis_flags.h"
   #include "isisd/isis_circuit.h"
   #include "isisd/isis_csm.h"
 #include "isisd/isisd.h"  #include "isisd/isisd.h"
 #include "isisd/isis_dynhn.h"  #include "isisd/isis_dynhn.h"
 #include "isisd/isis_adjacency.h"  #include "isisd/isis_adjacency.h"
Line 52 Line 54
 #include "isisd/isis_route.h"  #include "isisd/isis_route.h"
 #include "isisd/isis_zebra.h"  #include "isisd/isis_zebra.h"
 #include "isisd/isis_events.h"  #include "isisd/isis_events.h"
 #include "isisd/isis_csm.h"  
   
 #ifdef TOPOLOGY_GENERATE  #ifdef TOPOLOGY_GENERATE
 #include "spgrid.h"  #include "spgrid.h"
Line 60  u_char DEFAULT_TOPOLOGY_BASEIS[6] = { 0xFE, 0xED, 0xFE Line 61  u_char DEFAULT_TOPOLOGY_BASEIS[6] = { 0xFE, 0xED, 0xFE
 #endif /* TOPOLOGY_GENERATE */  #endif /* TOPOLOGY_GENERATE */
   
 struct isis *isis = NULL;  struct isis *isis = NULL;
 extern struct thread_master *master;  
   
 /*  /*
  * Prototypes.   * Prototypes.
  */   */
 void isis_new(unsigned long);  
 struct isis_area *isis_area_create(void);  
 int isis_area_get(struct vty *, const char *);  int isis_area_get(struct vty *, const char *);
 int isis_area_destroy(struct vty *, const char *);  int isis_area_destroy(struct vty *, const char *);
int area_net_title(struct vty *, const u_char *);int area_net_title(struct vty *, const char *);
int area_clear_net_title(struct vty *, const u_char *);int area_clear_net_title(struct vty *, const char *);
int show_clns_neigh(struct vty *, char);int show_isis_interface_common(struct vty *, const char *ifname, char);
void print_debug(struct vty *, int, int);int show_isis_neighbor_common(struct vty *, const char *id, char);
 int clear_isis_neighbor_common(struct vty *, const char *id);
 int isis_config_write(struct vty *);  int isis_config_write(struct vty *);
   
   
Line 85  isis_new (unsigned long process_id) Line 84  isis_new (unsigned long process_id)
    * Default values     * Default values
    */     */
   isis->max_area_addrs = 3;    isis->max_area_addrs = 3;
   
   isis->process_id = process_id;    isis->process_id = process_id;
     isis->router_id = 0;
   isis->area_list = list_new ();    isis->area_list = list_new ();
   isis->init_circ_list = list_new ();    isis->init_circ_list = list_new ();
   isis->uptime = time (NULL);    isis->uptime = time (NULL);
Line 94  isis_new (unsigned long process_id) Line 93  isis_new (unsigned long process_id)
 #ifdef HAVE_IPV6  #ifdef HAVE_IPV6
   isis->nexthops6 = list_new ();    isis->nexthops6 = list_new ();
 #endif /* HAVE_IPV6 */  #endif /* HAVE_IPV6 */
     dyn_cache_init ();
   /*    /*
    * uncomment the next line for full debugs     * uncomment the next line for full debugs
    */     */
Line 101  isis_new (unsigned long process_id) Line 101  isis_new (unsigned long process_id)
 }  }
   
 struct isis_area *  struct isis_area *
isis_area_create ()isis_area_create (const char *area_tag)
 {  {
   struct isis_area *area;    struct isis_area *area;
   
Line 115  isis_area_create () Line 115  isis_area_create ()
     area->is_type = IS_LEVEL_1;      area->is_type = IS_LEVEL_1;
   else    else
     area->is_type = IS_LEVEL_1_AND_2;      area->is_type = IS_LEVEL_1_AND_2;
   
   /*    /*
    * intialize the databases     * intialize the databases
    */     */
  area->lspdb[0] = lsp_db_init ();  if (area->is_type & IS_LEVEL_1)
  area->lspdb[1] = lsp_db_init ();    {
      area->lspdb[0] = lsp_db_init ();
  spftree_area_init (area);      area->route_table[0] = route_table_init ();
  area->route_table[0] = route_table_init (); 
  area->route_table[1] = route_table_init (); 
 #ifdef HAVE_IPV6  #ifdef HAVE_IPV6
  area->route_table6[0] = route_table_init ();      area->route_table6[0] = route_table_init ();
  area->route_table6[1] = route_table_init (); 
 #endif /* HAVE_IPV6 */  #endif /* HAVE_IPV6 */
       }
     if (area->is_type & IS_LEVEL_2)
       {
         area->lspdb[1] = lsp_db_init ();
         area->route_table[1] = route_table_init ();
   #ifdef HAVE_IPV6
         area->route_table6[1] = route_table_init ();
   #endif /* HAVE_IPV6 */
       }
   
     spftree_area_init (area);
   
   area->circuit_list = list_new ();    area->circuit_list = list_new ();
   area->area_addrs = list_new ();    area->area_addrs = list_new ();
   THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);    THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);
   flags_initialize (&area->flags);    flags_initialize (&area->flags);
   
   /*    /*
    * Default values     * Default values
    */     */
  area->max_lsp_lifetime[0] = MAX_AGE;      /* 1200 */  area->max_lsp_lifetime[0] = DEFAULT_LSP_LIFETIME;      /* 1200 */
  area->max_lsp_lifetime[1] = MAX_AGE;      /* 1200 */  area->max_lsp_lifetime[1] = DEFAULT_LSP_LIFETIME;      /* 1200 */
  area->lsp_gen_interval[0] = LSP_GEN_INTERVAL_DEFAULT;  area->lsp_refresh[0] = DEFAULT_MAX_LSP_GEN_INTERVAL;   /* 900 */
  area->lsp_gen_interval[1] = LSP_GEN_INTERVAL_DEFAULT;  area->lsp_refresh[1] = DEFAULT_MAX_LSP_GEN_INTERVAL;   /* 900 */
  area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL;   /* 900 */  area->lsp_gen_interval[0] = DEFAULT_MIN_LSP_GEN_INTERVAL;
  area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL;   /* 900 */  area->lsp_gen_interval[1] = DEFAULT_MIN_LSP_GEN_INTERVAL;
   area->min_spf_interval[0] = MINIMUM_SPF_INTERVAL;    area->min_spf_interval[0] = MINIMUM_SPF_INTERVAL;
   area->min_spf_interval[1] = MINIMUM_SPF_INTERVAL;    area->min_spf_interval[1] = MINIMUM_SPF_INTERVAL;
   area->dynhostname = 1;    area->dynhostname = 1;
  area->oldmetric = 1;  area->oldmetric = 0;
   area->newmetric = 1;
   area->lsp_frag_threshold = 90;    area->lsp_frag_threshold = 90;
     area->lsp_mtu = DEFAULT_LSP_MTU;
 #ifdef TOPOLOGY_GENERATE  #ifdef TOPOLOGY_GENERATE
   memcpy (area->topology_baseis, DEFAULT_TOPOLOGY_BASEIS, ISIS_SYS_ID_LEN);    memcpy (area->topology_baseis, DEFAULT_TOPOLOGY_BASEIS, ISIS_SYS_ID_LEN);
 #endif /* TOPOLOGY_GENERATE */  #endif /* TOPOLOGY_GENERATE */
   
  /* FIXME: Think of a better way... */  area->area_tag = strdup (area_tag);
  area->min_bcast_mtu = 1497;  listnode_add (isis->area_list, area);
   area->isis = isis;
   
   return area;    return area;
 }  }
Line 185  isis_area_get (struct vty *vty, const char *area_tag) Line 199  isis_area_get (struct vty *vty, const char *area_tag)
       return CMD_SUCCESS;        return CMD_SUCCESS;
     }      }
   
  area = isis_area_create ();  area = isis_area_create (area_tag);
  area->area_tag = strdup (area_tag); 
  listnode_add (isis->area_list, area); 
   
   if (isis->debugs & DEBUG_EVENTS)    if (isis->debugs & DEBUG_EVENTS)
     zlog_debug ("New IS-IS area instance %s", area->area_tag);      zlog_debug ("New IS-IS area instance %s", area->area_tag);
Line 204  isis_area_destroy (struct vty *vty, const char *area_t Line 216  isis_area_destroy (struct vty *vty, const char *area_t
   struct isis_area *area;    struct isis_area *area;
   struct listnode *node, *nnode;    struct listnode *node, *nnode;
   struct isis_circuit *circuit;    struct isis_circuit *circuit;
     struct area_addr *addr;
   
   area = isis_area_lookup (area_tag);    area = isis_area_lookup (area_tag);
   
   if (area == NULL)    if (area == NULL)
     {      {
       vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);        vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   if (area->circuit_list)    if (area->circuit_list)
     {      {
       for (ALL_LIST_ELEMENTS (area->circuit_list, node, nnode, circuit))        for (ALL_LIST_ELEMENTS (area->circuit_list, node, nnode, circuit))
        {        {
          /* The fact that it's in circuit_list means that it was configured */          circuit->ip_router = 0;
          isis_csm_state_change (ISIS_DISABLE, circuit, area);#ifdef HAVE_IPV6
          isis_circuit_down (circuit);          circuit->ipv6_router = 0;
          isis_circuit_deconfigure (circuit, area);#endif
        }          isis_csm_state_change (ISIS_DISABLE, circuit, area);
              }
       list_delete (area->circuit_list);        list_delete (area->circuit_list);
         area->circuit_list = NULL;
     }      }
   listnode_delete (isis->area_list, area);  
   
     if (area->lspdb[0] != NULL)
       {
         lsp_db_destroy (area->lspdb[0]);
         area->lspdb[0] = NULL;
       }
     if (area->lspdb[1] != NULL)
       {
         lsp_db_destroy (area->lspdb[1]);
         area->lspdb[1] = NULL;
       }
   
     spftree_area_del (area);
   
     /* invalidate and validate would delete all routes from zebra */
     isis_route_invalidate (area);
     isis_route_validate (area);
   
     if (area->route_table[0])
       {
         route_table_finish (area->route_table[0]);
         area->route_table[0] = NULL;
       }
     if (area->route_table[1])
       {
         route_table_finish (area->route_table[1]);
         area->route_table[1] = NULL;
       }
   #ifdef HAVE_IPV6
     if (area->route_table6[0])
       {
         route_table_finish (area->route_table6[0]);
         area->route_table6[0] = NULL;
       }
     if (area->route_table6[1])
       {
         route_table_finish (area->route_table6[1]);
         area->route_table6[1] = NULL;
       }
   #endif /* HAVE_IPV6 */
   
     isis_redist_area_finish(area);
   
     for (ALL_LIST_ELEMENTS (area->area_addrs, node, nnode, addr))
       {
         list_delete_node (area->area_addrs, node);
         XFREE (MTYPE_ISIS_AREA_ADDR, addr);
       }
     area->area_addrs = NULL;
   
   THREAD_TIMER_OFF (area->t_tick);    THREAD_TIMER_OFF (area->t_tick);
   if (area->t_remove_aged)  
     thread_cancel (area->t_remove_aged);  
   THREAD_TIMER_OFF (area->t_lsp_refresh[0]);    THREAD_TIMER_OFF (area->t_lsp_refresh[0]);
   THREAD_TIMER_OFF (area->t_lsp_refresh[1]);    THREAD_TIMER_OFF (area->t_lsp_refresh[1]);
   
  THREAD_TIMER_OFF (area->spftree[0]->t_spf);  thread_cancel_event (master, area);
  THREAD_TIMER_OFF (area->spftree[1]->t_spf); 
   
  THREAD_TIMER_OFF (area->t_lsp_l1_regenerate);  listnode_delete (isis->area_list, area);
  THREAD_TIMER_OFF (area->t_lsp_l2_regenerate); 
   
     free (area->area_tag);
   
   XFREE (MTYPE_ISIS_AREA, area);    XFREE (MTYPE_ISIS_AREA, area);
   
  isis->sysid_set=0;  if (listcount (isis->area_list) == 0)
     {
       memset (isis->sysid, 0, ISIS_SYS_ID_LEN);
       isis->sysid_set = 0;
     }
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
 int  int
area_net_title (struct vty *vty, const u_char *net_title)area_net_title (struct vty *vty, const char *net_title)
 {  {
   struct isis_area *area;    struct isis_area *area;
   struct area_addr *addr;    struct area_addr *addr;
Line 260  area_net_title (struct vty *vty, const u_char *net_tit Line 324  area_net_title (struct vty *vty, const u_char *net_tit
   if (!area)    if (!area)
     {      {
       vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);        vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   /* We check that we are not over the maximal number of addresses */    /* We check that we are not over the maximal number of addresses */
Line 268  area_net_title (struct vty *vty, const u_char *net_tit Line 332  area_net_title (struct vty *vty, const u_char *net_tit
     {      {
       vty_out (vty, "Maximum of area addresses (%d) already reached %s",        vty_out (vty, "Maximum of area addresses (%d) already reached %s",
                isis->max_area_addrs, VTY_NEWLINE);                 isis->max_area_addrs, VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NOTHING_TODO;
     }      }
   
   addr = XMALLOC (MTYPE_ISIS_AREA_ADDR, sizeof (struct area_addr));    addr = XMALLOC (MTYPE_ISIS_AREA_ADDR, sizeof (struct area_addr));
Line 280  area_net_title (struct vty *vty, const u_char *net_tit Line 344  area_net_title (struct vty *vty, const u_char *net_tit
 #endif /* EXTREME_DEBUG */  #endif /* EXTREME_DEBUG */
   if (addr->addr_len < 8 || addr->addr_len > 20)    if (addr->addr_len < 8 || addr->addr_len > 20)
     {      {
      zlog_warn ("area address must be at least 8..20 octets long (%d)",      vty_out (vty, "area address must be at least 8..20 octets long (%d)%s",
                 addr->addr_len);               addr->addr_len, VTY_NEWLINE);
       XFREE (MTYPE_ISIS_AREA_ADDR, addr);        XFREE (MTYPE_ISIS_AREA_ADDR, addr);
      return CMD_WARNING;      return CMD_ERR_AMBIGUOUS;
     }      }
   
     if (addr->area_addr[addr->addr_len-1] != 0)
       {
         vty_out (vty, "nsel byte (last byte) in area address must be 0%s",
                  VTY_NEWLINE);
         XFREE (MTYPE_ISIS_AREA_ADDR, addr);
         return CMD_ERR_AMBIGUOUS;
       }
   
   if (isis->sysid_set == 0)    if (isis->sysid_set == 0)
     {      {
       /*        /*
        * First area address - get the SystemID for this router         * First area address - get the SystemID for this router
        */         */
      memcpy (isis->sysid, GETSYSID (addr, ISIS_SYS_ID_LEN), ISIS_SYS_ID_LEN);      memcpy (isis->sysid, GETSYSID (addr), ISIS_SYS_ID_LEN);
       isis->sysid_set = 1;        isis->sysid_set = 1;
       if (isis->debugs & DEBUG_EVENTS)        if (isis->debugs & DEBUG_EVENTS)
         zlog_debug ("Router has SystemID %s", sysid_print (isis->sysid));          zlog_debug ("Router has SystemID %s", sysid_print (isis->sysid));
Line 301  area_net_title (struct vty *vty, const u_char *net_tit Line 373  area_net_title (struct vty *vty, const u_char *net_tit
       /*        /*
        * Check that the SystemID portions match         * Check that the SystemID portions match
        */         */
      if (memcmp (isis->sysid, GETSYSID (addr, ISIS_SYS_ID_LEN),      if (memcmp (isis->sysid, GETSYSID (addr), ISIS_SYS_ID_LEN))
                  ISIS_SYS_ID_LEN)) 
         {          {
           vty_out (vty,            vty_out (vty,
                    "System ID must not change when defining additional area"                     "System ID must not change when defining additional area"
                    " addresses%s", VTY_NEWLINE);                     " addresses%s", VTY_NEWLINE);
           XFREE (MTYPE_ISIS_AREA_ADDR, addr);            XFREE (MTYPE_ISIS_AREA_ADDR, addr);
          return CMD_WARNING;          return CMD_ERR_AMBIGUOUS;
         }          }
   
       /* now we see that we don't already have this address */        /* now we see that we don't already have this address */
       for (ALL_LIST_ELEMENTS_RO (area->area_addrs, node, addrp))        for (ALL_LIST_ELEMENTS_RO (area->area_addrs, node, addrp))
         {          {
          if ((addrp->addr_len + ISIS_SYS_ID_LEN + 1) != (addr->addr_len))          if ((addrp->addr_len + ISIS_SYS_ID_LEN + ISIS_NSEL_LEN) != (addr->addr_len))
             continue;              continue;
           if (!memcmp (addrp->area_addr, addr->area_addr, addr->addr_len))            if (!memcmp (addrp->area_addr, addr->area_addr, addr->addr_len))
             {              {
Line 322  area_net_title (struct vty *vty, const u_char *net_tit Line 393  area_net_title (struct vty *vty, const u_char *net_tit
               return CMD_SUCCESS;       /* silent fail */                return CMD_SUCCESS;       /* silent fail */
             }              }
         }          }
   
     }      }
   
   /*    /*
    * Forget the systemID part of the address     * Forget the systemID part of the address
    */     */
  addr->addr_len -= (ISIS_SYS_ID_LEN + 1);  addr->addr_len -= (ISIS_SYS_ID_LEN + ISIS_NSEL_LEN);
   listnode_add (area->area_addrs, addr);    listnode_add (area->area_addrs, addr);
   
   /* only now we can safely generate our LSPs for this area */    /* only now we can safely generate our LSPs for this area */
   if (listcount (area->area_addrs) > 0)    if (listcount (area->area_addrs) > 0)
     {      {
      lsp_l1_generate (area);      if (area->is_type & IS_LEVEL_1)
      lsp_l2_generate (area);        lsp_generate (area, IS_LEVEL_1);
       if (area->is_type & IS_LEVEL_2)
         lsp_generate (area, IS_LEVEL_2);
     }      }
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
 int  int
area_clear_net_title (struct vty *vty, const u_char *net_title)area_clear_net_title (struct vty *vty, const char *net_title)
 {  {
   struct isis_area *area;    struct isis_area *area;
   struct area_addr addr, *addrp = NULL;    struct area_addr addr, *addrp = NULL;
Line 352  area_clear_net_title (struct vty *vty, const u_char *n Line 425  area_clear_net_title (struct vty *vty, const u_char *n
   if (!area)    if (!area)
     {      {
       vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);        vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   addr.addr_len = dotformat2buff (buff, net_title);    addr.addr_len = dotformat2buff (buff, net_title);
Line 360  area_clear_net_title (struct vty *vty, const u_char *n Line 433  area_clear_net_title (struct vty *vty, const u_char *n
     {      {
       vty_out (vty, "Unsupported area address length %d, should be 8...20 %s",        vty_out (vty, "Unsupported area address length %d, should be 8...20 %s",
                addr.addr_len, VTY_NEWLINE);                 addr.addr_len, VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_AMBIGUOUS;
     }      }
   
   memcpy (addr.area_addr, buff, (int) addr.addr_len);    memcpy (addr.area_addr, buff, (int) addr.addr_len);
   
   for (ALL_LIST_ELEMENTS_RO (area->area_addrs, node, addrp))    for (ALL_LIST_ELEMENTS_RO (area->area_addrs, node, addrp))
    if (addrp->addr_len == addr.addr_len &&    if ((addrp->addr_len + ISIS_SYS_ID_LEN + 1) == addr.addr_len &&
         !memcmp (addrp->area_addr, addr.area_addr, addr.addr_len))          !memcmp (addrp->area_addr, addr.area_addr, addr.addr_len))
     break;      break;
   
Line 374  area_clear_net_title (struct vty *vty, const u_char *n Line 447  area_clear_net_title (struct vty *vty, const u_char *n
     {      {
       vty_out (vty, "No area address %s for area %s %s", net_title,        vty_out (vty, "No area address %s for area %s %s", net_title,
                area->area_tag, VTY_NEWLINE);                 area->area_tag, VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   listnode_delete (area->area_addrs, addrp);    listnode_delete (area->area_addrs, addrp);
     XFREE (MTYPE_ISIS_AREA_ADDR, addrp);
   
     /*
      * Last area address - reset the SystemID for this router
      */
     if (listcount (area->area_addrs) == 0)
       {
         memset (isis->sysid, 0, ISIS_SYS_ID_LEN);
         isis->sysid_set = 0;
         if (isis->debugs & DEBUG_EVENTS)
           zlog_debug ("Router has no SystemID");
       }
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
 /*  /*
 * 'show clns neighbors' command * 'show isis interface' command
  */   */
   
 int  int
show_clns_neigh (struct vty *vty, char detail)show_isis_interface_common (struct vty *vty, const char *ifname, char detail)
 {  {
   struct listnode *anode, *cnode;    struct listnode *anode, *cnode;
   struct isis_area *area;    struct isis_area *area;
   struct isis_circuit *circuit;    struct isis_circuit *circuit;
   struct list *db;  
   int i;  
   
   if (!isis)    if (!isis)
     {      {
Line 406  show_clns_neigh (struct vty *vty, char detail) Line 489  show_clns_neigh (struct vty *vty, char detail)
       vty_out (vty, "Area %s:%s", area->area_tag, VTY_NEWLINE);        vty_out (vty, "Area %s:%s", area->area_tag, VTY_NEWLINE);
   
       if (detail == ISIS_UI_LEVEL_BRIEF)        if (detail == ISIS_UI_LEVEL_BRIEF)
        vty_out (vty, "  System Id           Interface   L  State        "        vty_out (vty, "  Interface   CircId   State    Type     Level%s",
                 "Holdtime SNPA%s", VTY_NEWLINE);                 VTY_NEWLINE);
   
       for (ALL_LIST_ELEMENTS_RO (area->circuit_list, cnode, circuit))        for (ALL_LIST_ELEMENTS_RO (area->circuit_list, cnode, circuit))
        {        if (!ifname)
          if (circuit->circ_type == CIRCUIT_T_BROADCAST)          isis_circuit_print_vty (circuit, vty, detail);
            {        else if (strcmp(circuit->interface->name, ifname) == 0)
              for (i = 0; i < 2; i++)          isis_circuit_print_vty (circuit, vty, detail);
                { 
                  db = circuit->u.bc.adjdb[i]; 
                  if (db && db->count) 
                    { 
                      if (detail == ISIS_UI_LEVEL_BRIEF) 
                        isis_adjdb_iterate (db, 
                                            (void (*) 
                                             (struct isis_adjacency *, 
                                              void *)) isis_adj_print_vty, 
                                            vty); 
                      if (detail == ISIS_UI_LEVEL_DETAIL) 
                        isis_adjdb_iterate (db, 
                                            (void (*) 
                                             (struct isis_adjacency *, 
                                              void *)) 
                                            isis_adj_print_vty_detail, vty); 
                      if (detail == ISIS_UI_LEVEL_EXTENSIVE) 
                        isis_adjdb_iterate (db, 
                                            (void (*) 
                                             (struct isis_adjacency *, 
                                              void *)) 
                                            isis_adj_print_vty_extensive, 
                                            vty); 
                    } 
                } 
            } 
          else if (circuit->circ_type == CIRCUIT_T_P2P && 
                   circuit->u.p2p.neighbor) 
            { 
              if (detail == ISIS_UI_LEVEL_BRIEF) 
                isis_adj_p2p_print_vty (circuit->u.p2p.neighbor, vty); 
              if (detail == ISIS_UI_LEVEL_DETAIL) 
                isis_adj_p2p_print_vty_detail (circuit->u.p2p.neighbor, vty); 
              if (detail == ISIS_UI_LEVEL_EXTENSIVE) 
                isis_adj_p2p_print_vty_extensive (circuit->u.p2p.neighbor, 
                                                  vty); 
            } 
        } 
     }      }
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
DEFUN (show_clns_neighbors,DEFUN (show_isis_interface,
       show_clns_neighbors_cmd,       show_isis_interface_cmd,
       "show clns neighbors",       "show isis interface",
        SHOW_STR         SHOW_STR
       "clns network information\n"       "ISIS network information\n"
       "CLNS neighbor adjacencies\n")       "ISIS interface\n")
 {  {
  return show_clns_neigh (vty, ISIS_UI_LEVEL_BRIEF);  return show_isis_interface_common (vty, NULL, ISIS_UI_LEVEL_BRIEF);
 }  }
   
ALIAS (show_clns_neighbors,DEFUN (show_isis_interface_detail,
       show_isis_neighbors_cmd,       show_isis_interface_detail_cmd,
       "show isis neighbors",       "show isis interface detail",
        SHOW_STR         SHOW_STR
       "IS-IS network information\n"       "ISIS network information\n"
       "IS-IS neighbor adjacencies\n")       "ISIS interface\n"
        "show detailed information\n")
 {
   return show_isis_interface_common (vty, NULL, ISIS_UI_LEVEL_DETAIL);
 }
   
DEFUN (show_clns_neighbors_detail,DEFUN (show_isis_interface_arg,
       show_clns_neighbors_detail_cmd,       show_isis_interface_arg_cmd,
       "show clns neighbors detail",       "show isis interface WORD",
        SHOW_STR         SHOW_STR
       "clns network information\n"       "ISIS network information\n"
       "CLNS neighbor adjacencies\n"       "ISIS interface\n"
       "show detailed information\n")       "ISIS interface name\n")
 {  {
  return show_clns_neigh (vty, ISIS_UI_LEVEL_DETAIL);  return show_isis_interface_common (vty, argv[0], ISIS_UI_LEVEL_DETAIL);
 }  }
   
ALIAS (show_clns_neighbors_detail,/*
       show_isis_neighbors_detail_cmd, * 'show isis neighbor' command
       "show isis neighbors detail", */
 
 int
 show_isis_neighbor_common (struct vty *vty, const char *id, char detail)
 {
   struct listnode *anode, *cnode, *node;
   struct isis_area *area;
   struct isis_circuit *circuit;
   struct list *adjdb;
   struct isis_adjacency *adj;
   struct isis_dynhn *dynhn;
   u_char sysid[ISIS_SYS_ID_LEN];
   int i;
 
   if (!isis)
     {
       vty_out (vty, "IS-IS Routing Process not enabled%s", VTY_NEWLINE);
       return CMD_SUCCESS;
     }
 
   memset (sysid, 0, ISIS_SYS_ID_LEN);
   if (id)
     {
       if (sysid2buff (sysid, id) == 0)
         {
           dynhn = dynhn_find_by_name (id);
           if (dynhn == NULL)
             {
               vty_out (vty, "Invalid system id %s%s", id, VTY_NEWLINE);
               return CMD_SUCCESS;
             }
           memcpy (sysid, dynhn->id, ISIS_SYS_ID_LEN);
         }
     }
 
   for (ALL_LIST_ELEMENTS_RO (isis->area_list, anode, area))
     {
       vty_out (vty, "Area %s:%s", area->area_tag, VTY_NEWLINE);
 
       if (detail == ISIS_UI_LEVEL_BRIEF)
         vty_out (vty, "  System Id           Interface   L  State"
                       "        Holdtime SNPA%s", VTY_NEWLINE);
 
       for (ALL_LIST_ELEMENTS_RO (area->circuit_list, cnode, circuit))
         {
           if (circuit->circ_type == CIRCUIT_T_BROADCAST)
             {
               for (i = 0; i < 2; i++)
                 {
                   adjdb = circuit->u.bc.adjdb[i];
                   if (adjdb && adjdb->count)
                     {
                       for (ALL_LIST_ELEMENTS_RO (adjdb, node, adj))
                         if (!id || !memcmp (adj->sysid, sysid,
                                             ISIS_SYS_ID_LEN))
                           isis_adj_print_vty (adj, vty, detail);
                     }
                 }
             }
           else if (circuit->circ_type == CIRCUIT_T_P2P &&
                    circuit->u.p2p.neighbor)
             {
               adj = circuit->u.p2p.neighbor;
               if (!id || !memcmp (adj->sysid, sysid, ISIS_SYS_ID_LEN))
                 isis_adj_print_vty (adj, vty, detail);
             }
         }
     }
 
   return CMD_SUCCESS;
 }
 
 /*
  * 'clear isis neighbor' command
  */
 int
 clear_isis_neighbor_common (struct vty *vty, const char *id)
 {
   struct listnode *anode, *cnode, *cnextnode, *node, *nnode;
   struct isis_area *area;
   struct isis_circuit *circuit;
   struct list *adjdb;
   struct isis_adjacency *adj;
   struct isis_dynhn *dynhn;
   u_char sysid[ISIS_SYS_ID_LEN];
   int i;
 
   if (!isis)
     {
       vty_out (vty, "IS-IS Routing Process not enabled%s", VTY_NEWLINE);
       return CMD_SUCCESS;
     }
 
   memset (sysid, 0, ISIS_SYS_ID_LEN);
   if (id)
     {
       if (sysid2buff (sysid, id) == 0)
         {
           dynhn = dynhn_find_by_name (id);
           if (dynhn == NULL)
             {
               vty_out (vty, "Invalid system id %s%s", id, VTY_NEWLINE);
               return CMD_SUCCESS;
             }
           memcpy (sysid, dynhn->id, ISIS_SYS_ID_LEN);
         }
     }
 
   for (ALL_LIST_ELEMENTS_RO (isis->area_list, anode, area))
     {
       for (ALL_LIST_ELEMENTS (area->circuit_list, cnode, cnextnode, circuit))
         {
           if (circuit->circ_type == CIRCUIT_T_BROADCAST)
             {
               for (i = 0; i < 2; i++)
                 {
                   adjdb = circuit->u.bc.adjdb[i];
                   if (adjdb && adjdb->count)
                     {
                       for (ALL_LIST_ELEMENTS (adjdb, node, nnode, adj))
                         if (!id || !memcmp (adj->sysid, sysid, ISIS_SYS_ID_LEN))
                           isis_adj_state_change (adj, ISIS_ADJ_DOWN,
                                                  "clear user request");
                     }
                 }
             }
           else if (circuit->circ_type == CIRCUIT_T_P2P &&
                    circuit->u.p2p.neighbor)
             {
               adj = circuit->u.p2p.neighbor;
               if (!id || !memcmp (adj->sysid, sysid, ISIS_SYS_ID_LEN))
                 isis_adj_state_change (adj, ISIS_ADJ_DOWN,
                                        "clear user request");
             }
         }
     }
 
   return CMD_SUCCESS;
 }
 
 DEFUN (show_isis_neighbor,
        show_isis_neighbor_cmd,
        "show isis neighbor",
        SHOW_STR         SHOW_STR
       "IS-IS network information\n"       "ISIS network information\n"
       "IS-IS neighbor adjacencies\n"       "ISIS neighbor adjacencies\n")
 {
   return show_isis_neighbor_common (vty, NULL, ISIS_UI_LEVEL_BRIEF);
 }
 
 DEFUN (show_isis_neighbor_detail,
        show_isis_neighbor_detail_cmd,
        "show isis neighbor detail",
        SHOW_STR
        "ISIS network information\n"
        "ISIS neighbor adjacencies\n"
        "show detailed information\n")         "show detailed information\n")
   {
     return show_isis_neighbor_common (vty, NULL, ISIS_UI_LEVEL_DETAIL);
   }
   
   DEFUN (show_isis_neighbor_arg,
          show_isis_neighbor_arg_cmd,
          "show isis neighbor WORD",
          SHOW_STR
          "ISIS network information\n"
          "ISIS neighbor adjacencies\n"
          "System id\n")
   {
     return show_isis_neighbor_common (vty, argv[0], ISIS_UI_LEVEL_DETAIL);
   }
   
   DEFUN (clear_isis_neighbor,
          clear_isis_neighbor_cmd,
          "clear isis neighbor",
          CLEAR_STR
          "Reset ISIS network information\n"
          "Reset ISIS neighbor adjacencies\n")
   {
     return clear_isis_neighbor_common (vty, NULL);
   }
   
   DEFUN (clear_isis_neighbor_arg,
          clear_isis_neighbor_arg_cmd,
          "clear isis neighbor WORD",
          CLEAR_STR
          "ISIS network information\n"
          "ISIS neighbor adjacencies\n"
          "System id\n")
   {
     return clear_isis_neighbor_common (vty, argv[0]);
   }
   
 /*  /*
  * 'isis debug', 'show debugging'   * 'isis debug', 'show debugging'
  */   */
Line 535  print_debug (struct vty *vty, int flags, int onoff) Line 772  print_debug (struct vty *vty, int flags, int onoff)
              VTY_NEWLINE);               VTY_NEWLINE);
   if (flags & DEBUG_EVENTS)    if (flags & DEBUG_EVENTS)
     vty_out (vty, "IS-IS Event debugging is %s%s", onoffs, VTY_NEWLINE);      vty_out (vty, "IS-IS Event debugging is %s%s", onoffs, VTY_NEWLINE);
  if (flags & DEBUG_PACKET_DUMP)
     vty_out (vty, "IS-IS Packet dump debugging is %s%s", onoffs, VTY_NEWLINE);
   if (flags & DEBUG_LSP_GEN)
     vty_out (vty, "IS-IS LSP generation debugging is %s%s", onoffs, VTY_NEWLINE);
   if (flags & DEBUG_LSP_SCHED)
     vty_out (vty, "IS-IS LSP scheduling debugging is %s%s", onoffs, VTY_NEWLINE);
 }  }
   
 DEFUN (show_debugging,  DEFUN (show_debugging,
Line 617  config_write_debug (struct vty *vty) Line 859  config_write_debug (struct vty *vty)
       vty_out (vty, "debug isis events%s", VTY_NEWLINE);        vty_out (vty, "debug isis events%s", VTY_NEWLINE);
       write++;        write++;
     }      }
     if (flags & DEBUG_PACKET_DUMP)
       {
         vty_out (vty, "debug isis packet-dump%s", VTY_NEWLINE);
         write++;
       }
     if (flags & DEBUG_LSP_GEN)
       {
         vty_out (vty, "debug isis lsp-gen%s", VTY_NEWLINE);
         write++;
       }
     if (flags & DEBUG_LSP_SCHED)
       {
         vty_out (vty, "debug isis lsp-sched%s", VTY_NEWLINE);
         write++;
       }
   
   return write;    return write;
 }  }
Line 803  DEFUN (no_debug_isis_spfevents, Line 1060  DEFUN (no_debug_isis_spfevents,
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
   
 DEFUN (debug_isis_spfstats,  DEFUN (debug_isis_spfstats,
        debug_isis_spfstats_cmd,         debug_isis_spfstats_cmd,
        "debug isis spf-statistics ",         "debug isis spf-statistics ",
Line 908  DEFUN (no_debug_isis_events, Line 1164  DEFUN (no_debug_isis_events,
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
   DEFUN (debug_isis_packet_dump,
          debug_isis_packet_dump_cmd,
          "debug isis packet-dump",
          DEBUG_STR
          "IS-IS information\n"
          "IS-IS packet dump\n")
   {
     isis->debugs |= DEBUG_PACKET_DUMP;
     print_debug (vty, DEBUG_PACKET_DUMP, 1);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (no_debug_isis_packet_dump,
          no_debug_isis_packet_dump_cmd,
          "no debug isis packet-dump",
          UNDEBUG_STR
          "IS-IS information\n"
          "IS-IS packet dump\n")
   {
     isis->debugs &= ~DEBUG_PACKET_DUMP;
     print_debug (vty, DEBUG_PACKET_DUMP, 0);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (debug_isis_lsp_gen,
          debug_isis_lsp_gen_cmd,
          "debug isis lsp-gen",
          DEBUG_STR
          "IS-IS information\n"
          "IS-IS generation of own LSPs\n")
   {
     isis->debugs |= DEBUG_LSP_GEN;
     print_debug (vty, DEBUG_LSP_GEN, 1);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (no_debug_isis_lsp_gen,
          no_debug_isis_lsp_gen_cmd,
          "no debug isis lsp-gen",
          UNDEBUG_STR
          "IS-IS information\n"
          "IS-IS generation of own LSPs\n")
   {
     isis->debugs &= ~DEBUG_LSP_GEN;
     print_debug (vty, DEBUG_LSP_GEN, 0);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (debug_isis_lsp_sched,
          debug_isis_lsp_sched_cmd,
          "debug isis lsp-sched",
          DEBUG_STR
          "IS-IS information\n"
          "IS-IS scheduling of LSP generation\n")
   {
     isis->debugs |= DEBUG_LSP_SCHED;
     print_debug (vty, DEBUG_LSP_SCHED, 1);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (no_debug_isis_lsp_sched,
          no_debug_isis_lsp_sched_cmd,
          "no debug isis lsp-gen",
          UNDEBUG_STR
          "IS-IS information\n"
          "IS-IS scheduling of LSP generation\n")
   {
     isis->debugs &= ~DEBUG_LSP_SCHED;
     print_debug (vty, DEBUG_LSP_SCHED, 0);
   
     return CMD_SUCCESS;
   }
   
 DEFUN (show_hostname,  DEFUN (show_hostname,
        show_hostname_cmd,         show_hostname_cmd,
        "show isis hostname",         "show isis hostname",
Line 920  DEFUN (show_hostname, Line 1254  DEFUN (show_hostname,
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
DEFUN (show_database,static void
       show_database_cmd,vty_out_timestr(struct vty *vty, time_t uptime)
       "show isis database", 
       SHOW_STR "IS-IS information\n" "IS-IS link state database\n") 
 {  {
  struct listnode *node;  struct tm *tm;
   time_t difftime = time (NULL);
   difftime -= uptime;
   tm = gmtime (&difftime);
 
 #define ONE_DAY_SECOND 60*60*24
 #define ONE_WEEK_SECOND 60*60*24*7
   if (difftime < ONE_DAY_SECOND)
     vty_out (vty,  "%02d:%02d:%02d", 
         tm->tm_hour, tm->tm_min, tm->tm_sec);
   else if (difftime < ONE_WEEK_SECOND)
     vty_out (vty, "%dd%02dh%02dm", 
         tm->tm_yday, tm->tm_hour, tm->tm_min);
   else
     vty_out (vty, "%02dw%dd%02dh", 
         tm->tm_yday/7,
         tm->tm_yday - ((tm->tm_yday/7) * 7), tm->tm_hour);
   vty_out (vty, " ago");
 }
 
 DEFUN (show_isis_summary,
        show_isis_summary_cmd,
        "show isis summary",
        SHOW_STR "IS-IS information\n" "IS-IS summary\n")
 {
   struct listnode *node, *node2;
   struct isis_area *area;    struct isis_area *area;
  int level, lsp_count;  struct isis_spftree *spftree;
   int level;
   
  if (isis->area_list->count == 0)  if (isis == NULL)
   {
     vty_out (vty, "ISIS is not running%s", VTY_NEWLINE);
     return CMD_SUCCESS;      return CMD_SUCCESS;
     }
   
     vty_out (vty, "Process Id      : %ld%s", isis->process_id,
         VTY_NEWLINE);
     if (isis->sysid_set)
       vty_out (vty, "System Id       : %s%s", sysid_print (isis->sysid),
           VTY_NEWLINE);
   
     vty_out (vty, "Up time         : ");
     vty_out_timestr(vty, isis->uptime);
     vty_out (vty, "%s", VTY_NEWLINE);
   
     if (isis->area_list)
       vty_out (vty, "Number of areas : %d%s", isis->area_list->count,
           VTY_NEWLINE);
   
   for (ALL_LIST_ELEMENTS_RO (isis->area_list, node, area))    for (ALL_LIST_ELEMENTS_RO (isis->area_list, node, area))
     {
       vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
           VTY_NEWLINE);
   
       if (listcount (area->area_addrs) > 0)
     {      {
      vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",      struct area_addr *area_addr;
               VTY_NEWLINE);      for (ALL_LIST_ELEMENTS_RO (area->area_addrs, node2, area_addr))
      for (level = 0; level < ISIS_LEVELS; level++)      {
        {        vty_out (vty, "  Net: %s%s",
          if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0)            isonet_print (area_addr->area_addr,
            {              area_addr->addr_len + ISIS_SYS_ID_LEN +
              vty_out (vty, "IS-IS Level-%d link-state database:%s",              1), VTY_NEWLINE);
                       level + 1, VTY_NEWLINE);      }
     }
   
              lsp_count = lsp_print_all (vty, area->lspdb[level],    for (level = ISIS_LEVEL1; level <= ISIS_LEVELS; level++)
                                         ISIS_UI_LEVEL_BRIEF,    {
                                         area->dynhostname);      if ((area->is_type & level) == 0)
         continue;
   
              vty_out (vty, "%s    %u LSPs%s%s",      vty_out (vty, "  Level-%d:%s", level, VTY_NEWLINE);
                       VTY_NEWLINE, lsp_count, VTY_NEWLINE, VTY_NEWLINE);      spftree = area->spftree[level - 1];
            }      if (spftree->pending)
        }        vty_out (vty, "    IPv4 SPF: (pending)%s", VTY_NEWLINE);
       else
         vty_out (vty, "    IPv4 SPF:%s", VTY_NEWLINE);
 
       vty_out (vty, "      minimum interval  : %d%s",
           area->min_spf_interval[level - 1], VTY_NEWLINE);
 
       vty_out (vty, "      last run elapsed  : ");
       vty_out_timestr(vty, spftree->last_run_timestamp);
       vty_out (vty, "%s", VTY_NEWLINE);
 
       vty_out (vty, "      last run duration : %u usec%s",
                (u_int32_t)spftree->last_run_duration, VTY_NEWLINE);
 
       vty_out (vty, "      run count         : %d%s",
           spftree->runcount, VTY_NEWLINE);
 
 #ifdef HAVE_IPV6
       spftree = area->spftree6[level - 1];
       if (spftree->pending)
         vty_out (vty, "    IPv6 SPF: (pending)%s", VTY_NEWLINE);
       else
         vty_out (vty, "    IPv6 SPF:%s", VTY_NEWLINE);
 
       vty_out (vty, "      minimum interval  : %d%s",
           area->min_spf_interval[level - 1], VTY_NEWLINE);
 
       vty_out (vty, "      last run elapsed  : ");
       vty_out_timestr(vty, spftree->last_run_timestamp);
       vty_out (vty, "%s", VTY_NEWLINE);
 
       vty_out (vty, "      last run duration : %llu msec%s",
                (unsigned long long)spftree->last_run_duration, VTY_NEWLINE);
 
       vty_out (vty, "      run count         : %d%s",
           spftree->runcount, VTY_NEWLINE);
 #endif
     }      }
     }
     vty_out (vty, "%s", VTY_NEWLINE);
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
DEFUN (show_database_detail,/*
       show_database_detail_cmd, * This function supports following display options:
       "show isis database detail", * [ show isis database [detail] ]
       SHOW_STR * [ show isis database <sysid> [detail] ]
       "IS-IS information\n" * [ show isis database <hostname> [detail] ]
       "IS-IS link state database\n") * [ show isis database <sysid>.<pseudo-id> [detail] ]
  * [ show isis database <hostname>.<pseudo-id> [detail] ]
  * [ show isis database <sysid>.<pseudo-id>-<fragment-number> [detail] ]
  * [ show isis database <hostname>.<pseudo-id>-<fragment-number> [detail] ]
  * [ show isis database detail <sysid> ]
  * [ show isis database detail <hostname> ]
  * [ show isis database detail <sysid>.<pseudo-id> ]
  * [ show isis database detail <hostname>.<pseudo-id> ]
  * [ show isis database detail <sysid>.<pseudo-id>-<fragment-number> ]
  * [ show isis database detail <hostname>.<pseudo-id>-<fragment-number> ]
  */
 static int
 show_isis_database (struct vty *vty, const char *argv, int ui_level)
 {  {
   struct listnode *node;    struct listnode *node;
   struct isis_area *area;    struct isis_area *area;
     struct isis_lsp *lsp;
     struct isis_dynhn *dynhn;
     const char *pos = argv;
     u_char lspid[ISIS_SYS_ID_LEN+2];
     char sysid[255];
     u_char number[3];
   int level, lsp_count;    int level, lsp_count;
   
   if (isis->area_list->count == 0)    if (isis->area_list->count == 0)
     return CMD_SUCCESS;      return CMD_SUCCESS;
   
     memset (&lspid, 0, ISIS_SYS_ID_LEN);
     memset (&sysid, 0, 255);
   
     /*
      * extract fragment and pseudo id from the string argv
      * in the forms:
      * (a) <systemid/hostname>.<pseudo-id>-<framenent> or
      * (b) <systemid/hostname>.<pseudo-id> or
      * (c) <systemid/hostname> or
      * Where systemid is in the form:
      * xxxx.xxxx.xxxx
      */
     if (argv)
        strncpy (sysid, argv, 254);
     if (argv && strlen (argv) > 3)
       {
         pos = argv + strlen (argv) - 3;
         if (strncmp (pos, "-", 1) == 0)
         {
           memcpy (number, ++pos, 2);
           lspid[ISIS_SYS_ID_LEN+1] = (u_char) strtol ((char *)number, NULL, 16);
           pos -= 4;
           if (strncmp (pos, ".", 1) != 0)
             return CMD_ERR_AMBIGUOUS;
         }
         if (strncmp (pos, ".", 1) == 0)
         {
           memcpy (number, ++pos, 2);
           lspid[ISIS_SYS_ID_LEN] = (u_char) strtol ((char *)number, NULL, 16);
           sysid[pos - argv - 1] = '\0';
         }
       }
   
   for (ALL_LIST_ELEMENTS_RO (isis->area_list, node, area))    for (ALL_LIST_ELEMENTS_RO (isis->area_list, node, area))
     {      {
       vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",        vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
               VTY_NEWLINE);               VTY_NEWLINE);
 
       for (level = 0; level < ISIS_LEVELS; level++)        for (level = 0; level < ISIS_LEVELS; level++)
        {        {
          if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0)          if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0)
            {            {
              vty_out (vty, "IS-IS Level-%d Link State Database:%s",              lsp = NULL;
                       level + 1, VTY_NEWLINE);              if (argv != NULL)
                 {
                   /*
                    * Try to find the lsp-id if the argv string is in
                    * the form hostname.<pseudo-id>-<fragment>
                    */
                   if (sysid2buff (lspid, sysid))
                     {
                       lsp = lsp_search (lspid, area->lspdb[level]);
                     }
                   else if ((dynhn = dynhn_find_by_name (sysid)))
                     {
                       memcpy (lspid, dynhn->id, ISIS_SYS_ID_LEN);
                       lsp = lsp_search (lspid, area->lspdb[level]);
                     }
                   else if (strncmp(unix_hostname (), sysid, 15) == 0)
                     {
                       memcpy (lspid, isis->sysid, ISIS_SYS_ID_LEN);
                       lsp = lsp_search (lspid, area->lspdb[level]);
                     }
                 }
   
              lsp_count = lsp_print_all (vty, area->lspdb[level],              if (lsp != NULL || argv == NULL)
                                         ISIS_UI_LEVEL_DETAIL,                {
                                         area->dynhostname);                  vty_out (vty, "IS-IS Level-%d link-state database:%s",
                            level + 1, VTY_NEWLINE);
   
              vty_out (vty, "%s    %u LSPs%s%s",                  /* print the title in all cases */
                       VTY_NEWLINE, lsp_count, VTY_NEWLINE, VTY_NEWLINE);                  vty_out (vty, "LSP ID                  PduLen  "
            }                           "SeqNumber   Chksum  Holdtime  ATT/P/OL%s",
        }                           VTY_NEWLINE);
                 }
 
               if (lsp)
                 {
                   if (ui_level == ISIS_UI_LEVEL_DETAIL)
                     lsp_print_detail (lsp, vty, area->dynhostname);
                   else
                     lsp_print (lsp, vty, area->dynhostname);
                 }
               else if (argv == NULL)
                 {
                   lsp_count = lsp_print_all (vty, area->lspdb[level],
                                              ui_level,
                                              area->dynhostname);
 
                   vty_out (vty, "    %u LSPs%s%s",
                            lsp_count, VTY_NEWLINE, VTY_NEWLINE);
                 }
             }
         }
     }      }
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
   DEFUN (show_database_brief,
          show_database_cmd,
          "show isis database",
          SHOW_STR
          "IS-IS information\n"
          "IS-IS link state database\n")
   {
     return show_isis_database (vty, NULL, ISIS_UI_LEVEL_BRIEF);
   }
   
   DEFUN (show_database_lsp_brief,
          show_database_arg_cmd,
          "show isis database WORD",
          SHOW_STR
          "IS-IS information\n"
          "IS-IS link state database\n"
          "LSP ID\n")
   {
     return show_isis_database (vty, argv[0], ISIS_UI_LEVEL_BRIEF);
   }
   
   DEFUN (show_database_lsp_detail,
          show_database_arg_detail_cmd,
          "show isis database WORD detail",
          SHOW_STR
          "IS-IS information\n"
          "IS-IS link state database\n"
          "LSP ID\n"
          "Detailed information\n")
   {
     return show_isis_database (vty, argv[0], ISIS_UI_LEVEL_DETAIL);
   }
   
   DEFUN (show_database_detail,
          show_database_detail_cmd,
          "show isis database detail",
          SHOW_STR
          "IS-IS information\n"
          "IS-IS link state database\n")
   {
     return show_isis_database (vty, NULL, ISIS_UI_LEVEL_DETAIL);
   }
   
   DEFUN (show_database_detail_lsp,
          show_database_detail_arg_cmd,
          "show isis database detail WORD",
          SHOW_STR
          "IS-IS information\n"
          "IS-IS link state database\n"
          "Detailed information\n"
          "LSP ID\n")
   {
     return show_isis_database (vty, argv[0], ISIS_UI_LEVEL_DETAIL);
   }
   
 /*   /* 
  * 'router isis' command    * 'router isis' command 
  */   */
Line 1043  DEFUN (no_net, Line 1611  DEFUN (no_net,
   return area_clear_net_title (vty, argv[0]);    return area_clear_net_title (vty, argv[0]);
 }  }
   
DEFUN (area_passwd,static
       area_passwd_cmd,int area_set_lsp_mtu(struct vty *vty, struct isis_area *area, unsigned int lsp_mtu)
       "area-password WORD",{
   struct isis_circuit *circuit;
   struct listnode *node;
 
   for (ALL_LIST_ELEMENTS_RO(area->circuit_list, node, circuit))
     {
       if(lsp_mtu > isis_circuit_pdu_size(circuit))
         {
           vty_out(vty, "ISIS area contains circuit %s, which has a maximum PDU size of %zu.%s",
                   circuit->interface->name, isis_circuit_pdu_size(circuit),
                   VTY_NEWLINE);
           return CMD_ERR_AMBIGUOUS;
         }
     }
 
   area->lsp_mtu = lsp_mtu;
   lsp_regenerate_schedule(area, IS_LEVEL_1_AND_2, 1);
 
   return CMD_SUCCESS;
 }
 
 DEFUN (area_lsp_mtu,
        area_lsp_mtu_cmd,
        "lsp-mtu <128-4352>",
        "Configure the maximum size of generated LSPs\n"
        "Maximum size of generated LSPs\n")
 {
   struct isis_area *area;
 
   area = vty->index;
   if (!area)
     {
       vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
       return CMD_ERR_NO_MATCH;
     }
 
   unsigned int lsp_mtu;
 
   VTY_GET_INTEGER_RANGE("lsp-mtu", lsp_mtu, argv[0], 128, 4352);
 
   return area_set_lsp_mtu(vty, area, lsp_mtu);
 }
 
 DEFUN(no_area_lsp_mtu,
       no_area_lsp_mtu_cmd,
       "no lsp-mtu",
       NO_STR
       "Configure the maximum size of generated LSPs\n")
 {
   struct isis_area *area;
 
   area = vty->index;
   if (!area)
     {
       vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
       return CMD_ERR_NO_MATCH;
     }
 
   return area_set_lsp_mtu(vty, area, DEFAULT_LSP_MTU);
 }
 
 ALIAS(no_area_lsp_mtu,
       no_area_lsp_mtu_arg_cmd,
       "no lsp-mtu <128-4352>",
       NO_STR
       "Configure the maximum size of generated LSPs\n"
       "Maximum size of generated LSPs\n");
 
 DEFUN (area_passwd_md5,
        area_passwd_md5_cmd,
        "area-password md5 WORD",
        "Configure the authentication password for an area\n"         "Configure the authentication password for an area\n"
          "Authentication type\n"
        "Area password\n")         "Area password\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
Line 1056  DEFUN (area_passwd, Line 1695  DEFUN (area_passwd,
   
   if (!area)    if (!area)
     {      {
      vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);      vty_out (vty, "Can't find IS-IS instance%s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   len = strlen (argv[0]);    len = strlen (argv[0]);
   if (len > 254)    if (len > 254)
     {      {
       vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);        vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_AMBIGUOUS;
     }      }
   
   area->area_passwd.len = (u_char) len;    area->area_passwd.len = (u_char) len;
     area->area_passwd.type = ISIS_PASSWD_TYPE_HMAC_MD5;
     strncpy ((char *)area->area_passwd.passwd, argv[0], 255);
   
     if (argc > 1)
       {
         SET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_SEND);
         if (strncmp(argv[1], "v", 1) == 0)
           SET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_RECV);
         else
           UNSET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_RECV);
       }
     else
       {
         UNSET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_SEND);
         UNSET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_RECV);
       }
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
     return CMD_SUCCESS;
   }
   
   ALIAS (area_passwd_md5,
          area_passwd_md5_snpauth_cmd,
          "area-password md5 WORD authenticate snp (send-only|validate)",
          "Configure the authentication password for an area\n"
          "Authentication type\n"
          "Area password\n"
          "Authentication\n"
          "SNP PDUs\n"
          "Send but do not check PDUs on receiving\n"
          "Send and check PDUs on receiving\n")
   
   DEFUN (area_passwd_clear,
          area_passwd_clear_cmd,
          "area-password clear WORD",
          "Configure the authentication password for an area\n"
          "Authentication type\n"
          "Area password\n")
   {
     struct isis_area *area;
     int len;
   
     area = vty->index;
   
     if (!area)
       {
         vty_out (vty, "Can't find IS-IS instance%s", VTY_NEWLINE);
         return CMD_ERR_NO_MATCH;
       }
   
     len = strlen (argv[0]);
     if (len > 254)
       {
         vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);
         return CMD_ERR_AMBIGUOUS;
       }
   
     area->area_passwd.len = (u_char) len;
   area->area_passwd.type = ISIS_PASSWD_TYPE_CLEARTXT;    area->area_passwd.type = ISIS_PASSWD_TYPE_CLEARTXT;
   strncpy ((char *)area->area_passwd.passwd, argv[0], 255);    strncpy ((char *)area->area_passwd.passwd, argv[0], 255);
   
Line 1083  DEFUN (area_passwd, Line 1781  DEFUN (area_passwd,
       UNSET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_SEND);        UNSET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_SEND);
       UNSET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_RECV);        UNSET_FLAG(area->area_passwd.snp_auth, SNP_AUTH_RECV);
     }      }
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
ALIAS (area_passwd,ALIAS (area_passwd_clear,
       area_passwd_snpauth_cmd,       area_passwd_clear_snpauth_cmd,
       "area-password WORD authenticate snp (send-only|validate)",       "area-password clear WORD authenticate snp (send-only|validate)",
        "Configure the authentication password for an area\n"         "Configure the authentication password for an area\n"
          "Authentication type\n"
        "Area password\n"         "Area password\n"
        "Authentication\n"         "Authentication\n"
        "SNP PDUs\n"         "SNP PDUs\n"
        "Send but do not check PDUs on receiving\n"         "Send but do not check PDUs on receiving\n"
       "Send and check PDUs on receiving\n");       "Send and check PDUs on receiving\n")
   
 DEFUN (no_area_passwd,  DEFUN (no_area_passwd,
        no_area_passwd_cmd,         no_area_passwd_cmd,
Line 1109  DEFUN (no_area_passwd, Line 1809  DEFUN (no_area_passwd,
   
   if (!area)    if (!area)
     {      {
      vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);      vty_out (vty, "Can't find IS-IS instance%s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   memset (&area->area_passwd, 0, sizeof (struct isis_passwd));    memset (&area->area_passwd, 0, sizeof (struct isis_passwd));
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
DEFUN (domain_passwd,DEFUN (domain_passwd_md5,
       domain_passwd_cmd,       domain_passwd_md5_cmd,
       "domain-password WORD",       "domain-password md5 WORD",
        "Set the authentication password for a routing domain\n"         "Set the authentication password for a routing domain\n"
          "Authentication type\n"
        "Routing domain password\n")         "Routing domain password\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
Line 1131  DEFUN (domain_passwd, Line 1833  DEFUN (domain_passwd,
   
   if (!area)    if (!area)
     {      {
      vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);      vty_out (vty, "Can't find IS-IS instance%s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   len = strlen (argv[0]);    len = strlen (argv[0]);
   if (len > 254)    if (len > 254)
     {      {
       vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);        vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_AMBIGUOUS;
     }      }
   
   area->domain_passwd.len = (u_char) len;    area->domain_passwd.len = (u_char) len;
     area->domain_passwd.type = ISIS_PASSWD_TYPE_HMAC_MD5;
     strncpy ((char *)area->domain_passwd.passwd, argv[0], 255);
   
     if (argc > 1)
       {
         SET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_SEND);
         if (strncmp(argv[1], "v", 1) == 0)
           SET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_RECV);
         else
           UNSET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_RECV);
       }
     else
       {
         UNSET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_SEND);
         UNSET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_RECV);
       }
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
     return CMD_SUCCESS;
   }
   
   ALIAS (domain_passwd_md5,
          domain_passwd_md5_snpauth_cmd,
          "domain-password md5 WORD authenticate snp (send-only|validate)",
          "Set the authentication password for a routing domain\n"
          "Authentication type\n"
          "Routing domain password\n"
          "Authentication\n"
          "SNP PDUs\n"
          "Send but do not check PDUs on receiving\n"
          "Send and check PDUs on receiving\n")
   
   DEFUN (domain_passwd_clear,
          domain_passwd_clear_cmd,
          "domain-password clear WORD",
          "Set the authentication password for a routing domain\n"
          "Authentication type\n"
          "Routing domain password\n")
   {
     struct isis_area *area;
     int len;
   
     area = vty->index;
   
     if (!area)
       {
         vty_out (vty, "Can't find IS-IS instance%s", VTY_NEWLINE);
         return CMD_ERR_NO_MATCH;
       }
   
     len = strlen (argv[0]);
     if (len > 254)
       {
         vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);
         return CMD_ERR_AMBIGUOUS;
       }
   
     area->domain_passwd.len = (u_char) len;
   area->domain_passwd.type = ISIS_PASSWD_TYPE_CLEARTXT;    area->domain_passwd.type = ISIS_PASSWD_TYPE_CLEARTXT;
   strncpy ((char *)area->domain_passwd.passwd, argv[0], 255);    strncpy ((char *)area->domain_passwd.passwd, argv[0], 255);
   
Line 1158  DEFUN (domain_passwd, Line 1919  DEFUN (domain_passwd,
       UNSET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_SEND);        UNSET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_SEND);
       UNSET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_RECV);        UNSET_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_RECV);
     }      }
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
ALIAS (domain_passwd,ALIAS (domain_passwd_clear,
       domain_passwd_snpauth_cmd,       domain_passwd_clear_snpauth_cmd,
       "domain-password WORD authenticate snp (send-only|validate)",       "domain-password clear WORD authenticate snp (send-only|validate)",
        "Set the authentication password for a routing domain\n"         "Set the authentication password for a routing domain\n"
          "Authentication type\n"
        "Routing domain password\n"         "Routing domain password\n"
        "Authentication\n"         "Authentication\n"
        "SNP PDUs\n"         "SNP PDUs\n"
        "Send but do not check PDUs on receiving\n"         "Send but do not check PDUs on receiving\n"
       "Send and check PDUs on receiving\n");       "Send and check PDUs on receiving\n")
   
 DEFUN (no_domain_passwd,  DEFUN (no_domain_passwd,
        no_domain_passwd_cmd,         no_domain_passwd_cmd,
       "no domain-password WORD",       "no domain-password",
        NO_STR         NO_STR
        "Set the authentication password for a routing domain\n")         "Set the authentication password for a routing domain\n")
 {  {
Line 1184  DEFUN (no_domain_passwd, Line 1947  DEFUN (no_domain_passwd,
   
   if (!area)    if (!area)
     {      {
      vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);      vty_out (vty, "Can't find IS-IS instance%s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   memset (&area->domain_passwd, 0, sizeof (struct isis_passwd));    memset (&area->domain_passwd, 0, sizeof (struct isis_passwd));
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
Line 1208  DEFUN (is_type, Line 1972  DEFUN (is_type,
   
   if (!area)    if (!area)
     {      {
      vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);      vty_out (vty, "Can't find IS-IS instance%s", VTY_NEWLINE);
      return CMD_WARNING;      return CMD_ERR_NO_MATCH;
     }      }
   
   type = string2circuit_t (argv[0]);    type = string2circuit_t (argv[0]);
Line 1240  DEFUN (no_is_type, Line 2004  DEFUN (no_is_type,
   assert (area);    assert (area);
   
   /*    /*
   * Put the is-type back to default. Which is level-1-2 on first   * Put the is-type back to defaults:
   * circuit for the area level-1 for the rest   * - level-1-2 on first area
    * - level-1 for the rest
    */     */
   if (listgetdata (listhead (isis->area_list)) == area)    if (listgetdata (listhead (isis->area_list)) == area)
     type = IS_LEVEL_1_AND_2;      type = IS_LEVEL_1_AND_2;
Line 1253  DEFUN (no_is_type, Line 2018  DEFUN (no_is_type,
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
   static int
   set_lsp_gen_interval (struct vty *vty, struct isis_area *area,
                         uint16_t interval, int level)
   {
     int lvl;
   
     for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; ++lvl)
       {
         if (!(lvl & level))
           continue;
   
         if (interval >= area->lsp_refresh[lvl-1])
           {
             vty_out (vty, "LSP gen interval %us must be less than "
                      "the LSP refresh interval %us%s",
                      interval, area->lsp_refresh[lvl-1], VTY_NEWLINE);
             return CMD_ERR_AMBIGUOUS;
           }
       }
   
     for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; ++lvl)
       {
         if (!(lvl & level))
           continue;
         area->lsp_gen_interval[lvl-1] = interval;
       }
   
     return CMD_SUCCESS;
   }
   
 DEFUN (lsp_gen_interval,  DEFUN (lsp_gen_interval,
        lsp_gen_interval_cmd,         lsp_gen_interval_cmd,
        "lsp-gen-interval <1-120>",         "lsp-gen-interval <1-120>",
Line 1261  DEFUN (lsp_gen_interval, Line 2056  DEFUN (lsp_gen_interval,
 {  {
   struct isis_area *area;    struct isis_area *area;
   uint16_t interval;    uint16_t interval;
     int level;
   
   area = vty->index;    area = vty->index;
   assert (area);  
   
   interval = atoi (argv[0]);    interval = atoi (argv[0]);
  area->lsp_gen_interval[0] = interval;  level = IS_LEVEL_1 | IS_LEVEL_2;
  area->lsp_gen_interval[1] = interval;  return set_lsp_gen_interval (vty, area, interval, level);
 
  return CMD_SUCCESS; 
 }  }
   
 DEFUN (no_lsp_gen_interval,  DEFUN (no_lsp_gen_interval,
Line 1279  DEFUN (no_lsp_gen_interval, Line 2071  DEFUN (no_lsp_gen_interval,
        "Minimum interval between regenerating same LSP\n")         "Minimum interval between regenerating same LSP\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
     uint16_t interval;
     int level;
   
   area = vty->index;    area = vty->index;
  assert (area);  interval = DEFAULT_MIN_LSP_GEN_INTERVAL;
  level = IS_LEVEL_1 | IS_LEVEL_2;
  area->lsp_gen_interval[0] = LSP_GEN_INTERVAL_DEFAULT;  return set_lsp_gen_interval (vty, area, interval, level);
  area->lsp_gen_interval[1] = LSP_GEN_INTERVAL_DEFAULT; 
 
  return CMD_SUCCESS; 
 }  }
   
 ALIAS (no_lsp_gen_interval,  ALIAS (no_lsp_gen_interval,
Line 1305  DEFUN (lsp_gen_interval_l1, Line 2096  DEFUN (lsp_gen_interval_l1,
 {  {
   struct isis_area *area;    struct isis_area *area;
   uint16_t interval;    uint16_t interval;
     int level;
   
   area = vty->index;    area = vty->index;
   assert (area);  
   
   interval = atoi (argv[0]);    interval = atoi (argv[0]);
  area->lsp_gen_interval[0] = interval;  level = IS_LEVEL_1;
  return set_lsp_gen_interval (vty, area, interval, level);
  return CMD_SUCCESS; 
 }  }
   
 DEFUN (no_lsp_gen_interval_l1,  DEFUN (no_lsp_gen_interval_l1,
Line 1323  DEFUN (no_lsp_gen_interval_l1, Line 2112  DEFUN (no_lsp_gen_interval_l1,
        "Set interval for level 1 only\n")         "Set interval for level 1 only\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
     uint16_t interval;
     int level;
   
   area = vty->index;    area = vty->index;
  assert (area);  interval = DEFAULT_MIN_LSP_GEN_INTERVAL;
  level = IS_LEVEL_1;
  area->lsp_gen_interval[0] = LSP_GEN_INTERVAL_DEFAULT;  return set_lsp_gen_interval (vty, area, interval, level);
 
  return CMD_SUCCESS; 
 }  }
   
 ALIAS (no_lsp_gen_interval_l1,  ALIAS (no_lsp_gen_interval_l1,
Line 1348  DEFUN (lsp_gen_interval_l2, Line 2137  DEFUN (lsp_gen_interval_l2,
        "Minimum interval in seconds\n")         "Minimum interval in seconds\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
  int interval;  uint16_t interval;
   int level;
   
   area = vty->index;    area = vty->index;
   assert (area);  
   
   interval = atoi (argv[0]);    interval = atoi (argv[0]);
  area->lsp_gen_interval[1] = interval;  level = IS_LEVEL_2;
  return set_lsp_gen_interval (vty, area, interval, level);
  return CMD_SUCCESS; 
 }  }
   
 DEFUN (no_lsp_gen_interval_l2,  DEFUN (no_lsp_gen_interval_l2,
Line 1367  DEFUN (no_lsp_gen_interval_l2, Line 2154  DEFUN (no_lsp_gen_interval_l2,
        "Set interval for level 2 only\n")         "Set interval for level 2 only\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
  int interval;  uint16_t interval;
   int level;
   
   area = vty->index;    area = vty->index;
  assert (area);  interval = DEFAULT_MIN_LSP_GEN_INTERVAL;
  level = IS_LEVEL_2;
  interval = atoi (argv[0]);  return set_lsp_gen_interval (vty, area, interval, level);
  area->lsp_gen_interval[1] = LSP_GEN_INTERVAL_DEFAULT; 
 
  return CMD_SUCCESS; 
 }  }
   
 ALIAS (no_lsp_gen_interval_l2,  ALIAS (no_lsp_gen_interval_l2,
Line 1386  ALIAS (no_lsp_gen_interval_l2, Line 2171  ALIAS (no_lsp_gen_interval_l2,
        "Set interval for level 2 only\n"         "Set interval for level 2 only\n"
        "Minimum interval in seconds\n")         "Minimum interval in seconds\n")
   
   static int
   validate_metric_style_narrow (struct vty *vty, struct isis_area *area)
   {
     struct isis_circuit *circuit;
     struct listnode *node;
     
     if (! vty)
       return CMD_ERR_AMBIGUOUS;
   
     if (! area)
       {
         vty_out (vty, "ISIS area is invalid%s", VTY_NEWLINE);
         return CMD_ERR_AMBIGUOUS;
       }
   
     for (ALL_LIST_ELEMENTS_RO (area->circuit_list, node, circuit))
       {
         if ((area->is_type & IS_LEVEL_1) &&
             (circuit->is_type & IS_LEVEL_1) &&
             (circuit->te_metric[0] > MAX_NARROW_LINK_METRIC))
           {
             vty_out (vty, "ISIS circuit %s metric is invalid%s",
                      circuit->interface->name, VTY_NEWLINE);
             return CMD_ERR_AMBIGUOUS;
           }
         if ((area->is_type & IS_LEVEL_2) &&
             (circuit->is_type & IS_LEVEL_2) &&
             (circuit->te_metric[1] > MAX_NARROW_LINK_METRIC))
           {
             vty_out (vty, "ISIS circuit %s metric is invalid%s",
                      circuit->interface->name, VTY_NEWLINE);
             return CMD_ERR_AMBIGUOUS;
           }
       }
   
     return CMD_SUCCESS;
   }
   
 DEFUN (metric_style,  DEFUN (metric_style,
        metric_style_cmd,         metric_style_cmd,
        "metric-style (narrow|transition|wide)",         "metric-style (narrow|transition|wide)",
Line 1395  DEFUN (metric_style, Line 2218  DEFUN (metric_style,
        "Use new style of TLVs to carry wider metric\n")         "Use new style of TLVs to carry wider metric\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
     int ret;
   
   area = vty->index;    area = vty->index;
   assert (area);    assert (area);
Line 1404  DEFUN (metric_style, Line 2228  DEFUN (metric_style,
       area->newmetric = 1;        area->newmetric = 1;
       area->oldmetric = 0;        area->oldmetric = 0;
     }      }
  else if (strncmp (argv[0], "t", 1) == 0)  else
     {      {
      area->newmetric = 1;      ret = validate_metric_style_narrow (vty, area);
      area->oldmetric = 1;      if (ret != CMD_SUCCESS)
         return ret;
 
       if (strncmp (argv[0], "t", 1) == 0)
         {
           area->newmetric = 1;
           area->oldmetric = 1;
         }
       else if (strncmp (argv[0], "n", 1) == 0)
         {
           area->newmetric = 0;
           area->oldmetric = 1;
         }
     }      }
   else if (strncmp (argv[0], "n", 1) == 0)  
     {  
       area->newmetric = 0;  
       area->oldmetric = 1;  
     }  
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
Line 1425  DEFUN (no_metric_style, Line 2256  DEFUN (no_metric_style,
        "Use old-style (ISO 10589) or new-style packet formats\n")         "Use old-style (ISO 10589) or new-style packet formats\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
     int ret;
   
   area = vty->index;    area = vty->index;
   assert (area);    assert (area);
   
     ret = validate_metric_style_narrow (vty, area);
     if (ret != CMD_SUCCESS)
       return ret;
   
   /* Default is narrow metric. */    /* Default is narrow metric. */
   area->newmetric = 0;    area->newmetric = 0;
   area->oldmetric = 1;    area->oldmetric = 1;
Line 1436  DEFUN (no_metric_style, Line 2272  DEFUN (no_metric_style,
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
   DEFUN (set_overload_bit,
          set_overload_bit_cmd,
          "set-overload-bit",
          "Set overload bit to avoid any transit traffic\n"
          "Set overload bit\n")
   {
     struct isis_area *area;
   
     area = vty->index;
     assert (area);
   
     area->overload_bit = LSPBIT_OL;
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (no_set_overload_bit,
          no_set_overload_bit_cmd,
          "no set-overload-bit",
          "Reset overload bit to accept transit traffic\n"
          "Reset overload bit\n")
   {
     struct isis_area *area;
   
     area = vty->index;
     assert (area);
   
     area->overload_bit = 0;
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (set_attached_bit,
          set_attached_bit_cmd,
          "set-attached-bit",
          "Set attached bit to identify as L1/L2 router for inter-area traffic\n"
          "Set attached bit\n")
   {
     struct isis_area *area;
   
     area = vty->index;
     assert (area);
   
     area->attached_bit = LSPBIT_ATT;
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (no_set_attached_bit,
          no_set_attached_bit_cmd,
          "no set-attached-bit",
          "Reset attached bit\n")
   {
     struct isis_area *area;
   
     area = vty->index;
     assert (area);
   
     area->attached_bit = 0;
     lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
   
     return CMD_SUCCESS;
   }
   
 DEFUN (dynamic_hostname,  DEFUN (dynamic_hostname,
        dynamic_hostname_cmd,         dynamic_hostname_cmd,
        "hostname dynamic",         "hostname dynamic",
Line 1447  DEFUN (dynamic_hostname, Line 2350  DEFUN (dynamic_hostname,
   area = vty->index;    area = vty->index;
   assert (area);    assert (area);
   
  area->dynhostname = 1;  if (!area->dynhostname)
    {
      area->dynhostname = 1;
      lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 0);
    }
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
Line 1464  DEFUN (no_dynamic_hostname, Line 2371  DEFUN (no_dynamic_hostname,
   area = vty->index;    area = vty->index;
   assert (area);    assert (area);
   
  area->dynhostname = 0;  if (area->dynhostname)
     {
       area->dynhostname = 0;
       lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 0);
     }
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
Line 1591  ALIAS (no_spf_interval, Line 2502  ALIAS (no_spf_interval,
        "Set interval for level 2 only\n"         "Set interval for level 2 only\n"
        "Minimum interval between consecutive SPFs in seconds\n")         "Minimum interval between consecutive SPFs in seconds\n")
   
   static int
   set_lsp_max_lifetime (struct vty *vty, struct isis_area *area,
                         uint16_t interval, int level)
   {
     int lvl;
     int set_refresh_interval[ISIS_LEVELS] = {0, 0};
     uint16_t refresh_interval;
   
     refresh_interval = interval - 300;
   
     for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; lvl++)
       {
         if (!(lvl & level))
           continue;
         if (refresh_interval < area->lsp_refresh[lvl-1])
           {
             vty_out (vty, "Level %d Max LSP lifetime %us must be 300s greater than "
                      "the configured LSP refresh interval %us%s",
                      lvl, interval, area->lsp_refresh[lvl-1], VTY_NEWLINE);
             vty_out (vty, "Automatically reducing level %d LSP refresh interval "
                      "to %us%s", lvl, refresh_interval, VTY_NEWLINE);
             set_refresh_interval[lvl-1] = 1;
   
             if (refresh_interval <= area->lsp_gen_interval[lvl-1])
               {
                 vty_out (vty, "LSP refresh interval %us must be greater than "
                          "the configured LSP gen interval %us%s",
                          refresh_interval, area->lsp_gen_interval[lvl-1],
                          VTY_NEWLINE);
                 return CMD_ERR_AMBIGUOUS;
               }
           }
       }
   
     for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; lvl++)
       {
         if (!(lvl & level))
           continue;
         area->max_lsp_lifetime[lvl-1] = interval;
         /* Automatically reducing lsp_refresh_interval to interval - 300 */
         if (set_refresh_interval[lvl-1])
           area->lsp_refresh[lvl-1] = refresh_interval;
       }
   
     lsp_regenerate_schedule (area, level, 1);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (max_lsp_lifetime,
          max_lsp_lifetime_cmd,
          "max-lsp-lifetime <350-65535>",
          "Maximum LSP lifetime\n"
          "LSP lifetime in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = atoi (argv[0]);
     level = IS_LEVEL_1 | IS_LEVEL_2;
     return set_lsp_max_lifetime (vty, area, interval, level);
   }
   
   DEFUN (no_max_lsp_lifetime,
          no_max_lsp_lifetime_cmd,
          "no max-lsp-lifetime",
          NO_STR
          "LSP lifetime in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = DEFAULT_LSP_LIFETIME;
     level = IS_LEVEL_1 | IS_LEVEL_2;
     return set_lsp_max_lifetime (vty, area, interval, level);
   }
   
   ALIAS (no_max_lsp_lifetime,
          no_max_lsp_lifetime_arg_cmd,
          "no max-lsp-lifetime <350-65535>",
          NO_STR
          "Maximum LSP lifetime\n"
          "LSP lifetime in seconds\n")
   
   DEFUN (max_lsp_lifetime_l1,
          max_lsp_lifetime_l1_cmd,
          "max-lsp-lifetime level-1 <350-65535>",
          "Maximum LSP lifetime for Level 1 only\n"
          "LSP lifetime for Level 1 only in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = atoi (argv[0]);
     level = IS_LEVEL_1;
     return set_lsp_max_lifetime (vty, area, interval, level);
   }
   
   DEFUN (no_max_lsp_lifetime_l1,
          no_max_lsp_lifetime_l1_cmd,
          "no max-lsp-lifetime level-1",
          NO_STR
          "LSP lifetime for Level 1 only in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = DEFAULT_LSP_LIFETIME;
     level = IS_LEVEL_1;
     return set_lsp_max_lifetime (vty, area, interval, level);
   }
   
   ALIAS (no_max_lsp_lifetime_l1,
          no_max_lsp_lifetime_l1_arg_cmd,
          "no max-lsp-lifetime level-1 <350-65535>",
          NO_STR
          "Maximum LSP lifetime for Level 1 only\n"
          "LSP lifetime for Level 1 only in seconds\n")
   
   DEFUN (max_lsp_lifetime_l2,
          max_lsp_lifetime_l2_cmd,
          "max-lsp-lifetime level-2 <350-65535>",
          "Maximum LSP lifetime for Level 2 only\n"
          "LSP lifetime for Level 2 only in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = atoi (argv[0]);
     level = IS_LEVEL_2;
     return set_lsp_max_lifetime (vty, area, interval, level);
   }
   
   DEFUN (no_max_lsp_lifetime_l2,
          no_max_lsp_lifetime_l2_cmd,
          "no max-lsp-lifetime level-2",
          NO_STR
          "LSP lifetime for Level 2 only in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = DEFAULT_LSP_LIFETIME;
     level = IS_LEVEL_2;
     return set_lsp_max_lifetime (vty, area, interval, level);
   }
   
   ALIAS (no_max_lsp_lifetime_l2,
          no_max_lsp_lifetime_l2_arg_cmd,
          "no max-lsp-lifetime level-2 <350-65535>",
          NO_STR
          "Maximum LSP lifetime for Level 2 only\n"
          "LSP lifetime for Level 2 only in seconds\n")
   
   static int
   set_lsp_refresh_interval (struct vty *vty, struct isis_area *area,
                             uint16_t interval, int level)
   {
     int lvl;
   
     for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; ++lvl)
       {
         if (!(lvl & level))
           continue;
         if (interval <= area->lsp_gen_interval[lvl-1])
           {
             vty_out (vty, "LSP refresh interval %us must be greater than "
                      "the configured LSP gen interval %us%s",
                      interval, area->lsp_gen_interval[lvl-1],
                      VTY_NEWLINE);
             return CMD_ERR_AMBIGUOUS;
           }
         if (interval > (area->max_lsp_lifetime[lvl-1] - 300))
           {
             vty_out (vty, "LSP refresh interval %us must be less than "
                      "the configured LSP lifetime %us less 300%s",
                      interval, area->max_lsp_lifetime[lvl-1],
                      VTY_NEWLINE);
             return CMD_ERR_AMBIGUOUS;
           }
       }
   
     for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; ++lvl)
       {
         if (!(lvl & level))
           continue;
         area->lsp_refresh[lvl-1] = interval;
       }
     lsp_regenerate_schedule (area, level, 1);
   
     return CMD_SUCCESS;
   }
   
   DEFUN (lsp_refresh_interval,
          lsp_refresh_interval_cmd,
          "lsp-refresh-interval <1-65235>",
          "LSP refresh interval\n"
          "LSP refresh interval in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = atoi (argv[0]);
     level = IS_LEVEL_1 | IS_LEVEL_2;
     return set_lsp_refresh_interval (vty, area, interval, level);
   }
   
   DEFUN (no_lsp_refresh_interval,
          no_lsp_refresh_interval_cmd,
          "no lsp-refresh-interval",
          NO_STR
          "LSP refresh interval in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = DEFAULT_MAX_LSP_GEN_INTERVAL;
     level = IS_LEVEL_1 | IS_LEVEL_2;
     return set_lsp_refresh_interval (vty, area, interval, level);
   }
   
   ALIAS (no_lsp_refresh_interval,
          no_lsp_refresh_interval_arg_cmd,
          "no lsp-refresh-interval <1-65235>",
          NO_STR
          "LSP refresh interval\n"
          "LSP refresh interval in seconds\n")
   
   DEFUN (lsp_refresh_interval_l1,
          lsp_refresh_interval_l1_cmd,
          "lsp-refresh-interval level-1 <1-65235>",
          "LSP refresh interval for Level 1 only\n"
          "LSP refresh interval for Level 1 only in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = atoi (argv[0]);
     level = IS_LEVEL_1;
     return set_lsp_refresh_interval (vty, area, interval, level);
   }
   
   DEFUN (no_lsp_refresh_interval_l1,
          no_lsp_refresh_interval_l1_cmd,
          "no lsp-refresh-interval level-1",
          NO_STR
          "LSP refresh interval for Level 1 only in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = DEFAULT_MAX_LSP_GEN_INTERVAL;
     level = IS_LEVEL_1;
     return set_lsp_refresh_interval (vty, area, interval, level);
   }
   
   ALIAS (no_lsp_refresh_interval_l1,
          no_lsp_refresh_interval_l1_arg_cmd,
          "no lsp-refresh-interval level-1 <1-65235>",
          NO_STR
          "LSP refresh interval for Level 1 only\n"
          "LSP refresh interval for Level 1 only in seconds\n")
   
   DEFUN (lsp_refresh_interval_l2,
          lsp_refresh_interval_l2_cmd,
          "lsp-refresh-interval level-2 <1-65235>",
          "LSP refresh interval for Level 2 only\n"
          "LSP refresh interval for Level 2 only in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = atoi (argv[0]);
     level = IS_LEVEL_2;
     return set_lsp_refresh_interval (vty, area, interval, level);
   }
   
   DEFUN (no_lsp_refresh_interval_l2,
          no_lsp_refresh_interval_l2_cmd,
          "no lsp-refresh-interval level-2",
          NO_STR
          "LSP refresh interval for Level 2 only in seconds\n")
   {
     struct isis_area *area;
     uint16_t interval;
     int level;
   
     area = vty->index;
     interval = DEFAULT_MAX_LSP_GEN_INTERVAL;
     level = IS_LEVEL_2;
     return set_lsp_refresh_interval (vty, area, interval, level);
   }
   
   ALIAS (no_lsp_refresh_interval_l2,
          no_lsp_refresh_interval_l2_arg_cmd,
          "no lsp-refresh-interval level-2 <1-65235>",
          NO_STR
          "LSP refresh interval for Level 2 only\n"
          "LSP refresh interval for Level 2 only in seconds\n")
   
   DEFUN (log_adj_changes,
          log_adj_changes_cmd,
          "log-adjacency-changes",
          "Log changes in adjacency state\n")
   {
     struct isis_area *area;
   
     area = vty->index;
     assert (area);
   
     area->log_adj_changes = 1;
   
     return CMD_SUCCESS;
   }
   
   DEFUN (no_log_adj_changes,
          no_log_adj_changes_cmd,
          "no log-adjacency-changes",
          "Stop logging changes in adjacency state\n")
   {
     struct isis_area *area;
   
     area = vty->index;
     assert (area);
   
     area->log_adj_changes = 0;
   
     return CMD_SUCCESS;
   }
   
 #ifdef TOPOLOGY_GENERATE  #ifdef TOPOLOGY_GENERATE
   
 DEFUN (topology_generate_grid,  DEFUN (topology_generate_grid,
        topology_generate_grid_cmd,         topology_generate_grid_cmd,
        "topology generate grid <1-100> <1-100> <1-65000> [param] [param] "         "topology generate grid <1-100> <1-100> <1-65000> [param] [param] "
Line 1623  DEFUN (topology_generate_grid, Line 2887  DEFUN (topology_generate_grid,
       generate_topology_lsps (area);        generate_topology_lsps (area);
       /* Regenerate L1 LSP to get two way connection to the generated        /* Regenerate L1 LSP to get two way connection to the generated
        * topology. */         * topology. */
      lsp_regenerate_schedule (area);      lsp_regenerate_schedule (area, IS_LEVEL_1 | IS_LEVEL_2, 1);
     }      }
   
   return CMD_SUCCESS;    return CMD_SUCCESS;
Line 1633  DEFUN (show_isis_generated_topology, Line 2897  DEFUN (show_isis_generated_topology,
        show_isis_generated_topology_cmd,         show_isis_generated_topology_cmd,
        "show isis generated-topologies",         "show isis generated-topologies",
        SHOW_STR         SHOW_STR
       "CLNS network information\n"       "ISIS network information\n"
        "Show generated topologies\n")         "Show generated topologies\n")
 {  {
   struct isis_area *area;    struct isis_area *area;
Line 1717  DEFUN (topology_basedynh, Line 2981  DEFUN (topology_basedynh,
   area->topology_basedynh = strndup (argv[0], 16);     area->topology_basedynh = strndup (argv[0], 16); 
   return CMD_SUCCESS;    return CMD_SUCCESS;
 }  }
   
 #endif /* TOPOLOGY_GENERATE */  #endif /* TOPOLOGY_GENERATE */
   
 DEFUN (lsp_lifetime,  
        lsp_lifetime_cmd,  
        "lsp-lifetime <380-65535>",  
        "Maximum LSP lifetime\n"  
        "LSP lifetime in seconds\n")  
 {  
   struct isis_area *area;  
   uint16_t interval;  
   
   area = vty->index;  
   assert (area);  
   
   interval = atoi (argv[0]);  
   
   if (interval < ISIS_MIN_LSP_LIFETIME)  
     {  
       vty_out (vty, "LSP lifetime (%us) below %us%s",  
                interval, ISIS_MIN_LSP_LIFETIME, VTY_NEWLINE);  
   
       return CMD_WARNING;  
     }  
   
   
   area->max_lsp_lifetime[0] = interval;  
   area->max_lsp_lifetime[1] = interval;  
   area->lsp_refresh[0] = interval - 300;  
   area->lsp_refresh[1] = interval - 300;  
   
   if (area->t_lsp_refresh[0])  
     {  
       thread_cancel (area->t_lsp_refresh[0]);  
       thread_execute (master, lsp_refresh_l1, area, 0);  
     }  
   
   if (area->t_lsp_refresh[1])  
     {  
       thread_cancel (area->t_lsp_refresh[1]);  
       thread_execute (master, lsp_refresh_l2, area, 0);  
     }  
   
   
   return CMD_SUCCESS;  
 }  
   
 DEFUN (no_lsp_lifetime,  
        no_lsp_lifetime_cmd,  
        "no lsp-lifetime",  
        NO_STR  
        "LSP lifetime in seconds\n")  
 {  
   struct isis_area *area;  
   
   area = vty->index;  
   assert (area);  
   
   area->max_lsp_lifetime[0] = MAX_AGE;  /* 1200s */  
   area->max_lsp_lifetime[1] = MAX_AGE;  /* 1200s */  
   area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL;  /*  900s */  
   area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL;  /*  900s */  
   
   return CMD_SUCCESS;  
 }  
   
 ALIAS (no_lsp_lifetime,  
        no_lsp_lifetime_arg_cmd,  
        "no lsp-lifetime <380-65535>",  
        NO_STR  
        "Maximum LSP lifetime\n"  
        "LSP lifetime in seconds\n")  
   
 DEFUN (lsp_lifetime_l1,  
        lsp_lifetime_l1_cmd,  
        "lsp-lifetime level-1 <380-65535>",  
        "Maximum LSP lifetime for Level 1 only\n"  
        "LSP lifetime for Level 1 only in seconds\n")  
 {  
   struct isis_area *area;  
   uint16_t interval;  
   
   area = vty->index;  
   assert (area);  
   
   interval = atoi (argv[0]);  
   
   if (interval < ISIS_MIN_LSP_LIFETIME)  
     {  
       vty_out (vty, "Level-1 LSP lifetime (%us) below %us%s",  
                interval, ISIS_MIN_LSP_LIFETIME, VTY_NEWLINE);  
   
       return CMD_WARNING;  
     }  
   
   
   area->max_lsp_lifetime[0] = interval;  
   area->lsp_refresh[0] = interval - 300;  
   
   return CMD_SUCCESS;  
 }  
   
 DEFUN (no_lsp_lifetime_l1,  
        no_lsp_lifetime_l1_cmd,  
        "no lsp-lifetime level-1",  
        NO_STR  
        "LSP lifetime for Level 1 only in seconds\n")  
 {  
   struct isis_area *area;  
   
   area = vty->index;  
   assert (area);  
   
   area->max_lsp_lifetime[0] = MAX_AGE;  /* 1200s */  
   area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL;  /*  900s */  
   
   return CMD_SUCCESS;  
 }  
   
 ALIAS (no_lsp_lifetime_l1,  
        no_lsp_lifetime_l1_arg_cmd,  
        "no lsp-lifetime level-1 <380-65535>",  
        NO_STR  
        "Maximum LSP lifetime for Level 1 only\n"  
        "LSP lifetime for Level 1 only in seconds\n")  
   
 DEFUN (lsp_lifetime_l2,  
        lsp_lifetime_l2_cmd,  
        "lsp-lifetime level-2 <380-65535>",  
        "Maximum LSP lifetime for Level 2 only\n"  
        "LSP lifetime for Level 2 only in seconds\n")  
 {  
   struct isis_area *area;  
   uint16_t interval;  
   
   area = vty->index;  
   assert (area);  
   
   interval = atoi (argv[0]);  
   
   if (interval < ISIS_MIN_LSP_LIFETIME)  
     {  
       vty_out (vty, "Level-2 LSP lifetime (%us) below %us%s",  
                interval, ISIS_MIN_LSP_LIFETIME, VTY_NEWLINE);  
   
       return CMD_WARNING;  
     }  
   
   area->max_lsp_lifetime[1] = interval;  
   area->lsp_refresh[1] = interval - 300;  
   
   return CMD_SUCCESS;  
 }  
   
 DEFUN (no_lsp_lifetime_l2,  
        no_lsp_lifetime_l2_cmd,  
        "no lsp-lifetime level-2",  
        NO_STR  
        "LSP lifetime for Level 2 only in seconds\n")  
 {  
   struct isis_area *area;  
   
   area = vty->index;  
   assert (area);  
   
   area->max_lsp_lifetime[1] = MAX_AGE;  /* 1200s */  
   area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL;  /*  900s */  
   
   return CMD_SUCCESS;  
 }  
   
 ALIAS (no_lsp_lifetime_l2,  
        no_lsp_lifetime_l2_arg_cmd,  
        "no lsp-lifetime level-2 <380-65535>",  
        NO_STR  
        "Maximum LSP lifetime for Level 2 only\n"  
        "LSP lifetime for Level 2 only in seconds\n")  
   
 /* IS-IS configuration write function */  /* IS-IS configuration write function */
 int  int
 isis_config_write (struct vty *vty)  isis_config_write (struct vty *vty)
Line 1939  isis_config_write (struct vty *vty) Line 3029  isis_config_write (struct vty *vty)
               vty_out (vty, " metric-style transition%s", VTY_NEWLINE);                vty_out (vty, " metric-style transition%s", VTY_NEWLINE);
             write++;              write++;
           }            }
        else
           {
             vty_out (vty, " metric-style narrow%s", VTY_NEWLINE);
             write++;
           }
         /* ISIS - overload-bit */
         if (area->overload_bit)
           {
             vty_out (vty, " set-overload-bit%s", VTY_NEWLINE);
             write++;
           }
         /* ISIS - Area is-type (level-1-2 is default) */          /* ISIS - Area is-type (level-1-2 is default) */
         if (area->is_type == IS_LEVEL_1)          if (area->is_type == IS_LEVEL_1)
           {            {
             vty_out (vty, " is-type level-1%s", VTY_NEWLINE);              vty_out (vty, " is-type level-1%s", VTY_NEWLINE);
             write++;              write++;
           }            }
        else        else if (area->is_type == IS_LEVEL_2)
           {            {
            if (area->is_type == IS_LEVEL_2)            vty_out (vty, " is-type level-2-only%s", VTY_NEWLINE);
              {            write++;
                vty_out (vty, " is-type level-2-only%s", VTY_NEWLINE); 
                write++; 
              } 
           }            }
           write += isis_redist_config_write(vty, area, AF_INET);
           write += isis_redist_config_write(vty, area, AF_INET6);
         /* ISIS - Lsp generation interval */          /* ISIS - Lsp generation interval */
         if (area->lsp_gen_interval[0] == area->lsp_gen_interval[1])          if (area->lsp_gen_interval[0] == area->lsp_gen_interval[1])
           {            {
            if (area->lsp_gen_interval[0] != LSP_GEN_INTERVAL_DEFAULT)            if (area->lsp_gen_interval[0] != DEFAULT_MIN_LSP_GEN_INTERVAL)
               {                {
                 vty_out (vty, " lsp-gen-interval %d%s",                  vty_out (vty, " lsp-gen-interval %d%s",
                          area->lsp_gen_interval[0], VTY_NEWLINE);                           area->lsp_gen_interval[0], VTY_NEWLINE);
Line 1966  isis_config_write (struct vty *vty) Line 3065  isis_config_write (struct vty *vty)
           }            }
         else          else
           {            {
            if (area->lsp_gen_interval[0] != LSP_GEN_INTERVAL_DEFAULT)            if (area->lsp_gen_interval[0] != DEFAULT_MIN_LSP_GEN_INTERVAL)
               {                {
                 vty_out (vty, " lsp-gen-interval level-1 %d%s",                  vty_out (vty, " lsp-gen-interval level-1 %d%s",
                          area->lsp_gen_interval[0], VTY_NEWLINE);                           area->lsp_gen_interval[0], VTY_NEWLINE);
                 write++;                  write++;
               }                }
            if (area->lsp_gen_interval[1] != LSP_GEN_INTERVAL_DEFAULT)            if (area->lsp_gen_interval[1] != DEFAULT_MIN_LSP_GEN_INTERVAL)
               {                {
                 vty_out (vty, " lsp-gen-interval level-2 %d%s",                  vty_out (vty, " lsp-gen-interval level-2 %d%s",
                          area->lsp_gen_interval[1], VTY_NEWLINE);                           area->lsp_gen_interval[1], VTY_NEWLINE);
Line 1982  isis_config_write (struct vty *vty) Line 3081  isis_config_write (struct vty *vty)
         /* ISIS - LSP lifetime */          /* ISIS - LSP lifetime */
         if (area->max_lsp_lifetime[0] == area->max_lsp_lifetime[1])          if (area->max_lsp_lifetime[0] == area->max_lsp_lifetime[1])
           {            {
            if (area->max_lsp_lifetime[0] != MAX_AGE)            if (area->max_lsp_lifetime[0] != DEFAULT_LSP_LIFETIME)
               {                {
                vty_out (vty, " lsp-lifetime %u%s", area->max_lsp_lifetime[0],                vty_out (vty, " max-lsp-lifetime %u%s", area->max_lsp_lifetime[0],
                          VTY_NEWLINE);                           VTY_NEWLINE);
                 write++;                  write++;
               }                }
           }            }
         else          else
           {            {
            if (area->max_lsp_lifetime[0] != MAX_AGE)            if (area->max_lsp_lifetime[0] != DEFAULT_LSP_LIFETIME)
               {                {
                vty_out (vty, " lsp-lifetime level-1 %u%s",                vty_out (vty, " max-lsp-lifetime level-1 %u%s",
                          area->max_lsp_lifetime[0], VTY_NEWLINE);                           area->max_lsp_lifetime[0], VTY_NEWLINE);
                 write++;                  write++;
               }                }
            if (area->max_lsp_lifetime[1] != MAX_AGE)            if (area->max_lsp_lifetime[1] != DEFAULT_LSP_LIFETIME)
               {                {
                vty_out (vty, " lsp-lifetime level-2 %u%s",                vty_out (vty, " max-lsp-lifetime level-2 %u%s",
                          area->max_lsp_lifetime[1], VTY_NEWLINE);                           area->max_lsp_lifetime[1], VTY_NEWLINE);
                 write++;                  write++;
               }                }
           }            }
           /* ISIS - LSP refresh interval */
           if (area->lsp_refresh[0] == area->lsp_refresh[1])
             {
               if (area->lsp_refresh[0] != DEFAULT_MAX_LSP_GEN_INTERVAL)
                 {
                   vty_out (vty, " lsp-refresh-interval %u%s", area->lsp_refresh[0],
                            VTY_NEWLINE);
                   write++;
                 }
             }
           else
             {
               if (area->lsp_refresh[0] != DEFAULT_MAX_LSP_GEN_INTERVAL)
                 {
                   vty_out (vty, " lsp-refresh-interval level-1 %u%s",
                            area->lsp_refresh[0], VTY_NEWLINE);
                   write++;
                 }
               if (area->lsp_refresh[1] != DEFAULT_MAX_LSP_GEN_INTERVAL)
                 {
                   vty_out (vty, " lsp-refresh-interval level-2 %u%s",
                            area->lsp_refresh[1], VTY_NEWLINE);
                   write++;
                 }
             }
           if (area->lsp_mtu != DEFAULT_LSP_MTU)
             {
               vty_out(vty, " lsp-mtu %u%s", area->lsp_mtu, VTY_NEWLINE);
               write++;
             }
   
         /* Minimum SPF interval. */          /* Minimum SPF interval. */
         if (area->min_spf_interval[0] == area->min_spf_interval[1])          if (area->min_spf_interval[0] == area->min_spf_interval[1])
           {            {
Line 2030  isis_config_write (struct vty *vty) Line 3160  isis_config_write (struct vty *vty)
               }                }
           }            }
         /* Authentication passwords. */          /* Authentication passwords. */
        if (area->area_passwd.len > 0)        if (area->area_passwd.type == ISIS_PASSWD_TYPE_HMAC_MD5)
           {            {
            vty_out(vty, " area-password %s", area->area_passwd.passwd);            vty_out(vty, " area-password md5 %s", area->area_passwd.passwd);
             if (CHECK_FLAG(area->area_passwd.snp_auth, SNP_AUTH_SEND))              if (CHECK_FLAG(area->area_passwd.snp_auth, SNP_AUTH_SEND))
               {                {
                 vty_out(vty, " authenticate snp ");                  vty_out(vty, " authenticate snp ");
Line 2043  isis_config_write (struct vty *vty) Line 3173  isis_config_write (struct vty *vty)
               }                }
             vty_out(vty, "%s", VTY_NEWLINE);              vty_out(vty, "%s", VTY_NEWLINE);
             write++;               write++; 
          }            }
        if (area->domain_passwd.len > 0)        else if (area->area_passwd.type == ISIS_PASSWD_TYPE_CLEARTXT)
           {
             vty_out(vty, " area-password clear %s", area->area_passwd.passwd);
             if (CHECK_FLAG(area->area_passwd.snp_auth, SNP_AUTH_SEND))
               {
                 vty_out(vty, " authenticate snp ");
                 if (CHECK_FLAG(area->area_passwd.snp_auth, SNP_AUTH_RECV))
                   vty_out(vty, "validate");
                 else
                   vty_out(vty, "send-only");
               }
             vty_out(vty, "%s", VTY_NEWLINE);
             write++; 
           }
         if (area->domain_passwd.type == ISIS_PASSWD_TYPE_HMAC_MD5)
           {            {
            vty_out(vty, " domain-password %s", area->domain_passwd.passwd);            vty_out(vty, " domain-password md5 %s",
                     area->domain_passwd.passwd);
             if (CHECK_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_SEND))              if (CHECK_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_SEND))
               {                {
                 vty_out(vty, " authenticate snp ");                  vty_out(vty, " authenticate snp ");
Line 2058  isis_config_write (struct vty *vty) Line 3203  isis_config_write (struct vty *vty)
             vty_out(vty, "%s", VTY_NEWLINE);              vty_out(vty, "%s", VTY_NEWLINE);
             write++;              write++;
           }            }
           else if (area->domain_passwd.type == ISIS_PASSWD_TYPE_CLEARTXT)
             {
               vty_out(vty, " domain-password clear %s",
                       area->domain_passwd.passwd); 
               if (CHECK_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_SEND))
                 {
                   vty_out(vty, " authenticate snp ");
                   if (CHECK_FLAG(area->domain_passwd.snp_auth, SNP_AUTH_RECV))
                     vty_out(vty, "validate");
                   else
                     vty_out(vty, "send-only");
                 }
               vty_out(vty, "%s", VTY_NEWLINE);
               write++;
             }
   
           if (area->log_adj_changes)
             {
               vty_out (vty, " log-adjacency-changes%s", VTY_NEWLINE);
               write++;
             }
   
 #ifdef TOPOLOGY_GENERATE  #ifdef TOPOLOGY_GENERATE
         if (memcmp (area->topology_baseis, DEFAULT_TOPOLOGY_BASEIS,          if (memcmp (area->topology_baseis, DEFAULT_TOPOLOGY_BASEIS,
                     ISIS_SYS_ID_LEN))                      ISIS_SYS_ID_LEN))
           {            {
             vty_out (vty, " topology base-is %s%s",              vty_out (vty, " topology base-is %s%s",
                     sysid_print (area->topology_baseis), VTY_NEWLINE);                     sysid_print ((u_char *)area->topology_baseis), VTY_NEWLINE);
             write++;              write++;
           }            }
         if (area->topology_basedynh)          if (area->topology_basedynh)
Line 2087  isis_config_write (struct vty *vty) Line 3253  isis_config_write (struct vty *vty)
   return write;    return write;
 }  }
   
static struct cmd_node isis_node = {struct cmd_node isis_node = {
   ISIS_NODE,    ISIS_NODE,
   "%s(config-router)# ",    "%s(config-router)# ",
   1    1
Line 2099  isis_init () Line 3265  isis_init ()
   /* Install IS-IS top node */    /* Install IS-IS top node */
   install_node (&isis_node, isis_config_write);    install_node (&isis_node, isis_config_write);
   
  install_element (VIEW_NODE, &show_clns_neighbors_cmd);  install_element (VIEW_NODE, &show_isis_summary_cmd);
  install_element (VIEW_NODE, &show_isis_neighbors_cmd); 
  install_element (VIEW_NODE, &show_clns_neighbors_detail_cmd); 
  install_element (VIEW_NODE, &show_isis_neighbors_detail_cmd); 
   
     install_element (VIEW_NODE, &show_isis_interface_cmd);
     install_element (VIEW_NODE, &show_isis_interface_detail_cmd);
     install_element (VIEW_NODE, &show_isis_interface_arg_cmd);
   
     install_element (VIEW_NODE, &show_isis_neighbor_cmd);
     install_element (VIEW_NODE, &show_isis_neighbor_detail_cmd);
     install_element (VIEW_NODE, &show_isis_neighbor_arg_cmd);
     install_element (VIEW_NODE, &clear_isis_neighbor_cmd);
     install_element (VIEW_NODE, &clear_isis_neighbor_arg_cmd);
   
   install_element (VIEW_NODE, &show_hostname_cmd);    install_element (VIEW_NODE, &show_hostname_cmd);
   install_element (VIEW_NODE, &show_database_cmd);    install_element (VIEW_NODE, &show_database_cmd);
     install_element (VIEW_NODE, &show_database_arg_cmd);
     install_element (VIEW_NODE, &show_database_arg_detail_cmd);
   install_element (VIEW_NODE, &show_database_detail_cmd);    install_element (VIEW_NODE, &show_database_detail_cmd);
     install_element (VIEW_NODE, &show_database_detail_arg_cmd);
   
  install_element (ENABLE_NODE, &show_clns_neighbors_cmd);  install_element (ENABLE_NODE, &show_isis_summary_cmd);
  install_element (ENABLE_NODE, &show_isis_neighbors_cmd); 
  install_element (ENABLE_NODE, &show_clns_neighbors_detail_cmd); 
  install_element (ENABLE_NODE, &show_isis_neighbors_detail_cmd); 
   
     install_element (ENABLE_NODE, &show_isis_interface_cmd);
     install_element (ENABLE_NODE, &show_isis_interface_detail_cmd);
     install_element (ENABLE_NODE, &show_isis_interface_arg_cmd);
   
     install_element (ENABLE_NODE, &show_isis_neighbor_cmd);
     install_element (ENABLE_NODE, &show_isis_neighbor_detail_cmd);
     install_element (ENABLE_NODE, &show_isis_neighbor_arg_cmd);
     install_element (ENABLE_NODE, &clear_isis_neighbor_cmd);
     install_element (ENABLE_NODE, &clear_isis_neighbor_arg_cmd);
   
   install_element (ENABLE_NODE, &show_hostname_cmd);    install_element (ENABLE_NODE, &show_hostname_cmd);
   install_element (ENABLE_NODE, &show_database_cmd);    install_element (ENABLE_NODE, &show_database_cmd);
     install_element (ENABLE_NODE, &show_database_arg_cmd);
     install_element (ENABLE_NODE, &show_database_arg_detail_cmd);
   install_element (ENABLE_NODE, &show_database_detail_cmd);    install_element (ENABLE_NODE, &show_database_detail_cmd);
     install_element (ENABLE_NODE, &show_database_detail_arg_cmd);
   install_element (ENABLE_NODE, &show_debugging_cmd);    install_element (ENABLE_NODE, &show_debugging_cmd);
   
   install_node (&debug_node, config_write_debug);    install_node (&debug_node, config_write_debug);
Line 2142  isis_init () Line 3328  isis_init ()
   install_element (ENABLE_NODE, &no_debug_isis_rtevents_cmd);    install_element (ENABLE_NODE, &no_debug_isis_rtevents_cmd);
   install_element (ENABLE_NODE, &debug_isis_events_cmd);    install_element (ENABLE_NODE, &debug_isis_events_cmd);
   install_element (ENABLE_NODE, &no_debug_isis_events_cmd);    install_element (ENABLE_NODE, &no_debug_isis_events_cmd);
     install_element (ENABLE_NODE, &debug_isis_packet_dump_cmd);
     install_element (ENABLE_NODE, &no_debug_isis_packet_dump_cmd);
     install_element (ENABLE_NODE, &debug_isis_lsp_gen_cmd);
     install_element (ENABLE_NODE, &no_debug_isis_lsp_gen_cmd);
     install_element (ENABLE_NODE, &debug_isis_lsp_sched_cmd);
     install_element (ENABLE_NODE, &no_debug_isis_lsp_sched_cmd);
   
   install_element (CONFIG_NODE, &debug_isis_adj_cmd);    install_element (CONFIG_NODE, &debug_isis_adj_cmd);
   install_element (CONFIG_NODE, &no_debug_isis_adj_cmd);    install_element (CONFIG_NODE, &no_debug_isis_adj_cmd);
Line 2165  isis_init () Line 3357  isis_init ()
   install_element (CONFIG_NODE, &no_debug_isis_rtevents_cmd);    install_element (CONFIG_NODE, &no_debug_isis_rtevents_cmd);
   install_element (CONFIG_NODE, &debug_isis_events_cmd);    install_element (CONFIG_NODE, &debug_isis_events_cmd);
   install_element (CONFIG_NODE, &no_debug_isis_events_cmd);    install_element (CONFIG_NODE, &no_debug_isis_events_cmd);
     install_element (CONFIG_NODE, &debug_isis_packet_dump_cmd);
     install_element (CONFIG_NODE, &no_debug_isis_packet_dump_cmd);
     install_element (CONFIG_NODE, &debug_isis_lsp_gen_cmd);
     install_element (CONFIG_NODE, &no_debug_isis_lsp_gen_cmd);
     install_element (CONFIG_NODE, &debug_isis_lsp_sched_cmd);
     install_element (CONFIG_NODE, &no_debug_isis_lsp_sched_cmd);
   
   install_element (CONFIG_NODE, &router_isis_cmd);    install_element (CONFIG_NODE, &router_isis_cmd);
   install_element (CONFIG_NODE, &no_router_isis_cmd);    install_element (CONFIG_NODE, &no_router_isis_cmd);
Line 2177  isis_init () Line 3375  isis_init ()
   install_element (ISIS_NODE, &is_type_cmd);    install_element (ISIS_NODE, &is_type_cmd);
   install_element (ISIS_NODE, &no_is_type_cmd);    install_element (ISIS_NODE, &no_is_type_cmd);
   
  install_element (ISIS_NODE, &area_passwd_cmd);  install_element (ISIS_NODE, &area_lsp_mtu_cmd);
  install_element (ISIS_NODE, &area_passwd_snpauth_cmd);  install_element (ISIS_NODE, &no_area_lsp_mtu_cmd);
   install_element (ISIS_NODE, &no_area_lsp_mtu_arg_cmd);
 
   install_element (ISIS_NODE, &area_passwd_md5_cmd);
   install_element (ISIS_NODE, &area_passwd_md5_snpauth_cmd);
   install_element (ISIS_NODE, &area_passwd_clear_cmd);
   install_element (ISIS_NODE, &area_passwd_clear_snpauth_cmd);
   install_element (ISIS_NODE, &no_area_passwd_cmd);    install_element (ISIS_NODE, &no_area_passwd_cmd);
   
  install_element (ISIS_NODE, &domain_passwd_cmd);  install_element (ISIS_NODE, &domain_passwd_md5_cmd);
  install_element (ISIS_NODE, &domain_passwd_snpauth_cmd);  install_element (ISIS_NODE, &domain_passwd_md5_snpauth_cmd);
   install_element (ISIS_NODE, &domain_passwd_clear_cmd);
   install_element (ISIS_NODE, &domain_passwd_clear_snpauth_cmd);
   install_element (ISIS_NODE, &no_domain_passwd_cmd);    install_element (ISIS_NODE, &no_domain_passwd_cmd);
   
   install_element (ISIS_NODE, &lsp_gen_interval_cmd);    install_element (ISIS_NODE, &lsp_gen_interval_cmd);
Line 2205  isis_init () Line 3411  isis_init ()
   install_element (ISIS_NODE, &no_spf_interval_l2_cmd);    install_element (ISIS_NODE, &no_spf_interval_l2_cmd);
   install_element (ISIS_NODE, &no_spf_interval_l2_arg_cmd);    install_element (ISIS_NODE, &no_spf_interval_l2_arg_cmd);
   
  install_element (ISIS_NODE, &lsp_lifetime_cmd);  install_element (ISIS_NODE, &max_lsp_lifetime_cmd);
  install_element (ISIS_NODE, &no_lsp_lifetime_cmd);  install_element (ISIS_NODE, &no_max_lsp_lifetime_cmd);
  install_element (ISIS_NODE, &no_lsp_lifetime_arg_cmd);  install_element (ISIS_NODE, &no_max_lsp_lifetime_arg_cmd);
  install_element (ISIS_NODE, &lsp_lifetime_l1_cmd);  install_element (ISIS_NODE, &max_lsp_lifetime_l1_cmd);
  install_element (ISIS_NODE, &no_lsp_lifetime_l1_cmd);  install_element (ISIS_NODE, &no_max_lsp_lifetime_l1_cmd);
  install_element (ISIS_NODE, &no_lsp_lifetime_l1_arg_cmd);  install_element (ISIS_NODE, &no_max_lsp_lifetime_l1_arg_cmd);
  install_element (ISIS_NODE, &lsp_lifetime_l2_cmd);  install_element (ISIS_NODE, &max_lsp_lifetime_l2_cmd);
  install_element (ISIS_NODE, &no_lsp_lifetime_l2_cmd);  install_element (ISIS_NODE, &no_max_lsp_lifetime_l2_cmd);
  install_element (ISIS_NODE, &no_lsp_lifetime_l2_arg_cmd);  install_element (ISIS_NODE, &no_max_lsp_lifetime_l2_arg_cmd);
   
     install_element (ISIS_NODE, &lsp_refresh_interval_cmd);
     install_element (ISIS_NODE, &no_lsp_refresh_interval_cmd);
     install_element (ISIS_NODE, &no_lsp_refresh_interval_arg_cmd);
     install_element (ISIS_NODE, &lsp_refresh_interval_l1_cmd);
     install_element (ISIS_NODE, &no_lsp_refresh_interval_l1_cmd);
     install_element (ISIS_NODE, &no_lsp_refresh_interval_l1_arg_cmd);
     install_element (ISIS_NODE, &lsp_refresh_interval_l2_cmd);
     install_element (ISIS_NODE, &no_lsp_refresh_interval_l2_cmd);
     install_element (ISIS_NODE, &no_lsp_refresh_interval_l2_arg_cmd);
   
     install_element (ISIS_NODE, &set_overload_bit_cmd);
     install_element (ISIS_NODE, &no_set_overload_bit_cmd);
   
     install_element (ISIS_NODE, &set_attached_bit_cmd);
     install_element (ISIS_NODE, &no_set_attached_bit_cmd);
   
   install_element (ISIS_NODE, &dynamic_hostname_cmd);    install_element (ISIS_NODE, &dynamic_hostname_cmd);
   install_element (ISIS_NODE, &no_dynamic_hostname_cmd);    install_element (ISIS_NODE, &no_dynamic_hostname_cmd);
   
   install_element (ISIS_NODE, &metric_style_cmd);    install_element (ISIS_NODE, &metric_style_cmd);
   install_element (ISIS_NODE, &no_metric_style_cmd);    install_element (ISIS_NODE, &no_metric_style_cmd);
   
     install_element (ISIS_NODE, &log_adj_changes_cmd);
     install_element (ISIS_NODE, &no_log_adj_changes_cmd);
   
 #ifdef TOPOLOGY_GENERATE  #ifdef TOPOLOGY_GENERATE
   install_element (ISIS_NODE, &topology_generate_grid_cmd);    install_element (ISIS_NODE, &topology_generate_grid_cmd);
   install_element (ISIS_NODE, &topology_baseis_cmd);    install_element (ISIS_NODE, &topology_baseis_cmd);
Line 2229  isis_init () Line 3455  isis_init ()
   install_element (VIEW_NODE, &show_isis_generated_topology_cmd);    install_element (VIEW_NODE, &show_isis_generated_topology_cmd);
   install_element (ENABLE_NODE, &show_isis_generated_topology_cmd);    install_element (ENABLE_NODE, &show_isis_generated_topology_cmd);
 #endif /* TOPOLOGY_GENERATE */  #endif /* TOPOLOGY_GENERATE */
   
   isis_new (0);  
   isis_circuit_init ();  
   isis_zebra_init ();  
   isis_spf_cmds_init ();  
 }  }
Removed from v.1.1  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>