Return to isis_dynhn.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / isisd

quagga

    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_TIMER_ON (master, isis->t_dync_clean, dyn_cache_cleanup, NULL, 120);
   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_TIMER_ON (master, isis->t_dync_clean, dyn_cache_cleanup, NULL, 120);
   77:   return ISIS_OK;
   78: }
   79: 
   80: struct isis_dynhn *
   81: dynhn_find_by_id (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 (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 (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: }