isisd/isis_redist.c

   1 /*
   2  * IS-IS Rout(e)ing protocol - isis_redist.c
   3  *
   4  * Copyright (C) 2013-2015 Christian Franke <chris@opensourcerouting.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "command.h"
  24 #include "if.h"
  25 #include "linklist.h"
  26 #include "memory.h"
  27 #include "isis_memory.h"
  28 #include "prefix.h"
  29 #include "routemap.h"
  30 #include "stream.h"
  31 #include "table.h"
  32 #include "vty.h"
  33 #include "srcdest_table.h"
  34
  35 #include "isisd/dict.h"
  36 #include "isisd/isis_constants.h"
  37 #include "isisd/isis_common.h"
  38 #include "isisd/isis_flags.h"
  39 #include "isisd/isis_misc.h"
  40 #include "isisd/isis_circuit.h"
  41 #include "isisd/isisd.h"
  42 #include "isisd/isis_lsp.h"
  43 #include "isisd/isis_route.h"
  44 #include "isisd/isis_zebra.h"
  45
  46 static int redist_protocol(int family)
  47 {
  48         if (family == AF_INET)
  49                 return 0;
  50         if (family == AF_INET6)
  51                 return 1;
  52
  53         assert(!"Unsupported address family!");
  54         return 0;
  55 }
  56
  57 static afi_t afi_for_redist_protocol(int protocol)
  58 {
  59         if (protocol == 0)
  60                 return AFI_IP;
  61         if (protocol == 1)
  62                 return AFI_IP6;
  63
  64         assert(!"Unknown redist protocol!");
  65         return AFI_IP;
  66 }
  67
  68 static struct route_table *get_ext_info(struct isis *i, int family)
  69 {
  70         int protocol = redist_protocol(family);
  71
  72         return i->ext_info[protocol];
  73 }
  74
  75 static struct isis_redist *get_redist_settings(struct isis_area *area,
  76                                                int family, int type, int level)
  77 {
  78         int protocol = redist_protocol(family);
  79
  80         return &area->redist_settings[protocol][type][level - 1];
  81 }
  82
  83 struct route_table *get_ext_reach(struct isis_area *area, int family, int level)
  84 {
  85         int protocol = redist_protocol(family);
  86
  87         return area->ext_reach[protocol][level - 1];
  88 }
  89
  90 /* Install external reachability information into a
  91  * specific area for a specific level.
  92  * Schedule an lsp regenerate if necessary */
  93 static void isis_redist_install(struct isis_area *area, int level,
  94                                 const struct prefix *p,
  95                                 const struct prefix_ipv6 *src_p,
  96                                 struct isis_ext_info *info)
  97 {
  98         int family = p->family;
  99         struct route_table *er_table = get_ext_reach(area, family, level);
 100         struct route_node *er_node;
 101
 102         if (!er_table) {
 103                 zlog_warn(
 104                         "%s: External reachability table of area %s"
 105                         " is not initialized.",
 106                         __func__, area->area_tag);
 107                 return;
 108         }
 109
 110         er_node = srcdest_rnode_get(er_table, p, src_p);
 111         if (er_node->info) {
 112                 route_unlock_node(er_node);
 113
 114                 /* Don't update/reschedule lsp generation if nothing changed. */
 115                 if (!memcmp(er_node->info, info, sizeof(*info)))
 116                         return;
 117         } else {
 118                 er_node->info = XMALLOC(MTYPE_ISIS_EXT_INFO, sizeof(*info));
 119         }
 120
 121         memcpy(er_node->info, info, sizeof(*info));
 122         lsp_regenerate_schedule(area, level, 0);
 123 }
 124
 125 /* Remove external reachability information from a
 126  * specific area for a specific level.
 127  * Schedule an lsp regenerate if necessary. */
 128 static void isis_redist_uninstall(struct isis_area *area, int level,
 129                                   const struct prefix *p,
 130                                   const struct prefix_ipv6 *src_p)
 131 {
 132         int family = p->family;
 133         struct route_table *er_table = get_ext_reach(area, family, level);
 134         struct route_node *er_node;
 135
 136         if (!er_table) {
 137                 zlog_warn(
 138                         "%s: External reachability table of area %s"
 139                         " is not initialized.",
 140                         __func__, area->area_tag);
 141                 return;
 142         }
 143
 144         er_node = srcdest_rnode_lookup(er_table, p, src_p);
 145         if (!er_node)
 146                 return;
 147         else
 148                 route_unlock_node(er_node);
 149
 150         if (!er_node->info)
 151                 return;
 152
 153         XFREE(MTYPE_ISIS_EXT_INFO, er_node->info);
 154         route_unlock_node(er_node);
 155         lsp_regenerate_schedule(area, level, 0);
 156 }
 157
 158 /* Update external reachability info of area for a given level
 159  * and prefix, using the given redistribution settings. */
 160 static void isis_redist_update_ext_reach(struct isis_area *area, int level,
 161                                          struct isis_redist *redist,
 162                                          const struct prefix *p,
 163                                          const struct prefix_ipv6 *src_p,
 164                                          struct isis_ext_info *info)
 165 {
 166         struct isis_ext_info area_info;
 167         route_map_result_t map_ret;
 168
 169         memcpy(&area_info, info, sizeof(area_info));
 170         area_info.metric = redist->metric;
 171
 172         if (redist->map_name) {
 173                 map_ret =
 174                         route_map_apply(redist->map, p, RMAP_ISIS, &area_info);
 175                 if (map_ret == RMAP_DENYMATCH)
 176                         area_info.distance = 255;
 177         }
 178
 179         /* Allow synthesized default routes only on always orignate */
 180         if (area_info.origin == DEFAULT_ROUTE
 181             && redist->redist != DEFAULT_ORIGINATE_ALWAYS)
 182                 area_info.distance = 255;
 183
 184         if (area_info.distance < 255)
 185                 isis_redist_install(area, level, p, src_p, &area_info);
 186         else
 187                 isis_redist_uninstall(area, level, p, src_p);
 188 }
 189
 190 static void isis_redist_ensure_default(struct isis *isis, int family)
 191 {
 192         struct prefix p;
 193         struct route_table *ei_table = get_ext_info(isis, family);
 194         struct route_node *ei_node;
 195         struct isis_ext_info *info;
 196
 197         if (family == AF_INET) {
 198                 p.family = AF_INET;
 199                 p.prefixlen = 0;
 200                 memset(&p.u.prefix4, 0, sizeof(p.u.prefix4));
 201         } else if (family == AF_INET6) {
 202                 p.family = AF_INET6;
 203                 p.prefixlen = 0;
 204                 memset(&p.u.prefix6, 0, sizeof(p.u.prefix6));
 205         } else
 206                 assert(!"Unknown family!");
 207
 208         ei_node = srcdest_rnode_get(ei_table, &p, NULL);
 209         if (ei_node->info) {
 210                 route_unlock_node(ei_node);
 211                 return;
 212         }
 213
 214         ei_node->info =
 215                 XCALLOC(MTYPE_ISIS_EXT_INFO, sizeof(struct isis_ext_info));
 216
 217         info = ei_node->info;
 218         info->origin = DEFAULT_ROUTE;
 219         info->distance = 254;
 220         info->metric = MAX_WIDE_PATH_METRIC;
 221 }
 222
 223 /* Handle notification about route being added */
 224 void isis_redist_add(int type, struct prefix *p, struct prefix_ipv6 *src_p,
 225                      uint8_t distance, uint32_t metric)
 226 {
 227         int family = p->family;
 228         struct route_table *ei_table = get_ext_info(isis, family);
 229         struct route_node *ei_node;
 230         struct isis_ext_info *info;
 231         struct listnode *node;
 232         struct isis_area *area;
 233         int level;
 234         struct isis_redist *redist;
 235
 236         char debug_buf[BUFSIZ];
 237         prefix2str(p, debug_buf, sizeof(debug_buf));
 238
 239         zlog_debug("%s: New route %s from %s: distance %d.", __func__,
 240                    debug_buf, zebra_route_string(type), distance);
 241
 242         if (!ei_table) {
 243                 zlog_warn("%s: External information table not initialized.",
 244                           __func__);
 245                 return;
 246         }
 247
 248         ei_node = srcdest_rnode_get(ei_table, p, src_p);
 249         if (ei_node->info)
 250                 route_unlock_node(ei_node);
 251         else
 252                 ei_node->info = XCALLOC(MTYPE_ISIS_EXT_INFO,
 253                                         sizeof(struct isis_ext_info));
 254
 255         info = ei_node->info;
 256         info->origin = type;
 257         info->distance = distance;
 258         info->metric = metric;
 259
 260         if (is_default_prefix(p)
 261             && (!src_p || !src_p->prefixlen)) {
 262                 type = DEFAULT_ROUTE;
 263         }
 264
 265         for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area))
 266                 for (level = 1; level <= ISIS_LEVELS; level++) {
 267                         redist = get_redist_settings(area, family, type, level);
 268                         if (!redist->redist)
 269                                 continue;
 270
 271                         isis_redist_update_ext_reach(area, level, redist, p,
 272                                                      src_p, info);
 273                 }
 274 }
 275
 276 void isis_redist_delete(int type, struct prefix *p, struct prefix_ipv6 *src_p)
 277 {
 278         int family = p->family;
 279         struct route_table *ei_table = get_ext_info(isis, family);
 280         struct route_node *ei_node;
 281         struct listnode *node;
 282         struct isis_area *area;
 283         int level;
 284         struct isis_redist *redist;
 285
 286         char debug_buf[BUFSIZ];
 287         prefix2str(p, debug_buf, sizeof(debug_buf));
 288
 289         zlog_debug("%s: Removing route %s from %s.", __func__, debug_buf,
 290                    zebra_route_string(type));
 291
 292         if (is_default_prefix(p)
 293             && (!src_p || !src_p->prefixlen)) {
 294                 /* Don't remove default route but add synthetic route for use
 295                  * by "default-information originate always". Areas without the
 296                  * "always" setting will ignore routes with origin
 297                  * DEFAULT_ROUTE. */
 298                 isis_redist_add(DEFAULT_ROUTE, p, NULL,
 299                                 254, MAX_WIDE_PATH_METRIC);
 300                 return;
 301         }
 302
 303         if (!ei_table) {
 304                 zlog_warn("%s: External information table not initialized.",
 305                           __func__);
 306                 return;
 307         }
 308
 309         ei_node = srcdest_rnode_lookup(ei_table, p, src_p);
 310         if (!ei_node || !ei_node->info) {
 311                 char buf[BUFSIZ];
 312                 prefix2str(p, buf, sizeof(buf));
 313                 zlog_warn(
 314                         "%s: Got a delete for %s route %s, but that route"
 315                         " was never added.",
 316                         __func__, zebra_route_string(type), buf);
 317                 if (ei_node)
 318                         route_unlock_node(ei_node);
 319                 return;
 320         }
 321         route_unlock_node(ei_node);
 322
 323         for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area))
 324                 for (level = ISIS_LEVEL1; level <= ISIS_LEVEL2; level++) {
 325                         redist = get_redist_settings(area, family, type, level);
 326                         if (!redist->redist)
 327                                 continue;
 328
 329                         isis_redist_uninstall(area, level, p, src_p);
 330                 }
 331
 332         XFREE(MTYPE_ISIS_EXT_INFO, ei_node->info);
 333         route_unlock_node(ei_node);
 334 }
 335
 336 static void isis_redist_routemap_set(struct isis_redist *redist,
 337                                      const char *routemap)
 338 {
 339         if (redist->map_name) {
 340                 XFREE(MTYPE_ISIS, redist->map_name);
 341                 route_map_counter_decrement(redist->map);
 342                 redist->map = NULL;
 343         }
 344
 345         if (routemap && strlen(routemap)) {
 346                 redist->map_name = XSTRDUP(MTYPE_ISIS, routemap);
 347                 redist->map = route_map_lookup_by_name(routemap);
 348                 route_map_counter_increment(redist->map);
 349         }
 350 }
 351
 352 static void isis_redist_update_zebra_subscriptions(struct isis *isis)
 353 {
 354         struct listnode *node;
 355         struct isis_area *area;
 356         int type;
 357         int level;
 358         int protocol;
 359
 360         char do_subscribe[REDIST_PROTOCOL_COUNT][ZEBRA_ROUTE_MAX + 1];
 361
 362         memset(do_subscribe, 0, sizeof(do_subscribe));
 363
 364         for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area))
 365                 for (protocol = 0; protocol < REDIST_PROTOCOL_COUNT; protocol++)
 366                         for (type = 0; type < ZEBRA_ROUTE_MAX + 1; type++)
 367                                 for (level = 0; level < ISIS_LEVELS; level++)
 368                                         if (area->redist_settings[protocol]
 369                                                                  [type]
 370                                                                  [level].redist)
 371                                                 do_subscribe[protocol][type] =
 372                                                         1;
 373
 374         for (protocol = 0; protocol < REDIST_PROTOCOL_COUNT; protocol++)
 375                 for (type = 0; type < ZEBRA_ROUTE_MAX + 1; type++) {
 376                         /* This field is actually controlling transmission of
 377                          * the IS-IS
 378                          * routes to Zebra and has nothing to do with
 379                          * redistribution,
 380                          * so skip it. */
 381                         if (type == PROTO_TYPE)
 382                                 continue;
 383
 384                         afi_t afi = afi_for_redist_protocol(protocol);
 385
 386                         if (do_subscribe[protocol][type])
 387                                 isis_zebra_redistribute_set(afi, type);
 388                         else
 389                                 isis_zebra_redistribute_unset(afi, type);
 390                 }
 391 }
 392
 393 void isis_redist_set(struct isis_area *area, int level, int family, int type,
 394                      uint32_t metric, const char *routemap, int originate_type)
 395 {
 396         int protocol = redist_protocol(family);
 397         struct isis_redist *redist =
 398                 get_redist_settings(area, family, type, level);
 399         int i;
 400         struct route_table *ei_table;
 401         struct route_node *rn;
 402         struct isis_ext_info *info;
 403
 404         redist->redist = (type == DEFAULT_ROUTE) ? originate_type : 1;
 405         redist->metric = metric;
 406         isis_redist_routemap_set(redist, routemap);
 407
 408         if (!area->ext_reach[protocol][level - 1]) {
 409                 area->ext_reach[protocol][level - 1] = srcdest_table_init();
 410         }
 411
 412         for (i = 0; i < REDIST_PROTOCOL_COUNT; i++) {
 413                 if (!area->isis->ext_info[i]) {
 414                         area->isis->ext_info[i] = srcdest_table_init();
 415                 }
 416         }
 417
 418         isis_redist_update_zebra_subscriptions(area->isis);
 419
 420         if (type == DEFAULT_ROUTE && originate_type == DEFAULT_ORIGINATE_ALWAYS)
 421                 isis_redist_ensure_default(area->isis, family);
 422
 423         ei_table = get_ext_info(area->isis, family);
 424         for (rn = route_top(ei_table); rn; rn = srcdest_route_next(rn)) {
 425                 if (!rn->info)
 426                         continue;
 427                 info = rn->info;
 428
 429                 const struct prefix *p, *src_p;
 430
 431                 srcdest_rnode_prefixes(rn, &p, &src_p);
 432
 433                 if (type == DEFAULT_ROUTE) {
 434                         if (!is_default_prefix(p)
 435                             || (src_p && src_p->prefixlen)) {
 436                                 continue;
 437                         }
 438                 } else {
 439                         if (info->origin != type)
 440                                 continue;
 441                 }
 442
 443                 isis_redist_update_ext_reach(area, level, redist, p,
 444                                              (const struct prefix_ipv6 *)src_p,
 445                                              info);
 446         }
 447 }
 448
 449 void isis_redist_unset(struct isis_area *area, int level, int family, int type)
 450 {
 451         struct isis_redist *redist =
 452                 get_redist_settings(area, family, type, level);
 453         struct route_table *er_table = get_ext_reach(area, family, level);
 454         struct route_node *rn;
 455         struct isis_ext_info *info;
 456
 457         if (!redist->redist)
 458                 return;
 459
 460         redist->redist = 0;
 461         if (!er_table) {
 462                 zlog_warn("%s: External reachability table uninitialized.",
 463                           __func__);
 464                 return;
 465         }
 466
 467         for (rn = route_top(er_table); rn; rn = srcdest_route_next(rn)) {
 468                 if (!rn->info)
 469                         continue;
 470                 info = rn->info;
 471
 472                 const struct prefix *p, *src_p;
 473                 srcdest_rnode_prefixes(rn, &p, &src_p);
 474
 475                 if (type == DEFAULT_ROUTE) {
 476                         if (!is_default_prefix(p)
 477                             || (src_p && src_p->prefixlen)) {
 478                                 continue;
 479                         }
 480                 } else {
 481                         if (info->origin != type)
 482                                 continue;
 483                 }
 484
 485                 XFREE(MTYPE_ISIS_EXT_INFO, rn->info);
 486                 route_unlock_node(rn);
 487         }
 488
 489         lsp_regenerate_schedule(area, level, 0);
 490         isis_redist_update_zebra_subscriptions(area->isis);
 491 }
 492
 493 void isis_redist_area_finish(struct isis_area *area)
 494 {
 495         int protocol;
 496         int level;
 497         int type;
 498
 499         for (protocol = 0; protocol < REDIST_PROTOCOL_COUNT; protocol++)
 500                 for (level = 0; level < ISIS_LEVELS; level++) {
 501                         for (type = 0; type < ZEBRA_ROUTE_MAX + 1; type++) {
 502                                 struct isis_redist *redist;
 503
 504                                 redist = &area->redist_settings[protocol][type]
 505                                                                [level];
 506                                 redist->redist = 0;
 507                                 XFREE(MTYPE_ISIS, redist->map_name);
 508                         }
 509                         route_table_finish(area->ext_reach[protocol][level]);
 510                 }
 511
 512         isis_redist_update_zebra_subscriptions(area->isis);
 513 }
 514
 515 #ifdef FABRICD
 516 DEFUN (isis_redistribute,
 517        isis_redistribute_cmd,
 518        "redistribute <ipv4|ipv6> " PROTO_REDIST_STR
 519        " [<metric (0-16777215)|route-map WORD>]",
 520        REDIST_STR
 521        "Redistribute IPv4 routes\n"
 522        "Redistribute IPv6 routes\n"
 523        PROTO_REDIST_HELP
 524        "Metric for redistributed routes\n"
 525        "ISIS default metric\n"
 526        "Route map reference\n"
 527        "Pointer to route-map entries\n")
 528 {
 529         int idx_afi = 1;
 530         int idx_protocol = 2;
 531         int idx_metric_rmap = fabricd ? 3 : 4;
 532         VTY_DECLVAR_CONTEXT(isis_area, area);
 533         int family;
 534         int afi;
 535         int type;
 536         int level;
 537         unsigned long metric = 0;
 538         const char *routemap = NULL;
 539
 540         family = str2family(argv[idx_afi]->text);
 541         if (family < 0)
 542                 return CMD_WARNING_CONFIG_FAILED;
 543
 544         afi = family2afi(family);
 545         if (!afi)
 546                 return CMD_WARNING_CONFIG_FAILED;
 547
 548         type = proto_redistnum(afi, argv[idx_protocol]->text);
 549         if (type < 0)
 550                 return CMD_WARNING_CONFIG_FAILED;
 551
 552         level = 2;
 553
 554         if ((area->is_type & level) != level) {
 555                 vty_out(vty, "Node is not a level-%d IS\n", level);
 556                 return CMD_WARNING_CONFIG_FAILED;
 557         }
 558
 559         if (argc > idx_metric_rmap + 1) {
 560                 if (argv[idx_metric_rmap + 1]->arg[0] == '\0')
 561                         return CMD_WARNING_CONFIG_FAILED;
 562
 563                 if (strmatch(argv[idx_metric_rmap]->text, "metric")) {
 564                         char *endp;
 565                         metric = strtoul(argv[idx_metric_rmap + 1]->arg, &endp,
 566                                          10);
 567
 568                         if (*endp != '\0')
 569                                 return CMD_WARNING_CONFIG_FAILED;
 570                 } else {
 571                         routemap = argv[idx_metric_rmap + 1]->arg;
 572                 }
 573         }
 574
 575         isis_redist_set(area, level, family, type, metric, routemap, 0);
 576         return 0;
 577 }
 578
 579 DEFUN (no_isis_redistribute,
 580        no_isis_redistribute_cmd,
 581        "no redistribute <ipv4|ipv6> " PROTO_REDIST_STR,
 582        NO_STR
 583        REDIST_STR
 584        "Redistribute IPv4 routes\n"
 585        "Redistribute IPv6 routes\n"
 586        PROTO_REDIST_HELP)
 587 {
 588         int idx_afi = 2;
 589         int idx_protocol = 3;
 590         VTY_DECLVAR_CONTEXT(isis_area, area);
 591         int type;
 592         int level;
 593         int family;
 594         int afi;
 595
 596         family = str2family(argv[idx_afi]->arg);
 597         if (family < 0)
 598                 return CMD_WARNING_CONFIG_FAILED;
 599
 600         afi = family2afi(family);
 601         if (!afi)
 602                 return CMD_WARNING_CONFIG_FAILED;
 603
 604         type = proto_redistnum(afi, argv[idx_protocol]->text);
 605         if (type < 0)
 606                 return CMD_WARNING_CONFIG_FAILED;
 607
 608         level = 2;
 609
 610         isis_redist_unset(area, level, family, type);
 611         return 0;
 612 }
 613
 614 DEFUN (isis_default_originate,
 615        isis_default_originate_cmd,
 616        "default-information originate <ipv4|ipv6>"
 617        " [always] [<metric (0-16777215)|route-map WORD>]",
 618        "Control distribution of default information\n"
 619        "Distribute a default route\n"
 620        "Distribute default route for IPv4\n"
 621        "Distribute default route for IPv6\n"
 622        "Always advertise default route\n"
 623        "Metric for default route\n"
 624        "ISIS default metric\n"
 625        "Route map reference\n"
 626        "Pointer to route-map entries\n")
 627 {
 628         int idx_afi = 2;
 629         int idx_always = fabricd ? 3 : 4;
 630         int idx_metric_rmap = fabricd ? 3 : 4;
 631         VTY_DECLVAR_CONTEXT(isis_area, area);
 632         int family;
 633         int originate_type = DEFAULT_ORIGINATE;
 634         int level;
 635         unsigned long metric = 0;
 636         const char *routemap = NULL;
 637
 638         family = str2family(argv[idx_afi]->text);
 639         if (family < 0)
 640                 return CMD_WARNING_CONFIG_FAILED;
 641
 642         level = 2;
 643
 644         if ((area->is_type & level) != level) {
 645                 vty_out(vty, "Node is not a level-%d IS\n", level);
 646                 return CMD_WARNING_CONFIG_FAILED;
 647         }
 648
 649         if (argc > idx_always && strmatch(argv[idx_always]->text, "always")) {
 650                 originate_type = DEFAULT_ORIGINATE_ALWAYS;
 651                 idx_metric_rmap++;
 652         }
 653
 654         if (argc > idx_metric_rmap) {
 655                 if (strmatch(argv[idx_metric_rmap]->text, "metric"))
 656                         metric = strtoul(argv[idx_metric_rmap + 1]->arg, NULL,
 657                                          10);
 658                 else
 659                         routemap = argv[idx_metric_rmap + 1]->arg;
 660         }
 661
 662         if (family == AF_INET6 && originate_type != DEFAULT_ORIGINATE_ALWAYS) {
 663                 vty_out(vty,
 664                         "Zebra doesn't implement default-originate for IPv6 yet\n");
 665                 vty_out(vty,
 666                         "so use with care or use default-originate always.\n");
 667         }
 668
 669         isis_redist_set(area, level, family, DEFAULT_ROUTE, metric, routemap,
 670                         originate_type);
 671         return 0;
 672 }
 673
 674 DEFUN (no_isis_default_originate,
 675        no_isis_default_originate_cmd,
 676        "no default-information originate <ipv4|ipv6>",
 677        NO_STR
 678        "Control distribution of default information\n"
 679        "Distribute a default route\n"
 680        "Distribute default route for IPv4\n"
 681        "Distribute default route for IPv6\n")
 682 {
 683         int idx_afi = 3;
 684         VTY_DECLVAR_CONTEXT(isis_area, area);
 685         int family;
 686         int level;
 687
 688         family = str2family(argv[idx_afi]->text);
 689         if (family < 0)
 690                 return CMD_WARNING_CONFIG_FAILED;
 691
 692         level = 2;
 693
 694         isis_redist_unset(area, level, family, DEFAULT_ROUTE);
 695         return 0;
 696 }
 697 #endif /* ifdef FABRICD */
 698
 699 int isis_redist_config_write(struct vty *vty, struct isis_area *area,
 700                              int family)
 701 {
 702         int type;
 703         int level;
 704         int write = 0;
 705         struct isis_redist *redist;
 706         const char *family_str;
 707
 708         if (family == AF_INET)
 709                 family_str = "ipv4";
 710         else if (family == AF_INET6)
 711                 family_str = "ipv6";
 712         else
 713                 return 0;
 714
 715         for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
 716                 if (type == PROTO_TYPE)
 717                         continue;
 718
 719                 for (level = 1; level <= ISIS_LEVELS; level++) {
 720                         redist = get_redist_settings(area, family, type, level);
 721                         if (!redist->redist)
 722                                 continue;
 723                         vty_out(vty, " redistribute %s %s", family_str,
 724                                 zebra_route_string(type));
 725                         if (!fabricd)
 726                                 vty_out(vty, " level-%d", level);
 727                         if (redist->metric)
 728                                 vty_out(vty, " metric %u", redist->metric);
 729                         if (redist->map_name)
 730                                 vty_out(vty, " route-map %s", redist->map_name);
 731                         vty_out(vty, "\n");
 732                         write++;
 733                 }
 734         }
 735
 736         for (level = 1; level <= ISIS_LEVELS; level++) {
 737                 redist =
 738                         get_redist_settings(area, family, DEFAULT_ROUTE, level);
 739                 if (!redist->redist)
 740                         continue;
 741                 vty_out(vty, " default-information originate %s",
 742                         family_str);
 743                 if (!fabricd)
 744                         vty_out(vty, " level-%d", level);
 745                 if (redist->redist == DEFAULT_ORIGINATE_ALWAYS)
 746                         vty_out(vty, " always");
 747                 if (redist->metric)
 748                         vty_out(vty, " metric %u", redist->metric);
 749                 if (redist->map_name)
 750                         vty_out(vty, " route-map %s", redist->map_name);
 751                 vty_out(vty, "\n");
 752                 write++;
 753         }
 754
 755         return write;
 756 }
 757
 758 void isis_redist_init(void)
 759 {
 760 #ifdef FABRICD
 761         install_element(ROUTER_NODE, &isis_redistribute_cmd);
 762         install_element(ROUTER_NODE, &no_isis_redistribute_cmd);
 763
 764         install_element(ROUTER_NODE, &isis_default_originate_cmd);
 765         install_element(ROUTER_NODE, &no_isis_default_originate_cmd);
 766 #endif /* ifdef FABRICD */
 767 }