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                                 if (redist->map_name)
 508                                         XFREE(MTYPE_ISIS, redist->map_name);
 509                         }
 510                         route_table_finish(area->ext_reach[protocol][level]);
 511                 }
 512
 513         isis_redist_update_zebra_subscriptions(area->isis);
 514 }
 515
 516 #ifdef FABRICD
 517 DEFUN (isis_redistribute,
 518        isis_redistribute_cmd,
 519        "redistribute <ipv4|ipv6> " PROTO_REDIST_STR
 520        " [<metric (0-16777215)|route-map WORD>]",
 521        REDIST_STR
 522        "Redistribute IPv4 routes\n"
 523        "Redistribute IPv6 routes\n"
 524        PROTO_REDIST_HELP
 525        "Metric for redistributed routes\n"
 526        "ISIS default metric\n"
 527        "Route map reference\n"
 528        "Pointer to route-map entries\n")
 529 {
 530         int idx_afi = 1;
 531         int idx_protocol = 2;
 532         int idx_metric_rmap = fabricd ? 3 : 4;
 533         VTY_DECLVAR_CONTEXT(isis_area, area);
 534         int family;
 535         int afi;
 536         int type;
 537         int level;
 538         unsigned long metric = 0;
 539         const char *routemap = NULL;
 540
 541         family = str2family(argv[idx_afi]->text);
 542         if (family < 0)
 543                 return CMD_WARNING_CONFIG_FAILED;
 544
 545         afi = family2afi(family);
 546         if (!afi)
 547                 return CMD_WARNING_CONFIG_FAILED;
 548
 549         type = proto_redistnum(afi, argv[idx_protocol]->text);
 550         if (type < 0)
 551                 return CMD_WARNING_CONFIG_FAILED;
 552
 553         level = 2;
 554
 555         if ((area->is_type & level) != level) {
 556                 vty_out(vty, "Node is not a level-%d IS\n", level);
 557                 return CMD_WARNING_CONFIG_FAILED;
 558         }
 559
 560         if (argc > idx_metric_rmap + 1) {
 561                 if (argv[idx_metric_rmap + 1]->arg[0] == '\0')
 562                         return CMD_WARNING_CONFIG_FAILED;
 563
 564                 if (strmatch(argv[idx_metric_rmap]->text, "metric")) {
 565                         char *endp;
 566                         metric = strtoul(argv[idx_metric_rmap + 1]->arg, &endp,
 567                                          10);
 568
 569                         if (*endp != '\0')
 570                                 return CMD_WARNING_CONFIG_FAILED;
 571                 } else {
 572                         routemap = argv[idx_metric_rmap + 1]->arg;
 573                 }
 574         }
 575
 576         isis_redist_set(area, level, family, type, metric, routemap, 0);
 577         return 0;
 578 }
 579
 580 DEFUN (no_isis_redistribute,
 581        no_isis_redistribute_cmd,
 582        "no redistribute <ipv4|ipv6> " PROTO_REDIST_STR,
 583        NO_STR
 584        REDIST_STR
 585        "Redistribute IPv4 routes\n"
 586        "Redistribute IPv6 routes\n"
 587        PROTO_REDIST_HELP)
 588 {
 589         int idx_afi = 2;
 590         int idx_protocol = 3;
 591         VTY_DECLVAR_CONTEXT(isis_area, area);
 592         int type;
 593         int level;
 594         int family;
 595         int afi;
 596
 597         family = str2family(argv[idx_afi]->arg);
 598         if (family < 0)
 599                 return CMD_WARNING_CONFIG_FAILED;
 600
 601         afi = family2afi(family);
 602         if (!afi)
 603                 return CMD_WARNING_CONFIG_FAILED;
 604
 605         type = proto_redistnum(afi, argv[idx_protocol]->text);
 606         if (type < 0)
 607                 return CMD_WARNING_CONFIG_FAILED;
 608
 609         level = 2;
 610
 611         isis_redist_unset(area, level, family, type);
 612         return 0;
 613 }
 614
 615 DEFUN (isis_default_originate,
 616        isis_default_originate_cmd,
 617        "default-information originate <ipv4|ipv6>"
 618        " [always] [<metric (0-16777215)|route-map WORD>]",
 619        "Control distribution of default information\n"
 620        "Distribute a default route\n"
 621        "Distribute default route for IPv4\n"
 622        "Distribute default route for IPv6\n"
 623        "Always advertise default route\n"
 624        "Metric for default route\n"
 625        "ISIS default metric\n"
 626        "Route map reference\n"
 627        "Pointer to route-map entries\n")
 628 {
 629         int idx_afi = 2;
 630         int idx_always = fabricd ? 3 : 4;
 631         int idx_metric_rmap = fabricd ? 3 : 4;
 632         VTY_DECLVAR_CONTEXT(isis_area, area);
 633         int family;
 634         int originate_type = DEFAULT_ORIGINATE;
 635         int level;
 636         unsigned long metric = 0;
 637         const char *routemap = NULL;
 638
 639         family = str2family(argv[idx_afi]->text);
 640         if (family < 0)
 641                 return CMD_WARNING_CONFIG_FAILED;
 642
 643         level = 2;
 644
 645         if ((area->is_type & level) != level) {
 646                 vty_out(vty, "Node is not a level-%d IS\n", level);
 647                 return CMD_WARNING_CONFIG_FAILED;
 648         }
 649
 650         if (argc > idx_always && strmatch(argv[idx_always]->text, "always")) {
 651                 originate_type = DEFAULT_ORIGINATE_ALWAYS;
 652                 idx_metric_rmap++;
 653         }
 654
 655         if (argc > idx_metric_rmap) {
 656                 if (strmatch(argv[idx_metric_rmap]->text, "metric"))
 657                         metric = strtoul(argv[idx_metric_rmap + 1]->arg, NULL,
 658                                          10);
 659                 else
 660                         routemap = argv[idx_metric_rmap + 1]->arg;
 661         }
 662
 663         if (family == AF_INET6 && originate_type != DEFAULT_ORIGINATE_ALWAYS) {
 664                 vty_out(vty,
 665                         "Zebra doesn't implement default-originate for IPv6 yet\n");
 666                 vty_out(vty,
 667                         "so use with care or use default-originate always.\n");
 668         }
 669
 670         isis_redist_set(area, level, family, DEFAULT_ROUTE, metric, routemap,
 671                         originate_type);
 672         return 0;
 673 }
 674
 675 DEFUN (no_isis_default_originate,
 676        no_isis_default_originate_cmd,
 677        "no default-information originate <ipv4|ipv6>",
 678        NO_STR
 679        "Control distribution of default information\n"
 680        "Distribute a default route\n"
 681        "Distribute default route for IPv4\n"
 682        "Distribute default route for IPv6\n")
 683 {
 684         int idx_afi = 3;
 685         VTY_DECLVAR_CONTEXT(isis_area, area);
 686         int family;
 687         int level;
 688
 689         family = str2family(argv[idx_afi]->text);
 690         if (family < 0)
 691                 return CMD_WARNING_CONFIG_FAILED;
 692
 693         level = 2;
 694
 695         isis_redist_unset(area, level, family, DEFAULT_ROUTE);
 696         return 0;
 697 }
 698 #endif /* ifdef FABRICD */
 699
 700 int isis_redist_config_write(struct vty *vty, struct isis_area *area,
 701                              int family)
 702 {
 703         int type;
 704         int level;
 705         int write = 0;
 706         struct isis_redist *redist;
 707         const char *family_str;
 708
 709         if (family == AF_INET)
 710                 family_str = "ipv4";
 711         else if (family == AF_INET6)
 712                 family_str = "ipv6";
 713         else
 714                 return 0;
 715
 716         for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
 717                 if (type == PROTO_TYPE)
 718                         continue;
 719
 720                 for (level = 1; level <= ISIS_LEVELS; level++) {
 721                         redist = get_redist_settings(area, family, type, level);
 722                         if (!redist->redist)
 723                                 continue;
 724                         vty_out(vty, " redistribute %s %s", family_str,
 725                                 zebra_route_string(type));
 726                         if (!fabricd)
 727                                 vty_out(vty, " level-%d", level);
 728                         if (redist->metric)
 729                                 vty_out(vty, " metric %u", redist->metric);
 730                         if (redist->map_name)
 731                                 vty_out(vty, " route-map %s", redist->map_name);
 732                         vty_out(vty, "\n");
 733                         write++;
 734                 }
 735         }
 736
 737         for (level = 1; level <= ISIS_LEVELS; level++) {
 738                 redist =
 739                         get_redist_settings(area, family, DEFAULT_ROUTE, level);
 740                 if (!redist->redist)
 741                         continue;
 742                 vty_out(vty, " default-information originate %s",
 743                         family_str);
 744                 if (!fabricd)
 745                         vty_out(vty, " level-%d", level);
 746                 if (redist->redist == DEFAULT_ORIGINATE_ALWAYS)
 747                         vty_out(vty, " always");
 748                 if (redist->metric)
 749                         vty_out(vty, " metric %u", redist->metric);
 750                 if (redist->map_name)
 751                         vty_out(vty, " route-map %s", redist->map_name);
 752                 vty_out(vty, "\n");
 753                 write++;
 754         }
 755
 756         return write;
 757 }
 758
 759 void isis_redist_init(void)
 760 {
 761 #ifdef FABRICD
 762         install_element(ROUTER_NODE, &isis_redistribute_cmd);
 763         install_element(ROUTER_NODE, &no_isis_redistribute_cmd);
 764
 765         install_element(ROUTER_NODE, &isis_default_originate_cmd);
 766         install_element(ROUTER_NODE, &no_isis_default_originate_cmd);
 767 #endif /* ifdef FABRICD */
 768 }