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   int idx_acl = 3;
 358   return isis_route_match_add(vty, vty->index, "ip address", argv[idx_acl]->arg);
 359 }
 360
 361
 362 DEFUN (no_match_ip_address,
 363        no_match_ip_address_val_cmd,
 364        "no match ip address [<(1-199)|(1300-2699)|WORD>]",
 365        NO_STR
 366        MATCH_STR
 367        IP_STR
 368        "Match address of route\n"
 369        "IP access-list number\n"
 370        "IP access-list number (expanded range)\n"
 371        "IP Access-list name\n")
 372 {
 373   int idx_acl = 4;
 374   if (argc == 4)
 375     return isis_route_match_delete(vty, vty->index, "ip address", NULL);
 376   return isis_route_match_delete(vty, vty->index, "ip address", argv[idx_acl]->arg);
 377 }
 378
 379
 380 /* ------------------------------------------------------------*/
 381
 382 DEFUN (match_ip_address_prefix_list,
 383        match_ip_address_prefix_list_cmd,
 384        "match ip address prefix-list WORD",
 385        MATCH_STR
 386        IP_STR
 387        "Match address of route\n"
 388        "Match entries of prefix-lists\n"
 389        "IP prefix-list name\n")
 390 {
 391   int idx_word = 4;
 392   return isis_route_match_add(vty, vty->index, "ip address prefix-list", argv[idx_word]->arg);
 393 }
 394
 395
 396 DEFUN (no_match_ip_address_prefix_list,
 397        no_match_ip_address_prefix_list_cmd,
 398        "no match ip address prefix-list [WORD]",
 399        NO_STR
 400        MATCH_STR
 401        IP_STR
 402        "Match address of route\n"
 403        "Match entries of prefix-lists\n"
 404        "IP prefix-list name\n")
 405 {
 406   int idx_word = 5;
 407   if (argc == 5)
 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[idx_word]->arg);
 410 }
 411
 412
 413 /* ------------------------------------------------------------*/
 414
 415 DEFUN (match_ipv6_address,
 416        match_ipv6_address_cmd,
 417        "match ipv6 address WORD",
 418        MATCH_STR
 419        IPV6_STR
 420        "Match IPv6 address of route\n"
 421        "IPv6 access-list name\n")
 422 {
 423   int idx_word = 3;
 424   return isis_route_match_add(vty, vty->index, "ipv6 address", argv[idx_word]->arg);
 425 }
 426
 427
 428 DEFUN (no_match_ipv6_address,
 429        no_match_ipv6_address_val_cmd,
 430        "no match ipv6 address [WORD]",
 431        NO_STR
 432        MATCH_STR
 433        IPV6_STR
 434        "Match IPv6 address of route\n"
 435        "IPv6 access-list name\n")
 436 {
 437   int idx_word = 4;
 438   if (argc == 4)
 439     return isis_route_match_delete(vty, vty->index, "ipv6 address", NULL);
 440   return isis_route_match_delete(vty, vty->index, "ipv6 address", argv[idx_word]->arg);
 441 }
 442
 443
 444 /* ------------------------------------------------------------*/
 445
 446 DEFUN (match_ipv6_address_prefix_list,
 447        match_ipv6_address_prefix_list_cmd,
 448        "match ipv6 address prefix-list WORD",
 449        MATCH_STR
 450        IPV6_STR
 451        "Match address of route\n"
 452        "Match entries of prefix-lists\n"
 453        "IP prefix-list name\n")
 454 {
 455   int idx_word = 4;
 456   return isis_route_match_add(vty, vty->index, "ipv6 address prefix-list", argv[idx_word]->arg);
 457 }
 458
 459 DEFUN (no_match_ipv6_address_prefix_list,
 460        no_match_ipv6_address_prefix_list_cmd,
 461        "no match ipv6 address prefix-list [WORD]",
 462        NO_STR
 463        MATCH_STR
 464        IPV6_STR
 465        "Match address of route\n"
 466        "Match entries of prefix-lists\n"
 467        "IP prefix-list name\n")
 468 {
 469   int idx_word = 5;
 470   if (argc == 5)
 471     return isis_route_match_delete (vty, vty->index, "ipv6 address prefix-list", NULL);
 472   return isis_route_match_delete (vty, vty->index, "ipv6 address prefix-list", argv[idx_word]->arg);
 473 }
 474
 475
 476 /* ------------------------------------------------------------*/
 477
 478 /* set metric already exists e.g. in the ospf routemap. vtysh doesn't cope well with different
 479  * commands at the same node, therefore add set metric with the same 32-bit range as ospf and
 480  * verify that the input is a valid isis metric */
 481 DEFUN (set_metric,
 482        set_metric_cmd,
 483       "set metric (0-4294967295)",
 484       SET_STR
 485       "Metric vale for destination routing protocol\n"
 486       "Metric value\n")
 487 {
 488   int idx_number = 2;
 489   return isis_route_set_add(vty, vty->index, "metric", argv[idx_number]->arg);
 490 }
 491
 492 DEFUN (no_set_metric,
 493        no_set_metric_val_cmd,
 494       "no set metric [(0-4294967295)]",
 495       NO_STR
 496       SET_STR
 497       "Metric value for destination routing protocol\n"
 498       "Metric value\n")
 499 {
 500   int idx_number = 3;
 501   if (argc == 3)
 502     return isis_route_set_delete(vty, vty->index, "metric", NULL);
 503   return isis_route_set_delete(vty, vty->index, "metric", argv[idx_number]->arg);
 504 }
 505
 506 void
 507 isis_route_map_init(void)
 508 {
 509   route_map_init();
 510   route_map_init_vty();
 511
 512   route_map_install_match(&route_match_ip_address_cmd);
 513   install_element(RMAP_NODE, &match_ip_address_cmd);
 514   install_element(RMAP_NODE, &no_match_ip_address_val_cmd);
 515
 516   route_map_install_match(&route_match_ip_address_prefix_list_cmd);
 517   install_element(RMAP_NODE, &match_ip_address_prefix_list_cmd);
 518   install_element(RMAP_NODE, &no_match_ip_address_prefix_list_cmd);
 519
 520   route_map_install_match(&route_match_ipv6_address_cmd);
 521   install_element(RMAP_NODE, &match_ipv6_address_cmd);
 522   install_element(RMAP_NODE, &no_match_ipv6_address_val_cmd);
 523
 524   route_map_install_match(&route_match_ipv6_address_prefix_list_cmd);
 525   install_element(RMAP_NODE, &match_ipv6_address_prefix_list_cmd);
 526   install_element(RMAP_NODE, &no_match_ipv6_address_prefix_list_cmd);
 527
 528   route_map_install_set(&route_set_metric_cmd);
 529   install_element(RMAP_NODE, &set_metric_cmd);
 530   install_element(RMAP_NODE, &no_set_metric_val_cmd);
 531 }