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