zebra/zebra_routemap.c

   1 /* zebra routemap.
   2  * Copyright (C) 2006 IBM Corporation
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra 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
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "memory.h"
  24 #include "prefix.h"
  25 #include "rib.h"
  26 #include "vty.h"
  27 #include "routemap.h"
  28 #include "command.h"
  29 #include "filter.h"
  30 #include "plist.h"
  31 #include "nexthop.h"
  32 #include "northbound_cli.h"
  33 #include "lib/route_types.h"
  34 #include "vrf.h"
  35 #include "frrstr.h"
  36
  37 #include "zebra/zebra_router.h"
  38 #include "zebra/redistribute.h"
  39 #include "zebra/debug.h"
  40 #include "zebra/zebra_rnh.h"
  41 #include "zebra/zebra_routemap.h"
  42
  43 #include "zebra/zebra_routemap_clippy.c"
  44
  45 static uint32_t zebra_rmap_update_timer = ZEBRA_RMAP_DEFAULT_UPDATE_TIMER;
  46 static struct thread *zebra_t_rmap_update = NULL;
  47 char *zebra_import_table_routemap[AFI_MAX][ZEBRA_KERNEL_TABLE_MAX];
  48
  49 struct nh_rmap_obj {
  50         struct nexthop *nexthop;
  51         vrf_id_t vrf_id;
  52         uint32_t source_protocol;
  53         uint8_t instance;
  54         int metric;
  55         route_tag_t tag;
  56 };
  57
  58 static void zebra_route_map_set_delay_timer(uint32_t value);
  59
  60 /* 'match tag TAG'
  61  * Match function return 1 if match is success else return 0
  62  */
  63 static enum route_map_cmd_result_t
  64 route_match_tag(void *rule, const struct prefix *prefix, void *object)
  65 {
  66         route_tag_t *tag;
  67         struct nh_rmap_obj *nh_data;
  68
  69         tag = rule;
  70         nh_data = object;
  71
  72         if (nh_data->tag == *tag)
  73                 return RMAP_MATCH;
  74
  75         return RMAP_NOMATCH;
  76 }
  77
  78 /* Route map commands for tag matching */
  79 static const struct route_map_rule_cmd route_match_tag_cmd = {
  80         "tag",
  81         route_match_tag,
  82         route_map_rule_tag_compile,
  83         route_map_rule_tag_free,
  84 };
  85
  86
  87 /* `match interface IFNAME' */
  88 /* Match function return 1 if match is success else return zero. */
  89 static enum route_map_cmd_result_t
  90 route_match_interface(void *rule, const struct prefix *prefix, void *object)
  91 {
  92         struct nh_rmap_obj *nh_data;
  93         char *ifname = rule;
  94         ifindex_t ifindex;
  95
  96         if (strcasecmp(ifname, "any") == 0)
  97                 return RMAP_MATCH;
  98         nh_data = object;
  99         if (!nh_data || !nh_data->nexthop)
 100                 return RMAP_NOMATCH;
 101         ifindex = ifname2ifindex(ifname, nh_data->vrf_id);
 102         if (ifindex == 0)
 103                 return RMAP_NOMATCH;
 104         if (nh_data->nexthop->ifindex == ifindex)
 105                 return RMAP_MATCH;
 106
 107         return RMAP_NOMATCH;
 108 }
 109
 110 /* Route map `match interface' match statement. `arg' is IFNAME value */
 111 static void *route_match_interface_compile(const char *arg)
 112 {
 113         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
 114 }
 115
 116 /* Free route map's compiled `match interface' value. */
 117 static void route_match_interface_free(void *rule)
 118 {
 119         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
 120 }
 121
 122 static void show_vrf_proto_rm(struct vty *vty, struct zebra_vrf *zvrf,
 123                               int af_type)
 124 {
 125         int i;
 126
 127         vty_out(vty, "Protocol                  : route-map\n");
 128         vty_out(vty, "-------------------------------------\n");
 129
 130         for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
 131                 if (PROTO_RM_NAME(zvrf, af_type, i))
 132                         vty_out(vty, "%-24s  : %-10s\n", zebra_route_string(i),
 133                                 PROTO_RM_NAME(zvrf, af_type, i));
 134                 else
 135                         vty_out(vty, "%-24s  : none\n", zebra_route_string(i));
 136         }
 137
 138         if (PROTO_RM_NAME(zvrf, af_type, i))
 139                 vty_out(vty, "%-24s  : %-10s\n", "any",
 140                         PROTO_RM_NAME(zvrf, af_type, i));
 141         else
 142                 vty_out(vty, "%-24s  : none\n", "any");
 143 }
 144
 145 static void show_vrf_nht_rm(struct vty *vty, struct zebra_vrf *zvrf,
 146                             int af_type, json_object *json)
 147 {
 148         int i;
 149
 150         if (!json) {
 151                 vty_out(vty, "Protocol                  : route-map\n");
 152                 vty_out(vty, "-------------------------------------\n");
 153         }
 154
 155         for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
 156                 if (json) {
 157                         if (NHT_RM_NAME(zvrf, af_type, i))
 158                                 json_object_string_add(
 159                                         json, zebra_route_string(i),
 160                                         NHT_RM_NAME(zvrf, af_type, i));
 161                         else
 162                                 json_object_string_add(
 163                                         json, zebra_route_string(i), "none");
 164                 } else {
 165                         if (NHT_RM_NAME(zvrf, af_type, i))
 166                                 vty_out(vty, "%-24s  : %-10s\n",
 167                                         zebra_route_string(i),
 168                                         NHT_RM_NAME(zvrf, af_type, i));
 169                         else
 170                                 vty_out(vty, "%-24s  : none\n",
 171                                         zebra_route_string(i));
 172                 }
 173         }
 174
 175         if (json) {
 176                 if (NHT_RM_NAME(zvrf, af_type, i))
 177                         json_object_string_add(json, "any",
 178                                                NHT_RM_NAME(zvrf, af_type, i));
 179                 else
 180                         json_object_string_add(json, "any", "none");
 181         } else {
 182                 if (NHT_RM_NAME(zvrf, af_type, i))
 183                         vty_out(vty, "%-24s  : %-10s\n", "any",
 184                                 NHT_RM_NAME(zvrf, af_type, i));
 185                 else
 186                         vty_out(vty, "%-24s  : none\n", "any");
 187         }
 188 }
 189
 190 static int show_proto_rm(struct vty *vty, int af_type, const char *vrf_all,
 191                          const char *vrf_name)
 192 {
 193         struct zebra_vrf *zvrf;
 194
 195         if (vrf_all) {
 196                 struct vrf *vrf;
 197
 198                 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
 199                         zvrf = (struct zebra_vrf *)vrf->info;
 200                         if (zvrf == NULL)
 201                                 continue;
 202                         vty_out(vty, "VRF: %s\n", zvrf->vrf->name);
 203                         show_vrf_proto_rm(vty, zvrf, af_type);
 204                 }
 205         } else {
 206                 vrf_id_t vrf_id = VRF_DEFAULT;
 207
 208                 if (vrf_name)
 209                         VRF_GET_ID(vrf_id, vrf_name, false);
 210
 211                 zvrf = zebra_vrf_lookup_by_id(vrf_id);
 212                 if (!zvrf)
 213                         return CMD_SUCCESS;
 214
 215                 vty_out(vty, "VRF: %s\n", zvrf->vrf->name);
 216                 show_vrf_proto_rm(vty, zvrf, af_type);
 217         }
 218
 219         return CMD_SUCCESS;
 220 }
 221
 222 static int show_nht_rm(struct vty *vty, int af_type, const char *vrf_all,
 223                        const char *vrf_name, bool use_json)
 224 {
 225         struct zebra_vrf *zvrf;
 226         json_object *json = NULL;
 227         json_object *json_vrfs = NULL;
 228
 229         if (use_json) {
 230                 json = json_object_new_object();
 231                 json_vrfs = json_object_new_object();
 232                 json_object_string_add(json, "afi",
 233                                        (af_type == AFI_IP) ? "ipv4" : "ipv6");
 234         }
 235
 236         if (vrf_all) {
 237                 struct vrf *vrf;
 238
 239                 if (use_json)
 240                         json_object_object_add(json, "vrfs", json_vrfs);
 241
 242                 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
 243                         zvrf = (struct zebra_vrf *)vrf->info;
 244                         if (zvrf == NULL)
 245                                 continue;
 246
 247                         if (use_json) {
 248                                 json_object *json_proto = NULL;
 249                                 json_object *json_vrf = NULL;
 250                                 json_vrf = json_object_new_object();
 251                                 json_object_object_add(
 252                                         json_vrfs, zvrf->vrf->name, json_vrf);
 253                                 json_proto = json_object_new_object();
 254                                 json_object_object_add(json_vrf, "protocols",
 255                                                        json_proto);
 256                                 show_vrf_nht_rm(vty, zvrf, af_type, json_proto);
 257                         } else {
 258                                 vty_out(vty, "VRF: %s\n", zvrf->vrf->name);
 259                                 show_vrf_nht_rm(vty, zvrf, af_type, NULL);
 260                         }
 261                 }
 262         } else {
 263                 json_object *json_proto = NULL;
 264                 json_object *json_vrf = NULL;
 265                 vrf_id_t vrf_id = VRF_DEFAULT;
 266
 267                 if (vrf_name)
 268                         VRF_GET_ID(vrf_id, vrf_name, false);
 269
 270                 zvrf = zebra_vrf_lookup_by_id(vrf_id);
 271                 if (!zvrf) {
 272                         json_object_free(json);
 273                         json_object_free(json_vrfs);
 274                         return CMD_SUCCESS;
 275                 }
 276
 277                 if (use_json) {
 278                         json_object_object_add(json, "vrfs", json_vrfs);
 279                         json_vrf = json_object_new_object();
 280                         json_object_object_add(json_vrfs, zvrf->vrf->name,
 281                                                json_vrf);
 282                         json_proto = json_object_new_object();
 283                         json_object_object_add(json_vrf, "protocols",
 284                                                json_proto);
 285                         show_vrf_nht_rm(vty, zvrf, af_type, json_proto);
 286                 } else {
 287                         vty_out(vty, "VRF: %s\n", zvrf->vrf->name);
 288                         show_vrf_nht_rm(vty, zvrf, af_type, NULL);
 289                 }
 290         }
 291
 292         if (use_json)
 293                 vty_json(vty, json);
 294
 295         return CMD_SUCCESS;
 296 }
 297
 298 /* Route map commands for interface matching */
 299 static const struct route_map_rule_cmd route_match_interface_cmd = {
 300         "interface",
 301         route_match_interface,
 302         route_match_interface_compile,
 303         route_match_interface_free
 304 };
 305
 306 static int ip_protocol_rm_add(struct zebra_vrf *zvrf, const char *rmap,
 307                               int rtype, afi_t afi, safi_t safi)
 308 {
 309         struct route_table *table;
 310
 311         if (PROTO_RM_NAME(zvrf, afi, rtype)) {
 312                 if (strcmp(PROTO_RM_NAME(zvrf, afi, rtype), rmap) == 0)
 313                         return CMD_SUCCESS;
 314
 315                 XFREE(MTYPE_ROUTE_MAP_NAME, PROTO_RM_NAME(zvrf, afi, rtype));
 316         }
 317         route_map_counter_decrement(PROTO_RM_MAP(zvrf, afi, rtype));
 318         PROTO_RM_NAME(zvrf, afi, rtype) = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
 319         PROTO_RM_MAP(zvrf, afi, rtype) =
 320                 route_map_lookup_by_name(PROTO_RM_NAME(zvrf, afi, rtype));
 321         route_map_counter_increment(PROTO_RM_MAP(zvrf, afi, rtype));
 322
 323         if (PROTO_RM_MAP(zvrf, afi, rtype)) {
 324
 325                 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
 326                         zlog_debug(
 327                                 "%u: IPv4 Routemap config for protocol %d scheduling RIB processing",
 328                                 zvrf->vrf->vrf_id, rtype);
 329                 /* Process routes of interested address-families. */
 330                 table = zebra_vrf_table(afi, safi, zvrf->vrf->vrf_id);
 331                 if (table)
 332                         rib_update_table(table, RIB_UPDATE_RMAP_CHANGE,
 333                                          rtype);
 334         }
 335
 336         return CMD_SUCCESS;
 337 }
 338
 339 static int ip_protocol_rm_del(struct zebra_vrf *zvrf, const char *rmap,
 340                               int rtype, afi_t afi, safi_t safi)
 341 {
 342         struct route_table *table;
 343
 344         if (!PROTO_RM_NAME(zvrf, afi, rtype))
 345                 return CMD_SUCCESS;
 346
 347         if (!rmap || strcmp(rmap, PROTO_RM_NAME(zvrf, afi, rtype)) == 0) {
 348
 349                 route_map_counter_decrement(PROTO_RM_MAP(zvrf, afi, rtype));
 350                 if (PROTO_RM_MAP(zvrf, afi, rtype)) {
 351                         if (IS_ZEBRA_DEBUG_RIB_DETAILED)
 352                                 zlog_debug(
 353                                         "%u: IPv4 Routemap unconfig for protocol %d, scheduling RIB processing",
 354                                         zvrf->vrf->vrf_id, rtype);
 355                         PROTO_RM_MAP(zvrf, afi, rtype) = NULL;
 356
 357                         /* Process routes of interested address-families. */
 358                         table = zebra_vrf_table(afi, safi, zvrf->vrf->vrf_id);
 359                         if (table)
 360                                 rib_update_table(table, RIB_UPDATE_RMAP_CHANGE,
 361                                                  rtype);
 362                 }
 363                 XFREE(MTYPE_ROUTE_MAP_NAME, PROTO_RM_NAME(zvrf, afi, rtype));
 364         }
 365         return CMD_SUCCESS;
 366 }
 367
 368 static int ip_nht_rm_add(struct zebra_vrf *zvrf, const char *rmap, int rtype,
 369                          int afi)
 370 {
 371
 372         if (NHT_RM_NAME(zvrf, afi, rtype)) {
 373                 if (strcmp(NHT_RM_NAME(zvrf, afi, rtype), rmap) == 0)
 374                         return CMD_SUCCESS;
 375
 376                 XFREE(MTYPE_ROUTE_MAP_NAME, NHT_RM_NAME(zvrf, afi, rtype));
 377         }
 378         route_map_counter_decrement(NHT_RM_MAP(zvrf, afi, rtype));
 379         NHT_RM_NAME(zvrf, afi, rtype) = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
 380         NHT_RM_MAP(zvrf, afi, rtype) =
 381                 route_map_lookup_by_name(NHT_RM_NAME(zvrf, afi, rtype));
 382         route_map_counter_increment(NHT_RM_MAP(zvrf, afi, rtype));
 383
 384         if (NHT_RM_MAP(zvrf, afi, rtype))
 385                 zebra_evaluate_rnh(zvrf, AFI_IP, 1, NULL, SAFI_UNICAST);
 386
 387         return CMD_SUCCESS;
 388 }
 389
 390 static int ip_nht_rm_del(struct zebra_vrf *zvrf, const char *rmap, int rtype,
 391                          int afi)
 392 {
 393
 394         if (!NHT_RM_NAME(zvrf, afi, rtype))
 395                 return CMD_SUCCESS;
 396
 397         if (!rmap || strcmp(rmap, NHT_RM_NAME(zvrf, afi, rtype)) == 0) {
 398                 route_map_counter_decrement(NHT_RM_MAP(zvrf, afi, rtype));
 399                 if (NHT_RM_MAP(zvrf, afi, rtype)) {
 400                         if (IS_ZEBRA_DEBUG_RIB_DETAILED)
 401                                 zlog_debug(
 402                                         "%u: IPv4 Routemap unconfig for protocol %d, scheduling RIB processing",
 403                                         zvrf->vrf->vrf_id, rtype);
 404                         NHT_RM_MAP(zvrf, afi, rtype) = NULL;
 405
 406                         zebra_evaluate_rnh(zvrf, AFI_IP, 1, NULL, SAFI_UNICAST);
 407                 }
 408                 XFREE(MTYPE_ROUTE_MAP_NAME, NHT_RM_NAME(zvrf, afi, rtype));
 409         }
 410         return CMD_SUCCESS;
 411 }
 412
 413 DEFPY_YANG(
 414         match_ip_address_prefix_len, match_ip_address_prefix_len_cmd,
 415         "match ip address prefix-len (0-32)$length",
 416         MATCH_STR
 417         IP_STR
 418         "Match prefix length of IP address\n"
 419         "Match prefix length of IP address\n"
 420         "Prefix length\n")
 421 {
 422         const char *xpath =
 423                 "./match-condition[condition='frr-zebra-route-map:ipv4-prefix-length']";
 424         char xpath_value[XPATH_MAXLEN];
 425
 426         nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
 427         snprintf(
 428                 xpath_value, sizeof(xpath_value),
 429                 "%s/rmap-match-condition/frr-zebra-route-map:ipv4-prefix-length",
 430                 xpath);
 431         nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, length_str);
 432
 433         return nb_cli_apply_changes(vty, NULL);
 434 }
 435
 436 DEFPY_YANG(
 437         no_match_ip_address_prefix_len, no_match_ip_address_prefix_len_cmd,
 438         "no match ip address prefix-len [(0-32)]",
 439         NO_STR
 440         MATCH_STR
 441         IP_STR
 442         "Match prefix length of IP address\n"
 443         "Match prefix length of IP address\n"
 444         "Prefix length\n")
 445 {
 446         const char *xpath =
 447                 "./match-condition[condition='frr-zebra-route-map:ipv4-prefix-length']";
 448
 449         nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
 450
 451         return nb_cli_apply_changes(vty, NULL);
 452 }
 453
 454 DEFPY_YANG(
 455         match_ipv6_address_prefix_len, match_ipv6_address_prefix_len_cmd,
 456         "match ipv6 address prefix-len (0-128)$length",
 457         MATCH_STR
 458         IPV6_STR
 459         "Match prefix length of IPv6 address\n"
 460         "Match prefix length of IPv6 address\n"
 461         "Prefix length\n")
 462 {
 463         const char *xpath =
 464                 "./match-condition[condition='frr-zebra-route-map:ipv6-prefix-length']";
 465         char xpath_value[XPATH_MAXLEN];
 466
 467         nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
 468         snprintf(
 469                 xpath_value, sizeof(xpath_value),
 470                 "%s/rmap-match-condition/frr-zebra-route-map:ipv6-prefix-length",
 471                 xpath);
 472         nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, length_str);
 473
 474         return nb_cli_apply_changes(vty, NULL);
 475 }
 476
 477 DEFPY_YANG(
 478         no_match_ipv6_address_prefix_len, no_match_ipv6_address_prefix_len_cmd,
 479         "no match ipv6 address prefix-len [(0-128)]",
 480         NO_STR
 481         MATCH_STR
 482         IPV6_STR
 483         "Match prefix length of IPv6 address\n"
 484         "Match prefix length of IPv6 address\n"
 485         "Prefix length\n")
 486 {
 487         const char *xpath =
 488                 "./match-condition[condition='frr-zebra-route-map:ipv6-prefix-length']";
 489
 490         nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
 491
 492         return nb_cli_apply_changes(vty, NULL);
 493 }
 494
 495 DEFPY_YANG(
 496         match_ip_nexthop_prefix_len, match_ip_nexthop_prefix_len_cmd,
 497         "match ip next-hop prefix-len (0-32)$length",
 498         MATCH_STR
 499         IP_STR
 500         "Match prefixlen of nexthop IP address\n"
 501         "Match prefixlen of given nexthop\n"
 502         "Prefix length\n")
 503 {
 504         const char *xpath =
 505                 "./match-condition[condition='frr-zebra-route-map:ipv4-next-hop-prefix-length']";
 506         char xpath_value[XPATH_MAXLEN];
 507
 508         nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
 509         snprintf(
 510                 xpath_value, sizeof(xpath_value),
 511                 "%s/rmap-match-condition/frr-zebra-route-map:ipv4-prefix-length",
 512                 xpath);
 513         nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, length_str);
 514
 515         return nb_cli_apply_changes(vty, NULL);
 516 }
 517
 518 DEFPY_YANG(
 519         no_match_ip_nexthop_prefix_len, no_match_ip_nexthop_prefix_len_cmd,
 520         "no match ip next-hop prefix-len [(0-32)]",
 521         NO_STR
 522         MATCH_STR
 523         IP_STR
 524         "Match prefixlen of nexthop IP address\n"
 525         "Match prefix length of nexthop\n"
 526         "Prefix length\n")
 527 {
 528         const char *xpath =
 529                 "./match-condition[condition='frr-zebra-route-map:ipv4-next-hop-prefix-length']";
 530
 531         nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
 532
 533         return nb_cli_apply_changes(vty, NULL);
 534 }
 535
 536 DEFPY_YANG(
 537         match_source_protocol, match_source_protocol_cmd,
 538         "match source-protocol " FRR_REDIST_STR_ZEBRA "$proto",
 539         MATCH_STR
 540         "Match protocol via which the route was learnt\n"
 541         FRR_REDIST_HELP_STR_ZEBRA)
 542 {
 543         const char *xpath =
 544                 "./match-condition[condition='frr-zebra-route-map:source-protocol']";
 545         char xpath_value[XPATH_MAXLEN];
 546
 547         nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
 548         snprintf(xpath_value, sizeof(xpath_value),
 549                  "%s/rmap-match-condition/frr-zebra-route-map:source-protocol",
 550                  xpath);
 551         nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, proto);
 552
 553         return nb_cli_apply_changes(vty, NULL);
 554 }
 555
 556 DEFPY_YANG(
 557         no_match_source_protocol, no_match_source_protocol_cmd,
 558         "no match source-protocol [" FRR_REDIST_STR_ZEBRA "]",
 559         NO_STR
 560         MATCH_STR
 561         "Match protocol via which the route was learnt\n"
 562         FRR_REDIST_HELP_STR_ZEBRA)
 563 {
 564         const char *xpath =
 565                 "./match-condition[condition='frr-zebra-route-map:source-protocol']";
 566
 567         nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
 568
 569         return nb_cli_apply_changes(vty, NULL);
 570 }
 571
 572 DEFPY_YANG(
 573         match_source_instance, match_source_instance_cmd,
 574         "match source-instance (0-255)$instance",
 575         MATCH_STR
 576         "Match the protocol's instance number\n"
 577         "The instance number\n")
 578 {
 579         const char *xpath =
 580                 "./match-condition[condition='frr-zebra-route-map:source-instance']";
 581         char xpath_value[XPATH_MAXLEN];
 582
 583         nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
 584         snprintf(xpath_value, sizeof(xpath_value),
 585                  "%s/rmap-match-condition/frr-zebra-route-map:source-instance",
 586                  xpath);
 587         nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, instance_str);
 588
 589         return nb_cli_apply_changes(vty, NULL);
 590 }
 591
 592 DEFPY_YANG(
 593         no_match_source_instance, no_match_source_instance_cmd,
 594         "no match source-instance [(0-255)]",
 595         NO_STR MATCH_STR
 596         "Match the protocol's instance number\n"
 597         "The instance number\n")
 598 {
 599         const char *xpath =
 600                 "./match-condition[condition='frr-zebra-route-map:source-instance']";
 601
 602         nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
 603
 604         return nb_cli_apply_changes(vty, NULL);
 605 }
 606
 607 /* set functions */
 608
 609 DEFPY_YANG(
 610         set_src, set_src_cmd,
 611         "set src <A.B.C.D$addrv4|X:X::X:X$addrv6>",
 612         SET_STR
 613         "src address for route\n"
 614         "IPv4 src address\n"
 615         "IPv6 src address\n")
 616 {
 617         const char *xpath =
 618                 "./set-action[action='frr-zebra-route-map:src-address']";
 619         char xpath_value[XPATH_MAXLEN];
 620
 621         nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
 622         if (addrv4_str) {
 623                 snprintf(
 624                         xpath_value, sizeof(xpath_value),
 625                         "%s/rmap-set-action/frr-zebra-route-map:ipv4-src-address",
 626                         xpath);
 627                 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
 628                                       addrv4_str);
 629         } else {
 630                 snprintf(
 631                         xpath_value, sizeof(xpath_value),
 632                         "%s/rmap-set-action/frr-zebra-route-map:ipv6-src-address",
 633                         xpath);
 634                 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
 635                                       addrv6_str);
 636         }
 637
 638         return nb_cli_apply_changes(vty, NULL);
 639 }
 640
 641 DEFPY_YANG(
 642         no_set_src, no_set_src_cmd,
 643         "no set src [<A.B.C.D|X:X::X:X>]",
 644         NO_STR
 645         SET_STR
 646         "Source address for route\n"
 647         "IPv4 address\n"
 648         "IPv6 address\n")
 649 {
 650         const char *xpath =
 651                 "./set-action[action='frr-zebra-route-map:src-address']";
 652
 653         nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
 654
 655         return nb_cli_apply_changes(vty, NULL);
 656 }
 657
 658 DEFUN_YANG (zebra_route_map_timer,
 659        zebra_route_map_timer_cmd,
 660        "zebra route-map delay-timer (0-600)",
 661        ZEBRA_STR
 662        "Set route-map parameters\n"
 663        "Time to wait before route-map updates are processed\n"
 664        "0 means route-map changes are run immediately instead of delaying\n")
 665 {
 666         int idx_number = 3;
 667         uint32_t rmap_delay_timer;
 668
 669         rmap_delay_timer = strtoul(argv[idx_number]->arg, NULL, 10);
 670         zebra_route_map_set_delay_timer(rmap_delay_timer);
 671
 672         return (CMD_SUCCESS);
 673 }
 674
 675 DEFUN_YANG (no_zebra_route_map_timer,
 676        no_zebra_route_map_timer_cmd,
 677        "no zebra route-map delay-timer [(0-600)]",
 678        NO_STR
 679        ZEBRA_STR
 680        "Set route-map parameters\n"
 681        "Reset delay-timer to default value, 30 secs\n"
 682        "0 means route-map changes are run immediately instead of delaying\n")
 683 {
 684         zebra_route_map_set_delay_timer(ZEBRA_RMAP_DEFAULT_UPDATE_TIMER);
 685
 686         return (CMD_SUCCESS);
 687 }
 688
 689 DEFPY_YANG (ip_protocol,
 690        ip_protocol_cmd,
 691        "ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
 692        " $proto route-map ROUTE-MAP$rmap",
 693        IP_STR
 694        "Filter routing info exchanged between zebra and protocol\n"
 695        FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
 696        "Specify route-map\n"
 697        "Route map name\n")
 698 {
 699         int ret, rtype;
 700
 701         assert(proto);
 702         assert(rmap);
 703
 704         ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
 705
 706         if (!zvrf)
 707                 return CMD_WARNING;
 708
 709         if (strcasecmp(proto, "any") == 0)
 710                 rtype = ZEBRA_ROUTE_MAX;
 711         else
 712                 rtype = proto_name2num(proto);
 713         if (rtype < 0) {
 714                 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
 715                 return CMD_WARNING_CONFIG_FAILED;
 716         }
 717
 718         ret = ip_protocol_rm_add(zvrf, rmap, rtype, AFI_IP, SAFI_UNICAST);
 719
 720         return ret;
 721 }
 722
 723 DEFPY_YANG (no_ip_protocol,
 724        no_ip_protocol_cmd,
 725        "no ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
 726        " $proto [route-map ROUTE-MAP$rmap]",
 727        NO_STR
 728        IP_STR
 729        "Stop filtering routing info between zebra and protocol\n"
 730        FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
 731        "Specify route-map\n"
 732        "Route map name\n")
 733 {
 734         int ret, rtype;
 735
 736         assert(proto);
 737
 738         ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
 739
 740         if (!zvrf)
 741                 return CMD_WARNING;
 742
 743         if (strcasecmp(proto, "any") == 0)
 744                 rtype = ZEBRA_ROUTE_MAX;
 745         else
 746                 rtype = proto_name2num(proto);
 747         if (rtype < 0) {
 748                 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
 749                 return CMD_WARNING_CONFIG_FAILED;
 750         }
 751
 752         ret = ip_protocol_rm_del(zvrf, rmap, rtype, AFI_IP, SAFI_UNICAST);
 753
 754         return ret;
 755 }
 756
 757 DEFPY_YANG (show_ip_protocol,
 758        show_ip_protocol_cmd,
 759        "show ip protocol [vrf <NAME$vrf_name|all$vrf_all>]",
 760        SHOW_STR
 761        IP_STR
 762        "IP protocol filtering status\n"
 763        VRF_FULL_CMD_HELP_STR)
 764 {
 765         int ret = show_proto_rm(vty, AFI_IP, vrf_all, vrf_name);
 766
 767         return ret;
 768 }
 769
 770 DEFPY_YANG (ipv6_protocol,
 771        ipv6_protocol_cmd,
 772        "ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
 773        " $proto route-map ROUTE-MAP$rmap",
 774        IP6_STR
 775        "Filter IPv6 routing info exchanged between zebra and protocol\n"
 776        FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
 777        "Specify route-map\n"
 778        "Route map name\n")
 779 {
 780         int ret, rtype;
 781
 782         assert(rmap);
 783         assert(proto);
 784
 785         ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
 786
 787         if (!zvrf)
 788                 return CMD_WARNING;
 789
 790         if (strcasecmp(proto, "any") == 0)
 791                 rtype = ZEBRA_ROUTE_MAX;
 792         else
 793                 rtype = proto_name2num(proto);
 794         if (rtype < 0) {
 795                 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
 796                 return CMD_WARNING_CONFIG_FAILED;
 797         }
 798
 799         ret = ip_protocol_rm_add(zvrf, rmap, rtype, AFI_IP6, SAFI_UNICAST);
 800
 801         return ret;
 802 }
 803
 804 DEFPY_YANG (no_ipv6_protocol,
 805        no_ipv6_protocol_cmd,
 806        "no ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
 807        " $proto [route-map ROUTE-MAP$rmap]",
 808        NO_STR
 809        IP6_STR
 810        "Stop filtering IPv6 routing info between zebra and protocol\n"
 811        FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
 812        "Specify route-map\n"
 813        "Route map name\n")
 814 {
 815         int ret, rtype;
 816
 817         assert(proto);
 818
 819         ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
 820
 821         if (!zvrf)
 822                 return CMD_WARNING;
 823
 824         if (strcasecmp(proto, "any") == 0)
 825                 rtype = ZEBRA_ROUTE_MAX;
 826         else
 827                 rtype = proto_name2num(proto);
 828         if (rtype < 0) {
 829                 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
 830                 return CMD_WARNING_CONFIG_FAILED;
 831         }
 832
 833         ret = ip_protocol_rm_del(zvrf, rmap, rtype, AFI_IP6, SAFI_UNICAST);
 834
 835         return ret;
 836 }
 837
 838 DEFPY_YANG (show_ipv6_protocol,
 839        show_ipv6_protocol_cmd,
 840        "show ipv6 protocol [vrf <NAME$vrf_name|all$vrf_all>]",
 841        SHOW_STR
 842        IP6_STR
 843        "IPv6 protocol filtering status\n"
 844        VRF_FULL_CMD_HELP_STR)
 845 {
 846         int ret = show_proto_rm(vty, AFI_IP6, vrf_all, vrf_name);
 847
 848         return ret;
 849 }
 850
 851 DEFPY_YANG (ip_protocol_nht_rmap,
 852        ip_protocol_nht_rmap_cmd,
 853        "ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
 854        " $proto route-map ROUTE-MAP$rmap",
 855        IP_STR
 856        "Filter Next Hop tracking route resolution\n"
 857        FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
 858        "Specify route map\n"
 859        "Route map name\n")
 860 {
 861
 862         int ret, rtype;
 863
 864         assert(proto);
 865         assert(rmap);
 866
 867         ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
 868
 869         if (!zvrf)
 870                 return CMD_WARNING;
 871
 872         if (strcasecmp(proto, "any") == 0)
 873                 rtype = ZEBRA_ROUTE_MAX;
 874         else
 875                 rtype = proto_name2num(proto);
 876         if (rtype < 0) {
 877                 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
 878                 return CMD_WARNING_CONFIG_FAILED;
 879         }
 880
 881         ret = ip_nht_rm_add(zvrf, rmap, rtype, AFI_IP);
 882
 883         return ret;
 884 }
 885
 886 DEFPY_YANG (no_ip_protocol_nht_rmap,
 887        no_ip_protocol_nht_rmap_cmd,
 888        "no ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
 889        " $proto route-map [ROUTE-MAP$rmap]",
 890        NO_STR
 891        IP_STR
 892        "Filter Next Hop tracking route resolution\n"
 893        FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
 894        "Specify route map\n"
 895        "Route map name\n")
 896 {
 897         int ret, rtype;
 898
 899         assert(proto);
 900
 901         ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
 902
 903         if (!zvrf)
 904                 return CMD_WARNING;
 905
 906         if (strcasecmp(proto, "any") == 0)
 907                 rtype = ZEBRA_ROUTE_MAX;
 908         else
 909                 rtype = proto_name2num(proto);
 910         if (rtype < 0) {
 911                 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
 912                 return CMD_WARNING_CONFIG_FAILED;
 913         }
 914
 915         ret = ip_nht_rm_del(zvrf, rmap, rtype, AFI_IP);
 916
 917         return ret;
 918 }
 919
 920 DEFPY_YANG (show_ip_protocol_nht,
 921        show_ip_protocol_nht_cmd,
 922        "show ip nht route-map [vrf <NAME$vrf_name|all$vrf_all>] [json]",
 923        SHOW_STR
 924        IP_STR
 925        "IPv4 nexthop tracking table\n"
 926        "IPv4 Next Hop tracking filtering status\n"
 927        VRF_CMD_HELP_STR
 928        "All VRFs\n"
 929        JSON_STR)
 930 {
 931         int ret;
 932         bool uj = use_json(argc, argv);
 933
 934         ret = show_nht_rm(vty, AFI_IP, vrf_all, vrf_name, uj);
 935
 936         return ret;
 937 }
 938
 939 DEFPY_YANG (ipv6_protocol_nht_rmap,
 940        ipv6_protocol_nht_rmap_cmd,
 941        "ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
 942        " $proto route-map ROUTE-MAP$rmap",
 943        IP6_STR
 944        "Filter Next Hop tracking route resolution\n"
 945        FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
 946        "Specify route map\n"
 947        "Route map name\n")
 948 {
 949         int ret, rtype;
 950
 951         assert(rmap);
 952         assert(proto);
 953
 954         ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
 955
 956         if (!zvrf)
 957                 return CMD_WARNING;
 958
 959         if (strcasecmp(proto, "any") == 0)
 960                 rtype = ZEBRA_ROUTE_MAX;
 961         else
 962                 rtype = proto_name2num(proto);
 963         if (rtype < 0) {
 964                 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
 965                 return CMD_WARNING_CONFIG_FAILED;
 966         }
 967
 968         ret = ip_nht_rm_add(zvrf, rmap, rtype, AFI_IP6);
 969
 970         return ret;
 971 }
 972
 973 DEFPY_YANG (no_ipv6_protocol_nht_rmap,
 974        no_ipv6_protocol_nht_rmap_cmd,
 975        "no ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
 976        " $proto [route-map ROUTE-MAP$rmap]",
 977        NO_STR
 978        IP6_STR
 979        "Filter Next Hop tracking route resolution\n"
 980        FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
 981        "Specify route map\n"
 982        "Route map name\n")
 983 {
 984         int ret, rtype;
 985
 986         assert(proto);
 987
 988         ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
 989
 990         if (!zvrf)
 991                 return CMD_WARNING;
 992
 993         if (strcasecmp(proto, "any") == 0)
 994                 rtype = ZEBRA_ROUTE_MAX;
 995         else
 996                 rtype = proto_name2num(proto);
 997         if (rtype < 0) {
 998                 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
 999                 return CMD_WARNING_CONFIG_FAILED;
1000         }
1001
1002         ret = ip_nht_rm_del(zvrf, rmap, rtype, AFI_IP6);
1003
1004         return ret;
1005 }
1006
1007 DEFPY_YANG (show_ipv6_protocol_nht,
1008        show_ipv6_protocol_nht_cmd,
1009        "show ipv6 nht route-map [vrf <NAME$vrf_name|all$vrf_all>] [json]",
1010        SHOW_STR
1011        IP6_STR
1012        "IPv6 nexthop tracking table\n"
1013        "IPv6 Next Hop tracking filtering status\n"
1014        VRF_CMD_HELP_STR
1015        "All VRFs\n"
1016        JSON_STR)
1017 {
1018         int ret;
1019         bool uj = use_json(argc, argv);
1020
1021         ret = show_nht_rm(vty, AFI_IP6, vrf_all, vrf_name, uj);
1022
1023         return ret;
1024 }
1025
1026 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
1027
1028 /* `match ip next-hop IP_ACCESS_LIST' */
1029
1030 /* Match function return 1 if match is success else return zero. */
1031 static enum route_map_cmd_result_t
1032 route_match_ip_next_hop(void *rule, const struct prefix *prefix, void *object)
1033 {
1034         struct access_list *alist;
1035         struct nh_rmap_obj *nh_data;
1036         struct prefix_ipv4 p;
1037
1038         nh_data = object;
1039         if (!nh_data)
1040                 return RMAP_NOMATCH;
1041
1042         switch (nh_data->nexthop->type) {
1043         case NEXTHOP_TYPE_IFINDEX:
1044                 /* Interface routes can't match ip next-hop */
1045                 return RMAP_NOMATCH;
1046         case NEXTHOP_TYPE_IPV4_IFINDEX:
1047         case NEXTHOP_TYPE_IPV4:
1048                 p.family = AF_INET;
1049                 p.prefix = nh_data->nexthop->gate.ipv4;
1050                 p.prefixlen = IPV4_MAX_BITLEN;
1051                 break;
1052         default:
1053                 return RMAP_NOMATCH;
1054         }
1055         alist = access_list_lookup(AFI_IP, (char *)rule);
1056         if (alist == NULL)
1057                 return RMAP_NOMATCH;
1058
1059         return (access_list_apply(alist, &p) == FILTER_DENY ? RMAP_NOMATCH
1060                                                             : RMAP_MATCH);
1061 }
1062
1063 /* Route map `ip next-hop' match statement.  `arg' should be
1064    access-list name. */
1065 static void *route_match_ip_next_hop_compile(const char *arg)
1066 {
1067         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1068 }
1069
1070 /* Free route map's compiled `. */
1071 static void route_match_ip_next_hop_free(void *rule)
1072 {
1073         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1074 }
1075
1076 /* Route map commands for ip next-hop matching. */
1077 static const struct route_map_rule_cmd route_match_ip_next_hop_cmd = {
1078         "ip next-hop",
1079         route_match_ip_next_hop,
1080         route_match_ip_next_hop_compile,
1081         route_match_ip_next_hop_free
1082 };
1083
1084 /* `match ip next-hop prefix-list PREFIX_LIST' */
1085
1086 static enum route_map_cmd_result_t
1087 route_match_ip_next_hop_prefix_list(void *rule, const struct prefix *prefix,
1088                                     void *object)
1089 {
1090         struct prefix_list *plist;
1091         struct nh_rmap_obj *nh_data;
1092         struct prefix_ipv4 p;
1093
1094         nh_data = (struct nh_rmap_obj *)object;
1095         if (!nh_data)
1096                 return RMAP_NOMATCH;
1097
1098         switch (nh_data->nexthop->type) {
1099         case NEXTHOP_TYPE_IFINDEX:
1100                 /* Interface routes can't match ip next-hop */
1101                 return RMAP_NOMATCH;
1102         case NEXTHOP_TYPE_IPV4_IFINDEX:
1103         case NEXTHOP_TYPE_IPV4:
1104                 p.family = AF_INET;
1105                 p.prefix = nh_data->nexthop->gate.ipv4;
1106                 p.prefixlen = IPV4_MAX_BITLEN;
1107                 break;
1108         default:
1109                 return RMAP_NOMATCH;
1110         }
1111         plist = prefix_list_lookup(AFI_IP, (char *)rule);
1112         if (plist == NULL)
1113                 return RMAP_NOMATCH;
1114
1115         return (prefix_list_apply(plist, &p) == PREFIX_DENY ? RMAP_NOMATCH
1116                                                             : RMAP_MATCH);
1117 }
1118
1119 static void *route_match_ip_next_hop_prefix_list_compile(const char *arg)
1120 {
1121         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1122 }
1123
1124 static void route_match_ip_next_hop_prefix_list_free(void *rule)
1125 {
1126         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1127 }
1128
1129 static const struct route_map_rule_cmd
1130                 route_match_ip_next_hop_prefix_list_cmd = {
1131         "ip next-hop prefix-list",
1132         route_match_ip_next_hop_prefix_list,
1133         route_match_ip_next_hop_prefix_list_compile,
1134         route_match_ip_next_hop_prefix_list_free
1135 };
1136
1137 /* `match ip address IP_ACCESS_LIST' */
1138
1139 /* Match function should return 1 if match is success else return
1140    zero. */
1141 static enum route_map_cmd_result_t
1142 route_match_address(afi_t afi, void *rule, const struct prefix *prefix,
1143                     void *object)
1144 {
1145         struct access_list *alist;
1146
1147         alist = access_list_lookup(afi, (char *)rule);
1148         if (alist == NULL)
1149                 return RMAP_NOMATCH;
1150
1151         return (access_list_apply(alist, prefix) == FILTER_DENY ? RMAP_NOMATCH
1152                                                                 : RMAP_MATCH);
1153 }
1154
1155 static enum route_map_cmd_result_t
1156 route_match_ip_address(void *rule, const struct prefix *prefix, void *object)
1157 {
1158         return route_match_address(AFI_IP, rule, prefix, object);
1159 }
1160
1161 static enum route_map_cmd_result_t
1162 route_match_ipv6_address(void *rule, const struct prefix *prefix, void *object)
1163 {
1164         return route_match_address(AFI_IP6, rule, prefix, object);
1165 }
1166
1167 /* Route map `ip address' match statement.  `arg' should be
1168    access-list name. */
1169 static void *route_match_address_compile(const char *arg)
1170 {
1171         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1172 }
1173
1174 /* Free route map's compiled `ip address' value. */
1175 static void route_match_address_free(void *rule)
1176 {
1177         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1178 }
1179
1180 /* Route map commands for ip address matching. */
1181 static const struct route_map_rule_cmd route_match_ip_address_cmd = {
1182         "ip address",
1183         route_match_ip_address,
1184         route_match_address_compile,
1185         route_match_address_free
1186 };
1187
1188 /* Route map commands for ipv6 address matching. */
1189 static const struct route_map_rule_cmd route_match_ipv6_address_cmd = {
1190         "ipv6 address",
1191         route_match_ipv6_address,
1192         route_match_address_compile,
1193         route_match_address_free
1194 };
1195
1196 /* `match ip address prefix-list PREFIX_LIST' */
1197
1198 static enum route_map_cmd_result_t
1199 route_match_address_prefix_list(void *rule, const struct prefix *prefix,
1200                                 void *object, afi_t afi)
1201 {
1202         struct prefix_list *plist;
1203
1204         plist = prefix_list_lookup(afi, (char *)rule);
1205         if (plist == NULL)
1206                 return RMAP_NOMATCH;
1207
1208         return (prefix_list_apply(plist, prefix) == PREFIX_DENY ? RMAP_NOMATCH
1209                                                                 : RMAP_MATCH);
1210 }
1211
1212 static enum route_map_cmd_result_t
1213 route_match_ip_address_prefix_list(void *rule, const struct prefix *prefix,
1214                                    void *object)
1215 {
1216         return (route_match_address_prefix_list(rule, prefix, object, AFI_IP));
1217 }
1218
1219 static void *route_match_address_prefix_list_compile(const char *arg)
1220 {
1221         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1222 }
1223
1224 static void route_match_address_prefix_list_free(void *rule)
1225 {
1226         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1227 }
1228
1229 static const struct route_map_rule_cmd
1230                 route_match_ip_address_prefix_list_cmd = {
1231         "ip address prefix-list",
1232         route_match_ip_address_prefix_list,
1233         route_match_address_prefix_list_compile,
1234         route_match_address_prefix_list_free
1235 };
1236
1237 static enum route_map_cmd_result_t
1238 route_match_ipv6_address_prefix_list(void *rule, const struct prefix *prefix,
1239                                      void *object)
1240 {
1241         return (route_match_address_prefix_list(rule, prefix, object, AFI_IP6));
1242 }
1243
1244 static const struct route_map_rule_cmd
1245                 route_match_ipv6_address_prefix_list_cmd = {
1246         "ipv6 address prefix-list",
1247         route_match_ipv6_address_prefix_list,
1248         route_match_address_prefix_list_compile,
1249         route_match_address_prefix_list_free
1250 };
1251
1252 /* `match ipv6 next-hop type <TYPE>' */
1253
1254 static enum route_map_cmd_result_t
1255 route_match_ipv6_next_hop_type(void *rule, const struct prefix *prefix,
1256                                void *object)
1257 {
1258         struct nh_rmap_obj *nh_data;
1259
1260         if (prefix->family == AF_INET6) {
1261                 nh_data = (struct nh_rmap_obj *)object;
1262                 if (!nh_data)
1263                         return RMAP_NOMATCH;
1264
1265                 if (nh_data->nexthop->type == NEXTHOP_TYPE_BLACKHOLE)
1266                         return RMAP_MATCH;
1267         }
1268
1269         return RMAP_NOMATCH;
1270 }
1271
1272 static void *route_match_ipv6_next_hop_type_compile(const char *arg)
1273 {
1274         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1275 }
1276
1277 static void route_match_ipv6_next_hop_type_free(void *rule)
1278 {
1279         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1280 }
1281
1282 static const struct route_map_rule_cmd
1283                 route_match_ipv6_next_hop_type_cmd = {
1284         "ipv6 next-hop type",
1285         route_match_ipv6_next_hop_type,
1286         route_match_ipv6_next_hop_type_compile,
1287         route_match_ipv6_next_hop_type_free
1288 };
1289
1290 /* `match ip address prefix-len PREFIXLEN' */
1291
1292 static enum route_map_cmd_result_t
1293 route_match_address_prefix_len(void *rule, const struct prefix *prefix,
1294                                void *object)
1295 {
1296         uint32_t *prefixlen = (uint32_t *)rule;
1297
1298         return ((prefix->prefixlen == *prefixlen) ? RMAP_MATCH : RMAP_NOMATCH);
1299 }
1300
1301 static void *route_match_address_prefix_len_compile(const char *arg)
1302 {
1303         uint32_t *prefix_len;
1304         char *endptr = NULL;
1305         unsigned long tmpval;
1306
1307         /* prefix len value shoud be integer. */
1308         if (!all_digit(arg))
1309                 return NULL;
1310
1311         errno = 0;
1312         tmpval = strtoul(arg, &endptr, 10);
1313         if (*endptr != '\0' || errno || tmpval > UINT32_MAX)
1314                 return NULL;
1315
1316         prefix_len = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
1317
1318         *prefix_len = tmpval;
1319         return prefix_len;
1320 }
1321
1322 static void route_match_address_prefix_len_free(void *rule)
1323 {
1324         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1325 }
1326
1327 static const struct route_map_rule_cmd
1328                 route_match_ip_address_prefix_len_cmd = {
1329         "ip address prefix-len",
1330         route_match_address_prefix_len,
1331         route_match_address_prefix_len_compile,
1332         route_match_address_prefix_len_free
1333 };
1334
1335 static const struct route_map_rule_cmd
1336                 route_match_ipv6_address_prefix_len_cmd = {
1337         "ipv6 address prefix-len",
1338         route_match_address_prefix_len,
1339         route_match_address_prefix_len_compile,
1340         route_match_address_prefix_len_free
1341 };
1342
1343 /* `match ip nexthop prefix-len PREFIXLEN' */
1344
1345 static enum route_map_cmd_result_t
1346 route_match_ip_nexthop_prefix_len(void *rule, const struct prefix *prefix,
1347                                   void *object)
1348 {
1349         uint32_t *prefixlen = (uint32_t *)rule;
1350         struct nh_rmap_obj *nh_data;
1351         struct prefix_ipv4 p;
1352
1353         nh_data = (struct nh_rmap_obj *)object;
1354         if (!nh_data || !nh_data->nexthop)
1355                 return RMAP_NOMATCH;
1356
1357         switch (nh_data->nexthop->type) {
1358         case NEXTHOP_TYPE_IFINDEX:
1359                 /* Interface routes can't match ip next-hop */
1360                 return RMAP_NOMATCH;
1361         case NEXTHOP_TYPE_IPV4_IFINDEX:
1362         case NEXTHOP_TYPE_IPV4:
1363                 p.family = AF_INET;
1364                 p.prefix = nh_data->nexthop->gate.ipv4;
1365                 p.prefixlen = IPV4_MAX_BITLEN;
1366                 break;
1367         default:
1368                 return RMAP_NOMATCH;
1369         }
1370         return ((p.prefixlen == *prefixlen) ? RMAP_MATCH : RMAP_NOMATCH);
1371 }
1372
1373 static const struct route_map_rule_cmd
1374                 route_match_ip_nexthop_prefix_len_cmd = {
1375         "ip next-hop prefix-len",
1376         route_match_ip_nexthop_prefix_len,
1377         route_match_address_prefix_len_compile, /* reuse */
1378         route_match_address_prefix_len_free     /* reuse */
1379 };
1380
1381 /* `match ip next-hop type <blackhole>' */
1382
1383 static enum route_map_cmd_result_t
1384 route_match_ip_next_hop_type(void *rule, const struct prefix *prefix,
1385                              void *object)
1386 {
1387         struct nh_rmap_obj *nh_data;
1388
1389         if (prefix->family == AF_INET) {
1390                 nh_data = (struct nh_rmap_obj *)object;
1391                 if (!nh_data)
1392                         return RMAP_NOMATCH;
1393
1394                 if (nh_data->nexthop->type == NEXTHOP_TYPE_BLACKHOLE)
1395                         return RMAP_MATCH;
1396         }
1397
1398         return RMAP_NOMATCH;
1399 }
1400
1401 static void *route_match_ip_next_hop_type_compile(const char *arg)
1402 {
1403         return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1404 }
1405
1406 static void route_match_ip_next_hop_type_free(void *rule)
1407 {
1408         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1409 }
1410
1411 static const struct route_map_rule_cmd
1412                 route_match_ip_next_hop_type_cmd = {
1413         "ip next-hop type",
1414         route_match_ip_next_hop_type,
1415         route_match_ip_next_hop_type_compile,
1416         route_match_ip_next_hop_type_free
1417 };
1418
1419 /* `match source-protocol PROTOCOL' */
1420
1421 static enum route_map_cmd_result_t
1422 route_match_source_protocol(void *rule, const struct prefix *p, void *object)
1423 {
1424         uint32_t *rib_type = (uint32_t *)rule;
1425         struct nh_rmap_obj *nh_data;
1426
1427         nh_data = (struct nh_rmap_obj *)object;
1428         if (!nh_data)
1429                 return RMAP_NOMATCH;
1430
1431         return ((nh_data->source_protocol == *rib_type) ? RMAP_MATCH
1432                                                         : RMAP_NOMATCH);
1433 }
1434
1435 static void *route_match_source_protocol_compile(const char *arg)
1436 {
1437         uint32_t *rib_type;
1438         int i;
1439
1440         i = proto_name2num(arg);
1441         rib_type = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
1442
1443         *rib_type = i;
1444
1445         return rib_type;
1446 }
1447
1448 static void route_match_source_protocol_free(void *rule)
1449 {
1450         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1451 }
1452
1453 static const struct route_map_rule_cmd route_match_source_protocol_cmd = {
1454         "source-protocol",
1455         route_match_source_protocol,
1456         route_match_source_protocol_compile,
1457         route_match_source_protocol_free
1458 };
1459
1460 /* `source-instance` */
1461 static enum route_map_cmd_result_t
1462 route_match_source_instance(void *rule, const struct prefix *p, void *object)
1463 {
1464         uint8_t *instance = (uint8_t *)rule;
1465         struct nh_rmap_obj *nh_data;
1466
1467         nh_data = (struct nh_rmap_obj *)object;
1468         if (!nh_data)
1469                 return RMAP_NOMATCH;
1470
1471         return (nh_data->instance == *instance) ? RMAP_MATCH : RMAP_NOMATCH;
1472 }
1473
1474 static void *route_match_source_instance_compile(const char *arg)
1475 {
1476         uint8_t *instance;
1477         int i;
1478
1479         i = atoi(arg);
1480         instance = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
1481
1482         *instance = i;
1483
1484         return instance;
1485 }
1486
1487 static void route_match_source_instance_free(void *rule)
1488 {
1489         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1490 }
1491
1492 static const struct route_map_rule_cmd route_match_source_instance_cmd = {
1493         "source-instance",
1494         route_match_source_instance,
1495         route_match_source_instance_compile,
1496         route_match_source_instance_free
1497 };
1498
1499 /* `set src A.B.C.D' */
1500
1501 /* Set src. */
1502 static enum route_map_cmd_result_t
1503 route_set_src(void *rule, const struct prefix *prefix, void *object)
1504 {
1505         struct nh_rmap_obj *nh_data;
1506
1507         nh_data = (struct nh_rmap_obj *)object;
1508         nh_data->nexthop->rmap_src = *(union g_addr *)rule;
1509
1510         return RMAP_OKAY;
1511 }
1512
1513 /* set src compilation. */
1514 static void *route_set_src_compile(const char *arg)
1515 {
1516         union g_addr src, *psrc;
1517
1518         if ((inet_pton(AF_INET6, arg, &src.ipv6) == 1)
1519             || (inet_pton(AF_INET, arg, &src.ipv4) == 1)) {
1520                 psrc = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(union g_addr));
1521                 *psrc = src;
1522                 return psrc;
1523         }
1524         return NULL;
1525 }
1526
1527 /* Free route map's compiled `set src' value. */
1528 static void route_set_src_free(void *rule)
1529 {
1530         XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1531 }
1532
1533 /* Set src rule structure. */
1534 static const struct route_map_rule_cmd route_set_src_cmd = {
1535         "src",
1536         route_set_src,
1537         route_set_src_compile,
1538         route_set_src_free,
1539 };
1540
1541 /* The function checks if the changed routemap specified by parameter rmap
1542  * matches the configured protocol routemaps in proto_rm table. If there is
1543  * a match then rib_update_table() to process the routes.
1544  */
1545 static void zebra_rib_table_rm_update(const char *rmap)
1546 {
1547         int i = 0;
1548         struct route_table *table;
1549         struct vrf *vrf = NULL;
1550         struct zebra_vrf *zvrf = NULL;
1551         char *rmap_name;
1552         struct route_map *old = NULL;
1553
1554         RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1555                 zvrf = vrf->info;
1556                 if (!zvrf)
1557                         continue;
1558                 for (i = 0; i <= ZEBRA_ROUTE_MAX; i++) {
1559                         rmap_name = PROTO_RM_NAME(zvrf, AFI_IP, i);
1560                         if (rmap_name && (strcmp(rmap_name, rmap) == 0)) {
1561                                 if (IS_ZEBRA_DEBUG_EVENT)
1562                                         zlog_debug(
1563                                                 "%s : AFI_IP rmap %s, route type %s",
1564                                                 __func__, rmap,
1565                                                 zebra_route_string(i));
1566
1567                                 old = PROTO_RM_MAP(zvrf, AFI_IP, i);
1568
1569                                 PROTO_RM_MAP(zvrf, AFI_IP, i) =
1570                                         route_map_lookup_by_name(rmap_name);
1571                                 /* old is NULL. i.e Route map creation event.
1572                                  * So update applied_counter.
1573                                  * If Old is not NULL, i.e It may be routemap
1574                                  * updation or deletion.
1575                                  * So no need to update the counter.
1576                                  */
1577                                 if (!old)
1578                                         route_map_counter_increment(
1579                                                 PROTO_RM_MAP(zvrf, AFI_IP, i));
1580                                 /* There is single rib table for all protocols
1581                                  */
1582                                 table = zvrf->table[AFI_IP][SAFI_UNICAST];
1583                                 if (table) {
1584                                         rib_update_table(
1585                                                 table,
1586                                                 RIB_UPDATE_RMAP_CHANGE,
1587                                                 i);
1588                                 }
1589                         }
1590                         rmap_name = PROTO_RM_NAME(zvrf, AFI_IP6, i);
1591                         if (rmap_name && (strcmp(rmap_name, rmap) == 0)) {
1592                                 if (IS_ZEBRA_DEBUG_EVENT)
1593                                         zlog_debug(
1594                                                 "%s : AFI_IP6 rmap %s, route type %s",
1595                                                 __func__, rmap,
1596                                                 zebra_route_string(i));
1597
1598                                 old = PROTO_RM_MAP(zvrf, AFI_IP6, i);
1599
1600                                 PROTO_RM_MAP(zvrf, AFI_IP6, i) =
1601                                         route_map_lookup_by_name(rmap_name);
1602                                 if (!old)
1603                                         route_map_counter_increment(
1604                                                 PROTO_RM_MAP(zvrf, AFI_IP6, i));
1605                                 /* There is single rib table for all protocols
1606                                  */
1607                                 table = zvrf->table[AFI_IP6][SAFI_UNICAST];
1608                                 if (table) {
1609                                         rib_update_table(
1610                                                 table,
1611                                                 RIB_UPDATE_RMAP_CHANGE,
1612                                                 i);
1613                                 }
1614                         }
1615                 }
1616         }
1617 }
1618
1619 /* The function checks if the changed routemap specified by parameter rmap
1620  * matches the configured protocol routemaps in nht_rm table. If there is
1621  * a match then zebra_evaluate_rnh() to process the nexthops.
1622  */
1623 static void zebra_nht_rm_update(const char *rmap)
1624 {
1625         int i = 0;
1626         struct route_table *table;
1627         struct vrf *vrf = NULL;
1628         struct zebra_vrf *zvrf = NULL;
1629         char *rmap_name;
1630         char afi_ip = 0;
1631         char afi_ipv6 = 0;
1632         struct route_map *old = NULL;
1633
1634         RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1635                 zvrf = vrf->info;
1636                 if (!zvrf)
1637                         continue;
1638                 for (i = 0; i <= ZEBRA_ROUTE_MAX; i++) {
1639                         rmap_name = NHT_RM_NAME(zvrf, AFI_IP, i);
1640                         if (rmap_name && (strcmp(rmap_name, rmap) == 0)) {
1641                                 if (IS_ZEBRA_DEBUG_EVENT)
1642                                         zlog_debug(
1643                                                 "%s : AFI_IP rmap %s, route type %s",
1644                                                 __func__, rmap,
1645                                                 zebra_route_string(i));
1646
1647                                 old = NHT_RM_MAP(zvrf, AFI_IP, i);
1648
1649                                 NHT_RM_MAP(zvrf, AFI_IP, i) =
1650                                         route_map_lookup_by_name(rmap_name);
1651                                 if (!old)
1652                                         route_map_counter_increment(
1653                                                 NHT_RM_MAP(zvrf, AFI_IP, i));
1654                                 /* There is single rib table for all protocols
1655                                  */
1656                                 if (afi_ip == 0) {
1657                                         table = zvrf->table[AFI_IP]
1658                                                            [SAFI_UNICAST];
1659                                         if (table) {
1660
1661                                                 afi_ip = 1;
1662
1663                                                 zebra_evaluate_rnh(
1664                                                         zvrf, AFI_IP, 1, NULL,
1665                                                         SAFI_UNICAST);
1666                                         }
1667                                 }
1668                         }
1669
1670                         rmap_name = NHT_RM_NAME(zvrf, AFI_IP6, i);
1671                         if (rmap_name && (strcmp(rmap_name, rmap) == 0)) {
1672                                 if (IS_ZEBRA_DEBUG_EVENT)
1673                                         zlog_debug(
1674                                                 "%s : AFI_IP6 rmap %s, route type %s",
1675                                                 __func__, rmap,
1676                                                 zebra_route_string(i));
1677
1678                                 old = NHT_RM_MAP(zvrf, AFI_IP6, i);
1679
1680                                 NHT_RM_MAP(zvrf, AFI_IP6, i) =
1681                                         route_map_lookup_by_name(rmap_name);
1682                                 if (!old)
1683                                         route_map_counter_increment(
1684                                                 NHT_RM_MAP(zvrf, AFI_IP6, i));
1685                                 /* There is single rib table for all protocols
1686                                  */
1687                                 if (afi_ipv6 == 0) {
1688                                         table = zvrf->table[AFI_IP6]
1689                                                            [SAFI_UNICAST];
1690                                         if (table) {
1691
1692                                                 afi_ipv6 = 1;
1693
1694                                                 zebra_evaluate_rnh(
1695                                                         zvrf, AFI_IP, 1, NULL,
1696                                                         SAFI_UNICAST);
1697                                         }
1698                                 }
1699                         }
1700                 }
1701         }
1702 }
1703
1704 static void zebra_route_map_process_update_cb(char *rmap_name)
1705 {
1706         if (IS_ZEBRA_DEBUG_EVENT)
1707                 zlog_debug("Event handler for route-map: %s",
1708                            rmap_name);
1709         zebra_import_table_rm_update(rmap_name);
1710         zebra_rib_table_rm_update(rmap_name);
1711         zebra_nht_rm_update(rmap_name);
1712 }
1713
1714 static void zebra_route_map_update_timer(struct thread *thread)
1715 {
1716         if (IS_ZEBRA_DEBUG_EVENT)
1717                 zlog_debug("Event driven route-map update triggered");
1718
1719         if (IS_ZEBRA_DEBUG_RIB_DETAILED)
1720                 zlog_debug(
1721                         "%u: Routemap update-timer fired, scheduling RIB processing",
1722                         VRF_DEFAULT);
1723
1724         route_map_walk_update_list(zebra_route_map_process_update_cb);
1725
1726         /*
1727          * This code needs to be updated to be:
1728          * 1) VRF Aware <sigh>
1729          * 2) Route-map aware
1730          */
1731 }
1732
1733 static void zebra_route_map_set_delay_timer(uint32_t value)
1734 {
1735         zebra_rmap_update_timer = value;
1736         if (!value && zebra_t_rmap_update) {
1737                 /* Event driven route map updates is being disabled */
1738                 /* But there's a pending timer. Fire it off now */
1739                 THREAD_OFF(zebra_t_rmap_update);
1740                 zebra_route_map_update_timer(NULL);
1741         }
1742 }
1743
1744 void zebra_routemap_finish(void)
1745 {
1746         /* Set zebra_rmap_update_timer to 0 so that it wont schedule again */
1747         zebra_rmap_update_timer = 0;
1748         /* Thread off if any scheduled already */
1749         THREAD_OFF(zebra_t_rmap_update);
1750         route_map_finish();
1751 }
1752
1753 route_map_result_t
1754 zebra_route_map_check(afi_t family, int rib_type, uint8_t instance,
1755                       const struct prefix *p, struct nexthop *nexthop,
1756                       struct zebra_vrf *zvrf, route_tag_t tag)
1757 {
1758         struct route_map *rmap = NULL;
1759         char *rm_name;
1760         route_map_result_t ret = RMAP_PERMITMATCH;
1761         struct nh_rmap_obj nh_obj;
1762
1763         nh_obj.nexthop = nexthop;
1764         nh_obj.vrf_id = nexthop->vrf_id;
1765         nh_obj.source_protocol = rib_type;
1766         nh_obj.instance = instance;
1767         nh_obj.metric = 0;
1768         nh_obj.tag = tag;
1769
1770         if (rib_type >= 0 && rib_type < ZEBRA_ROUTE_MAX) {
1771                 rm_name = PROTO_RM_NAME(zvrf, family, rib_type);
1772                 rmap = PROTO_RM_MAP(zvrf, family, rib_type);
1773
1774                 if (rm_name && !rmap)
1775                         return RMAP_DENYMATCH;
1776         }
1777         if (!rmap) {
1778                 rm_name = PROTO_RM_NAME(zvrf, family, ZEBRA_ROUTE_MAX);
1779                 rmap = PROTO_RM_MAP(zvrf, family, ZEBRA_ROUTE_MAX);
1780
1781                 if (rm_name && !rmap)
1782                         return RMAP_DENYMATCH;
1783         }
1784         if (rmap) {
1785                 ret = route_map_apply(rmap, p, &nh_obj);
1786         }
1787
1788         return (ret);
1789 }
1790
1791 char *zebra_get_import_table_route_map(afi_t afi, uint32_t table)
1792 {
1793         return zebra_import_table_routemap[afi][table];
1794 }
1795
1796 void zebra_add_import_table_route_map(afi_t afi, const char *rmap_name,
1797                                       uint32_t table)
1798 {
1799         zebra_import_table_routemap[afi][table] =
1800                 XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap_name);
1801 }
1802
1803 void zebra_del_import_table_route_map(afi_t afi, uint32_t table)
1804 {
1805         XFREE(MTYPE_ROUTE_MAP_NAME, zebra_import_table_routemap[afi][table]);
1806 }
1807
1808 route_map_result_t
1809 zebra_import_table_route_map_check(int family, int re_type, uint8_t instance,
1810                                    const struct prefix *p,
1811                                    struct nexthop *nexthop,
1812                                    vrf_id_t vrf_id, route_tag_t tag,
1813                                    const char *rmap_name)
1814 {
1815         struct route_map *rmap = NULL;
1816         route_map_result_t ret = RMAP_DENYMATCH;
1817         struct nh_rmap_obj nh_obj;
1818
1819         nh_obj.nexthop = nexthop;
1820         nh_obj.vrf_id = vrf_id;
1821         nh_obj.source_protocol = re_type;
1822         nh_obj.instance = instance;
1823         nh_obj.metric = 0;
1824         nh_obj.tag = tag;
1825
1826         if (re_type >= 0 && re_type < ZEBRA_ROUTE_MAX)
1827                 rmap = route_map_lookup_by_name(rmap_name);
1828         if (rmap) {
1829                 ret = route_map_apply(rmap, p, &nh_obj);
1830         }
1831
1832         return (ret);
1833 }
1834
1835 route_map_result_t zebra_nht_route_map_check(afi_t afi, int client_proto,
1836                                              const struct prefix *p,
1837                                              struct zebra_vrf *zvrf,
1838                                              struct route_entry *re,
1839                                              struct nexthop *nexthop)
1840 {
1841         struct route_map *rmap = NULL;
1842         route_map_result_t ret = RMAP_PERMITMATCH;
1843         struct nh_rmap_obj nh_obj;
1844
1845         nh_obj.nexthop = nexthop;
1846         nh_obj.vrf_id = nexthop->vrf_id;
1847         nh_obj.source_protocol = re->type;
1848         nh_obj.instance = re->instance;
1849         nh_obj.metric = re->metric;
1850         nh_obj.tag = re->tag;
1851
1852         if (client_proto >= 0 && client_proto < ZEBRA_ROUTE_MAX)
1853                 rmap = NHT_RM_MAP(zvrf, afi, client_proto);
1854         if (!rmap && NHT_RM_MAP(zvrf, afi, ZEBRA_ROUTE_MAX))
1855                 rmap = NHT_RM_MAP(zvrf, afi, ZEBRA_ROUTE_MAX);
1856         if (rmap)
1857                 ret = route_map_apply(rmap, p, &nh_obj);
1858
1859         return ret;
1860 }
1861
1862 static void zebra_route_map_mark_update(const char *rmap_name)
1863 {
1864         /* rmap_update_timer of 0 means don't do route updates */
1865         if (zebra_rmap_update_timer)
1866                 THREAD_OFF(zebra_t_rmap_update);
1867
1868         thread_add_timer(zrouter.master, zebra_route_map_update_timer,
1869                          NULL, zebra_rmap_update_timer, &zebra_t_rmap_update);
1870 }
1871
1872 static void zebra_route_map_add(const char *rmap_name)
1873 {
1874         if (route_map_mark_updated(rmap_name) == 0)
1875                 zebra_route_map_mark_update(rmap_name);
1876
1877         route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
1878 }
1879
1880 static void zebra_route_map_delete(const char *rmap_name)
1881 {
1882         if (route_map_mark_updated(rmap_name) == 0)
1883                 zebra_route_map_mark_update(rmap_name);
1884
1885         route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_DELETED);
1886 }
1887
1888 static void zebra_route_map_event(const char *rmap_name)
1889 {
1890         if (route_map_mark_updated(rmap_name) == 0)
1891                 zebra_route_map_mark_update(rmap_name);
1892
1893         route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
1894 }
1895
1896 void zebra_routemap_vrf_delete(struct zebra_vrf *zvrf)
1897 {
1898         afi_t afi;
1899         uint8_t type;
1900
1901         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
1902                 for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
1903                         if (PROTO_RM_NAME(zvrf, afi, type))
1904                                 XFREE(MTYPE_ROUTE_MAP_NAME,
1905                                       PROTO_RM_NAME(zvrf, afi, type));
1906                         if (NHT_RM_NAME(zvrf, afi, type))
1907                                 XFREE(MTYPE_ROUTE_MAP_NAME,
1908                                       NHT_RM_NAME(zvrf, afi, type));
1909                 }
1910         }
1911 }
1912
1913 /* ip protocol configuration write function */
1914 void zebra_routemap_config_write_protocol(struct vty *vty,
1915                                           struct zebra_vrf *zvrf)
1916 {
1917         int i;
1918         char space[2];
1919
1920         memset(space, 0, sizeof(space));
1921
1922         if (zvrf_id(zvrf) != VRF_DEFAULT)
1923                 snprintf(space, sizeof(space), "%s", " ");
1924
1925         for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
1926                 if (PROTO_RM_NAME(zvrf, AFI_IP, i))
1927                         vty_out(vty, "%sip protocol %s route-map %s\n", space,
1928                                 zebra_route_string(i),
1929                                 PROTO_RM_NAME(zvrf, AFI_IP, i));
1930
1931                 if (PROTO_RM_NAME(zvrf, AFI_IP6, i))
1932                         vty_out(vty, "%sipv6 protocol %s route-map %s\n", space,
1933                                 zebra_route_string(i),
1934                                 PROTO_RM_NAME(zvrf, AFI_IP6, i));
1935
1936                 if (NHT_RM_NAME(zvrf, AFI_IP, i))
1937                         vty_out(vty, "%sip nht %s route-map %s\n", space,
1938                                 zebra_route_string(i),
1939                                 NHT_RM_NAME(zvrf, AFI_IP, i));
1940
1941                 if (NHT_RM_NAME(zvrf, AFI_IP6, i))
1942                         vty_out(vty, "%sipv6 nht %s route-map %s\n", space,
1943                                 zebra_route_string(i),
1944                                 NHT_RM_NAME(zvrf, AFI_IP6, i));
1945         }
1946
1947         if (PROTO_RM_NAME(zvrf, AFI_IP, ZEBRA_ROUTE_MAX))
1948                 vty_out(vty, "%sip protocol %s route-map %s\n", space, "any",
1949                         PROTO_RM_NAME(zvrf, AFI_IP, ZEBRA_ROUTE_MAX));
1950
1951         if (PROTO_RM_NAME(zvrf, AFI_IP6, ZEBRA_ROUTE_MAX))
1952                 vty_out(vty, "%sipv6 protocol %s route-map %s\n", space, "any",
1953                         PROTO_RM_NAME(zvrf, AFI_IP6, ZEBRA_ROUTE_MAX));
1954
1955         if (NHT_RM_NAME(zvrf, AFI_IP, ZEBRA_ROUTE_MAX))
1956                 vty_out(vty, "%sip nht %s route-map %s\n", space, "any",
1957                         NHT_RM_NAME(zvrf, AFI_IP, ZEBRA_ROUTE_MAX));
1958
1959         if (NHT_RM_NAME(zvrf, AFI_IP6, ZEBRA_ROUTE_MAX))
1960                 vty_out(vty, "%sipv6 nht %s route-map %s\n", space, "any",
1961                         NHT_RM_NAME(zvrf, AFI_IP6, ZEBRA_ROUTE_MAX));
1962
1963         if (zvrf_id(zvrf) == VRF_DEFAULT
1964             && zebra_rmap_update_timer != ZEBRA_RMAP_DEFAULT_UPDATE_TIMER)
1965                 vty_out(vty, "zebra route-map delay-timer %d\n",
1966                         zebra_rmap_update_timer);
1967 }
1968
1969 void zebra_route_map_init(void)
1970 {
1971         install_element(CONFIG_NODE, &ip_protocol_cmd);
1972         install_element(CONFIG_NODE, &no_ip_protocol_cmd);
1973         install_element(VRF_NODE, &ip_protocol_cmd);
1974         install_element(VRF_NODE, &no_ip_protocol_cmd);
1975         install_element(VIEW_NODE, &show_ip_protocol_cmd);
1976         install_element(CONFIG_NODE, &ipv6_protocol_cmd);
1977         install_element(CONFIG_NODE, &no_ipv6_protocol_cmd);
1978         install_element(VRF_NODE, &ipv6_protocol_cmd);
1979         install_element(VRF_NODE, &no_ipv6_protocol_cmd);
1980         install_element(VIEW_NODE, &show_ipv6_protocol_cmd);
1981         install_element(CONFIG_NODE, &ip_protocol_nht_rmap_cmd);
1982         install_element(CONFIG_NODE, &no_ip_protocol_nht_rmap_cmd);
1983         install_element(VRF_NODE, &ip_protocol_nht_rmap_cmd);
1984         install_element(VRF_NODE, &no_ip_protocol_nht_rmap_cmd);
1985         install_element(VIEW_NODE, &show_ip_protocol_nht_cmd);
1986         install_element(CONFIG_NODE, &ipv6_protocol_nht_rmap_cmd);
1987         install_element(CONFIG_NODE, &no_ipv6_protocol_nht_rmap_cmd);
1988         install_element(VRF_NODE, &ipv6_protocol_nht_rmap_cmd);
1989         install_element(VRF_NODE, &no_ipv6_protocol_nht_rmap_cmd);
1990         install_element(VIEW_NODE, &show_ipv6_protocol_nht_cmd);
1991         install_element(CONFIG_NODE, &zebra_route_map_timer_cmd);
1992         install_element(CONFIG_NODE, &no_zebra_route_map_timer_cmd);
1993
1994         route_map_init();
1995
1996         route_map_add_hook(zebra_route_map_add);
1997         route_map_delete_hook(zebra_route_map_delete);
1998         route_map_event_hook(zebra_route_map_event);
1999
2000         route_map_match_interface_hook(generic_match_add);
2001         route_map_no_match_interface_hook(generic_match_delete);
2002
2003         route_map_match_ip_address_hook(generic_match_add);
2004         route_map_no_match_ip_address_hook(generic_match_delete);
2005
2006         route_map_match_ip_address_prefix_list_hook(generic_match_add);
2007         route_map_no_match_ip_address_prefix_list_hook(generic_match_delete);
2008
2009         route_map_match_ip_next_hop_hook(generic_match_add);
2010         route_map_no_match_ip_next_hop_hook(generic_match_delete);
2011
2012         route_map_match_ip_next_hop_prefix_list_hook(generic_match_add);
2013         route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete);
2014
2015         route_map_match_ip_next_hop_type_hook(generic_match_add);
2016         route_map_no_match_ip_next_hop_type_hook(generic_match_delete);
2017
2018         route_map_match_tag_hook(generic_match_add);
2019         route_map_no_match_tag_hook(generic_match_delete);
2020
2021         route_map_match_ipv6_address_hook(generic_match_add);
2022         route_map_no_match_ipv6_address_hook(generic_match_delete);
2023
2024         route_map_match_ipv6_address_prefix_list_hook(generic_match_add);
2025         route_map_no_match_ipv6_address_prefix_list_hook(generic_match_delete);
2026
2027         route_map_match_ipv6_next_hop_type_hook(generic_match_add);
2028         route_map_no_match_ipv6_next_hop_type_hook(generic_match_delete);
2029
2030         route_map_install_match(&route_match_tag_cmd);
2031         route_map_install_match(&route_match_interface_cmd);
2032         route_map_install_match(&route_match_ip_next_hop_cmd);
2033         route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd);
2034         route_map_install_match(&route_match_ip_address_cmd);
2035         route_map_install_match(&route_match_ipv6_address_cmd);
2036         route_map_install_match(&route_match_ip_address_prefix_list_cmd);
2037         route_map_install_match(&route_match_ipv6_address_prefix_list_cmd);
2038         route_map_install_match(&route_match_ip_address_prefix_len_cmd);
2039         route_map_install_match(&route_match_ipv6_address_prefix_len_cmd);
2040         route_map_install_match(&route_match_ip_nexthop_prefix_len_cmd);
2041         route_map_install_match(&route_match_ip_next_hop_type_cmd);
2042         route_map_install_match(&route_match_ipv6_next_hop_type_cmd);
2043         route_map_install_match(&route_match_source_protocol_cmd);
2044         route_map_install_match(&route_match_source_instance_cmd);
2045
2046         /* */
2047         route_map_install_set(&route_set_src_cmd);
2048         /* */
2049         install_element(RMAP_NODE, &match_ip_nexthop_prefix_len_cmd);
2050         install_element(RMAP_NODE, &no_match_ip_nexthop_prefix_len_cmd);
2051         install_element(RMAP_NODE, &match_ip_address_prefix_len_cmd);
2052         install_element(RMAP_NODE, &match_ipv6_address_prefix_len_cmd);
2053         install_element(RMAP_NODE, &no_match_ipv6_address_prefix_len_cmd);
2054         install_element(RMAP_NODE, &no_match_ip_address_prefix_len_cmd);
2055         install_element(RMAP_NODE, &match_source_protocol_cmd);
2056         install_element(RMAP_NODE, &no_match_source_protocol_cmd);
2057         install_element(RMAP_NODE, &match_source_instance_cmd);
2058         install_element(RMAP_NODE, &no_match_source_instance_cmd);
2059
2060         /* */
2061         install_element(RMAP_NODE, &set_src_cmd);
2062         install_element(RMAP_NODE, &no_set_src_cmd);
2063 }