1 /* Redistribution Handler
2 * Copyright (C) 1998 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
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
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.
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
33 #include "srcdest_table.h"
35 #include "zebra/rib.h"
36 #include "zebra/zebra_router.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 #include "zebra/zebra_errors.h"
48 #define ZEBRA_PTM_SUPPORT
50 /* array holding redistribute info about table redistribution */
51 /* bit AFI is set if that AFI is redistributing routes from this table */
52 static int zebra_import_table_used
[AFI_MAX
][ZEBRA_KERNEL_TABLE_MAX
];
53 static uint32_t zebra_import_table_distance
[AFI_MAX
][ZEBRA_KERNEL_TABLE_MAX
];
55 int is_zebra_import_table_enabled(afi_t afi
, vrf_id_t vrf_id
, uint32_t table_id
)
58 * Make sure that what we are called with actualy makes sense
63 if (is_zebra_valid_kernel_table(table_id
) &&
64 table_id
< ZEBRA_KERNEL_TABLE_MAX
)
65 return zebra_import_table_used
[afi
][table_id
];
69 static void zebra_redistribute_default(struct zserv
*client
, vrf_id_t vrf_id
)
73 struct route_table
*table
;
74 struct route_node
*rn
;
75 struct route_entry
*newre
;
77 for (afi
= AFI_IP
; afi
<= AFI_IP6
; afi
++) {
79 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, vrf_id
);
83 /* Lookup default route. */
84 memset(&p
, 0, sizeof(p
));
85 p
.family
= afi2family(afi
);
86 rn
= route_node_lookup(table
, &p
);
90 RNODE_FOREACH_RE (rn
, newre
) {
91 if (CHECK_FLAG(newre
->flags
, ZEBRA_FLAG_SELECTED
)
92 && newre
->distance
!= DISTANCE_INFINITY
)
93 zsend_redistribute_route(
94 ZEBRA_REDISTRIBUTE_ROUTE_ADD
, client
,
98 route_unlock_node(rn
);
102 /* Redistribute routes. */
103 static void zebra_redistribute(struct zserv
*client
, int type
,
104 unsigned short instance
, vrf_id_t vrf_id
,
107 struct route_entry
*newre
;
108 struct route_table
*table
;
109 struct route_node
*rn
;
111 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, vrf_id
);
115 for (rn
= route_top(table
); rn
; rn
= srcdest_route_next(rn
))
116 RNODE_FOREACH_RE (rn
, newre
) {
117 const struct prefix
*dst_p
, *src_p
;
118 char buf
[PREFIX_STRLEN
];
120 srcdest_rnode_prefixes(rn
, &dst_p
, &src_p
);
122 if (IS_ZEBRA_DEBUG_EVENT
)
124 "%s: client %s %s(%u) checking: selected=%d, type=%d, distance=%d, metric=%d zebra_check_addr=%d",
126 zebra_route_string(client
->proto
),
127 prefix2str(dst_p
, buf
, sizeof(buf
)),
128 vrf_id
, CHECK_FLAG(newre
->flags
,
129 ZEBRA_FLAG_SELECTED
),
130 newre
->type
, newre
->distance
,
131 newre
->metric
, zebra_check_addr(dst_p
));
133 if (!CHECK_FLAG(newre
->flags
, ZEBRA_FLAG_SELECTED
))
135 if ((type
!= ZEBRA_ROUTE_ALL
136 && (newre
->type
!= type
137 || newre
->instance
!= instance
)))
139 if (newre
->distance
== DISTANCE_INFINITY
)
141 if (!zebra_check_addr(dst_p
))
144 zsend_redistribute_route(ZEBRA_REDISTRIBUTE_ROUTE_ADD
,
145 client
, dst_p
, src_p
, newre
);
149 /* Either advertise a route for redistribution to registered clients or */
150 /* withdraw redistribution if add cannot be done for client */
151 void redistribute_update(const struct prefix
*p
, const struct prefix
*src_p
,
152 const struct route_entry
*re
,
153 const struct route_entry
*prev_re
)
155 struct listnode
*node
, *nnode
;
156 struct zserv
*client
;
157 int send_redistribute
;
159 char buf
[PREFIX_STRLEN
];
161 if (IS_ZEBRA_DEBUG_RIB
) {
163 "%u:%s: Redist update re %p (%s), old %p (%s)",
164 re
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)),
165 re
, zebra_route_string(re
->type
), prev_re
,
166 prev_re
? zebra_route_string(prev_re
->type
) : "None");
169 afi
= family2afi(p
->family
);
171 flog_warn(EC_ZEBRA_REDISTRIBUTE_UNKNOWN_AF
,
172 "%s: Unknown AFI/SAFI prefix received\n",
176 if (!zebra_check_addr(p
)) {
177 if (IS_ZEBRA_DEBUG_RIB
)
178 zlog_debug("Redist update filter prefix %s",
179 prefix2str(p
, buf
, sizeof(buf
)));
184 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
)) {
185 send_redistribute
= 0;
187 if (is_default_prefix(p
)
188 && vrf_bitmap_check(client
->redist_default
[afi
],
190 send_redistribute
= 1;
191 else if (vrf_bitmap_check(client
->redist
[afi
][ZEBRA_ROUTE_ALL
],
193 send_redistribute
= 1;
194 else if (re
->instance
195 && redist_check_instance(
196 &client
->mi_redist
[afi
][re
->type
],
198 send_redistribute
= 1;
199 else if (vrf_bitmap_check(client
->redist
[afi
][re
->type
],
201 send_redistribute
= 1;
203 if (send_redistribute
) {
204 if (IS_ZEBRA_DEBUG_EVENT
) {
206 "%s: client %s %s(%u), type=%d, distance=%d, metric=%d",
208 zebra_route_string(client
->proto
),
209 prefix2str(p
, buf
, sizeof(buf
)),
210 re
->vrf_id
, re
->type
,
211 re
->distance
, re
->metric
);
213 zsend_redistribute_route(ZEBRA_REDISTRIBUTE_ROUTE_ADD
,
214 client
, p
, src_p
, re
);
217 && redist_check_instance(
218 &client
->mi_redist
[afi
]
222 client
->redist
[afi
][prev_re
->type
],
224 zsend_redistribute_route(ZEBRA_REDISTRIBUTE_ROUTE_DEL
,
225 client
, p
, src_p
, prev_re
);
231 * During a route delete, where 'new_re' is NULL, redist a delete to all
232 * clients registered for the type of 'old_re'.
233 * During a route update, redist a delete to any clients who will not see
234 * an update when the new route is installed. There are cases when a client
235 * may have seen a redist for 'old_re', but will not see
236 * the redist for 'new_re'.
238 void redistribute_delete(const struct prefix
*p
, const struct prefix
*src_p
,
239 const struct route_entry
*old_re
,
240 const struct route_entry
*new_re
)
242 struct listnode
*node
, *nnode
;
243 struct zserv
*client
;
245 char buf
[PREFIX_STRLEN
];
249 vrfid
= old_re
->vrf_id
;
251 vrfid
= new_re
->vrf_id
;
255 if (IS_ZEBRA_DEBUG_RIB
) {
257 "%u:%s: Redist del: re %p (%s), new re %p (%s)",
258 vrfid
, prefix2str(p
, buf
, sizeof(buf
)),
260 old_re
? zebra_route_string(old_re
->type
) : "None",
262 new_re
? zebra_route_string(new_re
->type
) : "None");
265 /* Add DISTANCE_INFINITY check. */
266 if (old_re
&& (old_re
->distance
== DISTANCE_INFINITY
))
269 afi
= family2afi(p
->family
);
271 flog_warn(EC_ZEBRA_REDISTRIBUTE_UNKNOWN_AF
,
272 "%s: Unknown AFI/SAFI prefix received\n",
277 /* Skip invalid (e.g. linklocal) prefix */
278 if (!zebra_check_addr(p
)) {
279 if (IS_ZEBRA_DEBUG_RIB
) {
281 "%u:%s: Redist del old: skipping invalid prefix",
282 vrfid
, prefix2str(p
, buf
, sizeof(buf
)));
287 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
)) {
289 /* Skip this client if it will receive an update for the
292 if (is_default_prefix(p
)
293 && vrf_bitmap_check(client
->redist_default
[afi
],
296 else if (vrf_bitmap_check(
297 client
->redist
[afi
][ZEBRA_ROUTE_ALL
],
300 else if (new_re
->instance
301 && redist_check_instance(
302 &client
->mi_redist
[afi
][new_re
->type
],
305 else if (vrf_bitmap_check(
306 client
->redist
[afi
][new_re
->type
],
311 /* Send a delete for the 'old' re to any subscribed client. */
313 && ((old_re
->instance
314 && redist_check_instance(
315 &client
->mi_redist
[afi
]
319 client
->redist
[afi
][old_re
->type
],
321 zsend_redistribute_route(ZEBRA_REDISTRIBUTE_ROUTE_DEL
,
322 client
, p
, src_p
, old_re
);
327 void zebra_redistribute_add(ZAPI_HANDLER_ARGS
)
331 unsigned short instance
;
333 STREAM_GETC(msg
, afi
);
334 STREAM_GETC(msg
, type
);
335 STREAM_GETW(msg
, instance
);
337 if (IS_ZEBRA_DEBUG_EVENT
)
339 "%s: client proto %s afi=%d, wants %s, vrf %u, instance=%d",
340 __func__
, zebra_route_string(client
->proto
), afi
,
341 zebra_route_string(type
), zvrf_id(zvrf
), instance
);
343 if (afi
== 0 || afi
>= AFI_MAX
) {
344 flog_warn(EC_ZEBRA_REDISTRIBUTE_UNKNOWN_AF
,
345 "%s: Specified afi %d does not exist",
346 __PRETTY_FUNCTION__
, afi
);
350 if (type
== 0 || type
>= ZEBRA_ROUTE_MAX
) {
351 zlog_debug("%s: Specified Route Type %d does not exist",
352 __PRETTY_FUNCTION__
, type
);
357 if (!redist_check_instance(&client
->mi_redist
[afi
][type
],
359 redist_add_instance(&client
->mi_redist
[afi
][type
],
361 zebra_redistribute(client
, type
, instance
,
365 if (!vrf_bitmap_check(client
->redist
[afi
][type
],
367 if (IS_ZEBRA_DEBUG_EVENT
)
368 zlog_debug("%s: setting vrf %u redist bitmap",
369 __func__
, zvrf_id(zvrf
));
370 vrf_bitmap_set(client
->redist
[afi
][type
],
372 zebra_redistribute(client
, type
, 0, zvrf_id(zvrf
), afi
);
380 void zebra_redistribute_delete(ZAPI_HANDLER_ARGS
)
384 unsigned short instance
;
386 STREAM_GETC(msg
, afi
);
387 STREAM_GETC(msg
, type
);
388 STREAM_GETW(msg
, instance
);
390 if (afi
== 0 || afi
>= AFI_MAX
) {
391 flog_warn(EC_ZEBRA_REDISTRIBUTE_UNKNOWN_AF
,
392 "%s: Specified afi %d does not exist",
393 __PRETTY_FUNCTION__
, afi
);
397 if (type
== 0 || type
>= ZEBRA_ROUTE_MAX
) {
398 zlog_debug("%s: Specified Route Type %d does not exist",
399 __PRETTY_FUNCTION__
, type
);
404 * NOTE: no need to withdraw the previously advertised routes. The
406 * themselves should keep track of the received routes from zebra and
407 * withdraw them when necessary.
410 redist_del_instance(&client
->mi_redist
[afi
][type
], instance
);
412 vrf_bitmap_unset(client
->redist
[afi
][type
], zvrf_id(zvrf
));
418 void zebra_redistribute_default_add(ZAPI_HANDLER_ARGS
)
422 STREAM_GETC(msg
, afi
);
424 if (afi
== 0 || afi
>= AFI_MAX
) {
425 flog_warn(EC_ZEBRA_REDISTRIBUTE_UNKNOWN_AF
,
426 "%s: Specified afi %u does not exist",
427 __PRETTY_FUNCTION__
, afi
);
431 vrf_bitmap_set(client
->redist_default
[afi
], zvrf_id(zvrf
));
432 zebra_redistribute_default(client
, zvrf_id(zvrf
));
438 void zebra_redistribute_default_delete(ZAPI_HANDLER_ARGS
)
442 STREAM_GETC(msg
, afi
);
444 if (afi
== 0 || afi
>= AFI_MAX
) {
445 flog_warn(EC_ZEBRA_REDISTRIBUTE_UNKNOWN_AF
,
446 "%s: Specified afi %u does not exist",
447 __PRETTY_FUNCTION__
, afi
);
451 vrf_bitmap_unset(client
->redist_default
[afi
], zvrf_id(zvrf
));
457 /* Interface up information. */
458 void zebra_interface_up_update(struct interface
*ifp
)
460 struct listnode
*node
, *nnode
;
461 struct zserv
*client
;
463 if (IS_ZEBRA_DEBUG_EVENT
)
464 zlog_debug("MESSAGE: ZEBRA_INTERFACE_UP %s(%u)",
465 ifp
->name
, ifp
->vrf_id
);
467 if (ifp
->ptm_status
|| !ifp
->ptm_enable
) {
468 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
,
470 zsend_interface_update(ZEBRA_INTERFACE_UP
,
472 zsend_interface_link_params(client
, ifp
);
477 /* Interface down information. */
478 void zebra_interface_down_update(struct interface
*ifp
)
480 struct listnode
*node
, *nnode
;
481 struct zserv
*client
;
483 if (IS_ZEBRA_DEBUG_EVENT
)
484 zlog_debug("MESSAGE: ZEBRA_INTERFACE_DOWN %s(%u)",
485 ifp
->name
, ifp
->vrf_id
);
487 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
)) {
488 zsend_interface_update(ZEBRA_INTERFACE_DOWN
, client
, ifp
);
492 /* Interface information update. */
493 void zebra_interface_add_update(struct interface
*ifp
)
495 struct listnode
*node
, *nnode
;
496 struct zserv
*client
;
498 if (IS_ZEBRA_DEBUG_EVENT
)
499 zlog_debug("MESSAGE: ZEBRA_INTERFACE_ADD %s(%u)", ifp
->name
,
502 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
)) {
504 zsend_interface_add(client
, ifp
);
505 zsend_interface_link_params(client
, ifp
);
509 void zebra_interface_delete_update(struct interface
*ifp
)
511 struct listnode
*node
, *nnode
;
512 struct zserv
*client
;
514 if (IS_ZEBRA_DEBUG_EVENT
)
515 zlog_debug("MESSAGE: ZEBRA_INTERFACE_DELETE %s(%u)",
516 ifp
->name
, ifp
->vrf_id
);
518 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
)) {
520 zsend_interface_delete(client
, ifp
);
524 /* Interface address addition. */
525 void zebra_interface_address_add_update(struct interface
*ifp
,
526 struct connected
*ifc
)
528 struct listnode
*node
, *nnode
;
529 struct zserv
*client
;
532 if (IS_ZEBRA_DEBUG_EVENT
) {
533 char buf
[PREFIX_STRLEN
];
536 zlog_debug("MESSAGE: ZEBRA_INTERFACE_ADDRESS_ADD %s on %s(%u)",
537 prefix2str(p
, buf
, sizeof(buf
)), ifp
->name
,
541 if (!CHECK_FLAG(ifc
->conf
, ZEBRA_IFC_REAL
))
543 EC_ZEBRA_ADVERTISING_UNUSABLE_ADDR
,
544 "WARNING: advertising address to clients that is not yet usable.");
546 zebra_vxlan_add_del_gw_macip(ifp
, ifc
->address
, 1);
548 router_id_add_address(ifc
);
550 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
))
551 if (CHECK_FLAG(ifc
->conf
, ZEBRA_IFC_REAL
)) {
552 client
->connected_rt_add_cnt
++;
553 zsend_interface_address(ZEBRA_INTERFACE_ADDRESS_ADD
,
558 /* Interface address deletion. */
559 void zebra_interface_address_delete_update(struct interface
*ifp
,
560 struct connected
*ifc
)
562 struct listnode
*node
, *nnode
;
563 struct zserv
*client
;
566 if (IS_ZEBRA_DEBUG_EVENT
) {
567 char buf
[PREFIX_STRLEN
];
570 zlog_debug("MESSAGE: ZEBRA_INTERFACE_ADDRESS_DELETE %s on %s(%u)",
571 prefix2str(p
, buf
, sizeof(buf
)),
572 ifp
->name
, ifp
->vrf_id
);
575 zebra_vxlan_add_del_gw_macip(ifp
, ifc
->address
, 0);
577 router_id_del_address(ifc
);
579 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
))
580 if (CHECK_FLAG(ifc
->conf
, ZEBRA_IFC_REAL
)) {
581 client
->connected_rt_del_cnt
++;
582 zsend_interface_address(ZEBRA_INTERFACE_ADDRESS_DELETE
,
587 /* Interface VRF change. May need to delete from clients not interested in
588 * the new VRF. Note that this function is invoked *prior* to the VRF change.
590 void zebra_interface_vrf_update_del(struct interface
*ifp
, vrf_id_t new_vrf_id
)
592 struct listnode
*node
, *nnode
;
593 struct zserv
*client
;
595 if (IS_ZEBRA_DEBUG_EVENT
)
597 "MESSAGE: ZEBRA_INTERFACE_VRF_UPDATE/DEL %s VRF Id %u -> %u",
598 ifp
->name
, ifp
->vrf_id
, new_vrf_id
);
600 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
)) {
601 /* Need to delete if the client is not interested in the new
603 zsend_interface_update(ZEBRA_INTERFACE_DOWN
, client
, ifp
);
605 zsend_interface_delete(client
, ifp
);
606 zsend_interface_vrf_update(client
, ifp
, new_vrf_id
);
610 /* Interface VRF change. This function is invoked *post* VRF change and sends an
611 * add to clients who are interested in the new VRF but not in the old VRF.
613 void zebra_interface_vrf_update_add(struct interface
*ifp
, vrf_id_t old_vrf_id
)
615 struct listnode
*node
, *nnode
;
616 struct zserv
*client
;
618 if (IS_ZEBRA_DEBUG_EVENT
)
620 "MESSAGE: ZEBRA_INTERFACE_VRF_UPDATE/ADD %s VRF Id %u -> %u",
621 ifp
->name
, old_vrf_id
, ifp
->vrf_id
);
623 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
)) {
624 /* Need to add if the client is interested in the new VRF. */
626 zsend_interface_add(client
, ifp
);
627 zsend_interface_addresses(client
, ifp
);
631 int zebra_add_import_table_entry(struct zebra_vrf
*zvrf
, struct route_node
*rn
,
632 struct route_entry
*re
, const char *rmap_name
)
634 struct route_entry
*newre
;
635 struct route_entry
*same
;
637 route_map_result_t ret
= RMAP_PERMITMATCH
;
640 afi
= family2afi(rn
->p
.family
);
642 ret
= zebra_import_table_route_map_check(
643 afi
, re
->type
, re
->instance
, &rn
->p
, re
->ng
.nexthop
,
644 zvrf
->vrf
->vrf_id
, re
->tag
, rmap_name
);
646 if (ret
!= RMAP_PERMITMATCH
) {
647 UNSET_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
);
648 zebra_del_import_table_entry(zvrf
, rn
, re
);
652 prefix_copy(&p
, &rn
->p
);
654 RNODE_FOREACH_RE (rn
, same
) {
655 if (CHECK_FLAG(same
->status
, ROUTE_ENTRY_REMOVED
))
658 if (same
->type
== re
->type
&& same
->instance
== re
->instance
659 && same
->table
== re
->table
660 && same
->type
!= ZEBRA_ROUTE_CONNECT
)
665 UNSET_FLAG(same
->flags
, ZEBRA_FLAG_SELECTED
);
666 zebra_del_import_table_entry(zvrf
, rn
, same
);
669 newre
= XCALLOC(MTYPE_RE
, sizeof(struct route_entry
));
670 newre
->type
= ZEBRA_ROUTE_TABLE
;
671 newre
->distance
= zebra_import_table_distance
[afi
][re
->table
];
672 newre
->flags
= re
->flags
;
673 newre
->metric
= re
->metric
;
674 newre
->mtu
= re
->mtu
;
675 newre
->table
= zvrf
->table_id
;
676 newre
->nexthop_num
= 0;
677 newre
->uptime
= monotime(NULL
);
678 newre
->instance
= re
->table
;
679 route_entry_copy_nexthops(newre
, re
->ng
.nexthop
);
681 rib_add_multipath(afi
, SAFI_UNICAST
, &p
, NULL
, newre
);
686 int zebra_del_import_table_entry(struct zebra_vrf
*zvrf
, struct route_node
*rn
,
687 struct route_entry
*re
)
692 afi
= family2afi(rn
->p
.family
);
693 prefix_copy(&p
, &rn
->p
);
695 rib_delete(afi
, SAFI_UNICAST
, zvrf
->vrf
->vrf_id
, ZEBRA_ROUTE_TABLE
,
696 re
->table
, re
->flags
, &p
, NULL
, re
->ng
.nexthop
,
697 zvrf
->table_id
, re
->metric
, re
->distance
, false);
702 /* Assuming no one calls this with the main routing table */
703 int zebra_import_table(afi_t afi
, vrf_id_t vrf_id
, uint32_t table_id
,
704 uint32_t distance
, const char *rmap_name
, int add
)
706 struct route_table
*table
;
707 struct route_entry
*re
;
708 struct route_node
*rn
;
709 struct zebra_vrf
*zvrf
= zebra_vrf_lookup_by_id(vrf_id
);
711 if (!is_zebra_valid_kernel_table(table_id
)
712 || (table_id
== RT_TABLE_MAIN
))
718 table
= zebra_vrf_table_with_table_id(afi
, SAFI_UNICAST
, vrf_id
,
722 } else if (IS_ZEBRA_DEBUG_RIB
) {
723 zlog_debug("%s routes from table %d",
724 add
? "Importing" : "Unimporting", table_id
);
729 zebra_add_import_table_route_map(afi
, rmap_name
,
733 zebra_get_import_table_route_map(afi
, table_id
);
735 zebra_del_import_table_route_map(afi
, table_id
);
740 zebra_import_table_used
[afi
][table_id
] = 1;
741 zebra_import_table_distance
[afi
][table_id
] = distance
;
743 zebra_import_table_used
[afi
][table_id
] = 0;
744 zebra_import_table_distance
[afi
][table_id
] =
745 ZEBRA_TABLE_DISTANCE_DEFAULT
;
747 rmap_name
= zebra_get_import_table_route_map(afi
, table_id
);
749 zebra_del_import_table_route_map(afi
, table_id
);
754 for (rn
= route_top(table
); rn
; rn
= route_next(rn
)) {
755 /* For each entry in the non-default routing table,
756 * add the entry in the main table
761 RNODE_FOREACH_RE (rn
, re
) {
762 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
))
770 if (((afi
== AFI_IP
) && (rn
->p
.family
== AF_INET
))
771 || ((afi
== AFI_IP6
) && (rn
->p
.family
== AF_INET6
))) {
773 zebra_add_import_table_entry(zvrf
, rn
, re
,
776 zebra_del_import_table_entry(zvrf
, rn
, re
);
782 int zebra_import_table_config(struct vty
*vty
, vrf_id_t vrf_id
)
787 char afi_str
[AFI_MAX
][10] = {"", "ip", "ipv6", "ethernet"};
788 const char *rmap_name
;
790 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
791 for (i
= 1; i
< ZEBRA_KERNEL_TABLE_MAX
; i
++) {
792 if (!is_zebra_import_table_enabled(afi
, vrf_id
, i
))
795 if (zebra_import_table_distance
[afi
][i
]
796 != ZEBRA_TABLE_DISTANCE_DEFAULT
) {
797 vty_out(vty
, "%s import-table %d distance %d",
799 zebra_import_table_distance
[afi
][i
]);
801 vty_out(vty
, "%s import-table %d", afi_str
[afi
],
805 rmap_name
= zebra_get_import_table_route_map(afi
, i
);
807 vty_out(vty
, " route-map %s", rmap_name
);
817 static void zebra_import_table_rm_update_vrf_afi(struct zebra_vrf
*zvrf
,
818 afi_t afi
, int table_id
,
821 struct route_table
*table
;
822 struct route_entry
*re
;
823 struct route_node
*rn
;
824 const char *rmap_name
;
826 rmap_name
= zebra_get_import_table_route_map(afi
, table_id
);
827 if ((!rmap_name
) || (strcmp(rmap_name
, rmap
) != 0))
830 table
= zebra_vrf_table_with_table_id(afi
, SAFI_UNICAST
,
831 zvrf
->vrf
->vrf_id
, table_id
);
833 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
834 zlog_debug("%s: Table id=%d not found", __func__
,
839 for (rn
= route_top(table
); rn
; rn
= route_next(rn
)) {
841 * For each entry in the non-default routing table,
842 * add the entry in the main table
847 RNODE_FOREACH_RE (rn
, re
) {
848 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
))
856 if (((afi
== AFI_IP
) && (rn
->p
.family
== AF_INET
))
857 || ((afi
== AFI_IP6
) && (rn
->p
.family
== AF_INET6
)))
858 zebra_add_import_table_entry(zvrf
, rn
, re
, rmap_name
);
864 static void zebra_import_table_rm_update_vrf(struct zebra_vrf
*zvrf
,
870 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
871 for (i
= 1; i
< ZEBRA_KERNEL_TABLE_MAX
; i
++) {
872 if (!is_zebra_import_table_enabled(
873 afi
, zvrf
->vrf
->vrf_id
, i
))
876 zebra_import_table_rm_update_vrf_afi(zvrf
, afi
, i
,
882 void zebra_import_table_rm_update(const char *rmap
)
885 struct zebra_vrf
*zvrf
;
887 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
893 zebra_import_table_rm_update_vrf(zvrf
, rmap
);
897 /* Interface parameters update */
898 void zebra_interface_parameters_update(struct interface
*ifp
)
900 struct listnode
*node
, *nnode
;
901 struct zserv
*client
;
903 if (IS_ZEBRA_DEBUG_EVENT
)
904 zlog_debug("MESSAGE: ZEBRA_INTERFACE_LINK_PARAMS %s(%u)",
905 ifp
->name
, ifp
->vrf_id
);
907 for (ALL_LIST_ELEMENTS(zrouter
.client_list
, node
, nnode
, client
))
908 zsend_interface_link_params(client
, ifp
);