ospfd/ospf_routemap.c

   1 /*
   2  * Route map function of ospfd.
   3  * Copyright (C) 2000 IP Infusion Inc.
   4  *
   5  * Written by Toshiaki Takada.
   6  *
   7  * This file is part of GNU Zebra.
   8  *
   9  * GNU Zebra is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by the
  11  * Free Software Foundation; either version 2, or (at your option) any
  12  * later version.
  13  *
  14  * GNU Zebra is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; see the file COPYING; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include <zebra.h>
  25
  26 #include "memory.h"
  27 #include "prefix.h"
  28 #include "table.h"
  29 #include "vty.h"
  30 #include "routemap.h"
  31 #include "command.h"
  32 #include "log.h"
  33 #include "plist.h"
  34 #include "vrf.h"
  35 #include "frrstr.h"
  36
  37 #include "ospfd/ospfd.h"
  38 #include "ospfd/ospf_asbr.h"
  39 #include "ospfd/ospf_interface.h"
  40 #include "ospfd/ospf_lsa.h"
  41 #include "ospfd/ospf_route.h"
  42 #include "ospfd/ospf_zebra.h"
  43 #include "ospfd/ospf_errors.h"
  44
  45 /* Hook function for updating route_map assignment. */
  46 static void ospf_route_map_update(const char *name)
  47 {
  48         struct ospf *ospf;
  49         int type;
  50         struct listnode *n1 = NULL;
  51
  52         /* If OSPF instatnce does not exist, return right now. */
  53         if (listcount(om->ospf) == 0)
  54                 return;
  55
  56         for (ALL_LIST_ELEMENTS_RO(om->ospf, n1, ospf)) {
  57                 /* Update route-map */
  58                 for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
  59                         struct list *red_list;
  60                         struct listnode *node;
  61                         struct ospf_redist *red;
  62
  63                         red_list = ospf->redist[type];
  64                         if (!red_list)
  65                                 continue;
  66
  67                         for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
  68                                 if (ROUTEMAP_NAME(red)
  69                                     && strcmp(ROUTEMAP_NAME(red), name) == 0) {
  70                                         /* Keep old route-map. */
  71                                         struct route_map *old = ROUTEMAP(red);
  72
  73                                         if (!old) {
  74                                                 /* Route-map creation */
  75                                                 /* Update route-map. */
  76                                                 ROUTEMAP(red) =
  77                                                         route_map_lookup_by_name(
  78                                                                 ROUTEMAP_NAME(red));
  79
  80                                                         route_map_counter_increment(
  81                                                                 ROUTEMAP(red));
  82                                         } else {
  83                                                 /* Route-map deletion */
  84                                                 ROUTEMAP(red) = NULL;
  85                                         }
  86                                         /* No update for this distribute type.
  87                                          */
  88                                         if (old == NULL
  89                                             && ROUTEMAP(red) == NULL)
  90                                                 continue;
  91
  92                                         ospf_distribute_list_update(
  93                                                 ospf, type, red->instance);
  94                                 }
  95                         }
  96                 }
  97         }
  98 }
  99
 100 static void ospf_route_map_event(route_map_event_t event, const char *name)
 101 {
 102         struct ospf *ospf;
 103         int type;
 104         struct listnode *n1 = NULL;
 105
 106         for (ALL_LIST_ELEMENTS_RO(om->ospf, n1, ospf)) {
 107                 for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
 108                         struct list *red_list;
 109                         struct listnode *node;
 110                         struct ospf_redist *red;
 111
 112                         red_list = ospf->redist[type];
 113                         if (!red_list)
 114                                 continue;
 115
 116                         for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
 117                                 if (ROUTEMAP_NAME(red) && ROUTEMAP(red)
 118                                     && !strcmp(ROUTEMAP_NAME(red), name)) {
 119                                         ospf_distribute_list_update(
 120                                                 ospf, type, red->instance);
 121                                 }
 122                         }
 123                 }
 124         }
 125 }
 126
 127 /* `match ip netxthop ' */
 128 /* Match function return 1 if match is success else return zero. */
 129 static route_map_result_t route_match_ip_nexthop(void *rule,
 130                                                  const struct prefix *prefix,
 131                                                  route_map_object_t type,
 132                                                  void *object)
 133 {
 134         struct access_list *alist;
 135         struct external_info *ei = object;
 136         struct prefix_ipv4 p;
 137
 138         if (type == RMAP_OSPF) {
 139                 p.family = AF_INET;
 140                 p.prefix = ei->nexthop;
 141                 p.prefixlen = IPV4_MAX_BITLEN;
 142
 143                 alist = access_list_lookup(AFI_IP, (char *)rule);
 144                 if (alist == NULL)
 145                         return RMAP_NOMATCH;
 146
 147                 return (access_list_apply(alist, &p) == FILTER_DENY
 148                                 ? RMAP_NOMATCH
 149                                 : RMAP_MATCH);
 150         }
 151         return RMAP_NOMATCH;
 152 }
 153
 154 /* Route map `ip next-hop' match statement. `arg' should be
 155    access-list name. */
 156 static void *route_match_ip_nexthop_compile(const char *arg)
 157 {
 158         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 159 }
 160
 161 /* Free route map's compiled `ip address' value. */
 162 static void route_match_ip_nexthop_free(void *rule)
 163 {
 164         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 165 }
 166
 167 /* Route map commands for metric matching. */
 168 struct route_map_rule_cmd route_match_ip_nexthop_cmd = {
 169         "ip next-hop", route_match_ip_nexthop, route_match_ip_nexthop_compile,
 170         route_match_ip_nexthop_free};
 171
 172 /* `match ip next-hop prefix-list PREFIX_LIST' */
 173
 174 static route_map_result_t
 175 route_match_ip_next_hop_prefix_list(void *rule, const struct prefix *prefix,
 176                                     route_map_object_t type, void *object)
 177 {
 178         struct prefix_list *plist;
 179         struct external_info *ei = object;
 180         struct prefix_ipv4 p;
 181
 182         if (type == RMAP_OSPF) {
 183                 p.family = AF_INET;
 184                 p.prefix = ei->nexthop;
 185                 p.prefixlen = IPV4_MAX_BITLEN;
 186
 187                 plist = prefix_list_lookup(AFI_IP, (char *)rule);
 188                 if (plist == NULL)
 189                         return RMAP_NOMATCH;
 190
 191                 return (prefix_list_apply(plist, &p) == PREFIX_DENY
 192                                 ? RMAP_NOMATCH
 193                                 : RMAP_MATCH);
 194         }
 195         return RMAP_NOMATCH;
 196 }
 197
 198 static void *route_match_ip_next_hop_prefix_list_compile(const char *arg)
 199 {
 200         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 201 }
 202
 203 static void route_match_ip_next_hop_prefix_list_free(void *rule)
 204 {
 205         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 206 }
 207
 208 struct route_map_rule_cmd route_match_ip_next_hop_prefix_list_cmd = {
 209         "ip next-hop prefix-list", route_match_ip_next_hop_prefix_list,
 210         route_match_ip_next_hop_prefix_list_compile,
 211         route_match_ip_next_hop_prefix_list_free};
 212
 213 /* `match ip next-hop type <blackhole>' */
 214
 215 static route_map_result_t
 216 route_match_ip_next_hop_type(void *rule, const struct prefix *prefix,
 217                              route_map_object_t type, void *object)
 218 {
 219         struct external_info *ei = object;
 220
 221         if (type == RMAP_OSPF && prefix->family == AF_INET) {
 222                 ei = (struct external_info *)object;
 223                 if (!ei)
 224                         return RMAP_DENYMATCH;
 225
 226                 if (ei->nexthop.s_addr == INADDR_ANY && !ei->ifindex)
 227                         return RMAP_MATCH;
 228         }
 229         return RMAP_NOMATCH;
 230 }
 231
 232 static void *route_match_ip_next_hop_type_compile(const char *arg)
 233 {
 234         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 235 }
 236
 237 static void route_match_ip_next_hop_type_free(void *rule)
 238 {
 239         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 240 }
 241
 242 static struct route_map_rule_cmd route_match_ip_next_hop_type_cmd = {
 243         "ip next-hop type", route_match_ip_next_hop_type,
 244         route_match_ip_next_hop_type_compile,
 245         route_match_ip_next_hop_type_free};
 246
 247 /* `match ip address IP_ACCESS_LIST' */
 248 /* Match function should return 1 if match is success else return
 249    zero. */
 250 static route_map_result_t route_match_ip_address(void *rule,
 251                                                  const struct prefix *prefix,
 252                                                  route_map_object_t type,
 253                                                  void *object)
 254 {
 255         struct access_list *alist;
 256         /* struct prefix_ipv4 match; */
 257
 258         if (type == RMAP_OSPF) {
 259                 alist = access_list_lookup(AFI_IP, (char *)rule);
 260                 if (alist == NULL)
 261                         return RMAP_NOMATCH;
 262
 263                 return (access_list_apply(alist, prefix) == FILTER_DENY
 264                                 ? RMAP_NOMATCH
 265                                 : RMAP_MATCH);
 266         }
 267         return RMAP_NOMATCH;
 268 }
 269
 270 /* Route map `ip address' match statement.  `arg' should be
 271    access-list name. */
 272 static void *route_match_ip_address_compile(const char *arg)
 273 {
 274         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 275 }
 276
 277 /* Free route map's compiled `ip address' value. */
 278 static void route_match_ip_address_free(void *rule)
 279 {
 280         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 281 }
 282
 283 /* Route map commands for ip address matching. */
 284 struct route_map_rule_cmd route_match_ip_address_cmd = {
 285         "ip address", route_match_ip_address, route_match_ip_address_compile,
 286         route_match_ip_address_free};
 287
 288 /* `match ip address prefix-list PREFIX_LIST' */
 289 static route_map_result_t
 290 route_match_ip_address_prefix_list(void *rule, const struct prefix *prefix,
 291                                    route_map_object_t type, void *object)
 292 {
 293         struct prefix_list *plist;
 294
 295         if (type == RMAP_OSPF) {
 296                 plist = prefix_list_lookup(AFI_IP, (char *)rule);
 297                 if (plist == NULL)
 298                         return RMAP_NOMATCH;
 299
 300                 return (prefix_list_apply(plist, prefix) == PREFIX_DENY
 301                                 ? RMAP_NOMATCH
 302                                 : RMAP_MATCH);
 303         }
 304         return RMAP_NOMATCH;
 305 }
 306
 307 static void *route_match_ip_address_prefix_list_compile(const char *arg)
 308 {
 309         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 310 }
 311
 312 static void route_match_ip_address_prefix_list_free(void *rule)
 313 {
 314         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 315 }
 316
 317 struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd = {
 318         "ip address prefix-list", route_match_ip_address_prefix_list,
 319         route_match_ip_address_prefix_list_compile,
 320         route_match_ip_address_prefix_list_free};
 321
 322 /* `match interface IFNAME' */
 323 /* Match function should return 1 if match is success else return
 324    zero. */
 325 static route_map_result_t route_match_interface(void *rule,
 326                                                 const struct prefix *prefix,
 327                                                 route_map_object_t type,
 328                                                 void *object)
 329 {
 330         struct interface *ifp;
 331         struct external_info *ei;
 332
 333         if (type == RMAP_OSPF) {
 334                 ei = object;
 335                 ifp = if_lookup_by_name_all_vrf((char *)rule);
 336
 337                 if (ifp == NULL || ifp->ifindex != ei->ifindex)
 338                         return RMAP_NOMATCH;
 339
 340                 return RMAP_MATCH;
 341         }
 342         return RMAP_NOMATCH;
 343 }
 344
 345 /* Route map `interface' match statement.  `arg' should be
 346    interface name. */
 347 static void *route_match_interface_compile(const char *arg)
 348 {
 349         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 350 }
 351
 352 /* Free route map's compiled `interface' value. */
 353 static void route_match_interface_free(void *rule)
 354 {
 355         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 356 }
 357
 358 /* Route map commands for ip address matching. */
 359 struct route_map_rule_cmd route_match_interface_cmd = {
 360         "interface", route_match_interface, route_match_interface_compile,
 361         route_match_interface_free};
 362
 363 /* Match function return 1 if match is success else return zero. */
 364 static route_map_result_t route_match_tag(void *rule,
 365                                           const struct prefix *prefix,
 366                                           route_map_object_t type, void *object)
 367 {
 368         route_tag_t *tag;
 369         struct external_info *ei;
 370
 371         if (type == RMAP_OSPF) {
 372                 tag = rule;
 373                 ei = object;
 374
 375                 return ((ei->tag == *tag) ? RMAP_MATCH : RMAP_NOMATCH);
 376         }
 377
 378         return RMAP_NOMATCH;
 379 }
 380
 381 /* Route map commands for tag matching. */
 382 static struct route_map_rule_cmd route_match_tag_cmd = {
 383         "tag", route_match_tag, route_map_rule_tag_compile,
 384         route_map_rule_tag_free,
 385 };
 386
 387 struct ospf_metric {
 388         enum { metric_increment, metric_decrement, metric_absolute } type;
 389         bool used;
 390         uint32_t metric;
 391 };
 392
 393 /* `set metric METRIC' */
 394 /* Set metric to attribute. */
 395 static route_map_result_t route_set_metric(void *rule,
 396                                            const struct prefix *prefix,
 397                                            route_map_object_t type,
 398                                            void *object)
 399 {
 400         struct ospf_metric *metric;
 401         struct external_info *ei;
 402
 403         if (type == RMAP_OSPF) {
 404                 /* Fetch routemap's rule information. */
 405                 metric = rule;
 406                 ei = object;
 407
 408                 /* Set metric out value. */
 409                 if (!metric->used)
 410                         return RMAP_OKAY;
 411
 412                 ei->route_map_set.metric = DEFAULT_DEFAULT_METRIC;
 413
 414                 if (metric->type == metric_increment)
 415                         ei->route_map_set.metric += metric->metric;
 416                 else if (metric->type == metric_decrement)
 417                         ei->route_map_set.metric -= metric->metric;
 418                 else if (metric->type == metric_absolute)
 419                         ei->route_map_set.metric = metric->metric;
 420
 421                 if (ei->route_map_set.metric > OSPF_LS_INFINITY)
 422                         ei->route_map_set.metric = OSPF_LS_INFINITY;
 423         }
 424         return RMAP_OKAY;
 425 }
 426
 427 /* set metric compilation. */
 428 static void *route_set_metric_compile(const char *arg)
 429 {
 430         struct ospf_metric *metric;
 431
 432         metric = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
 433         metric->used = false;
 434
 435         if (all_digit(arg))
 436                 metric->type = metric_absolute;
 437
 438         if (strmatch(arg, "+rtt") || strmatch(arg, "-rtt")) {
 439                 flog_warn(EC_OSPF_SET_METRIC_PLUS,
 440                           "OSPF does not support 'set metric +rtt / -rtt'");
 441                 return metric;
 442         }
 443
 444         if ((arg[0] == '+') && all_digit(arg + 1)) {
 445                 metric->type = metric_increment;
 446                 arg++;
 447         }
 448
 449         if ((arg[0] == '-') && all_digit(arg + 1)) {
 450                 metric->type = metric_decrement;
 451                 arg++;
 452         }
 453
 454         metric->metric = strtoul(arg, NULL, 10);
 455
 456         if (metric->metric)
 457                 metric->used = true;
 458
 459         return metric;
 460 }
 461
 462 /* Free route map's compiled `set metric' value. */
 463 static void route_set_metric_free(void *rule)
 464 {
 465         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 466 }
 467
 468 /* Set metric rule structure. */
 469 struct route_map_rule_cmd route_set_metric_cmd = {
 470         "metric", route_set_metric, route_set_metric_compile,
 471         route_set_metric_free,
 472 };
 473
 474 /* `set metric-type TYPE' */
 475 /* Set metric-type to attribute. */
 476 static route_map_result_t route_set_metric_type(void *rule,
 477                                                 const struct prefix *prefix,
 478                                                 route_map_object_t type,
 479                                                 void *object)
 480 {
 481         uint32_t *metric_type;
 482         struct external_info *ei;
 483
 484         if (type == RMAP_OSPF) {
 485                 /* Fetch routemap's rule information. */
 486                 metric_type = rule;
 487                 ei = object;
 488
 489                 /* Set metric out value. */
 490                 ei->route_map_set.metric_type = *metric_type;
 491         }
 492         return RMAP_OKAY;
 493 }
 494
 495 /* set metric-type compilation. */
 496 static void *route_set_metric_type_compile(const char *arg)
 497 {
 498         uint32_t *metric_type;
 499
 500         metric_type = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
 501         if (strcmp(arg, "type-1") == 0)
 502                 *metric_type = EXTERNAL_METRIC_TYPE_1;
 503         else if (strcmp(arg, "type-2") == 0)
 504                 *metric_type = EXTERNAL_METRIC_TYPE_2;
 505
 506         if (*metric_type == EXTERNAL_METRIC_TYPE_1
 507             || *metric_type == EXTERNAL_METRIC_TYPE_2)
 508                 return metric_type;
 509
 510         XFREE(MTYPE_ROUTE_MAP_COMPILED, metric_type);
 511         return NULL;
 512 }
 513
 514 /* Free route map's compiled `set metric-type' value. */
 515 static void route_set_metric_type_free(void *rule)
 516 {
 517         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 518 }
 519
 520 /* Set metric rule structure. */
 521 struct route_map_rule_cmd route_set_metric_type_cmd = {
 522         "metric-type", route_set_metric_type, route_set_metric_type_compile,
 523         route_set_metric_type_free,
 524 };
 525
 526 static route_map_result_t route_set_tag(void *rule, const struct prefix *prefix,
 527                                         route_map_object_t type, void *object)
 528 {
 529         route_tag_t *tag;
 530         struct external_info *ei;
 531
 532         if (type == RMAP_OSPF) {
 533                 tag = rule;
 534                 ei = object;
 535
 536                 /* Set tag value */
 537                 ei->tag = *tag;
 538         }
 539
 540         return RMAP_OKAY;
 541 }
 542
 543 /* Route map commands for tag set. */
 544 static struct route_map_rule_cmd route_set_tag_cmd = {
 545         "tag", route_set_tag, route_map_rule_tag_compile,
 546         route_map_rule_tag_free,
 547 };
 548
 549 DEFUN (set_metric_type,
 550        set_metric_type_cmd,
 551        "set metric-type <type-1|type-2>",
 552        SET_STR
 553        "Type of metric for destination routing protocol\n"
 554        "OSPF[6] external type 1 metric\n"
 555        "OSPF[6] external type 2 metric\n")
 556 {
 557         char *ext = argv[2]->text;
 558         return generic_set_add(vty, VTY_GET_CONTEXT(route_map_index),
 559                                "metric-type", ext);
 560 }
 561
 562 DEFUN (no_set_metric_type,
 563        no_set_metric_type_cmd,
 564        "no set metric-type [<type-1|type-2>]",
 565        NO_STR
 566        SET_STR
 567        "Type of metric for destination routing protocol\n"
 568        "OSPF[6] external type 1 metric\n"
 569        "OSPF[6] external type 2 metric\n")
 570 {
 571         char *ext = (argc == 4) ? argv[3]->text : NULL;
 572         return generic_set_delete(vty, VTY_GET_CONTEXT(route_map_index),
 573                                   "metric-type", ext);
 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 }