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; see the file COPYING; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 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/isis_constants.h"
  35 #include "isisd/isis_common.h"
  36 #include "isisd/isis_flags.h"
  37 #include "isisd/isis_circuit.h"
  38 #include "isisd/isisd.h"
  39 #include "isisd/isis_dynhn.h"
  40 #include "isisd/isis_misc.h"
  41 #include "isisd/isis_constants.h"
  42
  43 DEFINE_MTYPE_STATIC(ISISD, ISIS_DYNHN, "ISIS dyn hostname");
  44
  45 static void dyn_cache_cleanup(struct thread *);
  46
  47 void dyn_cache_init(struct isis *isis)
  48 {
  49         isis->dyn_cache = list_new();
  50         if (!CHECK_FLAG(im->options, F_ISIS_UNIT_TEST))
  51                 thread_add_timer(master, dyn_cache_cleanup, isis, 120,
  52                                  &isis->t_dync_clean);
  53 }
  54
  55 void dyn_cache_finish(struct isis *isis)
  56 {
  57         struct listnode *node, *nnode;
  58         struct isis_dynhn *dyn;
  59
  60         THREAD_OFF(isis->t_dync_clean);
  61
  62         for (ALL_LIST_ELEMENTS(isis->dyn_cache, node, nnode, dyn)) {
  63                 list_delete_node(isis->dyn_cache, node);
  64                 XFREE(MTYPE_ISIS_DYNHN, dyn);
  65         }
  66
  67         list_delete(&isis->dyn_cache);
  68 }
  69
  70 static void dyn_cache_cleanup(struct thread *thread)
  71 {
  72         struct listnode *node, *nnode;
  73         struct isis_dynhn *dyn;
  74         time_t now = time(NULL);
  75         struct isis *isis = NULL;
  76
  77         isis = THREAD_ARG(thread);
  78
  79         isis->t_dync_clean = NULL;
  80
  81         for (ALL_LIST_ELEMENTS(isis->dyn_cache, node, nnode, dyn)) {
  82                 if ((now - dyn->refresh) < MAX_LSP_LIFETIME)
  83                         continue;
  84                 list_delete_node(isis->dyn_cache, node);
  85                 XFREE(MTYPE_ISIS_DYNHN, dyn);
  86         }
  87
  88         thread_add_timer(master, dyn_cache_cleanup, isis, 120,
  89                         &isis->t_dync_clean);
  90 }
  91
  92 struct isis_dynhn *dynhn_find_by_id(struct isis *isis, const uint8_t *id)
  93 {
  94         struct listnode *node = NULL;
  95         struct isis_dynhn *dyn = NULL;
  96
  97         for (ALL_LIST_ELEMENTS_RO(isis->dyn_cache, node, dyn))
  98                 if (memcmp(dyn->id, id, ISIS_SYS_ID_LEN) == 0)
  99                         return dyn;
 100
 101         return NULL;
 102 }
 103
 104 struct isis_dynhn *dynhn_find_by_name(struct isis *isis, const char *hostname)
 105 {
 106         struct listnode *node = NULL;
 107         struct isis_dynhn *dyn = NULL;
 108
 109         for (ALL_LIST_ELEMENTS_RO(isis->dyn_cache, node, dyn))
 110                 if (strncmp(dyn->hostname, hostname, 255) == 0)
 111                         return dyn;
 112
 113         return NULL;
 114 }
 115
 116 void isis_dynhn_insert(struct isis *isis, const uint8_t *id,
 117                        const char *hostname, int level)
 118 {
 119         struct isis_dynhn *dyn;
 120
 121         dyn = dynhn_find_by_id(isis, id);
 122         if (!dyn) {
 123                 dyn = XCALLOC(MTYPE_ISIS_DYNHN, sizeof(struct isis_dynhn));
 124                 memcpy(dyn->id, id, ISIS_SYS_ID_LEN);
 125                 dyn->level = level;
 126                 listnode_add(isis->dyn_cache, dyn);
 127         }
 128
 129         snprintf(dyn->hostname, sizeof(dyn->hostname), "%s", hostname);
 130         dyn->refresh = time(NULL);
 131 }
 132
 133 void isis_dynhn_remove(struct isis *isis, const uint8_t *id)
 134 {
 135         struct isis_dynhn *dyn;
 136
 137         dyn = dynhn_find_by_id(isis, id);
 138         if (!dyn)
 139                 return;
 140         listnode_delete(isis->dyn_cache, dyn);
 141         XFREE(MTYPE_ISIS_DYNHN, dyn);
 142 }
 143
 144 /*
 145  * Level  System ID      Dynamic Hostname  (notag)
 146  *  2     0000.0000.0001 foo-gw
 147  *  2     0000.0000.0002 bar-gw
 148  *      * 0000.0000.0004 this-gw
 149  */
 150 void dynhn_print_all(struct vty *vty, struct isis *isis)
 151 {
 152         struct listnode *node;
 153         struct isis_dynhn *dyn;
 154
 155         vty_out(vty, "vrf     : %s\n", isis->name);
 156         if (!isis->sysid_set)
 157                 return;
 158         vty_out(vty, "Level  System ID      Dynamic Hostname\n");
 159         for (ALL_LIST_ELEMENTS_RO(isis->dyn_cache, node, dyn)) {
 160                 vty_out(vty, "%-7d", dyn->level);
 161                 vty_out(vty, "%-15s%-15s\n", sysid_print(dyn->id),
 162                         dyn->hostname);
 163         }
 164
 165         vty_out(vty, "     * %s %s\n", sysid_print(isis->sysid),
 166                 cmd_hostname_get());
 167         return;
 168 }
 169
 170 struct isis_dynhn *dynhn_snmp_next(struct isis *isis, const uint8_t *id,
 171                                    int level)
 172 {
 173         struct listnode *node = NULL;
 174         struct isis_dynhn *dyn = NULL;
 175         struct isis_dynhn *found_dyn = NULL;
 176         int res;
 177
 178         for (ALL_LIST_ELEMENTS_RO(isis->dyn_cache, node, dyn)) {
 179                 res = memcmp(dyn->id, id, ISIS_SYS_ID_LEN);
 180
 181                 if (res < 0)
 182                         continue;
 183
 184                 if (res == 0 && dyn->level <= level)
 185                         continue;
 186
 187                 if (res == 0) {
 188                         /*
 189                          * This is the best match, we can stop
 190                          * searching
 191                          */
 192
 193                         found_dyn = dyn;
 194                         break;
 195                 }
 196
 197                 if (found_dyn == NULL
 198                     || memcmp(dyn->id, found_dyn->id, ISIS_SYS_ID_LEN) < 0) {
 199                         found_dyn = dyn;
 200                 }
 201         }
 202
 203         return found_dyn;
 204 }