isisd/isis_routemap.c

   1 /*
   2  * IS-IS Rout(e)ing protocol - isis_routemap.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; if not, write to the Free Software Foundation, Inc.,
  18  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "command.h"
  24 #include "filter.h"
  25 #include "hash.h"
  26 #include "if.h"
  27 #include "linklist.h"
  28 #include "log.h"
  29 #include "memory.h"
  30 #include "prefix.h"
  31 #include "plist.h"
  32 #include "routemap.h"
  33 #include "table.h"
  34 #include "thread.h"
  35 #include "vty.h"
  36
  37 #include "isis_constants.h"
  38 #include "isis_common.h"
  39 #include "isis_flags.h"
  40 #include "dict.h"
  41 #include "isisd.h"
  42 #include "isis_misc.h"
  43 #include "isis_adjacency.h"
  44 #include "isis_circuit.h"
  45 #include "isis_tlv.h"
  46 #include "isis_pdu.h"
  47 #include "isis_lsp.h"
  48 #include "isis_spf.h"
  49 #include "isis_route.h"
  50 #include "isis_zebra.h"
  51 #include "isis_routemap.h"
  52
  53 static route_map_result_t
  54 route_match_ip_address(void *rule, struct prefix *prefix,
  55                        route_map_object_t type, void *object)
  56 {
  57   struct access_list *alist;
  58
  59   if (type != RMAP_ISIS)
  60     return RMAP_NOMATCH;
  61
  62   alist = access_list_lookup(AFI_IP, (char*)rule);
  63   if (access_list_apply(alist, prefix) != FILTER_DENY)
  64     return RMAP_MATCH;
  65
  66   return RMAP_NOMATCH;
  67 }
  68
  69 static void *
  70 route_match_ip_address_compile(const char *arg)
  71 {
  72   return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
  73 }
  74
  75 static void
  76 route_match_ip_address_free(void *rule)
  77 {
  78   XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
  79 }
  80
  81 static struct route_map_rule_cmd route_match_ip_address_cmd =
  82 {
  83   "ip address",
  84   route_match_ip_address,
  85   route_match_ip_address_compile,
  86   route_match_ip_address_free
  87 };
  88
  89 /* ------------------------------------------------------------*/
  90
  91 static route_map_result_t
  92 route_match_ip_address_prefix_list(void *rule, struct prefix *prefix,
  93                                    route_map_object_t type, void *object)
  94 {
  95   struct prefix_list *plist;
  96
  97   if (type != RMAP_ISIS)
  98     return RMAP_NOMATCH;
  99
 100   plist = prefix_list_lookup(AFI_IP, (char*)rule);
 101   if (prefix_list_apply(plist, prefix) != PREFIX_DENY)
 102     return RMAP_MATCH;
 103
 104   return RMAP_NOMATCH;
 105 }
 106
 107 static void *
 108 route_match_ip_address_prefix_list_compile(const char *arg)
 109 {
 110   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
 111 }
 112
 113 static void
 114 route_match_ip_address_prefix_list_free (void *rule)
 115 {
 116   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 117 }
 118
 119 struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd =
 120 {
 121   "ip address prefix-list",
 122   route_match_ip_address_prefix_list,
 123   route_match_ip_address_prefix_list_compile,
 124   route_match_ip_address_prefix_list_free
 125 };
 126
 127 /* ------------------------------------------------------------*/
 128
 129 static route_map_result_t
 130 route_match_ipv6_address(void *rule, struct prefix *prefix,
 131                          route_map_object_t type, void *object)
 132 {
 133   struct access_list *alist;
 134
 135   if (type != RMAP_ISIS)
 136     return RMAP_NOMATCH;
 137
 138   alist = access_list_lookup(AFI_IP6, (char*)rule);
 139   if (access_list_apply(alist, prefix) != FILTER_DENY)
 140     return RMAP_MATCH;
 141
 142   return RMAP_NOMATCH;
 143 }
 144
 145 static void *
 146 route_match_ipv6_address_compile(const char *arg)
 147 {
 148   return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 149 }
 150
 151 static void
 152 route_match_ipv6_address_free(void *rule)
 153 {
 154   XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 155 }
 156
 157 static struct route_map_rule_cmd route_match_ipv6_address_cmd =
 158 {
 159   "ipv6 address",
 160   route_match_ipv6_address,
 161   route_match_ipv6_address_compile,
 162   route_match_ipv6_address_free
 163 };
 164
 165 /* ------------------------------------------------------------*/
 166
 167 static route_map_result_t
 168 route_match_ipv6_address_prefix_list(void *rule, struct prefix *prefix,
 169                                      route_map_object_t type, void *object)
 170 {
 171   struct prefix_list *plist;
 172
 173   if (type != RMAP_ISIS)
 174     return RMAP_NOMATCH;
 175
 176   plist = prefix_list_lookup(AFI_IP6, (char*)rule);
 177   if (prefix_list_apply(plist, prefix) != PREFIX_DENY)
 178     return RMAP_MATCH;
 179
 180   return RMAP_NOMATCH;
 181 }
 182
 183 static void *
 184 route_match_ipv6_address_prefix_list_compile(const char *arg)
 185 {
 186   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
 187 }
 188
 189 static void
 190 route_match_ipv6_address_prefix_list_free (void *rule)
 191 {
 192   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 193 }
 194
 195 struct route_map_rule_cmd route_match_ipv6_address_prefix_list_cmd =
 196 {
 197   "ipv6 address prefix-list",
 198   route_match_ipv6_address_prefix_list,
 199   route_match_ipv6_address_prefix_list_compile,
 200   route_match_ipv6_address_prefix_list_free
 201 };
 202
 203 /* ------------------------------------------------------------*/
 204
 205 static route_map_result_t
 206 route_set_metric(void *rule, struct prefix *prefix,
 207                  route_map_object_t type, void *object)
 208 {
 209   uint32_t *metric;
 210   struct isis_ext_info *info;
 211
 212   if (type == RMAP_ISIS)
 213     {
 214       metric = rule;
 215       info = object;
 216
 217       info->metric = *metric;
 218     }
 219   return RMAP_OKAY;
 220 }
 221
 222 static void *
 223 route_set_metric_compile(const char *arg)
 224 {
 225   unsigned long metric;
 226   char *endp;
 227   uint32_t *ret;
 228
 229   metric = strtoul(arg, &endp, 10);
 230   if (arg[0] == '\0' || *endp != '\0' || metric > MAX_WIDE_PATH_METRIC)
 231     return NULL;
 232
 233   ret = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(ret));
 234   *ret = metric;
 235
 236   return ret;
 237 }
 238
 239 static void
 240 route_set_metric_free(void *rule)
 241 {
 242   XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 243 }
 244
 245 static struct route_map_rule_cmd route_set_metric_cmd =
 246 {
 247   "metric",
 248   route_set_metric,
 249   route_set_metric_compile,
 250   route_set_metric_free
 251 };
 252
 253 /* ------------------------------------------------------------*/
 254
 255 static int
 256 isis_route_match_add(struct vty *vty, struct route_map_index *index,
 257                       const char *command, const char *arg)
 258 {
 259   int ret;
 260
 261   ret = route_map_add_match (index, command, arg);
 262   if (ret)
 263     {
 264       switch (ret)
 265         {
 266         case RMAP_RULE_MISSING:
 267           vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
 268           return CMD_WARNING;
 269         case RMAP_COMPILE_ERROR:
 270           vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
 271           return CMD_WARNING;
 272         }
 273     }
 274   return CMD_SUCCESS;
 275 }
 276
 277 static int
 278 isis_route_match_delete(struct vty *vty, struct route_map_index *index,
 279                         const char *command, const char *arg)
 280 {
 281   int ret;
 282
 283   ret = route_map_delete_match (index, command, arg);
 284   if (ret)
 285     {
 286       switch (ret)
 287         {
 288         case RMAP_RULE_MISSING:
 289           vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
 290           return CMD_WARNING;
 291         case RMAP_COMPILE_ERROR:
 292           vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
 293           return CMD_WARNING;
 294         }
 295     }
 296   return CMD_SUCCESS;
 297 }
 298
 299 static int
 300 isis_route_set_add(struct vty *vty, struct route_map_index *index,
 301                    const char *command, const char *arg)
 302 {
 303   int ret;
 304
 305   ret = route_map_add_set(index, command, arg);
 306   if (ret)
 307     {
 308       switch (ret)
 309         {
 310         case RMAP_RULE_MISSING:
 311           vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
 312           return CMD_WARNING;
 313         case RMAP_COMPILE_ERROR:
 314           vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
 315           return CMD_WARNING;
 316         }
 317     }
 318
 319   return CMD_SUCCESS;
 320 }
 321
 322 static int
 323 isis_route_set_delete (struct vty *vty, struct route_map_index *index,
 324                        const char *command, const char *arg)
 325 {
 326   int ret;
 327
 328   ret = route_map_delete_set (index, command, arg);
 329   if (ret)
 330     {
 331       switch (ret)
 332         {
 333         case RMAP_RULE_MISSING:
 334           vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
 335           return CMD_WARNING;
 336         case RMAP_COMPILE_ERROR:
 337           vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
 338           return CMD_WARNING;
 339         }
 340     }
 341
 342   return CMD_SUCCESS;
 343 }
 344
 345 /* ------------------------------------------------------------*/
 346
 347 DEFUN (match_ip_address,
 348        match_ip_address_cmd,
 349        "match ip address (<1-199>|<1300-2699>|WORD)",
 350        MATCH_STR
 351        IP_STR
 352        "Match address of route\n"
 353        "IP access-list number\n"
 354        "IP access-list number (expanded range)\n"
 355        "IP Access-list name\n")
 356 {
 357   return isis_route_match_add(vty, vty->index, "ip address", argv[0]->arg);
 358 }
 359
 360 DEFUN (no_match_ip_address,
 361        no_match_ip_address_val_cmd,
 362        "no match ip address (<1-199>|<1300-2699>|WORD)",
 363        NO_STR
 364        MATCH_STR
 365        IP_STR
 366        "Match address of route\n"
 367        "IP access-list number\n"
 368        "IP access-list number (expanded range)\n"
 369        "IP Access-list name\n")
 370 {
 371   if (argc == 0)
 372     return isis_route_match_delete(vty, vty->index, "ip address", NULL);
 373   return isis_route_match_delete(vty, vty->index, "ip address", argv[0]->arg);
 374 }
 375
 376 ALIAS (no_match_ip_address,
 377        no_match_ip_address_cmd,
 378        "no match ip address",
 379        NO_STR
 380        MATCH_STR
 381        IP_STR
 382        "Match address of route\n")
 383
 384 /* ------------------------------------------------------------*/
 385
 386 DEFUN (match_ip_address_prefix_list,
 387        match_ip_address_prefix_list_cmd,
 388        "match ip address prefix-list WORD",
 389        MATCH_STR
 390        IP_STR
 391        "Match address of route\n"
 392        "Match entries of prefix-lists\n"
 393        "IP prefix-list name\n")
 394 {
 395   return isis_route_match_add(vty, vty->index, "ip address prefix-list", argv[0]->arg);
 396 }
 397
 398 DEFUN (no_match_ip_address_prefix_list,
 399        no_match_ip_address_prefix_list_cmd,
 400        "no match ip address prefix-list",
 401        NO_STR
 402        MATCH_STR
 403        IP_STR
 404        "Match address of route\n"
 405        "Match entries of prefix-lists\n")
 406 {
 407   if (argc == 0)
 408     return isis_route_match_delete (vty, vty->index, "ip address prefix-list", NULL);
 409   return isis_route_match_delete (vty, vty->index, "ip address prefix-list", argv[0]->arg);
 410 }
 411
 412 ALIAS (no_match_ip_address_prefix_list,
 413        no_match_ip_address_prefix_list_val_cmd,
 414        "no match ip address prefix-list WORD",
 415        NO_STR
 416        MATCH_STR
 417        IP_STR
 418        "Match address of route\n"
 419        "Match entries of prefix-lists\n"
 420        "IP prefix-list name\n")
 421
 422 /* ------------------------------------------------------------*/
 423
 424 DEFUN (match_ipv6_address,
 425        match_ipv6_address_cmd,
 426        "match ipv6 address WORD",
 427        MATCH_STR
 428        IPV6_STR
 429        "Match IPv6 address of route\n"
 430        "IPv6 access-list name\n")
 431 {
 432   return isis_route_match_add(vty, vty->index, "ipv6 address", argv[0]->arg);
 433 }
 434
 435 DEFUN (no_match_ipv6_address,
 436        no_match_ipv6_address_val_cmd,
 437        "no match ipv6 address WORD",
 438        NO_STR
 439        MATCH_STR
 440        IPV6_STR
 441        "Match IPv6 address of route\n"
 442        "IPv6 access-list name\n")
 443 {
 444   if (argc == 0)
 445     return isis_route_match_delete(vty, vty->index, "ipv6 address", NULL);
 446   return isis_route_match_delete(vty, vty->index, "ipv6 address", argv[0]->arg);
 447 }
 448
 449 ALIAS (no_match_ipv6_address,
 450        no_match_ipv6_address_cmd,
 451        "no match ipv6 address",
 452        NO_STR
 453        MATCH_STR
 454        IPV6_STR
 455        "Match IPv6 address of route\n")
 456
 457 /* ------------------------------------------------------------*/
 458
 459 DEFUN (match_ipv6_address_prefix_list,
 460        match_ipv6_address_prefix_list_cmd,
 461        "match ipv6 address prefix-list WORD",
 462        MATCH_STR
 463        IPV6_STR
 464        "Match address of route\n"
 465        "Match entries of prefix-lists\n"
 466        "IP prefix-list name\n")
 467 {
 468   return isis_route_match_add(vty, vty->index, "ipv6 address prefix-list", argv[0]->arg);
 469 }
 470
 471 DEFUN (no_match_ipv6_address_prefix_list,
 472        no_match_ipv6_address_prefix_list_cmd,
 473        "no match ipv6 address prefix-list",
 474        NO_STR
 475        MATCH_STR
 476        IPV6_STR
 477        "Match address of route\n"
 478        "Match entries of prefix-lists\n")
 479 {
 480   if (argc == 0)
 481     return isis_route_match_delete (vty, vty->index, "ipv6 address prefix-list", NULL);
 482   return isis_route_match_delete (vty, vty->index, "ipv6 address prefix-list", argv[0]->arg);
 483 }
 484
 485 ALIAS (no_match_ipv6_address_prefix_list,
 486        no_match_ipv6_address_prefix_list_val_cmd,
 487        "no match ipv6 address prefix-list WORD",
 488        NO_STR
 489        MATCH_STR
 490        IPV6_STR
 491        "Match address of route\n"
 492        "Match entries of prefix-lists\n"
 493        "IP prefix-list name\n")
 494
 495 /* ------------------------------------------------------------*/
 496
 497 /* set metric already exists e.g. in the ospf routemap. vtysh doesn't cope well with different
 498  * commands at the same node, therefore add set metric with the same 32-bit range as ospf and
 499  * verify that the input is a valid isis metric */
 500 DEFUN (set_metric,
 501       set_metric_cmd,
 502       "set metric <0-4294967295>",
 503       SET_STR
 504       "Metric vale for destination routing protocol\n"
 505       "Metric value\n")
 506 {
 507   return isis_route_set_add(vty, vty->index, "metric", argv[0]->arg);
 508 }
 509
 510 DEFUN (no_set_metric,
 511       no_set_metric_val_cmd,
 512       "no set metric <0-4294967295>",
 513       NO_STR
 514       SET_STR
 515       "Metric value for destination routing protocol\n"
 516       "Metric value\n")
 517 {
 518   if (argc == 0)
 519     return isis_route_set_delete(vty, vty->index, "metric", NULL);
 520   return isis_route_set_delete(vty, vty->index, "metric", argv[0]->arg);
 521 }
 522
 523 ALIAS (no_set_metric,
 524        no_set_metric_cmd,
 525        "no set metric",
 526        NO_STR
 527        SET_STR
 528        "Metric vale for destination routing protocol\n");
 529
 530 void
 531 isis_route_map_init(void)
 532 {
 533   route_map_init();
 534   route_map_init_vty();
 535
 536   route_map_install_match(&route_match_ip_address_cmd);
 537   install_element(RMAP_NODE, &match_ip_address_cmd);
 538   install_element(RMAP_NODE, &no_match_ip_address_val_cmd);
 539   install_element(RMAP_NODE, &no_match_ip_address_cmd);
 540
 541   route_map_install_match(&route_match_ip_address_prefix_list_cmd);
 542   install_element(RMAP_NODE, &match_ip_address_prefix_list_cmd);
 543   install_element(RMAP_NODE, &no_match_ip_address_prefix_list_val_cmd);
 544   install_element(RMAP_NODE, &no_match_ip_address_prefix_list_cmd);
 545
 546   route_map_install_match(&route_match_ipv6_address_cmd);
 547   install_element(RMAP_NODE, &match_ipv6_address_cmd);
 548   install_element(RMAP_NODE, &no_match_ipv6_address_val_cmd);
 549   install_element(RMAP_NODE, &no_match_ipv6_address_cmd);
 550
 551   route_map_install_match(&route_match_ipv6_address_prefix_list_cmd);
 552   install_element(RMAP_NODE, &match_ipv6_address_prefix_list_cmd);
 553   install_element(RMAP_NODE, &no_match_ipv6_address_prefix_list_val_cmd);
 554   install_element(RMAP_NODE, &no_match_ipv6_address_prefix_list_cmd);
 555
 556   route_map_install_set(&route_set_metric_cmd);
 557   install_element(RMAP_NODE, &set_metric_cmd);
 558   install_element(RMAP_NODE, &no_set_metric_val_cmd);
 559   install_element(RMAP_NODE, &no_set_metric_cmd);
 560 }