release/src/router/zebra/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 /* Hash of distribute list. */
  32 struct hash *disthash;
  33
  34 /* Hook functions. */
  35 void (*distribute_add_hook) (struct distribute *);
  36 void (*distribute_delete_hook) (struct distribute *);
  37 \f
  38 struct distribute *
  39 distribute_new ()
  40 {
  41   struct distribute *new;
  42
  43   new = XMALLOC (MTYPE_DISTRIBUTE, sizeof (struct distribute));
  44   memset (new, 0, sizeof (struct distribute));
  45
  46   return new;
  47 }
  48
  49 /* Free distribute object. */
  50 void
  51 distribute_free (struct distribute *dist)
  52 {
  53   if (dist->ifname)
  54     free (dist->ifname);
  55
  56   if (dist->list[DISTRIBUTE_IN])
  57     free (dist->list[DISTRIBUTE_IN]);
  58   if (dist->list[DISTRIBUTE_OUT])
  59     free (dist->list[DISTRIBUTE_OUT]);
  60
  61   if (dist->prefix[DISTRIBUTE_IN])
  62     free (dist->prefix[DISTRIBUTE_IN]);
  63   if (dist->prefix[DISTRIBUTE_OUT])
  64     free (dist->prefix[DISTRIBUTE_OUT]);
  65
  66   XFREE (MTYPE_DISTRIBUTE, dist);
  67 }
  68
  69 /* Lookup interface's distribute list. */
  70 struct distribute *
  71 distribute_lookup (char *ifname)
  72 {
  73   struct distribute key;
  74   struct distribute *dist;
  75
  76   key.ifname = ifname;
  77
  78   dist = hash_lookup (disthash, &key);
  79
  80   return dist;
  81 }
  82
  83 void
  84 distribute_list_add_hook (void (*func) (struct distribute *))
  85 {
  86   distribute_add_hook = func;
  87 }
  88
  89 void
  90 distribute_list_delete_hook (void (*func) (struct distribute *))
  91 {
  92   distribute_delete_hook = func;
  93 }
  94
  95 void *
  96 distribute_hash_alloc (struct distribute *arg)
  97 {
  98   struct distribute *dist;
  99
 100   dist = distribute_new ();
 101   if (arg->ifname)
 102     dist->ifname = strdup (arg->ifname);
 103   else
 104     dist->ifname = NULL;
 105   return dist;
 106 }
 107
 108 /* Make new distribute list and push into hash. */
 109 struct distribute *
 110 distribute_get (char *ifname)
 111 {
 112   struct distribute key;
 113
 114   key.ifname = ifname;
 115
 116   return hash_get (disthash, &key, distribute_hash_alloc);
 117 }
 118
 119 unsigned int
 120 distribute_hash_make (struct distribute *dist)
 121 {
 122   unsigned int key;
 123   int i;
 124
 125   key = 0;
 126   if (dist->ifname)
 127     for (i = 0; i < strlen (dist->ifname); i++)
 128       key += dist->ifname[i];
 129
 130   return key;
 131 }
 132
 133 /* If two distribute-list have same value then return 1 else return
 134    0. This function is used by hash package. */
 135 int
 136 distribute_cmp (struct distribute *dist1, struct distribute *dist2)
 137 {
 138   if (dist1->ifname && dist2->ifname)
 139     if (strcmp (dist1->ifname, dist2->ifname) == 0)
 140       return 1;
 141   if (! dist1->ifname && ! dist2->ifname)
 142     return 1;
 143   return 0;
 144 }
 145 \f
 146 /* Set access-list name to the distribute list. */
 147 struct distribute *
 148 distribute_list_set (char *ifname, enum distribute_type type, char *alist_name)
 149 {
 150   struct distribute *dist;
 151
 152   dist = distribute_get (ifname);
 153
 154   if (type == DISTRIBUTE_IN)
 155     {
 156       if (dist->list[DISTRIBUTE_IN])
 157         free (dist->list[DISTRIBUTE_IN]);
 158       dist->list[DISTRIBUTE_IN] = strdup (alist_name);
 159     }
 160   if (type == DISTRIBUTE_OUT)
 161     {
 162       if (dist->list[DISTRIBUTE_OUT])
 163         free (dist->list[DISTRIBUTE_OUT]);
 164       dist->list[DISTRIBUTE_OUT] = strdup (alist_name);
 165     }
 166
 167   /* Apply this distribute-list to the interface. */
 168   (*distribute_add_hook) (dist);
 169
 170   return dist;
 171 }
 172
 173 /* Unset distribute-list.  If matched distribute-list exist then
 174    return 1. */
 175 int
 176 distribute_list_unset (char *ifname, enum distribute_type type,
 177                        char *alist_name)
 178 {
 179   struct distribute *dist;
 180
 181   dist = distribute_lookup (ifname);
 182   if (!dist)
 183     return 0;
 184
 185   if (type == DISTRIBUTE_IN)
 186     {
 187       if (!dist->list[DISTRIBUTE_IN])
 188         return 0;
 189       if (strcmp (dist->list[DISTRIBUTE_IN], alist_name) != 0)
 190         return 0;
 191
 192       free (dist->list[DISTRIBUTE_IN]);
 193       dist->list[DISTRIBUTE_IN] = NULL;
 194     }
 195
 196   if (type == DISTRIBUTE_OUT)
 197     {
 198       if (!dist->list[DISTRIBUTE_OUT])
 199         return 0;
 200       if (strcmp (dist->list[DISTRIBUTE_OUT], alist_name) != 0)
 201         return 0;
 202
 203       free (dist->list[DISTRIBUTE_OUT]);
 204       dist->list[DISTRIBUTE_OUT] = NULL;
 205     }
 206
 207   /* Apply this distribute-list to the interface. */
 208   (*distribute_delete_hook) (dist);
 209
 210   /* If both out and in is NULL then free distribute list. */
 211   if (dist->list[DISTRIBUTE_IN] == NULL &&
 212       dist->list[DISTRIBUTE_OUT] == NULL &&
 213       dist->prefix[DISTRIBUTE_IN] == NULL &&
 214       dist->prefix[DISTRIBUTE_OUT] == NULL)
 215     {
 216       hash_release (disthash, dist);
 217       distribute_free (dist);
 218     }
 219
 220   return 1;
 221 }
 222
 223 /* Set access-list name to the distribute list. */
 224 struct distribute *
 225 distribute_list_prefix_set (char *ifname, enum distribute_type type,
 226                             char *plist_name)
 227 {
 228   struct distribute *dist;
 229
 230   dist = distribute_get (ifname);
 231
 232   if (type == DISTRIBUTE_IN)
 233     {
 234       if (dist->prefix[DISTRIBUTE_IN])
 235         free (dist->prefix[DISTRIBUTE_IN]);
 236       dist->prefix[DISTRIBUTE_IN] = strdup (plist_name);
 237     }
 238   if (type == DISTRIBUTE_OUT)
 239     {
 240       if (dist->prefix[DISTRIBUTE_OUT])
 241         free (dist->prefix[DISTRIBUTE_OUT]);
 242       dist->prefix[DISTRIBUTE_OUT] = strdup (plist_name);
 243     }
 244
 245   /* Apply this distribute-list to the interface. */
 246   (*distribute_add_hook) (dist);
 247
 248   return dist;
 249 }
 250
 251 /* Unset distribute-list.  If matched distribute-list exist then
 252    return 1. */
 253 int
 254 distribute_list_prefix_unset (char *ifname, enum distribute_type type,
 255                               char *plist_name)
 256 {
 257   struct distribute *dist;
 258
 259   dist = distribute_lookup (ifname);
 260   if (!dist)
 261     return 0;
 262
 263   if (type == DISTRIBUTE_IN)
 264     {
 265       if (!dist->prefix[DISTRIBUTE_IN])
 266         return 0;
 267       if (strcmp (dist->prefix[DISTRIBUTE_IN], plist_name) != 0)
 268         return 0;
 269
 270       free (dist->prefix[DISTRIBUTE_IN]);
 271       dist->prefix[DISTRIBUTE_IN] = NULL;
 272     }
 273
 274   if (type == DISTRIBUTE_OUT)
 275     {
 276       if (!dist->prefix[DISTRIBUTE_OUT])
 277         return 0;
 278       if (strcmp (dist->prefix[DISTRIBUTE_OUT], plist_name) != 0)
 279         return 0;
 280
 281       free (dist->prefix[DISTRIBUTE_OUT]);
 282       dist->prefix[DISTRIBUTE_OUT] = NULL;
 283     }
 284
 285   /* Apply this distribute-list to the interface. */
 286   (*distribute_delete_hook) (dist);
 287
 288   /* If both out and in is NULL then free distribute list. */
 289   if (dist->list[DISTRIBUTE_IN] == NULL &&
 290       dist->list[DISTRIBUTE_OUT] == NULL &&
 291       dist->prefix[DISTRIBUTE_IN] == NULL &&
 292       dist->prefix[DISTRIBUTE_OUT] == NULL)
 293     {
 294       hash_release (disthash, dist);
 295       distribute_free (dist);
 296     }
 297
 298   return 1;
 299 }
 300
 301 DEFUN (distribute_list_all,
 302        distribute_list_all_cmd,
 303        "distribute-list WORD (in|out)",
 304        "Filter networks in routing updates\n"
 305        "Access-list name\n"
 306        "Filter incoming routing updates\n"
 307        "Filter outgoing routing updates\n")
 308 {
 309   enum distribute_type type;
 310   struct distribute *dist;
 311
 312   /* Check of distribute list type. */
 313   if (strncmp (argv[1], "i", 1) == 0)
 314     type = DISTRIBUTE_IN;
 315   else if (strncmp (argv[1], "o", 1) == 0)
 316     type = DISTRIBUTE_OUT;
 317   else
 318     {
 319       vty_out (vty, "distribute list direction must be [in|out]%s",
 320                VTY_NEWLINE);
 321       return CMD_WARNING;
 322     }
 323
 324   /* Get interface name corresponding distribute list. */
 325   dist = distribute_list_set (NULL, type, argv[0]);
 326
 327   return CMD_SUCCESS;
 328 }
 329
 330 ALIAS (distribute_list_all,
 331        ipv6_distribute_list_all_cmd,
 332        "distribute-list WORD (in|out)",
 333        "Filter networks in routing updates\n"
 334        "Access-list name\n"
 335        "Filter incoming routing updates\n"
 336        "Filter outgoing routing updates\n");
 337
 338 DEFUN (no_distribute_list_all,
 339        no_distribute_list_all_cmd,
 340        "no distribute-list WORD (in|out)",
 341        NO_STR
 342        "Filter networks in routing updates\n"
 343        "Access-list name\n"
 344        "Filter incoming routing updates\n"
 345        "Filter outgoing routing updates\n")
 346 {
 347   int ret;
 348   enum distribute_type type;
 349
 350   /* Check of distribute list type. */
 351   if (strncmp (argv[1], "i", 1) == 0)
 352     type = DISTRIBUTE_IN;
 353   else if (strncmp (argv[1], "o", 1) == 0)
 354     type = DISTRIBUTE_OUT;
 355   else
 356     {
 357       vty_out (vty, "distribute list direction must be [in|out]%s",
 358                VTY_NEWLINE);
 359       return CMD_WARNING;
 360     }
 361
 362   ret = distribute_list_unset (NULL, type, argv[0]);
 363   if (! ret)
 364     {
 365       vty_out (vty, "distribute list doesn't exist%s", VTY_NEWLINE);
 366       return CMD_WARNING;
 367     }
 368   return CMD_SUCCESS;
 369 }
 370
 371 ALIAS (no_distribute_list_all,
 372        no_ipv6_distribute_list_all_cmd,
 373        "no distribute-list WORD (in|out)",
 374        NO_STR
 375        "Filter networks in routing updates\n"
 376        "Access-list name\n"
 377        "Filter incoming routing updates\n"
 378        "Filter outgoing routing updates\n");
 379
 380 DEFUN (distribute_list,
 381        distribute_list_cmd,
 382        "distribute-list WORD (in|out) WORD",
 383        "Filter networks in routing updates\n"
 384        "Access-list name\n"
 385        "Filter incoming routing updates\n"
 386        "Filter outgoing routing updates\n"
 387        "Interface name\n")
 388 {
 389   enum distribute_type type;
 390   struct distribute *dist;
 391
 392   /* Check of distribute list type. */
 393   if (strncmp (argv[1], "i", 1) == 0)
 394     type = DISTRIBUTE_IN;
 395   else if (strncmp (argv[1], "o", 1) == 0)
 396     type = DISTRIBUTE_OUT;
 397   else
 398     {
 399       vty_out (vty, "distribute list direction must be [in|out]%s", VTY_NEWLINE);
 400       return CMD_WARNING;
 401     }
 402
 403   /* Get interface name corresponding distribute list. */
 404   dist = distribute_list_set (argv[2], type, argv[0]);
 405
 406   return CMD_SUCCESS;
 407 }
 408
 409 ALIAS (distribute_list,
 410        ipv6_distribute_list_cmd,
 411        "distribute-list WORD (in|out) WORD",
 412        "Filter networks in routing updates\n"
 413        "Access-list name\n"
 414        "Filter incoming routing updates\n"
 415        "Filter outgoing routing updates\n"
 416        "Interface name\n");
 417
 418 DEFUN (no_districute_list,
 419        no_distribute_list_cmd,
 420        "no distribute-list WORD (in|out) WORD",
 421        NO_STR
 422        "Filter networks in routing updates\n"
 423        "Access-list name\n"
 424        "Filter incoming routing updates\n"
 425        "Filter outgoing routing updates\n"
 426        "Interface name\n")
 427 {
 428   int ret;
 429   enum distribute_type type;
 430
 431   /* Check of distribute list type. */
 432   if (strncmp (argv[1], "i", 1) == 0)
 433     type = DISTRIBUTE_IN;
 434   else if (strncmp (argv[1], "o", 1) == 0)
 435     type = DISTRIBUTE_OUT;
 436   else
 437     {
 438       vty_out (vty, "distribute list direction must be [in|out]%s", VTY_NEWLINE);
 439       return CMD_WARNING;
 440     }
 441
 442   ret = distribute_list_unset (argv[2], type, argv[0]);
 443   if (! ret)
 444     {
 445       vty_out (vty, "distribute list doesn't exist%s", VTY_NEWLINE);
 446       return CMD_WARNING;
 447     }
 448   return CMD_SUCCESS;
 449 }
 450
 451 ALIAS (no_districute_list,
 452        no_ipv6_distribute_list_cmd,
 453        "no distribute-list WORD (in|out) WORD",
 454        NO_STR
 455        "Filter networks in routing updates\n"
 456        "Access-list name\n"
 457        "Filter incoming routing updates\n"
 458        "Filter outgoing routing updates\n"
 459        "Interface name\n");
 460
 461 DEFUN (districute_list_prefix_all,
 462        distribute_list_prefix_all_cmd,
 463        "distribute-list prefix WORD (in|out)",
 464        "Filter networks in routing updates\n"
 465        "Filter prefixes in routing updates\n"
 466        "Name of an IP prefix-list\n"
 467        "Filter incoming routing updates\n"
 468        "Filter outgoing routing updates\n")
 469 {
 470   enum distribute_type type;
 471   struct distribute *dist;
 472
 473   /* Check of distribute list type. */
 474   if (strncmp (argv[1], "i", 1) == 0)
 475     type = DISTRIBUTE_IN;
 476   else if (strncmp (argv[1], "o", 1) == 0)
 477     type = DISTRIBUTE_OUT;
 478   else
 479     {
 480       vty_out (vty, "distribute list direction must be [in|out]%s",
 481                VTY_NEWLINE);
 482       return CMD_WARNING;
 483     }
 484
 485   /* Get interface name corresponding distribute list. */
 486   dist = distribute_list_prefix_set (NULL, type, argv[0]);
 487
 488   return CMD_SUCCESS;
 489 }
 490
 491 ALIAS (districute_list_prefix_all,
 492        ipv6_distribute_list_prefix_all_cmd,
 493        "distribute-list prefix WORD (in|out)",
 494        "Filter networks in routing updates\n"
 495        "Filter prefixes in routing updates\n"
 496        "Name of an IP prefix-list\n"
 497        "Filter incoming routing updates\n"
 498        "Filter outgoing routing updates\n");
 499
 500 DEFUN (no_districute_list_prefix_all,
 501        no_distribute_list_prefix_all_cmd,
 502        "no distribute-list prefix WORD (in|out)",
 503        NO_STR
 504        "Filter networks in routing updates\n"
 505        "Filter prefixes in routing updates\n"
 506        "Name of an IP prefix-list\n"
 507        "Filter incoming routing updates\n"
 508        "Filter outgoing routing updates\n")
 509 {
 510   int ret;
 511   enum distribute_type type;
 512
 513   /* Check of distribute list type. */
 514   if (strncmp (argv[1], "i", 1) == 0)
 515     type = DISTRIBUTE_IN;
 516   else if (strncmp (argv[1], "o", 1) == 0)
 517     type = DISTRIBUTE_OUT;
 518   else
 519     {
 520       vty_out (vty, "distribute list direction must be [in|out]%s",
 521                VTY_NEWLINE);
 522       return CMD_WARNING;
 523     }
 524
 525   ret = distribute_list_prefix_unset (NULL, type, argv[0]);
 526   if (! ret)
 527     {
 528       vty_out (vty, "distribute list doesn't exist%s", VTY_NEWLINE);
 529       return CMD_WARNING;
 530     }
 531   return CMD_SUCCESS;
 532 }
 533
 534 ALIAS (no_districute_list_prefix_all,
 535        no_ipv6_distribute_list_prefix_all_cmd,
 536        "no distribute-list prefix WORD (in|out)",
 537        NO_STR
 538        "Filter networks in routing updates\n"
 539        "Filter prefixes in routing updates\n"
 540        "Name of an IP prefix-list\n"
 541        "Filter incoming routing updates\n"
 542        "Filter outgoing routing updates\n");
 543
 544 DEFUN (districute_list_prefix, distribute_list_prefix_cmd,
 545        "distribute-list prefix WORD (in|out) WORD",
 546        "Filter networks in routing updates\n"
 547        "Filter prefixes in routing updates\n"
 548        "Name of an IP prefix-list\n"
 549        "Filter incoming routing updates\n"
 550        "Filter outgoing routing updates\n"
 551        "Interface name\n")
 552 {
 553   enum distribute_type type;
 554   struct distribute *dist;
 555
 556   /* Check of distribute list type. */
 557   if (strncmp (argv[1], "i", 1) == 0)
 558     type = DISTRIBUTE_IN;
 559   else if (strncmp (argv[1], "o", 1) == 0)
 560     type = DISTRIBUTE_OUT;
 561   else
 562     {
 563       vty_out (vty, "distribute list direction must be [in|out]%s",
 564                VTY_NEWLINE);
 565       return CMD_WARNING;
 566     }
 567
 568   /* Get interface name corresponding distribute list. */
 569   dist = distribute_list_prefix_set (argv[2], type, argv[0]);
 570
 571   return CMD_SUCCESS;
 572 }
 573
 574 ALIAS (districute_list_prefix,
 575        ipv6_distribute_list_prefix_cmd,
 576        "distribute-list prefix WORD (in|out) WORD",
 577        "Filter networks in routing updates\n"
 578        "Filter prefixes in routing updates\n"
 579        "Name of an IP prefix-list\n"
 580        "Filter incoming routing updates\n"
 581        "Filter outgoing routing updates\n"
 582        "Interface name\n");
 583
 584 DEFUN (no_districute_list_prefix,
 585        no_distribute_list_prefix_cmd,
 586        "no distribute-list prefix WORD (in|out) WORD",
 587        NO_STR
 588        "Filter networks in routing updates\n"
 589        "Filter prefixes in routing updates\n"
 590        "Name of an IP prefix-list\n"
 591        "Filter incoming routing updates\n"
 592        "Filter outgoing routing updates\n"
 593        "Interface name\n")
 594 {
 595   int ret;
 596   enum distribute_type type;
 597
 598   /* Check of distribute list type. */
 599   if (strncmp (argv[1], "i", 1) == 0)
 600     type = DISTRIBUTE_IN;
 601   else if (strncmp (argv[1], "o", 1) == 0)
 602     type = DISTRIBUTE_OUT;
 603   else
 604     {
 605       vty_out (vty, "distribute list direction must be [in|out]%s",
 606                VTY_NEWLINE);
 607       return CMD_WARNING;
 608     }
 609
 610   ret = distribute_list_prefix_unset (argv[2], type, argv[0]);
 611   if (! ret)
 612     {
 613       vty_out (vty, "distribute list doesn't exist%s", VTY_NEWLINE);
 614       return CMD_WARNING;
 615     }
 616   return CMD_SUCCESS;
 617 }
 618
 619 ALIAS (no_districute_list_prefix,
 620        no_ipv6_distribute_list_prefix_cmd,
 621        "no distribute-list prefix WORD (in|out) WORD",
 622        NO_STR
 623        "Filter networks in routing updates\n"
 624        "Filter prefixes in routing updates\n"
 625        "Name of an IP prefix-list\n"
 626        "Filter incoming routing updates\n"
 627        "Filter outgoing routing updates\n"
 628        "Interface name\n");
 629
 630 int
 631 config_show_distribute (struct vty *vty)
 632 {
 633   int i;
 634   struct hash_backet *mp;
 635   struct distribute *dist;
 636
 637   /* Output filter configuration. */
 638   dist = distribute_lookup (NULL);
 639   if (dist && (dist->list[DISTRIBUTE_OUT] || dist->prefix[DISTRIBUTE_OUT]))
 640     {
 641       vty_out (vty, "  Outgoing update filter list for all interface is");
 642       if (dist->list[DISTRIBUTE_OUT])
 643         vty_out (vty, " %s", dist->list[DISTRIBUTE_OUT]);
 644       if (dist->prefix[DISTRIBUTE_OUT])
 645         vty_out (vty, "%s (prefix-list) %s",
 646                  dist->list[DISTRIBUTE_OUT] ? "," : "",
 647                  dist->prefix[DISTRIBUTE_OUT]);
 648       vty_out (vty, "%s", VTY_NEWLINE);
 649     }
 650   else
 651     vty_out (vty, "  Outgoing update filter list for all interface is not set%s", VTY_NEWLINE);
 652
 653   for (i = 0; i < disthash->size; i++)
 654     for (mp = disthash->index[i]; mp; mp = mp->next)
 655       {
 656         dist = mp->data;
 657         if (dist->ifname)
 658           if (dist->list[DISTRIBUTE_OUT] || dist->prefix[DISTRIBUTE_OUT])
 659             {
 660               vty_out (vty, "    %s filtered by", dist->ifname);
 661               if (dist->list[DISTRIBUTE_OUT])
 662                 vty_out (vty, " %s", dist->list[DISTRIBUTE_OUT]);
 663               if (dist->prefix[DISTRIBUTE_OUT])
 664                 vty_out (vty, "%s (prefix-list) %s",
 665                          dist->list[DISTRIBUTE_OUT] ? "," : "",
 666                          dist->prefix[DISTRIBUTE_OUT]);
 667               vty_out (vty, "%s", VTY_NEWLINE);
 668             }
 669       }
 670
 671
 672   /* Input filter configuration. */
 673   dist = distribute_lookup (NULL);
 674   if (dist && (dist->list[DISTRIBUTE_IN] || dist->prefix[DISTRIBUTE_IN]))
 675     {
 676       vty_out (vty, "  Incoming update filter list for all interface is");
 677       if (dist->list[DISTRIBUTE_IN])
 678         vty_out (vty, " %s", dist->list[DISTRIBUTE_IN]);
 679       if (dist->prefix[DISTRIBUTE_IN])
 680         vty_out (vty, "%s (prefix-list) %s",
 681                  dist->list[DISTRIBUTE_IN] ? "," : "",
 682                  dist->prefix[DISTRIBUTE_IN]);
 683       vty_out (vty, "%s", VTY_NEWLINE);
 684     }
 685   else
 686     vty_out (vty, "  Incoming update filter list for all interface is not set%s", VTY_NEWLINE);
 687
 688   for (i = 0; i < disthash->size; i++)
 689     for (mp = disthash->index[i]; mp; mp = mp->next)
 690       {
 691         dist = mp->data;
 692         if (dist->ifname)
 693           if (dist->list[DISTRIBUTE_IN] || dist->prefix[DISTRIBUTE_IN])
 694             {
 695               vty_out (vty, "    %s filtered by", dist->ifname);
 696               if (dist->list[DISTRIBUTE_IN])
 697                 vty_out (vty, " %s", dist->list[DISTRIBUTE_IN]);
 698               if (dist->prefix[DISTRIBUTE_IN])
 699                 vty_out (vty, "%s (prefix-list) %s",
 700                          dist->list[DISTRIBUTE_IN] ? "," : "",
 701                          dist->prefix[DISTRIBUTE_IN]);
 702               vty_out (vty, "%s", VTY_NEWLINE);
 703             }
 704       }
 705   return 0;
 706 }
 707
 708 /* Configuration write function. */
 709 int
 710 config_write_distribute (struct vty *vty)
 711 {
 712   int i;
 713   struct hash_backet *mp;
 714   int write = 0;
 715
 716   for (i = 0; i < disthash->size; i++)
 717     for (mp = disthash->index[i]; mp; mp = mp->next)
 718       {
 719         struct distribute *dist;
 720
 721         dist = mp->data;
 722
 723         if (dist->list[DISTRIBUTE_IN])
 724           {
 725             vty_out (vty, " distribute-list %s in %s%s",
 726                      dist->list[DISTRIBUTE_IN],
 727                      dist->ifname ? dist->ifname : "",
 728                      VTY_NEWLINE);
 729             write++;
 730           }
 731
 732         if (dist->list[DISTRIBUTE_OUT])
 733           {
 734             vty_out (vty, " distribute-list %s out %s%s",
 735
 736                      dist->list[DISTRIBUTE_OUT],
 737                      dist->ifname ? dist->ifname : "",
 738                      VTY_NEWLINE);
 739             write++;
 740           }
 741
 742         if (dist->prefix[DISTRIBUTE_IN])
 743           {
 744             vty_out (vty, " distribute-list prefix %s in %s%s",
 745                      dist->prefix[DISTRIBUTE_IN],
 746                      dist->ifname ? dist->ifname : "",
 747                      VTY_NEWLINE);
 748             write++;
 749           }
 750
 751         if (dist->prefix[DISTRIBUTE_OUT])
 752           {
 753             vty_out (vty, " distribute-list prefix %s out %s%s",
 754                      dist->prefix[DISTRIBUTE_OUT],
 755                      dist->ifname ? dist->ifname : "",
 756                      VTY_NEWLINE);
 757             write++;
 758           }
 759       }
 760   return write;
 761 }
 762
 763 /* Clear all distribute list. */
 764 void
 765 distribute_list_reset ()
 766 {
 767   hash_clean (disthash, (void (*) (void *)) distribute_free);
 768 }
 769
 770 /* Initialize distribute list related hash. */
 771 void
 772 distribute_list_init (int node)
 773 {
 774   disthash = hash_create (distribute_hash_make, distribute_cmp);
 775
 776   if (node == RIP_NODE)
 777     {
 778       install_element (RIP_NODE, &distribute_list_all_cmd);
 779       install_element (RIP_NODE, &no_distribute_list_all_cmd);
 780       install_element (RIP_NODE, &distribute_list_cmd);
 781       install_element (RIP_NODE, &no_distribute_list_cmd);
 782       install_element (RIP_NODE, &distribute_list_prefix_all_cmd);
 783       install_element (RIP_NODE, &no_distribute_list_prefix_all_cmd);
 784       install_element (RIP_NODE, &distribute_list_prefix_cmd);
 785       install_element (RIP_NODE, &no_distribute_list_prefix_cmd);
 786     }
 787   else
 788     {
 789       install_element (RIPNG_NODE, &ipv6_distribute_list_all_cmd);
 790       install_element (RIPNG_NODE, &no_ipv6_distribute_list_all_cmd);
 791       install_element (RIPNG_NODE, &ipv6_distribute_list_cmd);
 792       install_element (RIPNG_NODE, &no_ipv6_distribute_list_cmd);
 793       install_element (RIPNG_NODE, &ipv6_distribute_list_prefix_all_cmd);
 794       install_element (RIPNG_NODE, &no_ipv6_distribute_list_prefix_all_cmd);
 795       install_element (RIPNG_NODE, &ipv6_distribute_list_prefix_cmd);
 796       install_element (RIPNG_NODE, &no_ipv6_distribute_list_prefix_cmd);
 797     }
 798 }