isisd/isis_dynhn.c

   1 /*
   2  * IS-IS Rout(e)ing protocol - isis_dynhn.c
   3  *                             Dynamic hostname cache
   4  * Copyright (C) 2001,2002   Sampo Saaristo
   5  *                           Tampere University of Technology
   6  *                           Institute of Communications Engineering
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public Licenseas published by the Free
  10  * Software Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "vty.h"
  26 #include "linklist.h"
  27 #include "memory.h"
  28 #include "log.h"
  29 #include "stream.h"
  30 #include "command.h"
  31 #include "if.h"
  32 #include "thread.h"
  33
  34 #include "isisd/dict.h"
  35 #include "isisd/isis_constants.h"
  36 #include "isisd/isis_common.h"
  37 #include "isisd/isis_flags.h"
  38 #include "isisd/isis_circuit.h"
  39 #include "isisd/isisd.h"
  40 #include "isisd/isis_dynhn.h"
  41 #include "isisd/isis_misc.h"
  42 #include "isisd/isis_constants.h"
  43
  44 extern struct host host;
  45
  46 struct list *dyn_cache = NULL;
  47 static int dyn_cache_cleanup (struct thread *);
  48
  49 void
  50 dyn_cache_init (void)
  51 {
  52   if (dyn_cache == NULL)
  53     dyn_cache = list_new ();
  54   thread_add_timer(master, dyn_cache_cleanup, NULL, 120, &isis->t_dync_clean);
  55   return;
  56 }
  57
  58 static int
  59 dyn_cache_cleanup (struct thread *thread)
  60 {
  61   struct listnode *node, *nnode;
  62   struct isis_dynhn *dyn;
  63   time_t now = time (NULL);
  64
  65   isis->t_dync_clean = NULL;
  66
  67   for (ALL_LIST_ELEMENTS (dyn_cache, node, nnode, dyn))
  68     {
  69       if ((now - dyn->refresh) < MAX_LSP_LIFETIME)
  70         continue;
  71
  72       list_delete_node (dyn_cache, node);
  73       XFREE (MTYPE_ISIS_DYNHN, dyn);
  74     }
  75
  76   thread_add_timer(master, dyn_cache_cleanup, NULL, 120, &isis->t_dync_clean);
  77   return ISIS_OK;
  78 }
  79
  80 struct isis_dynhn *
  81 dynhn_find_by_id (const u_char * id)
  82 {
  83   struct listnode *node = NULL;
  84   struct isis_dynhn *dyn = NULL;
  85
  86   for (ALL_LIST_ELEMENTS_RO (dyn_cache, node, dyn))
  87     if (memcmp (dyn->id, id, ISIS_SYS_ID_LEN) == 0)
  88       return dyn;
  89
  90   return NULL;
  91 }
  92
  93 struct isis_dynhn *
  94 dynhn_find_by_name (const char *hostname)
  95 {
  96   struct listnode *node = NULL;
  97   struct isis_dynhn *dyn = NULL;
  98
  99   for (ALL_LIST_ELEMENTS_RO (dyn_cache, node, dyn))
 100     if (strncmp ((char *)dyn->name.name, hostname, 255) == 0)
 101       return dyn;
 102
 103   return NULL;
 104 }
 105
 106 void
 107 isis_dynhn_insert (const u_char * id, struct hostname *hostname, int level)
 108 {
 109   struct isis_dynhn *dyn;
 110
 111   dyn = dynhn_find_by_id (id);
 112   if (dyn)
 113     {
 114       memcpy (&dyn->name, hostname, hostname->namelen + 1);
 115       memcpy (dyn->id, id, ISIS_SYS_ID_LEN);
 116       dyn->refresh = time (NULL);
 117       return;
 118     }
 119   dyn = XCALLOC (MTYPE_ISIS_DYNHN, sizeof (struct isis_dynhn));
 120   if (!dyn)
 121     {
 122       zlog_warn ("isis_dynhn_insert(): out of memory!");
 123       return;
 124     }
 125
 126   /* we also copy the length */
 127   memcpy (&dyn->name, hostname, hostname->namelen + 1);
 128   memcpy (dyn->id, id, ISIS_SYS_ID_LEN);
 129   dyn->refresh = time (NULL);
 130   dyn->level = level;
 131
 132   listnode_add (dyn_cache, dyn);
 133
 134   return;
 135 }
 136
 137 void
 138 isis_dynhn_remove (const u_char * id)
 139 {
 140   struct isis_dynhn *dyn;
 141
 142   dyn = dynhn_find_by_id (id);
 143   if (!dyn)
 144     return;
 145   listnode_delete (dyn_cache, dyn);
 146   XFREE (MTYPE_ISIS_DYNHN, dyn);
 147   return;
 148 }
 149
 150 /*
 151  * Level  System ID      Dynamic Hostname  (notag)
 152  *  2     0000.0000.0001 foo-gw
 153  *  2     0000.0000.0002 bar-gw
 154  *      * 0000.0000.0004 this-gw
 155  */
 156 void
 157 dynhn_print_all (struct vty *vty)
 158 {
 159   struct listnode *node;
 160   struct isis_dynhn *dyn;
 161
 162   vty_out (vty, "Level  System ID      Dynamic Hostname%s", VTY_NEWLINE);
 163   for (ALL_LIST_ELEMENTS_RO (dyn_cache, node, dyn))
 164     {
 165       vty_out (vty, "%-7d", dyn->level);
 166       vty_out (vty, "%-15s%-15s%s", sysid_print (dyn->id), dyn->name.name,
 167                VTY_NEWLINE);
 168     }
 169
 170   vty_out (vty, "     * %s %s%s", sysid_print (isis->sysid), unix_hostname (),
 171            VTY_NEWLINE);
 172   return;
 173 }