ospfd/ospf_routemap.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Route map function of ospfd.
   4  * Copyright (C) 2000 IP Infusion Inc.
   5  *
   6  * Written by Toshiaki Takada.
   7  */
   8
   9 #include <zebra.h>
  10
  11 #include "memory.h"
  12 #include "prefix.h"
  13 #include "table.h"
  14 #include "vty.h"
  15 #include "routemap.h"
  16 #include "command.h"
  17 #include "log.h"
  18 #include "plist.h"
  19 #include "vrf.h"
  20 #include "frrstr.h"
  21 #include "northbound_cli.h"
  22
  23 #include "ospfd/ospfd.h"
  24 #include "ospfd/ospf_asbr.h"
  25 #include "ospfd/ospf_interface.h"
  26 #include "ospfd/ospf_lsa.h"
  27 #include "ospfd/ospf_route.h"
  28 #include "ospfd/ospf_zebra.h"
  29 #include "ospfd/ospf_errors.h"
  30
  31 /* Hook function for updating route_map assignment. */
  32 static void ospf_route_map_update(const char *name)
  33 {
  34         struct ospf *ospf;
  35         int type;
  36         struct listnode *n1 = NULL;
  37
  38         /* If OSPF instatnce does not exist, return right now. */
  39         if (listcount(om->ospf) == 0)
  40                 return;
  41
  42         for (ALL_LIST_ELEMENTS_RO(om->ospf, n1, ospf)) {
  43                 /* Update route-map */
  44                 for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
  45                         struct list *red_list;
  46                         struct listnode *node;
  47                         struct ospf_redist *red;
  48
  49                         red_list = ospf->redist[type];
  50                         if (!red_list)
  51                                 continue;
  52
  53                         for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
  54                                 if (ROUTEMAP_NAME(red)
  55                                     && strcmp(ROUTEMAP_NAME(red), name) == 0) {
  56                                         /* Keep old route-map. */
  57                                         struct route_map *old = ROUTEMAP(red);
  58
  59                                         ROUTEMAP(red) =
  60                                                 route_map_lookup_by_name(
  61                                                         ROUTEMAP_NAME(red));
  62
  63                                         if (!old)
  64                                                 route_map_counter_increment(
  65                                                         ROUTEMAP(red));
  66
  67                                         /* No update for this distribute type.
  68                                          */
  69                                         if (old == NULL
  70                                             && ROUTEMAP(red) == NULL)
  71                                                 continue;
  72
  73                                         ospf_distribute_list_update(
  74                                                 ospf, type, red->instance);
  75                                 }
  76                         }
  77                 }
  78         }
  79 }
  80
  81 static void ospf_route_map_event(const char *name)
  82 {
  83         struct ospf *ospf;
  84         int type;
  85         struct listnode *n1 = NULL;
  86
  87         for (ALL_LIST_ELEMENTS_RO(om->ospf, n1, ospf)) {
  88                 for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
  89                         struct list *red_list;
  90                         struct listnode *node;
  91                         struct ospf_redist *red;
  92
  93                         red_list = ospf->redist[type];
  94                         if (!red_list)
  95                                 continue;
  96
  97                         for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
  98                                 if (ROUTEMAP_NAME(red) && ROUTEMAP(red)
  99                                     && !strcmp(ROUTEMAP_NAME(red), name)) {
 100                                         ospf_distribute_list_update(
 101                                                 ospf, type, red->instance);
 102                                 }
 103                         }
 104                 }
 105         }
 106 }
 107
 108 /* `match ip netxthop ' */
 109 /* Match function return 1 if match is success else return zero. */
 110 static enum route_map_cmd_result_t
 111 route_match_ip_nexthop(void *rule, const struct prefix *prefix, void *object)
 112 {
 113         struct access_list *alist;
 114         struct external_info *ei = object;
 115         struct prefix_ipv4 p;
 116
 117         p.family = AF_INET;
 118         p.prefix = ei->nexthop;
 119         p.prefixlen = IPV4_MAX_BITLEN;
 120
 121         alist = access_list_lookup(AFI_IP, (char *)rule);
 122         if (alist == NULL) {
 123                 if (unlikely(CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL)))
 124                         zlog_debug(
 125                                 "%s: Access-List Specified: %s does not exist defaulting to NO_MATCH",
 126                                 __func__, (char *)rule);
 127                 return RMAP_NOMATCH;
 128         }
 129
 130         return (access_list_apply(alist, &p) == FILTER_DENY ? RMAP_NOMATCH
 131                                                             : RMAP_MATCH);
 132 }
 133
 134 /* Route map `ip next-hop' match statement. `arg' should be
 135    access-list name. */
 136 static void *route_match_ip_nexthop_compile(const char *arg)
 137 {
 138         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 139 }
 140
 141 /* Free route map's compiled `ip address' value. */
 142 static void route_match_ip_nexthop_free(void *rule)
 143 {
 144         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 145 }
 146
 147 /* Route map commands for metric matching. */
 148 static const struct route_map_rule_cmd route_match_ip_nexthop_cmd = {
 149         "ip next-hop",
 150         route_match_ip_nexthop,
 151         route_match_ip_nexthop_compile,
 152         route_match_ip_nexthop_free
 153 };
 154
 155 /* `match ip next-hop prefix-list PREFIX_LIST' */
 156
 157 static enum route_map_cmd_result_t
 158 route_match_ip_next_hop_prefix_list(void *rule, const struct prefix *prefix,
 159                                     void *object)
 160 {
 161         struct prefix_list *plist;
 162         struct external_info *ei = object;
 163         struct prefix_ipv4 p;
 164
 165         p.family = AF_INET;
 166         p.prefix = ei->nexthop;
 167         p.prefixlen = IPV4_MAX_BITLEN;
 168
 169         plist = prefix_list_lookup(AFI_IP, (char *)rule);
 170         if (plist == NULL) {
 171                 if (unlikely(CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL)))
 172                         zlog_debug(
 173                                 "%s: Prefix List %s specified does not exist defaulting to NO_MATCH",
 174                                 __func__, (char *)rule);
 175                 return RMAP_NOMATCH;
 176         }
 177
 178         return (prefix_list_apply(plist, &p) == PREFIX_DENY ? RMAP_NOMATCH
 179                                                             : RMAP_MATCH);
 180 }
 181
 182 static void *route_match_ip_next_hop_prefix_list_compile(const char *arg)
 183 {
 184         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 185 }
 186
 187 static void route_match_ip_next_hop_prefix_list_free(void *rule)
 188 {
 189         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 190 }
 191
 192 static const struct route_map_rule_cmd
 193                 route_match_ip_next_hop_prefix_list_cmd = {
 194         "ip next-hop prefix-list",
 195         route_match_ip_next_hop_prefix_list,
 196         route_match_ip_next_hop_prefix_list_compile,
 197         route_match_ip_next_hop_prefix_list_free
 198 };
 199
 200 /* `match ip next-hop type <blackhole>' */
 201
 202 static enum route_map_cmd_result_t
 203 route_match_ip_next_hop_type(void *rule, const struct prefix *prefix,
 204                              void *object)
 205 {
 206         struct external_info *ei = object;
 207
 208         if (prefix->family == AF_INET) {
 209                 ei = (struct external_info *)object;
 210                 if (!ei)
 211                         return RMAP_NOMATCH;
 212
 213                 if (ei->nexthop.s_addr == INADDR_ANY && !ei->ifindex)
 214                         return RMAP_MATCH;
 215         }
 216         return RMAP_NOMATCH;
 217 }
 218
 219 static void *route_match_ip_next_hop_type_compile(const char *arg)
 220 {
 221         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 222 }
 223
 224 static void route_match_ip_next_hop_type_free(void *rule)
 225 {
 226         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 227 }
 228
 229 static const struct route_map_rule_cmd
 230                 route_match_ip_next_hop_type_cmd = {
 231         "ip next-hop type",
 232         route_match_ip_next_hop_type,
 233         route_match_ip_next_hop_type_compile,
 234         route_match_ip_next_hop_type_free
 235 };
 236
 237 /* `match ip address IP_ACCESS_LIST' */
 238 /* Match function should return 1 if match is success else return
 239    zero. */
 240 static enum route_map_cmd_result_t
 241 route_match_ip_address(void *rule, const struct prefix *prefix, void *object)
 242 {
 243         struct access_list *alist;
 244         /* struct prefix_ipv4 match; */
 245
 246         alist = access_list_lookup(AFI_IP, (char *)rule);
 247         if (alist == NULL) {
 248                 if (unlikely(CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL)))
 249                         zlog_debug(
 250                                 "%s: Access-List Specified: %s does not exist defaulting to NO_MATCH",
 251                                 __func__, (char *)rule);
 252                 return RMAP_NOMATCH;
 253         }
 254
 255         return (access_list_apply(alist, prefix) == FILTER_DENY ? RMAP_NOMATCH
 256                                                                 : RMAP_MATCH);
 257 }
 258
 259 /* Route map `ip address' match statement.  `arg' should be
 260    access-list name. */
 261 static void *route_match_ip_address_compile(const char *arg)
 262 {
 263         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 264 }
 265
 266 /* Free route map's compiled `ip address' value. */
 267 static void route_match_ip_address_free(void *rule)
 268 {
 269         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 270 }
 271
 272 /* Route map commands for ip address matching. */
 273 static const struct route_map_rule_cmd route_match_ip_address_cmd = {
 274         "ip address",
 275         route_match_ip_address,
 276         route_match_ip_address_compile,
 277         route_match_ip_address_free
 278 };
 279
 280 /* `match ip address prefix-list PREFIX_LIST' */
 281 static enum route_map_cmd_result_t
 282 route_match_ip_address_prefix_list(void *rule, const struct prefix *prefix,
 283                                    void *object)
 284 {
 285         struct prefix_list *plist;
 286
 287         plist = prefix_list_lookup(AFI_IP, (char *)rule);
 288         if (plist == NULL) {
 289                 if (unlikely(CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL)))
 290                         zlog_debug(
 291                                 "%s: Prefix List %s specified does not exist defaulting to NO_MATCH",
 292                                 __func__, (char *)rule);
 293
 294                 return RMAP_NOMATCH;
 295         }
 296
 297         return (prefix_list_apply(plist, prefix) == PREFIX_DENY ? RMAP_NOMATCH
 298                                                                 : RMAP_MATCH);
 299 }
 300
 301 static void *route_match_ip_address_prefix_list_compile(const char *arg)
 302 {
 303         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 304 }
 305
 306 static void route_match_ip_address_prefix_list_free(void *rule)
 307 {
 308         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 309 }
 310
 311 static const struct route_map_rule_cmd
 312                 route_match_ip_address_prefix_list_cmd = {
 313         "ip address prefix-list",
 314         route_match_ip_address_prefix_list,
 315         route_match_ip_address_prefix_list_compile,
 316         route_match_ip_address_prefix_list_free
 317 };
 318
 319 /* `match interface IFNAME' */
 320 /* Match function should return 1 if match is success else return
 321    zero. */
 322 static enum route_map_cmd_result_t
 323 route_match_interface(void *rule, const struct prefix *prefix, void *object)
 324 {
 325         struct interface *ifp;
 326         struct external_info *ei;
 327
 328         ei = object;
 329         ifp = if_lookup_by_name((char *)rule, ei->ospf->vrf_id);
 330
 331         if (ifp == NULL || ifp->ifindex != ei->ifindex)
 332                 return RMAP_NOMATCH;
 333
 334         return RMAP_MATCH;
 335 }
 336
 337 /* Route map `interface' match statement.  `arg' should be
 338    interface name. */
 339 static void *route_match_interface_compile(const char *arg)
 340 {
 341         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 342 }
 343
 344 /* Free route map's compiled `interface' value. */
 345 static void route_match_interface_free(void *rule)
 346 {
 347         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 348 }
 349
 350 /* Route map commands for ip address matching. */
 351 static const struct route_map_rule_cmd route_match_interface_cmd = {
 352         "interface",
 353         route_match_interface,
 354         route_match_interface_compile,
 355         route_match_interface_free
 356 };
 357
 358 /* Match function return 1 if match is success else return zero. */
 359 static enum route_map_cmd_result_t
 360 route_match_tag(void *rule, const struct prefix *prefix, void *object)
 361 {
 362         route_tag_t *tag;
 363         struct external_info *ei;
 364
 365         tag = rule;
 366         ei = object;
 367
 368         return ((ei->tag == *tag) ? RMAP_MATCH : RMAP_NOMATCH);
 369 }
 370
 371 /* Route map commands for tag matching. */
 372 static const struct route_map_rule_cmd route_match_tag_cmd = {
 373         "tag",
 374         route_match_tag,
 375         route_map_rule_tag_compile,
 376         route_map_rule_tag_free,
 377 };
 378
 379 struct ospf_metric {
 380         enum { metric_increment, metric_decrement, metric_absolute } type;
 381         bool used;
 382         uint32_t metric;
 383 };
 384
 385 /* `set metric METRIC' */
 386 /* Set metric to attribute. */
 387 static enum route_map_cmd_result_t
 388 route_set_metric(void *rule, const struct prefix *prefix, void *object)
 389 {
 390         struct ospf_metric *metric;
 391         struct external_info *ei;
 392
 393         /* Fetch routemap's rule information. */
 394         metric = rule;
 395         ei = object;
 396
 397         /* Set metric out value. */
 398         if (!metric->used)
 399                 return RMAP_OKAY;
 400
 401         ROUTEMAP_METRIC(ei) = ei->metric;
 402
 403         if (metric->type == metric_increment)
 404                 ROUTEMAP_METRIC(ei) += metric->metric;
 405         else if (metric->type == metric_decrement)
 406                 ROUTEMAP_METRIC(ei) -= metric->metric;
 407         else if (metric->type == metric_absolute)
 408                 ROUTEMAP_METRIC(ei) = metric->metric;
 409
 410         if ((uint32_t)ROUTEMAP_METRIC(ei) < ei->min_metric)
 411                 ROUTEMAP_METRIC(ei) = ei->min_metric;
 412         if ((uint32_t)ROUTEMAP_METRIC(ei) > ei->max_metric)
 413                 ROUTEMAP_METRIC(ei) = ei->max_metric;
 414
 415         return RMAP_OKAY;
 416 }
 417
 418 /* set metric compilation. */
 419 static void *route_set_metric_compile(const char *arg)
 420 {
 421         struct ospf_metric *metric;
 422
 423         metric = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(*metric));
 424         metric->used = false;
 425
 426         if (all_digit(arg))
 427                 metric->type = metric_absolute;
 428
 429         if (strmatch(arg, "+rtt") || strmatch(arg, "-rtt")) {
 430                 flog_warn(EC_OSPF_SET_METRIC_PLUS,
 431                           "OSPF does not support 'set metric +rtt / -rtt'");
 432                 return metric;
 433         }
 434
 435         if ((arg[0] == '+') && all_digit(arg + 1)) {
 436                 metric->type = metric_increment;
 437                 arg++;
 438         }
 439
 440         if ((arg[0] == '-') && all_digit(arg + 1)) {
 441                 metric->type = metric_decrement;
 442                 arg++;
 443         }
 444
 445         metric->metric = strtoul(arg, NULL, 10);
 446
 447         if (metric->metric)
 448                 metric->used = true;
 449
 450         return metric;
 451 }
 452
 453 /* Free route map's compiled `set metric' value. */
 454 static void route_set_metric_free(void *rule)
 455 {
 456         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 457 }
 458
 459 /* Set metric rule structure. */
 460 static const struct route_map_rule_cmd route_set_metric_cmd = {
 461         "metric",
 462         route_set_metric,
 463         route_set_metric_compile,
 464         route_set_metric_free,
 465 };
 466
 467 /* `set min-metric METRIC' */
 468 /* Set min-metric to attribute. */
 469 static enum route_map_cmd_result_t
 470 route_set_min_metric(void *rule, const struct prefix *prefix, void *object)
 471 {
 472         uint32_t *min_metric;
 473         struct external_info *ei;
 474
 475         /* Fetch routemap's rule information. */
 476         min_metric = rule;
 477         ei = object;
 478
 479         ei->min_metric = *min_metric;
 480
 481         if (ei->min_metric > OSPF_LS_INFINITY)
 482                 ei->min_metric = OSPF_LS_INFINITY;
 483
 484         if ((uint32_t)ROUTEMAP_METRIC(ei) < ei->min_metric)
 485                 ROUTEMAP_METRIC(ei) = ei->min_metric;
 486
 487         return RMAP_OKAY;
 488 }
 489
 490 /* set min-metric compilation. */
 491 static void *route_set_min_metric_compile(const char *arg)
 492 {
 493
 494         uint32_t *min_metric;
 495
 496         min_metric = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
 497
 498         *min_metric = strtoul(arg, NULL, 10);
 499
 500         if (*min_metric)
 501                 return min_metric;
 502
 503         XFREE(MTYPE_ROUTE_MAP_COMPILED, min_metric);
 504         return NULL;
 505 }
 506
 507 /* Free route map's compiled `set min-metric' value. */
 508 static void route_set_min_metric_free(void *rule)
 509 {
 510         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 511 }
 512
 513 /* Set metric rule structure. */
 514 static const struct route_map_rule_cmd route_set_min_metric_cmd = {
 515         "min-metric",
 516         route_set_min_metric,
 517         route_set_min_metric_compile,
 518         route_set_min_metric_free,
 519 };
 520
 521
 522 /* `set max-metric METRIC' */
 523 /* Set max-metric to attribute. */
 524 static enum route_map_cmd_result_t
 525 route_set_max_metric(void *rule, const struct prefix *prefix, void *object)
 526 {
 527         uint32_t *max_metric;
 528         struct external_info *ei;
 529
 530         /* Fetch routemap's rule information. */
 531         max_metric = rule;
 532         ei = object;
 533
 534         ei->max_metric = *max_metric;
 535
 536         if (ei->max_metric > OSPF_LS_INFINITY)
 537                 ei->max_metric = OSPF_LS_INFINITY;
 538
 539         if ((uint32_t)ROUTEMAP_METRIC(ei) > ei->max_metric)
 540                 ROUTEMAP_METRIC(ei) = ei->max_metric;
 541
 542         return RMAP_OKAY;
 543 }
 544
 545 /* set max-metric compilation. */
 546 static void *route_set_max_metric_compile(const char *arg)
 547 {
 548
 549         uint32_t *max_metric;
 550
 551         max_metric = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
 552
 553         *max_metric = strtoul(arg, NULL, 10);
 554
 555         if (*max_metric)
 556                 return max_metric;
 557
 558         XFREE(MTYPE_ROUTE_MAP_COMPILED, max_metric);
 559         return NULL;
 560 }
 561
 562 /* Free route map's compiled `set max-metric' value. */
 563 static void route_set_max_metric_free(void *rule)
 564 {
 565         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 566 }
 567
 568 /* Set metric rule structure. */
 569 static const struct route_map_rule_cmd route_set_max_metric_cmd = {
 570         "max-metric",
 571         route_set_max_metric,
 572         route_set_max_metric_compile,
 573         route_set_max_metric_free,
 574 };
 575
 576 /* `set metric-type TYPE' */
 577 /* Set metric-type to attribute. */
 578 static enum route_map_cmd_result_t
 579 route_set_metric_type(void *rule, const struct prefix *prefix, void *object)
 580 {
 581         uint32_t *metric_type;
 582         struct external_info *ei;
 583
 584         /* Fetch routemap's rule information. */
 585         metric_type = rule;
 586         ei = object;
 587
 588         /* Set metric out value. */
 589         ROUTEMAP_METRIC_TYPE(ei) = *metric_type;
 590
 591         return RMAP_OKAY;
 592 }
 593
 594 /* set metric-type compilation. */
 595 static void *route_set_metric_type_compile(const char *arg)
 596 {
 597         uint32_t *metric_type;
 598
 599         metric_type = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
 600         if (strcmp(arg, "type-1") == 0)
 601                 *metric_type = EXTERNAL_METRIC_TYPE_1;
 602         else if (strcmp(arg, "type-2") == 0)
 603                 *metric_type = EXTERNAL_METRIC_TYPE_2;
 604
 605         if (*metric_type == EXTERNAL_METRIC_TYPE_1
 606             || *metric_type == EXTERNAL_METRIC_TYPE_2)
 607                 return metric_type;
 608
 609         XFREE(MTYPE_ROUTE_MAP_COMPILED, metric_type);
 610         return NULL;
 611 }
 612
 613 /* Free route map's compiled `set metric-type' value. */
 614 static void route_set_metric_type_free(void *rule)
 615 {
 616         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 617 }
 618
 619 /* Set metric rule structure. */
 620 static const struct route_map_rule_cmd route_set_metric_type_cmd = {
 621         "metric-type",
 622         route_set_metric_type,
 623         route_set_metric_type_compile,
 624         route_set_metric_type_free,
 625 };
 626
 627 static enum route_map_cmd_result_t
 628 route_set_tag(void *rule, const struct prefix *prefix, void *object)
 629 {
 630         route_tag_t *tag;
 631         struct external_info *ei;
 632
 633         tag = rule;
 634         ei = object;
 635
 636         /* Set tag value */
 637         ei->tag = *tag;
 638
 639         return RMAP_OKAY;
 640 }
 641
 642 /* Route map commands for tag set. */
 643 static const struct route_map_rule_cmd route_set_tag_cmd = {
 644         "tag",
 645         route_set_tag,
 646         route_map_rule_tag_compile,
 647         route_map_rule_tag_free,
 648 };
 649
 650 DEFUN_YANG (set_metric_type,
 651        set_metric_type_cmd,
 652        "set metric-type <type-1|type-2>",
 653        SET_STR
 654        "Type of metric for destination routing protocol\n"
 655        "OSPF[6] external type 1 metric\n"
 656        "OSPF[6] external type 2 metric\n")
 657 {
 658         char *ext = argv[2]->text;
 659
 660         const char *xpath =
 661                 "./set-action[action='frr-ospf-route-map:metric-type']";
 662         char xpath_value[XPATH_MAXLEN];
 663
 664         nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
 665         snprintf(xpath_value, sizeof(xpath_value),
 666                  "%s/rmap-set-action/frr-ospf-route-map:metric-type", xpath);
 667         nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, ext);
 668         return nb_cli_apply_changes(vty, NULL);
 669 }
 670
 671 DEFUN_YANG (no_set_metric_type,
 672        no_set_metric_type_cmd,
 673        "no set metric-type [<type-1|type-2>]",
 674        NO_STR
 675        SET_STR
 676        "Type of metric for destination routing protocol\n"
 677        "OSPF[6] external type 1 metric\n"
 678        "OSPF[6] external type 2 metric\n")
 679 {
 680         const char *xpath =
 681                 "./set-action[action='frr-ospf-route-map:metric-type']";
 682
 683         nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
 684         return nb_cli_apply_changes(vty, NULL);
 685 }
 686
 687 /* Route-map init */
 688 void ospf_route_map_init(void)
 689 {
 690         route_map_init();
 691
 692         route_map_add_hook(ospf_route_map_update);
 693         route_map_delete_hook(ospf_route_map_update);
 694         route_map_event_hook(ospf_route_map_event);
 695
 696         route_map_match_ip_next_hop_hook(generic_match_add);
 697         route_map_no_match_ip_next_hop_hook(generic_match_delete);
 698
 699         route_map_match_interface_hook(generic_match_add);
 700         route_map_no_match_interface_hook(generic_match_delete);
 701
 702         route_map_match_ip_address_hook(generic_match_add);
 703         route_map_no_match_ip_address_hook(generic_match_delete);
 704
 705         route_map_match_ip_address_prefix_list_hook(generic_match_add);
 706         route_map_no_match_ip_address_prefix_list_hook(generic_match_delete);
 707
 708         route_map_match_ip_next_hop_prefix_list_hook(generic_match_add);
 709         route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete);
 710
 711         route_map_match_ip_next_hop_type_hook(generic_match_add);
 712         route_map_no_match_ip_next_hop_type_hook(generic_match_delete);
 713
 714         route_map_match_tag_hook(generic_match_add);
 715         route_map_no_match_tag_hook(generic_match_delete);
 716
 717         route_map_set_metric_hook(generic_set_add);
 718         route_map_no_set_metric_hook(generic_set_delete);
 719
 720         route_map_set_min_metric_hook(generic_set_add);
 721         route_map_no_set_min_metric_hook(generic_set_delete);
 722
 723         route_map_set_max_metric_hook(generic_set_add);
 724         route_map_no_set_max_metric_hook(generic_set_delete);
 725
 726         route_map_set_tag_hook(generic_set_add);
 727         route_map_no_set_tag_hook(generic_set_delete);
 728
 729         route_map_install_match(&route_match_ip_nexthop_cmd);
 730         route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd);
 731         route_map_install_match(&route_match_ip_address_cmd);
 732         route_map_install_match(&route_match_ip_address_prefix_list_cmd);
 733         route_map_install_match(&route_match_ip_next_hop_type_cmd);
 734         route_map_install_match(&route_match_interface_cmd);
 735         route_map_install_match(&route_match_tag_cmd);
 736
 737         route_map_install_set(&route_set_metric_cmd);
 738         route_map_install_set(&route_set_min_metric_cmd);
 739         route_map_install_set(&route_set_max_metric_cmd);
 740         route_map_install_set(&route_set_metric_type_cmd);
 741         route_map_install_set(&route_set_tag_cmd);
 742
 743         install_element(RMAP_NODE, &set_metric_type_cmd);
 744         install_element(RMAP_NODE, &no_set_metric_type_cmd);
 745 }