zebra/redistribute.c

   1 /* Redistribution Handler
   2  * Copyright (C) 1998 Kunihiro Ishiguro
   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 "vector.h"
  24 #include "vty.h"
  25 #include "command.h"
  26 #include "prefix.h"
  27 #include "table.h"
  28 #include "stream.h"
  29 #include "zclient.h"
  30 #include "linklist.h"
  31 #include "log.h"
  32 #include "vrf.h"
  33 #include "srcdest_table.h"
  34
  35 #include "zebra/rib.h"
  36 #include "zebra/zserv.h"
  37 #include "zebra/zebra_ns.h"
  38 #include "zebra/zebra_vrf.h"
  39 #include "zebra/zebra_routemap.h"
  40 #include "zebra/redistribute.h"
  41 #include "zebra/debug.h"
  42 #include "zebra/router-id.h"
  43 #include "zebra/zapi_msg.h"
  44 #include "zebra/zebra_memory.h"
  45 #include "zebra/zebra_vxlan.h"
  46
  47 #define ZEBRA_PTM_SUPPORT
  48
  49 /* array holding redistribute info about table redistribution */
  50 /* bit AFI is set if that AFI is redistributing routes from this table */
  51 static int zebra_import_table_used[AFI_MAX][ZEBRA_KERNEL_TABLE_MAX];
  52 static uint32_t zebra_import_table_distance[AFI_MAX][ZEBRA_KERNEL_TABLE_MAX];
  53
  54 int is_zebra_import_table_enabled(afi_t afi, uint32_t table_id)
  55 {
  56         /*
  57          * Make sure that what we are called with actualy makes sense
  58          */
  59         if (afi == AFI_MAX)
  60                 return 0;
  61
  62         if (is_zebra_valid_kernel_table(table_id) &&
  63             table_id < ZEBRA_KERNEL_TABLE_MAX)
  64                 return zebra_import_table_used[afi][table_id];
  65         return 0;
  66 }
  67
  68 static void zebra_redistribute_default(struct zserv *client, vrf_id_t vrf_id)
  69 {
  70         int afi;
  71         struct prefix p;
  72         struct route_table *table;
  73         struct route_node *rn;
  74         struct route_entry *newre;
  75
  76         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
  77                 /* Lookup table.  */
  78                 table = zebra_vrf_table(afi, SAFI_UNICAST, vrf_id);
  79                 if (!table)
  80                         continue;
  81
  82                 /* Lookup default route. */
  83                 memset(&p, 0, sizeof(p));
  84                 p.family = afi2family(afi);
  85                 rn = route_node_lookup(table, &p);
  86                 if (!rn)
  87                         continue;
  88
  89                 RNODE_FOREACH_RE (rn, newre) {
  90                         if (CHECK_FLAG(newre->flags, ZEBRA_FLAG_SELECTED)
  91                             && newre->distance != DISTANCE_INFINITY)
  92                                 zsend_redistribute_route(
  93                                         ZEBRA_REDISTRIBUTE_ROUTE_ADD, client,
  94                                         &rn->p, NULL, newre);
  95                 }
  96
  97                 route_unlock_node(rn);
  98         }
  99 }
 100
 101 /* Redistribute routes. */
 102 static void zebra_redistribute(struct zserv *client, int type,
 103                                unsigned short instance, vrf_id_t vrf_id,
 104                                int afi)
 105 {
 106         struct route_entry *newre;
 107         struct route_table *table;
 108         struct route_node *rn;
 109
 110         table = zebra_vrf_table(afi, SAFI_UNICAST, vrf_id);
 111         if (!table)
 112                 return;
 113
 114         for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
 115                 RNODE_FOREACH_RE (rn, newre) {
 116                         struct prefix *dst_p, *src_p;
 117                         char buf[PREFIX_STRLEN];
 118
 119                         srcdest_rnode_prefixes(rn, &dst_p, &src_p);
 120
 121                         if (IS_ZEBRA_DEBUG_EVENT)
 122                                 zlog_debug(
 123                                         "%s: client %s %s(%d) checking: selected=%d, type=%d, distance=%d, metric=%d zebra_check_addr=%d",
 124                                         __func__,
 125                                         zebra_route_string(client->proto),
 126                                         prefix2str(dst_p, buf, sizeof(buf)),
 127                                         vrf_id, CHECK_FLAG(newre->flags,
 128                                                            ZEBRA_FLAG_SELECTED),
 129                                         newre->type, newre->distance,
 130                                         newre->metric, zebra_check_addr(dst_p));
 131
 132                         if (!CHECK_FLAG(newre->flags, ZEBRA_FLAG_SELECTED))
 133                                 continue;
 134                         if ((type != ZEBRA_ROUTE_ALL
 135                              && (newre->type != type
 136                                  || newre->instance != instance)))
 137                                 continue;
 138                         if (newre->distance == DISTANCE_INFINITY)
 139                                 continue;
 140                         if (!zebra_check_addr(dst_p))
 141                                 continue;
 142
 143                         zsend_redistribute_route(ZEBRA_REDISTRIBUTE_ROUTE_ADD,
 144                                                  client, dst_p, src_p, newre);
 145                 }
 146 }
 147
 148 /* Either advertise a route for redistribution to registered clients or */
 149 /* withdraw redistribution if add cannot be done for client */
 150 void redistribute_update(struct prefix *p, struct prefix *src_p,
 151                          struct route_entry *re, struct route_entry *prev_re)
 152 {
 153         struct listnode *node, *nnode;
 154         struct zserv *client;
 155         int send_redistribute;
 156         int afi;
 157         char buf[PREFIX_STRLEN];
 158
 159         if (IS_ZEBRA_DEBUG_RIB) {
 160                 zlog_debug(
 161                         "%u:%s: Redist update re %p (type %d), old %p (type %d)",
 162                         re->vrf_id, prefix2str(p, buf, sizeof(buf)),
 163                         re, re->type, prev_re,
 164                         prev_re ? prev_re->type : -1);
 165         }
 166
 167         afi = family2afi(p->family);
 168         if (!afi) {
 169                 zlog_warn("%s: Unknown AFI/SAFI prefix received\n",
 170                           __FUNCTION__);
 171                 return;
 172         }
 173
 174         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client)) {
 175                 send_redistribute = 0;
 176
 177                 if (is_default_prefix(p)
 178                     && vrf_bitmap_check(client->redist_default, re->vrf_id))
 179                         send_redistribute = 1;
 180                 else if (vrf_bitmap_check(client->redist[afi][ZEBRA_ROUTE_ALL],
 181                                           re->vrf_id))
 182                         send_redistribute = 1;
 183                 else if (re->instance
 184                          && redist_check_instance(
 185                                     &client->mi_redist[afi][re->type],
 186                                     re->instance))
 187                         send_redistribute = 1;
 188                 else if (vrf_bitmap_check(client->redist[afi][re->type],
 189                                           re->vrf_id))
 190                         send_redistribute = 1;
 191
 192                 if (send_redistribute) {
 193                         if (IS_ZEBRA_DEBUG_EVENT) {
 194                                 zlog_debug(
 195                                            "%s: client %s %s(%d), type=%d, distance=%d, metric=%d",
 196                                            __func__,
 197                                            zebra_route_string(client->proto),
 198                                            prefix2str(p, buf, sizeof(buf)),
 199                                            re->vrf_id, re->type,
 200                                            re->distance, re->metric);
 201                         }
 202                         zsend_redistribute_route(ZEBRA_REDISTRIBUTE_ROUTE_ADD,
 203                                                  client, p, src_p, re);
 204                 } else if (prev_re
 205                            && ((re->instance
 206                                 && redist_check_instance(
 207                                            &client->mi_redist[afi]
 208                                                              [prev_re->type],
 209                                            re->instance))
 210                                || vrf_bitmap_check(
 211                                           client->redist[afi][prev_re->type],
 212                                           re->vrf_id))) {
 213                         zsend_redistribute_route(ZEBRA_REDISTRIBUTE_ROUTE_DEL,
 214                                                  client, p, src_p, prev_re);
 215                 }
 216         }
 217 }
 218
 219 void redistribute_delete(struct prefix *p, struct prefix *src_p,
 220                          struct route_entry *re)
 221 {
 222         struct listnode *node, *nnode;
 223         struct zserv *client;
 224         char buf[INET6_ADDRSTRLEN];
 225         int afi;
 226
 227         if (IS_ZEBRA_DEBUG_RIB) {
 228                 inet_ntop(p->family, &p->u.prefix, buf, INET6_ADDRSTRLEN);
 229                 zlog_debug("%u:%s/%d: Redist delete re %p (type %d)",
 230                            re->vrf_id, buf, p->prefixlen, re, re->type);
 231         }
 232
 233         /* Add DISTANCE_INFINITY check. */
 234         if (re->distance == DISTANCE_INFINITY)
 235                 return;
 236
 237         afi = family2afi(p->family);
 238         if (!afi) {
 239                 zlog_warn("%s: Unknown AFI/SAFI prefix received\n",
 240                           __FUNCTION__);
 241                 return;
 242         }
 243
 244         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client)) {
 245                 if ((is_default_prefix(p)
 246                      && vrf_bitmap_check(client->redist_default, re->vrf_id))
 247                     || vrf_bitmap_check(client->redist[afi][ZEBRA_ROUTE_ALL],
 248                                         re->vrf_id)
 249                     || (re->instance
 250                         && redist_check_instance(
 251                                    &client->mi_redist[afi][re->type],
 252                                    re->instance))
 253                     || vrf_bitmap_check(client->redist[afi][re->type],
 254                                         re->vrf_id)) {
 255                         zsend_redistribute_route(ZEBRA_REDISTRIBUTE_ROUTE_DEL,
 256                                                  client, p, src_p, re);
 257                 }
 258         }
 259 }
 260
 261 void zebra_redistribute_add(ZAPI_HANDLER_ARGS)
 262 {
 263         afi_t afi = 0;
 264         int type = 0;
 265         unsigned short instance;
 266
 267         STREAM_GETC(msg, afi);
 268         STREAM_GETC(msg, type);
 269         STREAM_GETW(msg, instance);
 270
 271         if (IS_ZEBRA_DEBUG_EVENT)
 272                 zlog_debug(
 273                         "%s: client proto %s afi=%d, wants %s, vrf %d, instance=%d",
 274                         __func__, zebra_route_string(client->proto), afi,
 275                         zebra_route_string(type), zvrf_id(zvrf), instance);
 276
 277         if (afi == 0 || afi > AFI_MAX) {
 278                 zlog_warn("%s: Specified afi %d does not exist",
 279                           __PRETTY_FUNCTION__, afi);
 280                 return;
 281         }
 282
 283         if (type == 0 || type >= ZEBRA_ROUTE_MAX) {
 284                 zlog_warn("%s: Specified Route Type %d does not exist",
 285                           __PRETTY_FUNCTION__, type);
 286                 return;
 287         }
 288
 289         if (instance) {
 290                 if (!redist_check_instance(&client->mi_redist[afi][type],
 291                                            instance)) {
 292                         redist_add_instance(&client->mi_redist[afi][type],
 293                                             instance);
 294                         zebra_redistribute(client, type, instance,
 295                                            zvrf_id(zvrf), afi);
 296                 }
 297         } else {
 298                 if (!vrf_bitmap_check(client->redist[afi][type],
 299                                       zvrf_id(zvrf))) {
 300                         if (IS_ZEBRA_DEBUG_EVENT)
 301                                 zlog_debug("%s: setting vrf %d redist bitmap",
 302                                            __func__, zvrf_id(zvrf));
 303                         vrf_bitmap_set(client->redist[afi][type],
 304                                        zvrf_id(zvrf));
 305                         zebra_redistribute(client, type, 0, zvrf_id(zvrf), afi);
 306                 }
 307         }
 308
 309 stream_failure:
 310         return;
 311 }
 312
 313 void zebra_redistribute_delete(ZAPI_HANDLER_ARGS)
 314 {
 315         afi_t afi = 0;
 316         int type = 0;
 317         unsigned short instance;
 318
 319         STREAM_GETC(msg, afi);
 320         STREAM_GETC(msg, type);
 321         STREAM_GETW(msg, instance);
 322
 323         if (afi == 0 || afi > AFI_MAX) {
 324                 zlog_warn("%s: Specified afi %d does not exist",
 325                           __PRETTY_FUNCTION__, afi);
 326                 return;
 327         }
 328
 329         if (type == 0 || type >= ZEBRA_ROUTE_MAX) {
 330                 zlog_warn("%s: Specified Route Type %d does not exist",
 331                           __PRETTY_FUNCTION__, type);
 332                 return;
 333         }
 334
 335         /*
 336          * NOTE: no need to withdraw the previously advertised routes. The
 337          * clients
 338          * themselves should keep track of the received routes from zebra and
 339          * withdraw them when necessary.
 340          */
 341         if (instance)
 342                 redist_del_instance(&client->mi_redist[afi][type], instance);
 343         else
 344                 vrf_bitmap_unset(client->redist[afi][type], zvrf_id(zvrf));
 345
 346 stream_failure:
 347         return;
 348 }
 349
 350 void zebra_redistribute_default_add(ZAPI_HANDLER_ARGS)
 351 {
 352         vrf_bitmap_set(client->redist_default, zvrf_id(zvrf));
 353         zebra_redistribute_default(client, zvrf_id(zvrf));
 354 }
 355
 356 void zebra_redistribute_default_delete(ZAPI_HANDLER_ARGS)
 357 {
 358         vrf_bitmap_unset(client->redist_default, zvrf_id(zvrf));
 359 }
 360
 361 /* Interface up information. */
 362 void zebra_interface_up_update(struct interface *ifp)
 363 {
 364         struct listnode *node, *nnode;
 365         struct zserv *client;
 366
 367         if (IS_ZEBRA_DEBUG_EVENT)
 368                 zlog_debug("MESSAGE: ZEBRA_INTERFACE_UP %s", ifp->name);
 369
 370         if (ifp->ptm_status || !ifp->ptm_enable) {
 371                 for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
 372                         if (client->ifinfo) {
 373                                 zsend_interface_update(ZEBRA_INTERFACE_UP,
 374                                                        client, ifp);
 375                                 zsend_interface_link_params(client, ifp);
 376                         }
 377         }
 378 }
 379
 380 /* Interface down information. */
 381 void zebra_interface_down_update(struct interface *ifp)
 382 {
 383         struct listnode *node, *nnode;
 384         struct zserv *client;
 385
 386         if (IS_ZEBRA_DEBUG_EVENT)
 387                 zlog_debug("MESSAGE: ZEBRA_INTERFACE_DOWN %s", ifp->name);
 388
 389         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client)) {
 390                 zsend_interface_update(ZEBRA_INTERFACE_DOWN, client, ifp);
 391         }
 392 }
 393
 394 /* Interface information update. */
 395 void zebra_interface_add_update(struct interface *ifp)
 396 {
 397         struct listnode *node, *nnode;
 398         struct zserv *client;
 399
 400         if (IS_ZEBRA_DEBUG_EVENT)
 401                 zlog_debug("MESSAGE: ZEBRA_INTERFACE_ADD %s[%d]", ifp->name,
 402                            ifp->vrf_id);
 403
 404         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
 405                 if (client->ifinfo) {
 406                         client->ifadd_cnt++;
 407                         zsend_interface_add(client, ifp);
 408                         zsend_interface_link_params(client, ifp);
 409                 }
 410 }
 411
 412 void zebra_interface_delete_update(struct interface *ifp)
 413 {
 414         struct listnode *node, *nnode;
 415         struct zserv *client;
 416
 417         if (IS_ZEBRA_DEBUG_EVENT)
 418                 zlog_debug("MESSAGE: ZEBRA_INTERFACE_DELETE %s", ifp->name);
 419
 420         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client)) {
 421                 client->ifdel_cnt++;
 422                 zsend_interface_delete(client, ifp);
 423         }
 424 }
 425
 426 /* Interface address addition. */
 427 void zebra_interface_address_add_update(struct interface *ifp,
 428                                         struct connected *ifc)
 429 {
 430         struct listnode *node, *nnode;
 431         struct zserv *client;
 432         struct prefix *p;
 433
 434         if (IS_ZEBRA_DEBUG_EVENT) {
 435                 char buf[PREFIX_STRLEN];
 436
 437                 p = ifc->address;
 438                 zlog_debug("MESSAGE: ZEBRA_INTERFACE_ADDRESS_ADD %s on %s",
 439                            prefix2str(p, buf, sizeof(buf)), ifc->ifp->name);
 440         }
 441
 442         if (!CHECK_FLAG(ifc->conf, ZEBRA_IFC_REAL))
 443                 zlog_warn(
 444                         "WARNING: advertising address to clients that is not yet usable.");
 445
 446         zebra_vxlan_add_del_gw_macip(ifp, ifc->address, 1);
 447
 448         router_id_add_address(ifc);
 449
 450         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
 451                 if (CHECK_FLAG(ifc->conf, ZEBRA_IFC_REAL)) {
 452                         client->connected_rt_add_cnt++;
 453                         zsend_interface_address(ZEBRA_INTERFACE_ADDRESS_ADD,
 454                                                 client, ifp, ifc);
 455                 }
 456 }
 457
 458 /* Interface address deletion. */
 459 void zebra_interface_address_delete_update(struct interface *ifp,
 460                                            struct connected *ifc)
 461 {
 462         struct listnode *node, *nnode;
 463         struct zserv *client;
 464         struct prefix *p;
 465
 466         if (IS_ZEBRA_DEBUG_EVENT) {
 467                 char buf[PREFIX_STRLEN];
 468
 469                 p = ifc->address;
 470                 zlog_debug("MESSAGE: ZEBRA_INTERFACE_ADDRESS_DELETE %s on %s",
 471                            prefix2str(p, buf, sizeof(buf)), ifc->ifp->name);
 472         }
 473
 474         zebra_vxlan_add_del_gw_macip(ifp, ifc->address, 0);
 475
 476         router_id_del_address(ifc);
 477
 478         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
 479                 if (CHECK_FLAG(ifc->conf, ZEBRA_IFC_REAL)) {
 480                         client->connected_rt_del_cnt++;
 481                         zsend_interface_address(ZEBRA_INTERFACE_ADDRESS_DELETE,
 482                                                 client, ifp, ifc);
 483                 }
 484 }
 485
 486 /* Interface VRF change. May need to delete from clients not interested in
 487  * the new VRF. Note that this function is invoked *prior* to the VRF change.
 488  */
 489 void zebra_interface_vrf_update_del(struct interface *ifp, vrf_id_t new_vrf_id)
 490 {
 491         struct listnode *node, *nnode;
 492         struct zserv *client;
 493
 494         if (IS_ZEBRA_DEBUG_EVENT)
 495                 zlog_debug(
 496                         "MESSAGE: ZEBRA_INTERFACE_VRF_UPDATE/DEL %s VRF Id %u -> %u",
 497                         ifp->name, ifp->vrf_id, new_vrf_id);
 498
 499         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client)) {
 500                 /* Need to delete if the client is not interested in the new
 501                  * VRF. */
 502                 zsend_interface_update(ZEBRA_INTERFACE_DOWN, client, ifp);
 503                 client->ifdel_cnt++;
 504                 zsend_interface_delete(client, ifp);
 505                 zsend_interface_vrf_update(client, ifp, new_vrf_id);
 506         }
 507 }
 508
 509 /* Interface VRF change. This function is invoked *post* VRF change and sends an
 510  * add to clients who are interested in the new VRF but not in the old VRF.
 511  */
 512 void zebra_interface_vrf_update_add(struct interface *ifp, vrf_id_t old_vrf_id)
 513 {
 514         struct listnode *node, *nnode;
 515         struct zserv *client;
 516
 517         if (IS_ZEBRA_DEBUG_EVENT)
 518                 zlog_debug(
 519                         "MESSAGE: ZEBRA_INTERFACE_VRF_UPDATE/ADD %s VRF Id %u -> %u",
 520                         ifp->name, old_vrf_id, ifp->vrf_id);
 521
 522         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client)) {
 523                 /* Need to add if the client is interested in the new VRF. */
 524                 client->ifadd_cnt++;
 525                 zsend_interface_add(client, ifp);
 526                 zsend_interface_addresses(client, ifp);
 527         }
 528 }
 529
 530 int zebra_add_import_table_entry(struct route_node *rn, struct route_entry *re,
 531                                  const char *rmap_name)
 532 {
 533         struct route_entry *newre;
 534         struct route_entry *same;
 535         struct prefix p;
 536         route_map_result_t ret = RMAP_MATCH;
 537         afi_t afi;
 538
 539         afi = family2afi(rn->p.family);
 540         if (rmap_name)
 541                 ret = zebra_import_table_route_map_check(
 542                         afi, re->type, re->instance, &rn->p, re->ng.nexthop,
 543                         re->vrf_id, re->tag, rmap_name);
 544
 545         if (ret != RMAP_MATCH) {
 546                 UNSET_FLAG(re->flags, ZEBRA_FLAG_SELECTED);
 547                 zebra_del_import_table_entry(rn, re);
 548                 return 0;
 549         }
 550
 551         prefix_copy(&p, &rn->p);
 552
 553         RNODE_FOREACH_RE (rn, same) {
 554                 if (CHECK_FLAG(same->status, ROUTE_ENTRY_REMOVED))
 555                         continue;
 556
 557                 if (same->type == re->type && same->instance == re->instance
 558                     && same->table == re->table
 559                     && same->type != ZEBRA_ROUTE_CONNECT)
 560                         break;
 561         }
 562
 563         if (same) {
 564                 UNSET_FLAG(same->flags, ZEBRA_FLAG_SELECTED);
 565                 zebra_del_import_table_entry(rn, same);
 566         }
 567
 568         newre = XCALLOC(MTYPE_RE, sizeof(struct route_entry));
 569         newre->type = ZEBRA_ROUTE_TABLE;
 570         newre->distance = zebra_import_table_distance[afi][re->table];
 571         newre->flags = re->flags;
 572         newre->metric = re->metric;
 573         newre->mtu = re->mtu;
 574         newre->table = zebrad.rtm_table_default;
 575         newre->nexthop_num = 0;
 576         newre->uptime = time(NULL);
 577         newre->instance = re->table;
 578         route_entry_copy_nexthops(newre, re->ng.nexthop);
 579
 580         rib_add_multipath(afi, SAFI_UNICAST, &p, NULL, newre);
 581
 582         return 0;
 583 }
 584
 585 int zebra_del_import_table_entry(struct route_node *rn, struct route_entry *re)
 586 {
 587         struct prefix p;
 588         afi_t afi;
 589
 590         afi = family2afi(rn->p.family);
 591         prefix_copy(&p, &rn->p);
 592
 593         rib_delete(afi, SAFI_UNICAST, re->vrf_id, ZEBRA_ROUTE_TABLE, re->table,
 594                    re->flags, &p, NULL, re->ng.nexthop,
 595                    zebrad.rtm_table_default, re->metric, false);
 596
 597         return 0;
 598 }
 599
 600 /* Assuming no one calls this with the main routing table */
 601 int zebra_import_table(afi_t afi, uint32_t table_id, uint32_t distance,
 602                        const char *rmap_name, int add)
 603 {
 604         struct route_table *table;
 605         struct route_entry *re;
 606         struct route_node *rn;
 607
 608         if (!is_zebra_valid_kernel_table(table_id)
 609             || ((table_id == RT_TABLE_MAIN)
 610                 || (table_id == zebrad.rtm_table_default)))
 611                 return (-1);
 612
 613         if (afi >= AFI_MAX)
 614                 return (-1);
 615
 616         table = zebra_vrf_other_route_table(afi, table_id, VRF_DEFAULT);
 617         if (table == NULL) {
 618                 return 0;
 619         } else if (IS_ZEBRA_DEBUG_RIB) {
 620                 zlog_debug("%s routes from table %d",
 621                            add ? "Importing" : "Unimporting", table_id);
 622         }
 623
 624         if (add) {
 625                 if (rmap_name)
 626                         zebra_add_import_table_route_map(afi, rmap_name,
 627                                                          table_id);
 628                 else {
 629                         rmap_name =
 630                                 zebra_get_import_table_route_map(afi, table_id);
 631                         if (rmap_name) {
 632                                 zebra_del_import_table_route_map(afi, table_id);
 633                                 rmap_name = NULL;
 634                         }
 635                 }
 636
 637                 zebra_import_table_used[afi][table_id] = 1;
 638                 zebra_import_table_distance[afi][table_id] = distance;
 639         } else {
 640                 zebra_import_table_used[afi][table_id] = 0;
 641                 zebra_import_table_distance[afi][table_id] =
 642                         ZEBRA_TABLE_DISTANCE_DEFAULT;
 643
 644                 rmap_name = zebra_get_import_table_route_map(afi, table_id);
 645                 if (rmap_name) {
 646                         zebra_del_import_table_route_map(afi, table_id);
 647                         rmap_name = NULL;
 648                 }
 649         }
 650
 651         for (rn = route_top(table); rn; rn = route_next(rn)) {
 652                 /* For each entry in the non-default routing table,
 653                  * add the entry in the main table
 654                  */
 655                 if (!rn->info)
 656                         continue;
 657
 658                 RNODE_FOREACH_RE (rn, re) {
 659                         if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
 660                                 continue;
 661                         break;
 662                 }
 663
 664                 if (!re)
 665                         continue;
 666
 667                 if (((afi == AFI_IP) && (rn->p.family == AF_INET))
 668                     || ((afi == AFI_IP6) && (rn->p.family == AF_INET6))) {
 669                         if (add)
 670                                 zebra_add_import_table_entry(rn, re, rmap_name);
 671                         else
 672                                 zebra_del_import_table_entry(rn, re);
 673                 }
 674         }
 675         return 0;
 676 }
 677
 678 int zebra_import_table_config(struct vty *vty)
 679 {
 680         int i;
 681         afi_t afi;
 682         int write = 0;
 683         char afi_str[AFI_MAX][10] = {"", "ip", "ipv6", "ethernet"};
 684         const char *rmap_name;
 685
 686         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
 687                 for (i = 1; i < ZEBRA_KERNEL_TABLE_MAX; i++) {
 688                         if (!is_zebra_import_table_enabled(afi, i))
 689                                 continue;
 690
 691                         if (zebra_import_table_distance[afi][i]
 692                             != ZEBRA_TABLE_DISTANCE_DEFAULT) {
 693                                 vty_out(vty, "%s import-table %d distance %d",
 694                                         afi_str[afi], i,
 695                                         zebra_import_table_distance[afi][i]);
 696                         } else {
 697                                 vty_out(vty, "%s import-table %d", afi_str[afi],
 698                                         i);
 699                         }
 700
 701                         rmap_name = zebra_get_import_table_route_map(afi, i);
 702                         if (rmap_name)
 703                                 vty_out(vty, " route-map %s", rmap_name);
 704
 705                         vty_out(vty, "\n");
 706                         write = 1;
 707                 }
 708         }
 709
 710         return write;
 711 }
 712
 713 void zebra_import_table_rm_update()
 714 {
 715         afi_t afi;
 716         int i;
 717         struct route_table *table;
 718         struct route_entry *re;
 719         struct route_node *rn;
 720         const char *rmap_name;
 721
 722         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
 723                 for (i = 1; i < ZEBRA_KERNEL_TABLE_MAX; i++) {
 724                         if (!is_zebra_import_table_enabled(afi, i))
 725                                 continue;
 726
 727                         rmap_name = zebra_get_import_table_route_map(afi, i);
 728                         if (!rmap_name)
 729                                 return;
 730
 731                         table = zebra_vrf_other_route_table(afi, i,
 732                                                             VRF_DEFAULT);
 733                         for (rn = route_top(table); rn; rn = route_next(rn)) {
 734                                 /* For each entry in the non-default
 735                                  * routing table,
 736                                  * add the entry in the main table
 737                                  */
 738                                 if (!rn->info)
 739                                         continue;
 740
 741                                 RNODE_FOREACH_RE (rn, re) {
 742                                         if (CHECK_FLAG(re->status,
 743                                                        ROUTE_ENTRY_REMOVED))
 744                                                 continue;
 745                                         break;
 746                                 }
 747
 748                                 if (!re)
 749                                         continue;
 750
 751                                 if (((afi == AFI_IP)
 752                                      && (rn->p.family == AF_INET))
 753                                     || ((afi == AFI_IP6)
 754                                         && (rn->p.family == AF_INET6)))
 755                                         zebra_add_import_table_entry(rn, re,
 756                                                                      rmap_name);
 757                         }
 758                 }
 759         }
 760
 761         return;
 762 }
 763
 764 /* Interface parameters update */
 765 void zebra_interface_parameters_update(struct interface *ifp)
 766 {
 767         struct listnode *node, *nnode;
 768         struct zserv *client;
 769
 770         if (IS_ZEBRA_DEBUG_EVENT)
 771                 zlog_debug("MESSAGE: ZEBRA_INTERFACE_LINK_PARAMS %s",
 772                            ifp->name);
 773
 774         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
 775                 if (client->ifinfo)
 776                         zsend_interface_link_params(client, ifp);
 777 }