lib/distribute.c

   1 /* Distribute list functions
   2  * Copyright (C) 1998, 1999 Kunihiro Ishiguro
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published
   8  * by the Free Software Foundation; either version 2, or (at your
   9  * option) any later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with GNU Zebra; see the file COPYING.  If not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "hash.h"
  25 #include "if.h"
  26 #include "filter.h"
  27 #include "command.h"
  28 #include "distribute.h"
  29 #include "memory.h"
  30
  31 DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE,        "Distribute list")
  32 DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_IFNAME, "Dist-list ifname")
  33 DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_NAME,   "Dist-list name")
  34
  35 /* Hash of distribute list. */
  36 struct hash *disthash;
  37
  38 /* Hook functions. */
  39 void (*distribute_add_hook) (struct distribute *);
  40 void (*distribute_delete_hook) (struct distribute *);
  41
  42 static struct distribute *
  43 distribute_new (void)
  44 {
  45   return XCALLOC (MTYPE_DISTRIBUTE, sizeof (struct distribute));
  46 }
  47
  48 /* Free distribute object. */
  49 static void
  50 distribute_free (struct distribute *dist)
  51 {
  52   int i = 0;
  53
  54   if (dist->ifname)
  55     XFREE (MTYPE_DISTRIBUTE_IFNAME, dist->ifname);
  56
  57   for (i = 0; i < DISTRIBUTE_MAX; i++)
  58     if (dist->list[i])
  59       XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[i]);
  60
  61   for (i = 0; i < DISTRIBUTE_MAX; i++)
  62     if (dist->prefix[i])
  63       XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[i]);
  64
  65   XFREE (MTYPE_DISTRIBUTE, dist);
  66 }
  67
  68 static void
  69 distribute_free_if_empty(struct distribute *dist)
  70 {
  71   int i;
  72
  73   for (i = 0; i < DISTRIBUTE_MAX; i++)
  74     if (dist->list[i] != NULL || dist->prefix[i] != NULL)
  75       return;
  76
  77   hash_release (disthash, dist);
  78   distribute_free (dist);
  79 }
  80
  81 /* Lookup interface's distribute list. */
  82 struct distribute *
  83 distribute_lookup (const char *ifname)
  84 {
  85   struct distribute key;
  86   struct distribute *dist;
  87
  88   /* temporary reference */
  89   key.ifname = (ifname) ? XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, ifname) : NULL;
  90
  91   dist = hash_lookup (disthash, &key);
  92
  93   if (key.ifname)
  94     XFREE(MTYPE_DISTRIBUTE_IFNAME, key.ifname);
  95
  96   return dist;
  97 }
  98
  99 void
 100 distribute_list_add_hook (void (*func) (struct distribute *))
 101 {
 102   distribute_add_hook = func;
 103 }
 104
 105 void
 106 distribute_list_delete_hook (void (*func) (struct distribute *))
 107 {
 108   distribute_delete_hook = func;
 109 }
 110
 111 static void *
 112 distribute_hash_alloc (struct distribute *arg)
 113 {
 114   struct distribute *dist;
 115
 116   dist = distribute_new ();
 117   if (arg->ifname)
 118     dist->ifname = XSTRDUP (MTYPE_DISTRIBUTE_IFNAME, arg->ifname);
 119   else
 120     dist->ifname = NULL;
 121   return dist;
 122 }
 123
 124 /* Make new distribute list and push into hash. */
 125 static struct distribute *
 126 distribute_get (const char *ifname)
 127 {
 128   struct distribute key;
 129   struct distribute *ret;
 130
 131   /* temporary reference */
 132   key.ifname = (ifname) ? XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, ifname) : NULL;
 133
 134   ret = hash_get (disthash, &key, (void * (*) (void *))distribute_hash_alloc);
 135
 136   if (key.ifname)
 137     XFREE(MTYPE_DISTRIBUTE_IFNAME, key.ifname);
 138
 139   return ret;
 140 }
 141
 142 static unsigned int
 143 distribute_hash_make (void *arg)
 144 {
 145   const struct distribute *dist = arg;
 146
 147   return dist->ifname ? string_hash_make (dist->ifname) : 0;
 148 }
 149
 150 /* If two distribute-list have same value then return 1 else return
 151    0. This function is used by hash package. */
 152 static int
 153 distribute_cmp (const struct distribute *dist1, const struct distribute *dist2)
 154 {
 155   if (dist1->ifname && dist2->ifname)
 156     if (strcmp (dist1->ifname, dist2->ifname) == 0)
 157       return 1;
 158   if (! dist1->ifname && ! dist2->ifname)
 159     return 1;
 160   return 0;
 161 }
 162
 163 /* Set access-list name to the distribute list. */
 164 static void
 165 distribute_list_set (const char *ifname, enum distribute_type type,
 166                      const char *alist_name)
 167 {
 168   struct distribute *dist;
 169
 170   dist = distribute_get (ifname);
 171
 172   if (dist->list[type])
 173     XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[type]);
 174   dist->list[type] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, alist_name);
 175
 176   /* Apply this distribute-list to the interface. */
 177   (*distribute_add_hook) (dist);
 178 }
 179
 180 /* Unset distribute-list.  If matched distribute-list exist then
 181    return 1. */
 182 static int
 183 distribute_list_unset (const char *ifname, enum distribute_type type,
 184                        const char *alist_name)
 185 {
 186   struct distribute *dist;
 187
 188   dist = distribute_lookup (ifname);
 189   if (!dist)
 190     return 0;
 191
 192   if (!dist->list[type])
 193         return 0;
 194   if (strcmp (dist->list[type], alist_name) != 0)
 195         return 0;
 196
 197   XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[type]);
 198   dist->list[type] = NULL;
 199
 200   /* Apply this distribute-list to the interface. */
 201   (*distribute_delete_hook) (dist);
 202
 203   /* If all dist are NULL, then free distribute list. */
 204   distribute_free_if_empty(dist);
 205   return 1;
 206 }
 207
 208 /* Set access-list name to the distribute list. */
 209 static void
 210 distribute_list_prefix_set (const char *ifname, enum distribute_type type,
 211                             const char *plist_name)
 212 {
 213   struct distribute *dist;
 214
 215   dist = distribute_get (ifname);
 216
 217   if (dist->prefix[type])
 218     XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[type]);
 219   dist->prefix[type] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, plist_name);
 220
 221   /* Apply this distribute-list to the interface. */
 222   (*distribute_add_hook) (dist);
 223 }
 224
 225 /* Unset distribute-list.  If matched distribute-list exist then
 226    return 1. */
 227 static int
 228 distribute_list_prefix_unset (const char *ifname, enum distribute_type type,
 229                               const char *plist_name)
 230 {
 231   struct distribute *dist;
 232
 233   dist = distribute_lookup (ifname);
 234   if (!dist)
 235     return 0;
 236
 237   if (!dist->prefix[type])
 238         return 0;
 239   if (strcmp (dist->prefix[type], plist_name) != 0)
 240         return 0;
 241
 242   XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[type]);
 243   dist->prefix[type] = NULL;
 244
 245   /* Apply this distribute-list to the interface. */
 246   (*distribute_delete_hook) (dist);
 247
 248   /* If all dist are NULL, then free distribute list. */
 249   distribute_free_if_empty(dist);
 250   return 1;
 251 }
 252
 253 DEFUN (distribute_list,
 254        distribute_list_cmd,
 255        "distribute-list [prefix] WORD <in|out> [WORD]",
 256        "Filter networks in routing updates\n"
 257        "Access-list name\n"
 258        "Filter incoming routing updates\n"
 259        "Filter outgoing routing updates\n"
 260        "Interface name\n")
 261 {
 262   int prefix = (argv[1]->type == WORD_TKN) ? 1 : 0;
 263
 264   /* Check of distribute list type. */
 265   enum distribute_type type = argv[2 + prefix]->arg[0] == 'i' ?
 266     DISTRIBUTE_V4_IN : DISTRIBUTE_V4_OUT;
 267
 268   /* Set appropriate function call */
 269   void (*distfn)(const char *, enum distribute_type, const char *) = prefix ?
 270     &distribute_list_prefix_set : &distribute_list_set;
 271
 272   /* if interface is present, get name */
 273   const char *ifname = NULL;
 274   if (argv[argc - 1]->type == VARIABLE_TKN)
 275     ifname = argv[argc - 1]->arg;
 276
 277   /* Get interface name corresponding distribute list. */
 278   distfn (ifname, type, argv[1 + prefix]->arg);
 279
 280   return CMD_SUCCESS;
 281 }
 282
 283 DEFUN (ipv6_distribute_list,
 284        ipv6_distribute_list_cmd,
 285        "ipv6 distribute-list [prefix] WORD <in|out> [WORD]",
 286        "IPv6\n"
 287        "Filter networks in routing updates\n"
 288        "Access-list name\n"
 289        "Filter incoming routing updates\n"
 290        "Filter outgoing routing updates\n"
 291        "Interface name\n")
 292 {
 293   int prefix = (argv[2]->type == WORD_TKN) ? 1 : 0;
 294
 295   /* Check of distribute list type. */
 296   enum distribute_type type = argv[3 + prefix]->arg[0] == 'i' ?
 297     DISTRIBUTE_V6_IN : DISTRIBUTE_V6_OUT;
 298
 299   /* Set appropriate function call */
 300   void (*distfn)(const char *, enum distribute_type, const char *) = prefix ?
 301     &distribute_list_prefix_set : &distribute_list_set;
 302
 303   /* if interface is present, get name */
 304   const char *ifname = NULL;
 305   if (argv[argc - 1]->type == VARIABLE_TKN)
 306     ifname = argv[argc - 1]->arg;
 307
 308   /* Get interface name corresponding distribute list. */
 309   distfn (ifname, type, argv[1 + prefix]->arg);
 310
 311   return CMD_SUCCESS;
 312 }
 313
 314 DEFUN (no_distribute_list,
 315        no_distribute_list_cmd,
 316        "no [ipv6] distribute-list [prefix] WORD <in|out> [WORD]",
 317        NO_STR
 318        "Filter networks in routing updates\n"
 319        "Access-list name\n"
 320        "Filter incoming routing updates\n"
 321        "Filter outgoing routing updates\n"
 322        "Interface name\n")
 323 {
 324   int ipv6 = strmatch(argv[1]->text, "ipv6");
 325   int prefix = (argv[2 + ipv6]->type == WORD_TKN) ? 1 : 0;
 326
 327   int idx_alname = 2 + ipv6 + prefix;
 328   int idx_disttype = idx_alname + 1;
 329
 330   /* Check of distribute list type. */
 331   enum distribute_type distin = (ipv6) ? DISTRIBUTE_V6_IN : DISTRIBUTE_V4_IN;
 332   enum distribute_type distout = (ipv6) ? DISTRIBUTE_V6_OUT : DISTRIBUTE_V4_OUT;
 333
 334   enum distribute_type type = argv[idx_disttype]->arg[0] == 'i' ? distin : distout;
 335
 336   /* Set appropriate function call */
 337   int (*distfn)(const char *, enum distribute_type, const char *) = prefix ?
 338     &distribute_list_prefix_unset : &distribute_list_unset;
 339
 340   /* if interface is present, get name */
 341   const char *ifname = NULL;
 342   if (argv[argc - 1]->type == VARIABLE_TKN)
 343     ifname = argv[argc - 1]->arg;
 344   /* Get interface name corresponding distribute list. */
 345   int ret = distfn (ifname, type, argv[2 + prefix]->arg);
 346
 347   if (! ret)
 348     {
 349       vty_out (vty, "distribute list doesn't exist%s", VTY_NEWLINE);
 350       return CMD_WARNING;
 351     }
 352   return CMD_SUCCESS;
 353 }
 354
 355 static int
 356 distribute_print (struct vty *vty, char *tab[], int is_prefix,
 357                   enum distribute_type type, int has_print)
 358 {
 359   if (tab[type]) {
 360     vty_out (vty, "%s %s%s",
 361              has_print ? "," : "",
 362              is_prefix ? "(prefix-list) " : "",
 363              tab[type]);
 364     return 1;
 365   }
 366   return has_print;
 367 }
 368
 369 int
 370 config_show_distribute (struct vty *vty)
 371 {
 372   unsigned int i;
 373   int has_print = 0;
 374   struct hash_backet *mp;
 375   struct distribute *dist;
 376
 377   /* Output filter configuration. */
 378   dist = distribute_lookup (NULL);
 379       vty_out (vty, "  Outgoing update filter list for all interface is");
 380   has_print = 0;
 381   if (dist)
 382     {
 383       has_print = distribute_print(vty, dist->list,   0,
 384                                    DISTRIBUTE_V4_OUT, has_print);
 385       has_print = distribute_print(vty, dist->prefix, 1,
 386                                    DISTRIBUTE_V4_OUT, has_print);
 387       has_print = distribute_print(vty, dist->list,   0,
 388                                    DISTRIBUTE_V6_OUT, has_print);
 389       has_print = distribute_print(vty, dist->prefix, 1,
 390                                    DISTRIBUTE_V6_OUT, has_print);
 391     }
 392   if (has_print)
 393     vty_out (vty, "%s", VTY_NEWLINE);
 394   else
 395     vty_out (vty, " not set%s", VTY_NEWLINE);
 396
 397   for (i = 0; i < disthash->size; i++)
 398     for (mp = disthash->index[i]; mp; mp = mp->next)
 399       {
 400         dist = mp->data;
 401         if (dist->ifname)
 402             {
 403               vty_out (vty, "    %s filtered by", dist->ifname);
 404             has_print = 0;
 405             has_print = distribute_print(vty, dist->list,   0,
 406                                          DISTRIBUTE_V4_OUT, has_print);
 407             has_print = distribute_print(vty, dist->prefix, 1,
 408                                          DISTRIBUTE_V4_OUT, has_print);
 409             has_print = distribute_print(vty, dist->list,   0,
 410                                          DISTRIBUTE_V6_OUT, has_print);
 411             has_print = distribute_print(vty, dist->prefix, 1,
 412                                          DISTRIBUTE_V6_OUT, has_print);
 413             if (has_print)
 414               vty_out (vty, "%s", VTY_NEWLINE);
 415             else
 416               vty_out(vty, " nothing%s", VTY_NEWLINE);
 417             }
 418       }
 419
 420
 421   /* Input filter configuration. */
 422   dist = distribute_lookup (NULL);
 423       vty_out (vty, "  Incoming update filter list for all interface is");
 424   has_print = 0;
 425   if (dist)
 426     {
 427       has_print = distribute_print(vty, dist->list,   0,
 428                                    DISTRIBUTE_V4_IN, has_print);
 429       has_print = distribute_print(vty, dist->prefix, 1,
 430                                    DISTRIBUTE_V4_IN, has_print);
 431       has_print = distribute_print(vty, dist->list,   0,
 432                                    DISTRIBUTE_V6_IN, has_print);
 433       has_print = distribute_print(vty, dist->prefix, 1,
 434                                    DISTRIBUTE_V6_IN, has_print);
 435     }
 436   if (has_print)
 437     vty_out (vty, "%s", VTY_NEWLINE);
 438   else
 439     vty_out (vty, " not set%s", VTY_NEWLINE);
 440
 441   for (i = 0; i < disthash->size; i++)
 442     for (mp = disthash->index[i]; mp; mp = mp->next)
 443       {
 444         dist = mp->data;
 445         if (dist->ifname)
 446             {
 447               vty_out (vty, "    %s filtered by", dist->ifname);
 448             has_print = 0;
 449             has_print = distribute_print(vty, dist->list,   0,
 450                                          DISTRIBUTE_V4_IN, has_print);
 451             has_print = distribute_print(vty, dist->prefix, 1,
 452                                          DISTRIBUTE_V4_IN, has_print);
 453             has_print = distribute_print(vty, dist->list,   0,
 454                                          DISTRIBUTE_V6_IN, has_print);
 455             has_print = distribute_print(vty, dist->prefix, 1,
 456                                          DISTRIBUTE_V6_IN, has_print);
 457             if (has_print)
 458               vty_out (vty, "%s", VTY_NEWLINE);
 459             else
 460               vty_out(vty, " nothing%s", VTY_NEWLINE);
 461             }
 462       }
 463   return 0;
 464 }
 465
 466 /* Configuration write function. */
 467 int
 468 config_write_distribute (struct vty *vty)
 469 {
 470   unsigned int i;
 471   int j;
 472   int output, v6;
 473   struct hash_backet *mp;
 474   int write = 0;
 475
 476   for (i = 0; i < disthash->size; i++)
 477     for (mp = disthash->index[i]; mp; mp = mp->next)
 478       {
 479         struct distribute *dist;
 480
 481         dist = mp->data;
 482
 483         for (j = 0; j < DISTRIBUTE_MAX; j++)
 484           if (dist->list[j]) {
 485             output = j == DISTRIBUTE_V4_OUT || j == DISTRIBUTE_V6_OUT;
 486             v6 = j == DISTRIBUTE_V6_IN || j == DISTRIBUTE_V6_OUT;
 487             vty_out (vty, " %sdistribute-list %s %s %s%s",
 488                      v6 ? "ipv6 " : "",
 489                      dist->list[j],
 490                      output ? "out" : "in",
 491                      dist->ifname ? dist->ifname : "",
 492                      VTY_NEWLINE);
 493             write++;
 494           }
 495
 496         for (j = 0; j < DISTRIBUTE_MAX; j++)
 497           if (dist->prefix[j]) {
 498             output = j == DISTRIBUTE_V4_OUT || j == DISTRIBUTE_V6_OUT;
 499             v6 = j == DISTRIBUTE_V6_IN || j == DISTRIBUTE_V6_OUT;
 500             vty_out (vty, " %sdistribute-list prefix %s %s %s%s",
 501                      v6 ? "ipv6 " : "",
 502                      dist->prefix[j],
 503                      output ? "out" : "in",
 504                      dist->ifname ? dist->ifname : "",
 505                      VTY_NEWLINE);
 506             write++;
 507           }
 508       }
 509   return write;
 510 }
 511
 512 /* Clear all distribute list. */
 513 void
 514 distribute_list_reset ()
 515 {
 516   hash_clean (disthash, (void (*) (void *)) distribute_free);
 517 }
 518
 519 /* Initialize distribute list related hash. */
 520 void
 521 distribute_list_init (int node)
 522 {
 523   disthash = hash_create (distribute_hash_make,
 524                           (int (*) (const void *, const void *)) distribute_cmp);
 525
 526   install_element (node, &distribute_list_cmd);
 527   install_element (node, &no_distribute_list_cmd);
 528 /*
 529   install_element (RIP_NODE, &distribute_list_cmd);
 530   install_element (RIP_NODE, &no_distribute_list_cmd);
 531   install_element (RIPNG_NODE, &distribute_list_cmd);
 532   install_element (RIPNG_NODE, &no_distribute_list_cmd);
 533  */
 534
 535   /* install v6 */
 536   if (node == RIPNG_NODE) {
 537     install_element (RIPNG_NODE, &ipv6_distribute_list_cmd);
 538   }
 539
 540   /* TODO: install v4 syntax command for v6 only protocols. */
 541  /* if (node == RIPNG_NODE) {
 542   *   install_element (node, &ipv6_as_v4_distribute_list_all_cmd);
 543   *   install_element (node, &no_ipv6_as_v4_distribute_list_all_cmd);
 544   *   install_element (node, &ipv6_as_v4_distribute_list_cmd);
 545   *   install_element (node, &no_ipv6_as_v4_distribute_list_cmd);
 546   *   install_element (node, &ipv6_as_v4_distribute_list_prefix_all_cmd);
 547   *   install_element (node, &no_ipv6_as_v4_distribute_list_prefix_all_cmd);
 548   *   install_element (node, &ipv6_as_v4_distribute_list_prefix_cmd);
 549   *   install_element (node, &no_ipv6_as_v4_distribute_list_prefix_cmd);
 550     }*/
 551 }