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         ei->route_map_set.metric = DEFAULT_DEFAULT_METRIC;
 402
 403         if (metric->type == metric_increment)
 404                 ei->route_map_set.metric += metric->metric;
 405         else if (metric->type == metric_decrement)
 406                 ei->route_map_set.metric -= metric->metric;
 407         else if (metric->type == metric_absolute)
 408                 ei->route_map_set.metric = metric->metric;
 409
 410         if (ei->route_map_set.metric > OSPF_LS_INFINITY)
 411                 ei->route_map_set.metric = OSPF_LS_INFINITY;
 412
 413         return RMAP_OKAY;
 414 }
 415
 416 /* set metric compilation. */
 417 static void *route_set_metric_compile(const char *arg)
 418 {
 419         struct ospf_metric *metric;
 420
 421         metric = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(*metric));
 422         metric->used = false;
 423
 424         if (all_digit(arg))
 425                 metric->type = metric_absolute;
 426
 427         if (strmatch(arg, "+rtt") || strmatch(arg, "-rtt")) {
 428                 flog_warn(EC_OSPF_SET_METRIC_PLUS,
 429                           "OSPF does not support 'set metric +rtt / -rtt'");
 430                 return metric;
 431         }
 432
 433         if ((arg[0] == '+') && all_digit(arg + 1)) {
 434                 metric->type = metric_increment;
 435                 arg++;
 436         }
 437
 438         if ((arg[0] == '-') && all_digit(arg + 1)) {
 439                 metric->type = metric_decrement;
 440                 arg++;
 441         }
 442
 443         metric->metric = strtoul(arg, NULL, 10);
 444
 445         if (metric->metric)
 446                 metric->used = true;
 447
 448         return metric;
 449 }
 450
 451 /* Free route map's compiled `set metric' value. */
 452 static void route_set_metric_free(void *rule)
 453 {
 454         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 455 }
 456
 457 /* Set metric rule structure. */
 458 static const struct route_map_rule_cmd route_set_metric_cmd = {
 459         "metric",
 460         route_set_metric,
 461         route_set_metric_compile,
 462         route_set_metric_free,
 463 };
 464
 465 /* `set metric-type TYPE' */
 466 /* Set metric-type to attribute. */
 467 static enum route_map_cmd_result_t
 468 route_set_metric_type(void *rule, const struct prefix *prefix, void *object)
 469 {
 470         uint32_t *metric_type;
 471         struct external_info *ei;
 472
 473         /* Fetch routemap's rule information. */
 474         metric_type = rule;
 475         ei = object;
 476
 477         /* Set metric out value. */
 478         ei->route_map_set.metric_type = *metric_type;
 479
 480         return RMAP_OKAY;
 481 }
 482
 483 /* set metric-type compilation. */
 484 static void *route_set_metric_type_compile(const char *arg)
 485 {
 486         uint32_t *metric_type;
 487
 488         metric_type = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
 489         if (strcmp(arg, "type-1") == 0)
 490                 *metric_type = EXTERNAL_METRIC_TYPE_1;
 491         else if (strcmp(arg, "type-2") == 0)
 492                 *metric_type = EXTERNAL_METRIC_TYPE_2;
 493
 494         if (*metric_type == EXTERNAL_METRIC_TYPE_1
 495             || *metric_type == EXTERNAL_METRIC_TYPE_2)
 496                 return metric_type;
 497
 498         XFREE(MTYPE_ROUTE_MAP_COMPILED, metric_type);
 499         return NULL;
 500 }
 501
 502 /* Free route map's compiled `set metric-type' value. */
 503 static void route_set_metric_type_free(void *rule)
 504 {
 505         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 506 }
 507
 508 /* Set metric rule structure. */
 509 static const struct route_map_rule_cmd route_set_metric_type_cmd = {
 510         "metric-type",
 511         route_set_metric_type,
 512         route_set_metric_type_compile,
 513         route_set_metric_type_free,
 514 };
 515
 516 static enum route_map_cmd_result_t
 517 route_set_tag(void *rule, const struct prefix *prefix, void *object)
 518 {
 519         route_tag_t *tag;
 520         struct external_info *ei;
 521
 522         tag = rule;
 523         ei = object;
 524
 525         /* Set tag value */
 526         ei->tag = *tag;
 527
 528         return RMAP_OKAY;
 529 }
 530
 531 /* Route map commands for tag set. */
 532 static const struct route_map_rule_cmd route_set_tag_cmd = {
 533         "tag",
 534         route_set_tag,
 535         route_map_rule_tag_compile,
 536         route_map_rule_tag_free,
 537 };
 538
 539 DEFUN_YANG (set_metric_type,
 540        set_metric_type_cmd,
 541        "set metric-type <type-1|type-2>",
 542        SET_STR
 543        "Type of metric for destination routing protocol\n"
 544        "OSPF[6] external type 1 metric\n"
 545        "OSPF[6] external type 2 metric\n")
 546 {
 547         char *ext = argv[2]->text;
 548
 549         const char *xpath =
 550                 "./set-action[action='frr-ospf-route-map:metric-type']";
 551         char xpath_value[XPATH_MAXLEN];
 552
 553         nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
 554         snprintf(xpath_value, sizeof(xpath_value),
 555                  "%s/rmap-set-action/frr-ospf-route-map:metric-type", xpath);
 556         nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, ext);
 557         return nb_cli_apply_changes(vty, NULL);
 558 }
 559
 560 DEFUN_YANG (no_set_metric_type,
 561        no_set_metric_type_cmd,
 562        "no set metric-type [<type-1|type-2>]",
 563        NO_STR
 564        SET_STR
 565        "Type of metric for destination routing protocol\n"
 566        "OSPF[6] external type 1 metric\n"
 567        "OSPF[6] external type 2 metric\n")
 568 {
 569         const char *xpath =
 570                 "./set-action[action='frr-ospf-route-map:metric-type']";
 571
 572         nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
 573         return nb_cli_apply_changes(vty, NULL);
 574 }
 575
 576 /* Route-map init */
 577 void ospf_route_map_init(void)
 578 {
 579         route_map_init();
 580
 581         route_map_add_hook(ospf_route_map_update);
 582         route_map_delete_hook(ospf_route_map_update);
 583         route_map_event_hook(ospf_route_map_event);
 584
 585         route_map_set_metric_hook(generic_set_add);
 586         route_map_no_set_metric_hook(generic_set_delete);
 587
 588         route_map_match_ip_next_hop_hook(generic_match_add);
 589         route_map_no_match_ip_next_hop_hook(generic_match_delete);
 590
 591         route_map_match_interface_hook(generic_match_add);
 592         route_map_no_match_interface_hook(generic_match_delete);
 593
 594         route_map_match_ip_address_hook(generic_match_add);
 595         route_map_no_match_ip_address_hook(generic_match_delete);
 596
 597         route_map_match_ip_address_prefix_list_hook(generic_match_add);
 598         route_map_no_match_ip_address_prefix_list_hook(generic_match_delete);
 599
 600         route_map_match_ip_next_hop_prefix_list_hook(generic_match_add);
 601         route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete);
 602
 603         route_map_match_ip_next_hop_type_hook(generic_match_add);
 604         route_map_no_match_ip_next_hop_type_hook(generic_match_delete);
 605
 606         route_map_match_tag_hook(generic_match_add);
 607         route_map_no_match_tag_hook(generic_match_delete);
 608
 609         route_map_set_metric_hook(generic_set_add);
 610         route_map_no_set_metric_hook(generic_set_delete);
 611
 612         route_map_set_tag_hook(generic_set_add);
 613         route_map_no_set_tag_hook(generic_set_delete);
 614
 615         route_map_install_match(&route_match_ip_nexthop_cmd);
 616         route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd);
 617         route_map_install_match(&route_match_ip_address_cmd);
 618         route_map_install_match(&route_match_ip_address_prefix_list_cmd);
 619         route_map_install_match(&route_match_ip_next_hop_type_cmd);
 620         route_map_install_match(&route_match_interface_cmd);
 621         route_map_install_match(&route_match_tag_cmd);
 622
 623         route_map_install_set(&route_set_metric_cmd);
 624         route_map_install_set(&route_set_metric_type_cmd);
 625         route_map_install_set(&route_set_tag_cmd);
 626
 627         install_element(RMAP_NODE, &set_metric_type_cmd);
 628         install_element(RMAP_NODE, &no_set_metric_type_cmd);
 629 }