ripd/rip_routemap.c

   1 /* RIPv2 routemap.
   2  * Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
   3  * Copyright (C) 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  19  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20  * 02111-1307, USA.
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "memory.h"
  26 #include "prefix.h"
  27 #include "routemap.h"
  28 #include "command.h"
  29 #include "filter.h"
  30 #include "log.h"
  31 #include "sockunion.h"          /* for inet_aton () */
  32 #include "plist.h"
  33
  34 #include "ripd/ripd.h"
  35
  36 struct rip_metric_modifier
  37 {
  38   enum
  39   {
  40     metric_increment,
  41     metric_decrement,
  42     metric_absolute
  43   } type;
  44
  45   u_char metric;
  46 };
  47
  48 /* Add rip route map rule. */
  49 static int
  50 rip_route_match_add (struct vty *vty, struct route_map_index *index,
  51                      const char *command, const char *arg)
  52 {
  53   int ret;
  54
  55   ret = route_map_add_match (index, command, arg);
  56   if (ret)
  57     {
  58       switch (ret)
  59         {
  60         case RMAP_RULE_MISSING:
  61           vty_out (vty, "%% RIP Can't find rule.%s", VTY_NEWLINE);
  62           return CMD_WARNING;
  63         case RMAP_COMPILE_ERROR:
  64           vty_out (vty, "%% RIP Argument is malformed.%s", VTY_NEWLINE);
  65           return CMD_WARNING;
  66         }
  67     }
  68   return CMD_SUCCESS;
  69 }
  70
  71 /* Delete rip route map rule. */
  72 static int
  73 rip_route_match_delete (struct vty *vty, struct route_map_index *index,
  74                         const char *command, const char *arg)
  75 {
  76   int ret;
  77
  78   ret = route_map_delete_match (index, command, arg);
  79   if (ret)
  80     {
  81       switch (ret)
  82         {
  83         case RMAP_RULE_MISSING:
  84           vty_out (vty, "%% RIP Can't find rule.%s", VTY_NEWLINE);
  85           return CMD_WARNING;
  86         case RMAP_COMPILE_ERROR:
  87           vty_out (vty, "%% RIP Argument is malformed.%s", VTY_NEWLINE);
  88           return CMD_WARNING;
  89         }
  90     }
  91   return CMD_SUCCESS;
  92 }
  93
  94 /* Add rip route map rule. */
  95 static int
  96 rip_route_set_add (struct vty *vty, struct route_map_index *index,
  97                    const char *command, const char *arg)
  98 {
  99   int ret;
 100
 101   ret = route_map_add_set (index, command, arg);
 102   if (ret)
 103     {
 104       switch (ret)
 105         {
 106         case RMAP_RULE_MISSING:
 107           vty_out (vty, "%% RIP Can't find rule.%s", VTY_NEWLINE);
 108           return CMD_WARNING;
 109         case RMAP_COMPILE_ERROR:
 110           /* rip, ripng and other protocols share the set metric command
 111              but only values from 0 to 16 are valid for rip and ripng
 112              if metric is out of range for rip and ripng, it is not for
 113              other protocols. Do not return an error */
 114           if (strcmp(command, "metric")) {
 115              vty_out (vty, "%% RIP Argument is malformed.%s", VTY_NEWLINE);
 116              return CMD_WARNING;
 117           }
 118         }
 119     }
 120   return CMD_SUCCESS;
 121 }
 122
 123 /* Delete rip route map rule. */
 124 static int
 125 rip_route_set_delete (struct vty *vty, struct route_map_index *index,
 126                       const char *command, const char *arg)
 127 {
 128   int ret;
 129
 130   ret = route_map_delete_set (index, command, arg);
 131   if (ret)
 132     {
 133       switch (ret)
 134         {
 135         case RMAP_RULE_MISSING:
 136           vty_out (vty, "%% RIP Can't find rule.%s", VTY_NEWLINE);
 137           return CMD_WARNING;
 138         case RMAP_COMPILE_ERROR:
 139           vty_out (vty, "%% RIP Argument is malformed.%s", VTY_NEWLINE);
 140           return CMD_WARNING;
 141         }
 142     }
 143   return CMD_SUCCESS;
 144 }
 145
 146 /* Hook function for updating route_map assignment. */
 147 /* ARGSUSED */
 148 static void
 149 rip_route_map_update (const char *notused)
 150 {
 151   int i;
 152
 153   if (rip)
 154     {
 155       for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
 156         {
 157           if (rip->route_map[i].name)
 158             rip->route_map[i].map =
 159               route_map_lookup_by_name (rip->route_map[i].name);
 160         }
 161     }
 162 }
 163
 164 /* `match metric METRIC' */
 165 /* Match function return 1 if match is success else return zero. */
 166 static route_map_result_t
 167 route_match_metric (void *rule, struct prefix *prefix,
 168                     route_map_object_t type, void *object)
 169 {
 170   u_int32_t *metric;
 171   u_int32_t  check;
 172   struct rip_info *rinfo;
 173
 174   if (type == RMAP_RIP)
 175     {
 176       metric = rule;
 177       rinfo = object;
 178
 179       /* If external metric is available, the route-map should
 180          work on this one (for redistribute purpose)  */
 181       check = (rinfo->external_metric) ? rinfo->external_metric :
 182                                          rinfo->metric;
 183       if (check == *metric)
 184         return RMAP_MATCH;
 185       else
 186         return RMAP_NOMATCH;
 187     }
 188   return RMAP_NOMATCH;
 189 }
 190
 191 /* Route map `match metric' match statement. `arg' is METRIC value */
 192 static void *
 193 route_match_metric_compile (const char *arg)
 194 {
 195   u_int32_t *metric;
 196
 197   metric = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (u_int32_t));
 198   *metric = atoi (arg);
 199
 200   if(*metric > 0)
 201     return metric;
 202
 203   XFREE (MTYPE_ROUTE_MAP_COMPILED, metric);
 204   return NULL;
 205 }
 206
 207 /* Free route map's compiled `match metric' value. */
 208 static void
 209 route_match_metric_free (void *rule)
 210 {
 211   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 212 }
 213
 214 /* Route map commands for metric matching. */
 215 struct route_map_rule_cmd route_match_metric_cmd =
 216 {
 217   "metric",
 218   route_match_metric,
 219   route_match_metric_compile,
 220   route_match_metric_free
 221 };
 222
 223 /* `match interface IFNAME' */
 224 /* Match function return 1 if match is success else return zero. */
 225 static route_map_result_t
 226 route_match_interface (void *rule, struct prefix *prefix,
 227                        route_map_object_t type, void *object)
 228 {
 229   struct rip_info *rinfo;
 230   struct interface *ifp;
 231   char *ifname;
 232
 233   if (type == RMAP_RIP)
 234     {
 235       ifname = rule;
 236       ifp = if_lookup_by_name(ifname);
 237
 238       if (!ifp)
 239         return RMAP_NOMATCH;
 240
 241       rinfo = object;
 242
 243       if (rinfo->ifindex_out == ifp->ifindex || rinfo->ifindex == ifp->ifindex)
 244         return RMAP_MATCH;
 245       else
 246         return RMAP_NOMATCH;
 247     }
 248   return RMAP_NOMATCH;
 249 }
 250
 251 /* Route map `match interface' match statement. `arg' is IFNAME value */
 252 /* XXX I don`t know if I need to check does interface exist? */
 253 static void *
 254 route_match_interface_compile (const char *arg)
 255 {
 256   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
 257 }
 258
 259 /* Free route map's compiled `match interface' value. */
 260 static void
 261 route_match_interface_free (void *rule)
 262 {
 263   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 264 }
 265
 266 /* Route map commands for interface matching. */
 267 struct route_map_rule_cmd route_match_interface_cmd =
 268 {
 269   "interface",
 270   route_match_interface,
 271   route_match_interface_compile,
 272   route_match_interface_free
 273 };
 274
 275 /* `match ip next-hop IP_ACCESS_LIST' */
 276
 277 /* Match function return 1 if match is success else return zero. */
 278 static route_map_result_t
 279 route_match_ip_next_hop (void *rule, struct prefix *prefix,
 280                         route_map_object_t type, void *object)
 281 {
 282   struct access_list *alist;
 283   struct rip_info *rinfo;
 284   struct prefix_ipv4 p;
 285
 286   if (type == RMAP_RIP)
 287     {
 288       rinfo = object;
 289       p.family = AF_INET;
 290       p.prefix = (rinfo->nexthop.s_addr) ? rinfo->nexthop : rinfo->from;
 291       p.prefixlen = IPV4_MAX_BITLEN;
 292
 293       alist = access_list_lookup (AFI_IP, (char *) rule);
 294       if (alist == NULL)
 295         return RMAP_NOMATCH;
 296
 297       return (access_list_apply (alist, &p) == FILTER_DENY ?
 298               RMAP_NOMATCH : RMAP_MATCH);
 299     }
 300   return RMAP_NOMATCH;
 301 }
 302
 303 /* Route map `ip next-hop' match statement.  `arg' should be
 304    access-list name. */
 305 static void *
 306 route_match_ip_next_hop_compile (const char *arg)
 307 {
 308   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
 309 }
 310
 311 /* Free route map's compiled `. */
 312 static void
 313 route_match_ip_next_hop_free (void *rule)
 314 {
 315   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 316 }
 317
 318 /* Route map commands for ip next-hop matching. */
 319 static struct route_map_rule_cmd route_match_ip_next_hop_cmd =
 320 {
 321   "ip next-hop",
 322   route_match_ip_next_hop,
 323   route_match_ip_next_hop_compile,
 324   route_match_ip_next_hop_free
 325 };
 326
 327 /* `match ip next-hop prefix-list PREFIX_LIST' */
 328
 329 static route_map_result_t
 330 route_match_ip_next_hop_prefix_list (void *rule, struct prefix *prefix,
 331                                     route_map_object_t type, void *object)
 332 {
 333   struct prefix_list *plist;
 334   struct rip_info *rinfo;
 335   struct prefix_ipv4 p;
 336
 337   if (type == RMAP_RIP)
 338     {
 339       rinfo = object;
 340       p.family = AF_INET;
 341       p.prefix = (rinfo->nexthop.s_addr) ? rinfo->nexthop : rinfo->from;
 342       p.prefixlen = IPV4_MAX_BITLEN;
 343
 344       plist = prefix_list_lookup (AFI_IP, (char *) rule);
 345       if (plist == NULL)
 346         return RMAP_NOMATCH;
 347
 348       return (prefix_list_apply (plist, &p) == PREFIX_DENY ?
 349               RMAP_NOMATCH : RMAP_MATCH);
 350     }
 351   return RMAP_NOMATCH;
 352 }
 353
 354 static void *
 355 route_match_ip_next_hop_prefix_list_compile (const char *arg)
 356 {
 357   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
 358 }
 359
 360 static void
 361 route_match_ip_next_hop_prefix_list_free (void *rule)
 362 {
 363   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 364 }
 365
 366 static struct route_map_rule_cmd route_match_ip_next_hop_prefix_list_cmd =
 367 {
 368   "ip next-hop prefix-list",
 369   route_match_ip_next_hop_prefix_list,
 370   route_match_ip_next_hop_prefix_list_compile,
 371   route_match_ip_next_hop_prefix_list_free
 372 };
 373
 374 /* `match ip address IP_ACCESS_LIST' */
 375
 376 /* Match function should return 1 if match is success else return
 377    zero. */
 378 static route_map_result_t
 379 route_match_ip_address (void *rule, struct prefix *prefix,
 380                         route_map_object_t type, void *object)
 381 {
 382   struct access_list *alist;
 383
 384   if (type == RMAP_RIP)
 385     {
 386       alist = access_list_lookup (AFI_IP, (char *) rule);
 387       if (alist == NULL)
 388         return RMAP_NOMATCH;
 389
 390       return (access_list_apply (alist, prefix) == FILTER_DENY ?
 391               RMAP_NOMATCH : RMAP_MATCH);
 392     }
 393   return RMAP_NOMATCH;
 394 }
 395
 396 /* Route map `ip address' match statement.  `arg' should be
 397    access-list name. */
 398 static void *
 399 route_match_ip_address_compile (const char *arg)
 400 {
 401   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
 402 }
 403
 404 /* Free route map's compiled `ip address' value. */
 405 static void
 406 route_match_ip_address_free (void *rule)
 407 {
 408   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 409 }
 410
 411 /* Route map commands for ip address matching. */
 412 static struct route_map_rule_cmd route_match_ip_address_cmd =
 413 {
 414   "ip address",
 415   route_match_ip_address,
 416   route_match_ip_address_compile,
 417   route_match_ip_address_free
 418 };
 419
 420 /* `match ip address prefix-list PREFIX_LIST' */
 421
 422 static route_map_result_t
 423 route_match_ip_address_prefix_list (void *rule, struct prefix *prefix,
 424                                     route_map_object_t type, void *object)
 425 {
 426   struct prefix_list *plist;
 427
 428   if (type == RMAP_RIP)
 429     {
 430       plist = prefix_list_lookup (AFI_IP, (char *) rule);
 431       if (plist == NULL)
 432         return RMAP_NOMATCH;
 433
 434       return (prefix_list_apply (plist, prefix) == PREFIX_DENY ?
 435               RMAP_NOMATCH : RMAP_MATCH);
 436     }
 437   return RMAP_NOMATCH;
 438 }
 439
 440 static void *
 441 route_match_ip_address_prefix_list_compile (const char *arg)
 442 {
 443   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
 444 }
 445
 446 static void
 447 route_match_ip_address_prefix_list_free (void *rule)
 448 {
 449   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 450 }
 451
 452 static struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd =
 453 {
 454   "ip address prefix-list",
 455   route_match_ip_address_prefix_list,
 456   route_match_ip_address_prefix_list_compile,
 457   route_match_ip_address_prefix_list_free
 458 };
 459
 460 /* `match tag TAG' */
 461 /* Match function return 1 if match is success else return zero. */
 462 static route_map_result_t
 463 route_match_tag (void *rule, struct prefix *prefix,
 464                     route_map_object_t type, void *object)
 465 {
 466   route_tag_t *tag;
 467   struct rip_info *rinfo;
 468
 469   if (type == RMAP_RIP)
 470     {
 471       tag = rule;
 472       rinfo = object;
 473
 474       /* The information stored by rinfo is host ordered. */
 475       if (rinfo->tag == *tag)
 476         return RMAP_MATCH;
 477       else
 478         return RMAP_NOMATCH;
 479     }
 480   return RMAP_NOMATCH;
 481 }
 482
 483 /* Route map commands for tag matching. */
 484 static struct route_map_rule_cmd route_match_tag_cmd =
 485 {
 486   "tag",
 487   route_match_tag,
 488   route_map_rule_tag_compile,
 489   route_map_rule_tag_free,
 490 };
 491
 492 /* `set metric METRIC' */
 493
 494 /* Set metric to attribute. */
 495 static route_map_result_t
 496 route_set_metric (void *rule, struct prefix *prefix,
 497                   route_map_object_t type, void *object)
 498 {
 499   if (type == RMAP_RIP)
 500     {
 501       struct rip_metric_modifier *mod;
 502       struct rip_info *rinfo;
 503
 504       mod = rule;
 505       rinfo = object;
 506
 507       if (mod->type == metric_increment)
 508         rinfo->metric_out += mod->metric;
 509       else if (mod->type == metric_decrement)
 510         rinfo->metric_out -= mod->metric;
 511       else if (mod->type == metric_absolute)
 512         rinfo->metric_out = mod->metric;
 513
 514       if ((signed int)rinfo->metric_out < 1)
 515         rinfo->metric_out = 1;
 516       if (rinfo->metric_out > RIP_METRIC_INFINITY)
 517         rinfo->metric_out = RIP_METRIC_INFINITY;
 518
 519       rinfo->metric_set = 1;
 520     }
 521   return RMAP_OKAY;
 522 }
 523
 524 /* set metric compilation. */
 525 static void *
 526 route_set_metric_compile (const char *arg)
 527 {
 528   int len;
 529   const char *pnt;
 530   int type;
 531   long metric;
 532   char *endptr = NULL;
 533   struct rip_metric_modifier *mod;
 534
 535   len = strlen (arg);
 536   pnt = arg;
 537
 538   if (len == 0)
 539     return NULL;
 540
 541   /* Examine first character. */
 542   if (arg[0] == '+')
 543     {
 544       type = metric_increment;
 545       pnt++;
 546     }
 547   else if (arg[0] == '-')
 548     {
 549       type = metric_decrement;
 550       pnt++;
 551     }
 552   else
 553     type = metric_absolute;
 554
 555   /* Check beginning with digit string. */
 556   if (*pnt < '0' || *pnt > '9')
 557     return NULL;
 558
 559   /* Convert string to integer. */
 560   metric = strtol (pnt, &endptr, 10);
 561
 562   if (metric == LONG_MAX || *endptr != '\0')
 563     return NULL;
 564   if (metric < 0 || metric > RIP_METRIC_INFINITY)
 565     return NULL;
 566
 567   mod = XMALLOC (MTYPE_ROUTE_MAP_COMPILED,
 568                  sizeof (struct rip_metric_modifier));
 569   mod->type = type;
 570   mod->metric = metric;
 571
 572   return mod;
 573 }
 574
 575 /* Free route map's compiled `set metric' value. */
 576 static void
 577 route_set_metric_free (void *rule)
 578 {
 579   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 580 }
 581
 582 /* Set metric rule structure. */
 583 static struct route_map_rule_cmd route_set_metric_cmd =
 584 {
 585   "metric",
 586   route_set_metric,
 587   route_set_metric_compile,
 588   route_set_metric_free,
 589 };
 590
 591 /* `set ip next-hop IP_ADDRESS' */
 592
 593 /* Set nexthop to object.  ojbect must be pointer to struct attr. */
 594 static route_map_result_t
 595 route_set_ip_nexthop (void *rule, struct prefix *prefix,
 596                       route_map_object_t type, void *object)
 597 {
 598   struct in_addr *address;
 599   struct rip_info *rinfo;
 600
 601   if(type == RMAP_RIP)
 602     {
 603       /* Fetch routemap's rule information. */
 604       address = rule;
 605       rinfo = object;
 606
 607       /* Set next hop value. */
 608       rinfo->nexthop_out = *address;
 609     }
 610
 611   return RMAP_OKAY;
 612 }
 613
 614 /* Route map `ip nexthop' compile function.  Given string is converted
 615    to struct in_addr structure. */
 616 static void *
 617 route_set_ip_nexthop_compile (const char *arg)
 618 {
 619   int ret;
 620   struct in_addr *address;
 621
 622   address = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (struct in_addr));
 623
 624   ret = inet_aton (arg, address);
 625
 626   if (ret == 0)
 627     {
 628       XFREE (MTYPE_ROUTE_MAP_COMPILED, address);
 629       return NULL;
 630     }
 631
 632   return address;
 633 }
 634
 635 /* Free route map's compiled `ip nexthop' value. */
 636 static void
 637 route_set_ip_nexthop_free (void *rule)
 638 {
 639   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
 640 }
 641
 642 /* Route map commands for ip nexthop set. */
 643 static struct route_map_rule_cmd route_set_ip_nexthop_cmd =
 644 {
 645   "ip next-hop",
 646   route_set_ip_nexthop,
 647   route_set_ip_nexthop_compile,
 648   route_set_ip_nexthop_free
 649 };
 650
 651 /* `set tag TAG' */
 652
 653 /* Set tag to object.  ojbect must be pointer to struct attr. */
 654 static route_map_result_t
 655 route_set_tag (void *rule, struct prefix *prefix,
 656                       route_map_object_t type, void *object)
 657 {
 658   route_tag_t *tag;
 659   struct rip_info *rinfo;
 660
 661   if(type == RMAP_RIP)
 662     {
 663       /* Fetch routemap's rule information. */
 664       tag = rule;
 665       rinfo = object;
 666
 667       /* Set next hop value. */
 668       rinfo->tag_out = *tag;
 669     }
 670
 671   return RMAP_OKAY;
 672 }
 673
 674 /* Route map commands for tag set. */
 675 static struct route_map_rule_cmd route_set_tag_cmd =
 676 {
 677   "tag",
 678   route_set_tag,
 679   route_map_rule_tag_compile,
 680   route_map_rule_tag_free
 681 };
 682
 683 #define MATCH_STR "Match values from routing table\n"
 684 #define SET_STR "Set values in destination routing protocol\n"
 685
 686 DEFUN (match_metric,
 687        match_metric_cmd,
 688        "match metric <0-4294967295>",
 689        MATCH_STR
 690        "Match metric of route\n"
 691        "Metric value\n")
 692 {
 693   return rip_route_match_add (vty, vty->index, "metric", argv[0]);
 694 }
 695
 696 DEFUN (no_match_metric,
 697        no_match_metric_cmd,
 698        "no match metric",
 699        NO_STR
 700        MATCH_STR
 701        "Match metric of route\n")
 702 {
 703   if (argc == 0)
 704     return rip_route_match_delete (vty, vty->index, "metric", NULL);
 705
 706   return rip_route_match_delete (vty, vty->index, "metric", argv[0]);
 707 }
 708
 709 ALIAS (no_match_metric,
 710        no_match_metric_val_cmd,
 711        "no match metric <0-4294967295>",
 712        NO_STR
 713        MATCH_STR
 714        "Match metric of route\n"
 715        "Metric value\n")
 716
 717 DEFUN (match_interface,
 718        match_interface_cmd,
 719        "match interface WORD",
 720        MATCH_STR
 721        "Match first hop interface of route\n"
 722        "Interface name\n")
 723 {
 724   return rip_route_match_add (vty, vty->index, "interface", argv[0]);
 725 }
 726
 727 DEFUN (no_match_interface,
 728        no_match_interface_cmd,
 729        "no match interface",
 730        NO_STR
 731        MATCH_STR
 732        "Match first hop interface of route\n")
 733 {
 734   if (argc == 0)
 735     return rip_route_match_delete (vty, vty->index, "interface", NULL);
 736
 737   return rip_route_match_delete (vty, vty->index, "interface", argv[0]);
 738 }
 739
 740 ALIAS (no_match_interface,
 741        no_match_interface_val_cmd,
 742        "no match interface WORD",
 743        NO_STR
 744        MATCH_STR
 745        "Match first hop interface of route\n"
 746        "Interface name\n")
 747
 748 DEFUN (match_ip_next_hop,
 749        match_ip_next_hop_cmd,
 750        "match ip next-hop (<1-199>|<1300-2699>|WORD)",
 751        MATCH_STR
 752        IP_STR
 753        "Match next-hop address of route\n"
 754        "IP access-list number\n"
 755        "IP access-list number (expanded range)\n"
 756        "IP Access-list name\n")
 757 {
 758   return rip_route_match_add (vty, vty->index, "ip next-hop", argv[0]);
 759 }
 760
 761 DEFUN (no_match_ip_next_hop,
 762        no_match_ip_next_hop_cmd,
 763        "no match ip next-hop",
 764        NO_STR
 765        MATCH_STR
 766        IP_STR
 767        "Match next-hop address of route\n")
 768 {
 769   if (argc == 0)
 770     return rip_route_match_delete (vty, vty->index, "ip next-hop", NULL);
 771
 772   return rip_route_match_delete (vty, vty->index, "ip next-hop", argv[0]);
 773 }
 774
 775 ALIAS (no_match_ip_next_hop,
 776        no_match_ip_next_hop_val_cmd,
 777        "no match ip next-hop (<1-199>|<1300-2699>|WORD)",
 778        NO_STR
 779        MATCH_STR
 780        IP_STR
 781        "Match next-hop address of route\n"
 782        "IP access-list number\n"
 783        "IP access-list number (expanded range)\n"
 784        "IP Access-list name\n")
 785
 786 DEFUN (match_ip_next_hop_prefix_list,
 787        match_ip_next_hop_prefix_list_cmd,
 788        "match ip next-hop prefix-list WORD",
 789        MATCH_STR
 790        IP_STR
 791        "Match next-hop address of route\n"
 792        "Match entries of prefix-lists\n"
 793        "IP prefix-list name\n")
 794 {
 795   return rip_route_match_add (vty, vty->index, "ip next-hop prefix-list", argv[0]);
 796 }
 797
 798 DEFUN (no_match_ip_next_hop_prefix_list,
 799        no_match_ip_next_hop_prefix_list_cmd,
 800        "no match ip next-hop prefix-list",
 801        NO_STR
 802        MATCH_STR
 803        IP_STR
 804        "Match next-hop address of route\n"
 805        "Match entries of prefix-lists\n")
 806 {
 807   if (argc == 0)
 808     return rip_route_match_delete (vty, vty->index, "ip next-hop prefix-list", NULL);
 809
 810   return rip_route_match_delete (vty, vty->index, "ip next-hop prefix-list", argv[0]);
 811 }
 812
 813 ALIAS (no_match_ip_next_hop_prefix_list,
 814        no_match_ip_next_hop_prefix_list_val_cmd,
 815        "no match ip next-hop prefix-list WORD",
 816        NO_STR
 817        MATCH_STR
 818        IP_STR
 819        "Match next-hop address of route\n"
 820        "Match entries of prefix-lists\n"
 821        "IP prefix-list name\n")
 822
 823 DEFUN (match_ip_address,
 824        match_ip_address_cmd,
 825        "match ip address (<1-199>|<1300-2699>|WORD)",
 826        MATCH_STR
 827        IP_STR
 828        "Match address of route\n"
 829        "IP access-list number\n"
 830        "IP access-list number (expanded range)\n"
 831        "IP Access-list name\n")
 832
 833 {
 834   return rip_route_match_add (vty, vty->index, "ip address", argv[0]);
 835 }
 836
 837 DEFUN (no_match_ip_address,
 838        no_match_ip_address_cmd,
 839        "no match ip address",
 840        NO_STR
 841        MATCH_STR
 842        IP_STR
 843        "Match address of route\n")
 844 {
 845   if (argc == 0)
 846     return rip_route_match_delete (vty, vty->index, "ip address", NULL);
 847
 848   return rip_route_match_delete (vty, vty->index, "ip address", argv[0]);
 849 }
 850
 851 ALIAS (no_match_ip_address,
 852        no_match_ip_address_val_cmd,
 853        "no match ip address (<1-199>|<1300-2699>|WORD)",
 854        NO_STR
 855        MATCH_STR
 856        IP_STR
 857        "Match address of route\n"
 858        "IP access-list number\n"
 859        "IP access-list number (expanded range)\n"
 860        "IP Access-list name\n")
 861
 862 DEFUN (match_ip_address_prefix_list,
 863        match_ip_address_prefix_list_cmd,
 864        "match ip address prefix-list WORD",
 865        MATCH_STR
 866        IP_STR
 867        "Match address of route\n"
 868        "Match entries of prefix-lists\n"
 869        "IP prefix-list name\n")
 870 {
 871   return rip_route_match_add (vty, vty->index, "ip address prefix-list", argv[0]);
 872 }
 873
 874 DEFUN (no_match_ip_address_prefix_list,
 875        no_match_ip_address_prefix_list_cmd,
 876        "no match ip address prefix-list",
 877        NO_STR
 878        MATCH_STR
 879        IP_STR
 880        "Match address of route\n"
 881        "Match entries of prefix-lists\n")
 882 {
 883   if (argc == 0)
 884     return rip_route_match_delete (vty, vty->index, "ip address prefix-list", NULL);
 885
 886   return rip_route_match_delete (vty, vty->index, "ip address prefix-list", argv[0]);
 887 }
 888
 889 ALIAS (no_match_ip_address_prefix_list,
 890        no_match_ip_address_prefix_list_val_cmd,
 891        "no match ip address prefix-list WORD",
 892        NO_STR
 893        MATCH_STR
 894        IP_STR
 895        "Match address of route\n"
 896        "Match entries of prefix-lists\n"
 897        "IP prefix-list name\n")
 898
 899 DEFUN (match_tag,
 900        match_tag_cmd,
 901        "match tag <1-4294967295>",
 902        MATCH_STR
 903        "Match tag of route\n"
 904        "Metric value\n")
 905 {
 906   return rip_route_match_add (vty, vty->index, "tag", argv[0]);
 907 }
 908
 909 DEFUN (no_match_tag,
 910        no_match_tag_cmd,
 911        "no match tag",
 912        NO_STR
 913        MATCH_STR
 914        "Match tag of route\n")
 915 {
 916   if (argc == 0)
 917     return rip_route_match_delete (vty, vty->index, "tag", NULL);
 918
 919   return rip_route_match_delete (vty, vty->index, "tag", argv[0]);
 920 }
 921
 922 ALIAS (no_match_tag,
 923        no_match_tag_val_cmd,
 924        "no match tag <1-4294967295>",
 925        NO_STR
 926        MATCH_STR
 927        "Match tag of route\n"
 928        "Metric value\n")
 929
 930 /* set functions */
 931
 932 DEFUN (set_metric,
 933        set_metric_cmd,
 934        "set metric <0-4294967295>",
 935        SET_STR
 936        "Metric value for destination routing protocol\n"
 937        "Metric value\n")
 938 {
 939   return rip_route_set_add (vty, vty->index, "metric", argv[0]);
 940 }
 941
 942 ALIAS (set_metric,
 943        set_metric_addsub_cmd,
 944        "set metric <+/-metric>",
 945        SET_STR
 946        "Metric value for destination routing protocol\n"
 947        "Add or subtract metric\n")
 948
 949 DEFUN (no_set_metric,
 950        no_set_metric_cmd,
 951        "no set metric",
 952        NO_STR
 953        SET_STR
 954        "Metric value for destination routing protocol\n")
 955 {
 956   if (argc == 0)
 957     return rip_route_set_delete (vty, vty->index, "metric", NULL);
 958
 959   return rip_route_set_delete (vty, vty->index, "metric", argv[0]);
 960 }
 961
 962 ALIAS (no_set_metric,
 963        no_set_metric_val_cmd,
 964        "no set metric <0-4294967295>",
 965        NO_STR
 966        SET_STR
 967        "Metric value for destination routing protocol\n"
 968        "Metric value\n")
 969
 970 ALIAS (no_set_metric,
 971        no_set_metric_addsub_cmd,
 972        "no set metric <+/-metric>",
 973        NO_STR
 974        SET_STR
 975        "Metric value for destination routing protocol\n"
 976        "Add or subtract metric\n")
 977
 978 DEFUN (set_ip_nexthop,
 979        set_ip_nexthop_cmd,
 980        "set ip next-hop A.B.C.D",
 981        SET_STR
 982        IP_STR
 983        "Next hop address\n"
 984        "IP address of next hop\n")
 985 {
 986   union sockunion su;
 987   int ret;
 988
 989   ret = str2sockunion (argv[0], &su);
 990   if (ret < 0)
 991     {
 992       vty_out (vty, "%% Malformed next-hop address%s", VTY_NEWLINE);
 993       return CMD_WARNING;
 994     }
 995
 996   return rip_route_set_add (vty, vty->index, "ip next-hop", argv[0]);
 997 }
 998
 999 DEFUN (no_set_ip_nexthop,
1000        no_set_ip_nexthop_cmd,
1001        "no set ip next-hop",
1002        NO_STR
1003        SET_STR
1004        IP_STR
1005        "Next hop address\n")
1006 {
1007   if (argc == 0)
1008     return rip_route_set_delete (vty, vty->index, "ip next-hop", NULL);
1009
1010   return rip_route_set_delete (vty, vty->index, "ip next-hop", argv[0]);
1011 }
1012
1013 ALIAS (no_set_ip_nexthop,
1014        no_set_ip_nexthop_val_cmd,
1015        "no set ip next-hop A.B.C.D",
1016        NO_STR
1017        SET_STR
1018        IP_STR
1019        "Next hop address\n"
1020        "IP address of next hop\n")
1021
1022 DEFUN (set_tag,
1023        set_tag_cmd,
1024        "set tag <1-4294967295>",
1025        SET_STR
1026        "Tag value for routing protocol\n"
1027        "Tag value\n")
1028 {
1029   return rip_route_set_add (vty, vty->index, "tag", argv[0]);
1030 }
1031
1032 DEFUN (no_set_tag,
1033        no_set_tag_cmd,
1034        "no set tag",
1035        NO_STR
1036        SET_STR
1037        "Tag value for routing protocol\n")
1038 {
1039   if (argc == 0)
1040     return rip_route_set_delete (vty, vty->index, "tag", NULL);
1041
1042   return rip_route_set_delete (vty, vty->index, "tag", argv[0]);
1043 }
1044
1045 ALIAS (no_set_tag,
1046        no_set_tag_val_cmd,
1047        "no set tag <1-4294967295>",
1048        NO_STR
1049        SET_STR
1050        "Tag value for routing protocol\n"
1051        "Tag value\n")
1052
1053 void
1054 rip_route_map_reset ()
1055 {
1056   ;
1057 }
1058
1059 /* Route-map init */
1060 void
1061 rip_route_map_init ()
1062 {
1063   route_map_init ();
1064   route_map_init_vty ();
1065   route_map_add_hook (rip_route_map_update);
1066   route_map_delete_hook (rip_route_map_update);
1067
1068   route_map_install_match (&route_match_metric_cmd);
1069   route_map_install_match (&route_match_interface_cmd);
1070   route_map_install_match (&route_match_ip_next_hop_cmd);
1071   route_map_install_match (&route_match_ip_next_hop_prefix_list_cmd);
1072   route_map_install_match (&route_match_ip_address_cmd);
1073   route_map_install_match (&route_match_ip_address_prefix_list_cmd);
1074   route_map_install_match (&route_match_tag_cmd);
1075
1076   route_map_install_set (&route_set_metric_cmd);
1077   route_map_install_set (&route_set_ip_nexthop_cmd);
1078   route_map_install_set (&route_set_tag_cmd);
1079
1080   install_element (RMAP_NODE, &match_metric_cmd);
1081   install_element (RMAP_NODE, &no_match_metric_cmd);
1082   install_element (RMAP_NODE, &no_match_metric_val_cmd);
1083   install_element (RMAP_NODE, &match_interface_cmd);
1084   install_element (RMAP_NODE, &no_match_interface_cmd);
1085   install_element (RMAP_NODE, &no_match_interface_val_cmd);
1086   install_element (RMAP_NODE, &match_ip_next_hop_cmd);
1087   install_element (RMAP_NODE, &no_match_ip_next_hop_cmd);
1088   install_element (RMAP_NODE, &no_match_ip_next_hop_val_cmd);
1089   install_element (RMAP_NODE, &match_ip_next_hop_prefix_list_cmd);
1090   install_element (RMAP_NODE, &no_match_ip_next_hop_prefix_list_cmd);
1091   install_element (RMAP_NODE, &no_match_ip_next_hop_prefix_list_val_cmd);
1092   install_element (RMAP_NODE, &match_ip_address_cmd);
1093   install_element (RMAP_NODE, &no_match_ip_address_cmd);
1094   install_element (RMAP_NODE, &no_match_ip_address_val_cmd);
1095   install_element (RMAP_NODE, &match_ip_address_prefix_list_cmd);
1096   install_element (RMAP_NODE, &no_match_ip_address_prefix_list_cmd);
1097   install_element (RMAP_NODE, &no_match_ip_address_prefix_list_val_cmd);
1098   install_element (RMAP_NODE, &match_tag_cmd);
1099   install_element (RMAP_NODE, &no_match_tag_cmd);
1100   install_element (RMAP_NODE, &no_match_tag_val_cmd);
1101
1102   install_element (RMAP_NODE, &set_metric_cmd);
1103   install_element (RMAP_NODE, &set_metric_addsub_cmd);
1104   install_element (RMAP_NODE, &no_set_metric_cmd);
1105   install_element (RMAP_NODE, &no_set_metric_val_cmd);
1106   install_element (RMAP_NODE, &no_set_metric_addsub_cmd);
1107   install_element (RMAP_NODE, &set_ip_nexthop_cmd);
1108   install_element (RMAP_NODE, &no_set_ip_nexthop_cmd);
1109   install_element (RMAP_NODE, &no_set_ip_nexthop_val_cmd);
1110   install_element (RMAP_NODE, &set_tag_cmd);
1111   install_element (RMAP_NODE, &no_set_tag_cmd);
1112   install_element (RMAP_NODE, &no_set_tag_val_cmd);
1113 }