]> git.proxmox.com Git - mirror_frr.git/blame - zebra/zebra_rib.c
zebra: Remove rib_lookup_ipv4_route
[mirror_frr.git] / zebra / zebra_rib.c
CommitLineData
718e3744 1/* Routing Information Base.
2 * Copyright (C) 1997, 98, 99, 2001 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 *
896014f4
DL
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
718e3744 19 */
20
21#include <zebra.h>
22
718e3744 23#include "command.h"
43e52561
QY
24#include "if.h"
25#include "linklist.h"
718e3744 26#include "log.h"
deaa50db 27#include "log_int.h"
43e52561
QY
28#include "memory.h"
29#include "mpls.h"
30#include "nexthop.h"
31#include "prefix.h"
7514fb77
PJ
32#include "prefix.h"
33#include "routemap.h"
43e52561 34#include "sockunion.h"
05737783 35#include "srcdest_table.h"
43e52561
QY
36#include "table.h"
37#include "thread.h"
38#include "vrf.h"
39#include "workqueue.h"
718e3744 40
89272910 41#include "zebra/zebra_router.h"
43e52561
QY
42#include "zebra/connected.h"
43#include "zebra/debug.h"
44#include "zebra/interface.h"
45#include "zebra/redistribute.h"
718e3744 46#include "zebra/rib.h"
47#include "zebra/rt.h"
43e52561
QY
48#include "zebra/zapi_msg.h"
49#include "zebra/zebra_errors.h"
50#include "zebra/zebra_memory.h"
7c551956 51#include "zebra/zebra_ns.h"
fb018d25 52#include "zebra/zebra_rnh.h"
43e52561
QY
53#include "zebra/zebra_routemap.h"
54#include "zebra/zebra_vrf.h"
6134fd82 55#include "zebra/zebra_vxlan.h"
7cdb1a84
MS
56#include "zebra/zapi_msg.h"
57#include "zebra/zebra_dplane.h"
58
59/*
60 * Event, list, and mutex for delivery of dataplane results
61 */
62static pthread_mutex_t dplane_mutex;
63static struct thread *t_dplane;
25779064 64static struct dplane_ctx_q rib_dplane_q;
718e3744 65
d62a17ae 66DEFINE_HOOK(rib_update, (struct route_node * rn, const char *reason),
67 (rn, reason))
4f8ea50c 68
6baf7bb8
DS
69/* Should we allow non Quagga processes to delete our routes */
70extern int allow_delete;
71
718e3744 72/* Each route type's string and default distance value. */
d62a17ae 73static const struct {
74 int key;
75 int distance;
76} route_info[ZEBRA_ROUTE_MAX] = {
9d303b37
DL
77 [ZEBRA_ROUTE_SYSTEM] = {ZEBRA_ROUTE_SYSTEM, 0},
78 [ZEBRA_ROUTE_KERNEL] = {ZEBRA_ROUTE_KERNEL, 0},
79 [ZEBRA_ROUTE_CONNECT] = {ZEBRA_ROUTE_CONNECT, 0},
80 [ZEBRA_ROUTE_STATIC] = {ZEBRA_ROUTE_STATIC, 1},
81 [ZEBRA_ROUTE_RIP] = {ZEBRA_ROUTE_RIP, 120},
82 [ZEBRA_ROUTE_RIPNG] = {ZEBRA_ROUTE_RIPNG, 120},
83 [ZEBRA_ROUTE_OSPF] = {ZEBRA_ROUTE_OSPF, 110},
84 [ZEBRA_ROUTE_OSPF6] = {ZEBRA_ROUTE_OSPF6, 110},
85 [ZEBRA_ROUTE_ISIS] = {ZEBRA_ROUTE_ISIS, 115},
86 [ZEBRA_ROUTE_BGP] = {ZEBRA_ROUTE_BGP, 20 /* IBGP is 200. */},
c710b277
DS
87 [ZEBRA_ROUTE_PIM] = {ZEBRA_ROUTE_PIM, 255},
88 [ZEBRA_ROUTE_EIGRP] = {ZEBRA_ROUTE_EIGRP, 90},
9d303b37 89 [ZEBRA_ROUTE_NHRP] = {ZEBRA_ROUTE_NHRP, 10},
c710b277
DS
90 [ZEBRA_ROUTE_HSLS] = {ZEBRA_ROUTE_HSLS, 255},
91 [ZEBRA_ROUTE_OLSR] = {ZEBRA_ROUTE_OLSR, 255},
92 [ZEBRA_ROUTE_TABLE] = {ZEBRA_ROUTE_TABLE, 150},
93 [ZEBRA_ROUTE_LDP] = {ZEBRA_ROUTE_LDP, 150},
94 [ZEBRA_ROUTE_VNC] = {ZEBRA_ROUTE_VNC, 20},
95 [ZEBRA_ROUTE_VNC_DIRECT] = {ZEBRA_ROUTE_VNC_DIRECT, 20},
96 [ZEBRA_ROUTE_VNC_DIRECT_RH] = {ZEBRA_ROUTE_VNC_DIRECT_RH, 20},
97 [ZEBRA_ROUTE_BGP_DIRECT] = {ZEBRA_ROUTE_BGP_DIRECT, 20},
98 [ZEBRA_ROUTE_BGP_DIRECT_EXT] = {ZEBRA_ROUTE_BGP_DIRECT_EXT, 20},
99 [ZEBRA_ROUTE_BABEL] = {ZEBRA_ROUTE_BABEL, 100},
400a663b 100 [ZEBRA_ROUTE_SHARP] = {ZEBRA_ROUTE_SHARP, 150},
c710b277 101
d62a17ae 102 /* no entry/default: 150 */
718e3744 103};
6b0655a2 104
4623d897
DL
105/* RPF lookup behaviour */
106static enum multicast_mode ipv4_multicast_mode = MCAST_NO_CONFIG;
107
6c4f4e6e 108
d62a17ae 109static void __attribute__((format(printf, 5, 6)))
110_rnode_zlog(const char *_func, vrf_id_t vrf_id, struct route_node *rn,
111 int priority, const char *msgfmt, ...)
2263a412 112{
d62a17ae 113 char buf[SRCDEST2STR_BUFFER + sizeof(" (MRIB)")];
114 char msgbuf[512];
115 va_list ap;
2263a412 116
d62a17ae 117 va_start(ap, msgfmt);
118 vsnprintf(msgbuf, sizeof(msgbuf), msgfmt, ap);
119 va_end(ap);
2263a412 120
d62a17ae 121 if (rn) {
122 rib_table_info_t *info = srcdest_rnode_table_info(rn);
123 srcdest_rnode2str(rn, buf, sizeof(buf));
cb653491 124
d62a17ae 125 if (info->safi == SAFI_MULTICAST)
126 strcat(buf, " (MRIB)");
127 } else {
128 snprintf(buf, sizeof(buf), "{(route_node *) NULL}");
129 }
2263a412 130
d62a17ae 131 zlog(priority, "%s: %d:%s: %s", _func, vrf_id, buf, msgbuf);
2263a412
DL
132}
133
d62a17ae 134#define rnode_debug(node, vrf_id, ...) \
2263a412 135 _rnode_zlog(__func__, vrf_id, node, LOG_DEBUG, __VA_ARGS__)
d62a17ae 136#define rnode_info(node, ...) \
2263a412
DL
137 _rnode_zlog(__func__, vrf_id, node, LOG_INFO, __VA_ARGS__)
138
fd289fc8 139uint8_t route_distance(int type)
40c7bdb0 140{
fd289fc8 141 uint8_t distance;
40c7bdb0 142
d62a17ae 143 if ((unsigned)type >= array_size(route_info))
144 distance = 150;
145 else
146 distance = route_info[type].distance;
40c7bdb0 147
d62a17ae 148 return distance;
40c7bdb0 149}
150
d7c0a89a 151int is_zebra_valid_kernel_table(uint32_t table_id)
7a4bb9c5 152{
8f500a1c 153#ifdef linux
d62a17ae 154 if ((table_id == RT_TABLE_UNSPEC) || (table_id == RT_TABLE_LOCAL)
155 || (table_id == RT_TABLE_COMPAT))
156 return 0;
8f500a1c
RW
157#endif
158
d62a17ae 159 return 1;
7a4bb9c5
DS
160}
161
d7c0a89a 162int is_zebra_main_routing_table(uint32_t table_id)
7a4bb9c5 163{
d62a17ae 164 if ((table_id == RT_TABLE_MAIN)
165 || (table_id == zebrad.rtm_table_default))
166 return 1;
167 return 0;
7a4bb9c5
DS
168}
169
86391e56 170int zebra_check_addr(const struct prefix *p)
0aabccc0 171{
d62a17ae 172 if (p->family == AF_INET) {
d7c0a89a 173 uint32_t addr;
0aabccc0 174
d62a17ae 175 addr = p->u.prefix4.s_addr;
176 addr = ntohl(addr);
0aabccc0 177
d62a17ae 178 if (IPV4_NET127(addr) || IN_CLASSD(addr)
179 || IPV4_LINKLOCAL(addr))
180 return 0;
181 }
182 if (p->family == AF_INET6) {
183 if (IN6_IS_ADDR_LOOPBACK(&p->u.prefix6))
184 return 0;
185 if (IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
186 return 0;
187 }
188 return 1;
0aabccc0
DD
189}
190
fa713d9e 191/* Add nexthop to the end of a rib node's nexthop list */
d62a17ae 192void route_entry_nexthop_add(struct route_entry *re, struct nexthop *nexthop)
fa713d9e 193{
7ee30f28 194 nexthop_add(&re->ng.nexthop, nexthop);
d62a17ae 195 re->nexthop_num++;
718e3744 196}
197
6e26278c 198
6e26278c
DS
199/**
200 * copy_nexthop - copy a nexthop to the rib structure.
201 */
d62a17ae 202void route_entry_copy_nexthops(struct route_entry *re, struct nexthop *nh)
6e26278c 203{
7ee30f28
DS
204 assert(!re->ng.nexthop);
205 copy_nexthops(&re->ng.nexthop, nh, NULL);
d62a17ae 206 for (struct nexthop *nexthop = nh; nexthop; nexthop = nexthop->next)
207 re->nexthop_num++;
6e26278c
DS
208}
209
718e3744 210/* Delete specified nexthop from the list. */
d62a17ae 211void route_entry_nexthop_delete(struct route_entry *re, struct nexthop *nexthop)
718e3744 212{
d62a17ae 213 if (nexthop->next)
214 nexthop->next->prev = nexthop->prev;
215 if (nexthop->prev)
216 nexthop->prev->next = nexthop->next;
217 else
7ee30f28 218 re->ng.nexthop = nexthop->next;
d62a17ae 219 re->nexthop_num--;
718e3744 220}
221
fa713d9e 222
d62a17ae 223struct nexthop *route_entry_nexthop_ifindex_add(struct route_entry *re,
4a7371e9
DS
224 ifindex_t ifindex,
225 vrf_id_t nh_vrf_id)
718e3744 226{
d62a17ae 227 struct nexthop *nexthop;
718e3744 228
d62a17ae 229 nexthop = nexthop_new();
230 nexthop->type = NEXTHOP_TYPE_IFINDEX;
231 nexthop->ifindex = ifindex;
4a7371e9 232 nexthop->vrf_id = nh_vrf_id;
718e3744 233
d62a17ae 234 route_entry_nexthop_add(re, nexthop);
718e3744 235
d62a17ae 236 return nexthop;
718e3744 237}
238
d62a17ae 239struct nexthop *route_entry_nexthop_ipv4_add(struct route_entry *re,
240 struct in_addr *ipv4,
4a7371e9
DS
241 struct in_addr *src,
242 vrf_id_t nh_vrf_id)
718e3744 243{
d62a17ae 244 struct nexthop *nexthop;
718e3744 245
d62a17ae 246 nexthop = nexthop_new();
247 nexthop->type = NEXTHOP_TYPE_IPV4;
4a7371e9 248 nexthop->vrf_id = nh_vrf_id;
d62a17ae 249 nexthop->gate.ipv4 = *ipv4;
250 if (src)
251 nexthop->src.ipv4 = *src;
718e3744 252
d62a17ae 253 route_entry_nexthop_add(re, nexthop);
718e3744 254
d62a17ae 255 return nexthop;
718e3744 256}
257
d62a17ae 258struct nexthop *route_entry_nexthop_ipv4_ifindex_add(struct route_entry *re,
259 struct in_addr *ipv4,
260 struct in_addr *src,
4a7371e9
DS
261 ifindex_t ifindex,
262 vrf_id_t nh_vrf_id)
718e3744 263{
d62a17ae 264 struct nexthop *nexthop;
265 struct interface *ifp;
718e3744 266
d62a17ae 267 nexthop = nexthop_new();
4a7371e9 268 nexthop->vrf_id = nh_vrf_id;
d62a17ae 269 nexthop->type = NEXTHOP_TYPE_IPV4_IFINDEX;
270 nexthop->gate.ipv4 = *ipv4;
271 if (src)
272 nexthop->src.ipv4 = *src;
273 nexthop->ifindex = ifindex;
4a7371e9 274 ifp = if_lookup_by_index(nexthop->ifindex, nh_vrf_id);
d62a17ae 275 /*Pending: need to think if null ifp here is ok during bootup?
276 There was a crash because ifp here was coming to be NULL */
277 if (ifp)
996c9314 278 if (connected_is_unnumbered(ifp)
103e4a71
CF
279 || CHECK_FLAG(re->flags, ZEBRA_FLAG_EVPN_ROUTE)
280 || CHECK_FLAG(re->flags, ZEBRA_FLAG_ONLINK)) {
d62a17ae 281 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK);
282 }
718e3744 283
d62a17ae 284 route_entry_nexthop_add(re, nexthop);
718e3744 285
d62a17ae 286 return nexthop;
718e3744 287}
288
d62a17ae 289struct nexthop *route_entry_nexthop_ipv6_add(struct route_entry *re,
4a7371e9
DS
290 struct in6_addr *ipv6,
291 vrf_id_t nh_vrf_id)
718e3744 292{
d62a17ae 293 struct nexthop *nexthop;
718e3744 294
d62a17ae 295 nexthop = nexthop_new();
4a7371e9 296 nexthop->vrf_id = nh_vrf_id;
d62a17ae 297 nexthop->type = NEXTHOP_TYPE_IPV6;
298 nexthop->gate.ipv6 = *ipv6;
718e3744 299
d62a17ae 300 route_entry_nexthop_add(re, nexthop);
718e3744 301
d62a17ae 302 return nexthop;
718e3744 303}
304
d62a17ae 305struct nexthop *route_entry_nexthop_ipv6_ifindex_add(struct route_entry *re,
306 struct in6_addr *ipv6,
4a7371e9
DS
307 ifindex_t ifindex,
308 vrf_id_t nh_vrf_id)
718e3744 309{
d62a17ae 310 struct nexthop *nexthop;
718e3744 311
d62a17ae 312 nexthop = nexthop_new();
4a7371e9 313 nexthop->vrf_id = nh_vrf_id;
d62a17ae 314 nexthop->type = NEXTHOP_TYPE_IPV6_IFINDEX;
315 nexthop->gate.ipv6 = *ipv6;
316 nexthop->ifindex = ifindex;
103e4a71
CF
317 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_EVPN_ROUTE)
318 || CHECK_FLAG(re->flags, ZEBRA_FLAG_ONLINK)) {
1ec31309 319 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK);
103e4a71 320 }
718e3744 321
d62a17ae 322 route_entry_nexthop_add(re, nexthop);
718e3744 323
d62a17ae 324 return nexthop;
718e3744 325}
718e3744 326
a8309422 327struct nexthop *route_entry_nexthop_blackhole_add(struct route_entry *re,
60466a63 328 enum blackhole_type bh_type)
595db7f1 329{
d62a17ae 330 struct nexthop *nexthop;
595db7f1 331
d62a17ae 332 nexthop = nexthop_new();
4a7371e9 333 nexthop->vrf_id = VRF_DEFAULT;
d62a17ae 334 nexthop->type = NEXTHOP_TYPE_BLACKHOLE;
a8309422 335 nexthop->bh_type = bh_type;
595db7f1 336
d62a17ae 337 route_entry_nexthop_add(re, nexthop);
595db7f1 338
d62a17ae 339 return nexthop;
595db7f1 340}
341
86391e56 342static void nexthop_set_resolved(afi_t afi, const struct nexthop *newhop,
d62a17ae 343 struct nexthop *nexthop)
4491a88f 344{
d62a17ae 345 struct nexthop *resolved_hop;
4491a88f 346
d62a17ae 347 resolved_hop = nexthop_new();
348 SET_FLAG(resolved_hop->flags, NEXTHOP_FLAG_ACTIVE);
d855d11f 349
4a7371e9 350 resolved_hop->vrf_id = nexthop->vrf_id;
d855d11f
RW
351 switch (newhop->type) {
352 case NEXTHOP_TYPE_IPV4:
353 case NEXTHOP_TYPE_IPV4_IFINDEX:
354 /* If the resolving route specifies a gateway, use it */
d62a17ae 355 resolved_hop->type = newhop->type;
356 resolved_hop->gate.ipv4 = newhop->gate.ipv4;
4491a88f 357
d62a17ae 358 if (newhop->ifindex) {
359 resolved_hop->type = NEXTHOP_TYPE_IPV4_IFINDEX;
360 resolved_hop->ifindex = newhop->ifindex;
d62a17ae 361 }
d855d11f
RW
362 break;
363 case NEXTHOP_TYPE_IPV6:
364 case NEXTHOP_TYPE_IPV6_IFINDEX:
d62a17ae 365 resolved_hop->type = newhop->type;
366 resolved_hop->gate.ipv6 = newhop->gate.ipv6;
367
368 if (newhop->ifindex) {
369 resolved_hop->type = NEXTHOP_TYPE_IPV6_IFINDEX;
370 resolved_hop->ifindex = newhop->ifindex;
371 }
d855d11f
RW
372 break;
373 case NEXTHOP_TYPE_IFINDEX:
374 /* If the resolving route is an interface route,
375 * it means the gateway we are looking up is connected
376 * to that interface. (The actual network is _not_ onlink).
377 * Therefore, the resolved route should have the original
378 * gateway as nexthop as it is directly connected.
379 *
380 * On Linux, we have to set the onlink netlink flag because
381 * otherwise, the kernel won't accept the route.
382 */
d62a17ae 383 resolved_hop->flags |= NEXTHOP_FLAG_ONLINK;
384 if (afi == AFI_IP) {
385 resolved_hop->type = NEXTHOP_TYPE_IPV4_IFINDEX;
386 resolved_hop->gate.ipv4 = nexthop->gate.ipv4;
387 } else if (afi == AFI_IP6) {
388 resolved_hop->type = NEXTHOP_TYPE_IPV6_IFINDEX;
389 resolved_hop->gate.ipv6 = nexthop->gate.ipv6;
390 }
391 resolved_hop->ifindex = newhop->ifindex;
d855d11f
RW
392 break;
393 case NEXTHOP_TYPE_BLACKHOLE:
59693377
DS
394 resolved_hop->type = NEXTHOP_TYPE_BLACKHOLE;
395 resolved_hop->bh_type = nexthop->bh_type;
d855d11f 396 break;
59693377 397 }
d855d11f 398
effcfaeb
DS
399 if (newhop->flags & NEXTHOP_FLAG_ONLINK)
400 resolved_hop->flags |= NEXTHOP_FLAG_ONLINK;
401
f674dfe2
RW
402 /* Copy labels of the resolved route */
403 if (newhop->nh_label)
404 nexthop_add_labels(resolved_hop, newhop->nh_label_type,
405 newhop->nh_label->num_labels,
406 &newhop->nh_label->label[0]);
407
d62a17ae 408 resolved_hop->rparent = nexthop;
409 nexthop_add(&nexthop->resolved, resolved_hop);
4491a88f
DS
410}
411
718e3744 412/* If force flag is not set, do not modify falgs at all for uninstall
413 the route from FIB. */
d62a17ae 414static int nexthop_active(afi_t afi, struct route_entry *re,
415 struct nexthop *nexthop, int set,
416 struct route_node *top)
417{
418 struct prefix p;
419 struct route_table *table;
420 struct route_node *rn;
5f7a4718 421 struct route_entry *match = NULL;
d62a17ae 422 int resolved;
423 struct nexthop *newhop;
424 struct interface *ifp;
5f7a4718 425 rib_dest_t *dest;
d62a17ae 426
427 if ((nexthop->type == NEXTHOP_TYPE_IPV4)
428 || nexthop->type == NEXTHOP_TYPE_IPV6)
429 nexthop->ifindex = 0;
430
431 if (set) {
432 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE);
d62a17ae 433 nexthops_free(nexthop->resolved);
434 nexthop->resolved = NULL;
435 re->nexthop_mtu = 0;
d44ca835 436 }
18ff3edd 437
1ec31309 438 /* Next hops (remote VTEPs) for EVPN routes are fully resolved. */
439 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_EVPN_RVTEP))
440 return 1;
441
d62a17ae 442 /* Skip nexthops that have been filtered out due to route-map */
443 /* The nexthops are specific to this route and so the same */
444 /* nexthop for a different route may not have this flag set */
34815ea3
DS
445 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED)) {
446 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
447 zlog_debug("\t%s: Nexthop Filtered",
448 __PRETTY_FUNCTION__);
d62a17ae 449 return 0;
34815ea3 450 }
d62a17ae 451
452 /*
453 * Check to see if we should trust the passed in information
454 * for UNNUMBERED interfaces as that we won't find the GW
455 * address in the routing table.
456 */
457 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK)) {
4a7371e9 458 ifp = if_lookup_by_index(nexthop->ifindex, nexthop->vrf_id);
103e4a71
CF
459 if ((ifp && connected_is_unnumbered(ifp))
460 || CHECK_FLAG(re->flags, ZEBRA_FLAG_ONLINK)) {
d62a17ae 461 if (if_is_operative(ifp))
462 return 1;
34815ea3
DS
463 else {
464 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
465 zlog_debug(
466 "\t%s: Onlink and interface %s is not operative",
467 __PRETTY_FUNCTION__, ifp->name);
d62a17ae 468 return 0;
34815ea3
DS
469 }
470 } else {
471 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
472 zlog_debug(
473 "\t%s: Interface %s is not unnumbered",
474 __PRETTY_FUNCTION__,
475 ifp ? ifp->name : "Unknown");
d62a17ae 476 return 0;
34815ea3 477 }
16814f96 478 }
718e3744 479
d62a17ae 480 /* Make lookup prefix. */
481 memset(&p, 0, sizeof(struct prefix));
482 switch (afi) {
483 case AFI_IP:
484 p.family = AF_INET;
485 p.prefixlen = IPV4_MAX_PREFIXLEN;
486 p.u.prefix4 = nexthop->gate.ipv4;
487 break;
488 case AFI_IP6:
489 p.family = AF_INET6;
490 p.prefixlen = IPV6_MAX_PREFIXLEN;
491 p.u.prefix6 = nexthop->gate.ipv6;
492 break;
493 default:
494 assert(afi != AFI_IP && afi != AFI_IP6);
495 break;
718e3744 496 }
d62a17ae 497 /* Lookup table. */
4a7371e9 498 table = zebra_vrf_table(afi, SAFI_UNICAST, nexthop->vrf_id);
34815ea3
DS
499 if (!table) {
500 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
501 zlog_debug("\t%s: Table not found",
502 __PRETTY_FUNCTION__);
d62a17ae 503 return 0;
34815ea3 504 }
d62a17ae 505
506 rn = route_node_match(table, (struct prefix *)&p);
507 while (rn) {
508 route_unlock_node(rn);
509
fd7fd9e5
DS
510 /* Lookup should halt if we've matched against ourselves ('top',
511 * if specified) - i.e., we cannot have a nexthop NH1 is
512 * resolved by a route NH1. The exception is if the route is a
513 * host route.
514 */
515 if (top && rn == top)
996c9314 516 if (((afi == AFI_IP) && (rn->p.prefixlen != 32))
34815ea3
DS
517 || ((afi == AFI_IP6) && (rn->p.prefixlen != 128))) {
518 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
519 zlog_debug(
520 "\t%s: Matched against ourself and prefix length is not max bit length",
521 __PRETTY_FUNCTION__);
fd7fd9e5 522 return 0;
34815ea3 523 }
d62a17ae 524
525 /* Pick up selected route. */
526 /* However, do not resolve over default route unless explicitly
527 * allowed. */
528 if (is_default_prefix(&rn->p)
34815ea3
DS
529 && !rnh_resolve_via_default(p.family)) {
530 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
531 zlog_debug(
532 "\t:%s: Resolved against default route",
533 __PRETTY_FUNCTION__);
d62a17ae 534 return 0;
34815ea3 535 }
d62a17ae 536
5f7a4718 537 dest = rib_dest_from_rnode(rn);
996c9314
LB
538 if (dest && dest->selected_fib
539 && !CHECK_FLAG(dest->selected_fib->status,
540 ROUTE_ENTRY_REMOVED)
541 && dest->selected_fib->type != ZEBRA_ROUTE_TABLE)
5f7a4718 542 match = dest->selected_fib;
48a53dc7 543
d62a17ae 544 /* If there is no selected route or matched route is EGP, go up
545 tree. */
546 if (!match) {
547 do {
548 rn = rn->parent;
549 } while (rn && rn->info == NULL);
550 if (rn)
551 route_lock_node(rn);
c87bdd2b 552
d62a17ae 553 continue;
554 }
555
d62a17ae 556 if (match->type == ZEBRA_ROUTE_CONNECT) {
557 /* Directly point connected route. */
7ee30f28 558 newhop = match->ng.nexthop;
d62a17ae 559 if (newhop) {
560 if (nexthop->type == NEXTHOP_TYPE_IPV4
561 || nexthop->type == NEXTHOP_TYPE_IPV6)
562 nexthop->ifindex = newhop->ifindex;
563 }
564 return 1;
4e8b02f4 565 } else if (CHECK_FLAG(re->flags, ZEBRA_FLAG_ALLOW_RECURSION)) {
d62a17ae 566 resolved = 0;
7ee30f28 567 for (ALL_NEXTHOPS(match->ng, newhop)) {
a8309422
DL
568 if (!CHECK_FLAG(newhop->flags,
569 NEXTHOP_FLAG_FIB))
570 continue;
571 if (CHECK_FLAG(newhop->flags,
572 NEXTHOP_FLAG_RECURSIVE))
573 continue;
574
575 if (set) {
576 SET_FLAG(nexthop->flags,
577 NEXTHOP_FLAG_RECURSIVE);
578 SET_FLAG(re->status,
579 ROUTE_ENTRY_NEXTHOPS_CHANGED);
580 nexthop_set_resolved(afi, newhop,
581 nexthop);
d62a17ae 582 }
a8309422
DL
583 resolved = 1;
584 }
43e31305
JB
585 if (resolved && set)
586 re->nexthop_mtu = match->mtu;
34815ea3
DS
587 if (!resolved && IS_ZEBRA_DEBUG_RIB_DETAILED)
588 zlog_debug("\t%s: Recursion failed to find",
589 __PRETTY_FUNCTION__);
d62a17ae 590 return resolved;
591 } else if (re->type == ZEBRA_ROUTE_STATIC) {
592 resolved = 0;
7ee30f28 593 for (ALL_NEXTHOPS(match->ng, newhop)) {
a8309422
DL
594 if (!CHECK_FLAG(newhop->flags,
595 NEXTHOP_FLAG_FIB))
596 continue;
597
598 if (set) {
599 SET_FLAG(nexthop->flags,
600 NEXTHOP_FLAG_RECURSIVE);
601 nexthop_set_resolved(afi, newhop,
602 nexthop);
d62a17ae 603 }
a8309422
DL
604 resolved = 1;
605 }
d62a17ae 606 if (resolved && set)
607 re->nexthop_mtu = match->mtu;
34815ea3
DS
608
609 if (!resolved && IS_ZEBRA_DEBUG_RIB_DETAILED)
610 zlog_debug(
611 "\t%s: Static route unable to resolve",
612 __PRETTY_FUNCTION__);
d62a17ae 613 return resolved;
614 } else {
7939ff76
DS
615 if (IS_ZEBRA_DEBUG_RIB_DETAILED) {
616 zlog_debug("\t%s: Route Type %s has not turned on recursion",
617 __PRETTY_FUNCTION__,
618 zebra_route_string(re->type));
619 if (re->type == ZEBRA_ROUTE_BGP &&
620 !CHECK_FLAG(re->flags, ZEBRA_FLAG_IBGP))
621 zlog_debug("\tEBGP: see \"disable-ebgp-connected-route-check\" or \"disable-connected-check\"");
622 }
d62a17ae 623 return 0;
624 }
718e3744 625 }
7939ff76
DS
626 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
627 zlog_debug("\t%s: Nexthop did not lookup in table",
628 __PRETTY_FUNCTION__);
d62a17ae 629 return 0;
718e3744 630}
718e3744 631
d62a17ae 632struct route_entry *rib_match(afi_t afi, safi_t safi, vrf_id_t vrf_id,
633 union g_addr *addr, struct route_node **rn_out)
634{
635 struct prefix p;
636 struct route_table *table;
637 struct route_node *rn;
5f7a4718 638 struct route_entry *match = NULL;
d62a17ae 639 struct nexthop *newhop;
640
641 /* Lookup table. */
642 table = zebra_vrf_table(afi, safi, vrf_id);
643 if (!table)
644 return 0;
645
646 memset(&p, 0, sizeof(struct prefix));
647 p.family = afi;
648 if (afi == AFI_IP) {
649 p.u.prefix4 = addr->ipv4;
650 p.prefixlen = IPV4_MAX_PREFIXLEN;
651 } else {
652 p.u.prefix6 = addr->ipv6;
653 p.prefixlen = IPV6_MAX_PREFIXLEN;
654 }
718e3744 655
d62a17ae 656 rn = route_node_match(table, (struct prefix *)&p);
718e3744 657
d62a17ae 658 while (rn) {
5f7a4718
DS
659 rib_dest_t *dest;
660
d62a17ae 661 route_unlock_node(rn);
718e3744 662
5f7a4718 663 dest = rib_dest_from_rnode(rn);
996c9314
LB
664 if (dest && dest->selected_fib
665 && !CHECK_FLAG(dest->selected_fib->status,
666 ROUTE_ENTRY_REMOVED))
5f7a4718 667 match = dest->selected_fib;
718e3744 668
d62a17ae 669 /* If there is no selected route or matched route is EGP, go up
670 tree. */
671 if (!match) {
672 do {
673 rn = rn->parent;
674 } while (rn && rn->info == NULL);
675 if (rn)
676 route_lock_node(rn);
677 } else {
678 if (match->type != ZEBRA_ROUTE_CONNECT) {
679 int found = 0;
7ee30f28 680 for (ALL_NEXTHOPS(match->ng, newhop))
d62a17ae 681 if (CHECK_FLAG(newhop->flags,
682 NEXTHOP_FLAG_FIB)) {
683 found = 1;
684 break;
685 }
686 if (!found)
687 return NULL;
688 }
689
690 if (rn_out)
691 *rn_out = rn;
692 return match;
693 }
16814f96 694 }
d62a17ae 695 return NULL;
696}
697
698struct route_entry *rib_match_ipv4_multicast(vrf_id_t vrf_id,
699 struct in_addr addr,
700 struct route_node **rn_out)
701{
702 struct route_entry *re = NULL, *mre = NULL, *ure = NULL;
703 struct route_node *m_rn = NULL, *u_rn = NULL;
704 union g_addr gaddr = {.ipv4 = addr};
705
706 switch (ipv4_multicast_mode) {
707 case MCAST_MRIB_ONLY:
708 return rib_match(AFI_IP, SAFI_MULTICAST, vrf_id, &gaddr,
709 rn_out);
710 case MCAST_URIB_ONLY:
711 return rib_match(AFI_IP, SAFI_UNICAST, vrf_id, &gaddr, rn_out);
712 case MCAST_NO_CONFIG:
713 case MCAST_MIX_MRIB_FIRST:
714 re = mre = rib_match(AFI_IP, SAFI_MULTICAST, vrf_id, &gaddr,
715 &m_rn);
716 if (!mre)
717 re = ure = rib_match(AFI_IP, SAFI_UNICAST, vrf_id,
718 &gaddr, &u_rn);
719 break;
720 case MCAST_MIX_DISTANCE:
721 mre = rib_match(AFI_IP, SAFI_MULTICAST, vrf_id, &gaddr, &m_rn);
722 ure = rib_match(AFI_IP, SAFI_UNICAST, vrf_id, &gaddr, &u_rn);
723 if (mre && ure)
724 re = ure->distance < mre->distance ? ure : mre;
725 else if (mre)
726 re = mre;
727 else if (ure)
728 re = ure;
729 break;
730 case MCAST_MIX_PFXLEN:
731 mre = rib_match(AFI_IP, SAFI_MULTICAST, vrf_id, &gaddr, &m_rn);
732 ure = rib_match(AFI_IP, SAFI_UNICAST, vrf_id, &gaddr, &u_rn);
733 if (mre && ure)
734 re = u_rn->p.prefixlen > m_rn->p.prefixlen ? ure : mre;
735 else if (mre)
736 re = mre;
737 else if (ure)
738 re = ure;
739 break;
718e3744 740 }
33550aa8 741
d62a17ae 742 if (rn_out)
743 *rn_out = (re == mre) ? m_rn : u_rn;
718e3744 744
d62a17ae 745 if (IS_ZEBRA_DEBUG_RIB) {
746 char buf[BUFSIZ];
747 inet_ntop(AF_INET, &addr, buf, BUFSIZ);
4623d897 748
32391aff
DS
749 zlog_debug("%s: %s: vrf: %u found %s, using %s",
750 __func__, buf, vrf_id,
d62a17ae 751 mre ? (ure ? "MRIB+URIB" : "MRIB")
752 : ure ? "URIB" : "nothing",
753 re == ure ? "URIB" : re == mre ? "MRIB" : "none");
754 }
755 return re;
4623d897
DL
756}
757
d62a17ae 758void multicast_mode_ipv4_set(enum multicast_mode mode)
4623d897 759{
d62a17ae 760 if (IS_ZEBRA_DEBUG_RIB)
761 zlog_debug("%s: multicast lookup mode set (%d)", __func__,
762 mode);
763 ipv4_multicast_mode = mode;
4623d897
DL
764}
765
d62a17ae 766enum multicast_mode multicast_mode_ipv4_get(void)
4623d897 767{
d62a17ae 768 return ipv4_multicast_mode;
4623d897
DL
769}
770
d62a17ae 771struct route_entry *rib_lookup_ipv4(struct prefix_ipv4 *p, vrf_id_t vrf_id)
718e3744 772{
d62a17ae 773 struct route_table *table;
774 struct route_node *rn;
5f7a4718 775 struct route_entry *match = NULL;
d62a17ae 776 struct nexthop *nexthop;
5f7a4718 777 rib_dest_t *dest;
718e3744 778
d62a17ae 779 /* Lookup table. */
780 table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id);
781 if (!table)
782 return 0;
718e3744 783
d62a17ae 784 rn = route_node_lookup(table, (struct prefix *)p);
718e3744 785
d62a17ae 786 /* No route for this prefix. */
787 if (!rn)
788 return NULL;
718e3744 789
d62a17ae 790 /* Unlock node. */
791 route_unlock_node(rn);
5f7a4718 792 dest = rib_dest_from_rnode(rn);
718e3744 793
996c9314
LB
794 if (dest && dest->selected_fib
795 && !CHECK_FLAG(dest->selected_fib->status, ROUTE_ENTRY_REMOVED))
5f7a4718 796 match = dest->selected_fib;
718e3744 797
d62a17ae 798 if (!match)
799 return NULL;
718e3744 800
d62a17ae 801 if (match->type == ZEBRA_ROUTE_CONNECT)
802 return match;
f9e1b38e 803
7ee30f28 804 for (ALL_NEXTHOPS(match->ng, nexthop))
d62a17ae 805 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB))
806 return match;
718e3744 807
d62a17ae 808 return NULL;
718e3744 809}
810
d62a17ae 811#define RIB_SYSTEM_ROUTE(R) \
812 ((R)->type == ZEBRA_ROUTE_KERNEL || (R)->type == ZEBRA_ROUTE_CONNECT)
7514fb77 813
212df1de
PG
814#define RIB_KERNEL_ROUTE(R) \
815 ((R)->type == ZEBRA_ROUTE_KERNEL)
816
dc95824a
DO
817/* This function verifies reachability of one given nexthop, which can be
818 * numbered or unnumbered, IPv4 or IPv6. The result is unconditionally stored
819 * in nexthop->flags field. If the 4th parameter, 'set', is non-zero,
820 * nexthop->ifindex will be updated appropriately as well.
821 * An existing route map can turn (otherwise active) nexthop into inactive, but
822 * not vice versa.
823 *
824 * The return value is the final value of 'ACTIVE' flag.
825 */
826
d62a17ae 827static unsigned nexthop_active_check(struct route_node *rn,
828 struct route_entry *re,
829 struct nexthop *nexthop, int set)
830{
831 struct interface *ifp;
832 route_map_result_t ret = RMAP_MATCH;
833 int family;
834 char buf[SRCDEST2STR_BUFFER];
86391e56 835 const struct prefix *p, *src_p;
ac6eebce 836 struct zebra_vrf *zvrf;
837
d62a17ae 838 srcdest_rnode_prefixes(rn, &p, &src_p);
839
840 if (rn->p.family == AF_INET)
841 family = AFI_IP;
842 else if (rn->p.family == AF_INET6)
843 family = AFI_IP6;
844 else
845 family = 0;
846 switch (nexthop->type) {
847 case NEXTHOP_TYPE_IFINDEX:
4a7371e9 848 ifp = if_lookup_by_index(nexthop->ifindex, nexthop->vrf_id);
d62a17ae 849 if (ifp && if_is_operative(ifp))
850 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
851 else
852 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
853 break;
854 case NEXTHOP_TYPE_IPV4:
855 case NEXTHOP_TYPE_IPV4_IFINDEX:
856 family = AFI_IP;
1ec31309 857 if (nexthop_active(AFI_IP, re, nexthop, set, rn))
d62a17ae 858 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
859 else
860 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
861 break;
862 case NEXTHOP_TYPE_IPV6:
863 family = AFI_IP6;
864 if (nexthop_active(AFI_IP6, re, nexthop, set, rn))
865 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
866 else
867 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
868 break;
869 case NEXTHOP_TYPE_IPV6_IFINDEX:
870 /* RFC 5549, v4 prefix with v6 NH */
871 if (rn->p.family != AF_INET)
872 family = AFI_IP6;
873 if (IN6_IS_ADDR_LINKLOCAL(&nexthop->gate.ipv6)) {
007dbee6 874 ifp = if_lookup_by_index(nexthop->ifindex,
4a7371e9 875 nexthop->vrf_id);
d62a17ae 876 if (ifp && if_is_operative(ifp))
877 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
878 else
879 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
880 } else {
881 if (nexthop_active(AFI_IP6, re, nexthop, set, rn))
882 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
883 else
884 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
885 }
886 break;
887 case NEXTHOP_TYPE_BLACKHOLE:
888 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
889 break;
890 default:
891 break;
892 }
34815ea3
DS
893 if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)) {
894 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
895 zlog_debug("\t%s: Unable to find a active nexthop",
896 __PRETTY_FUNCTION__);
d62a17ae 897 return 0;
34815ea3 898 }
d62a17ae 899
900 /* XXX: What exactly do those checks do? Do we support
ac6eebce 901 * e.g. IPv4 routes with IPv6 nexthops or vice versa?
902 */
d62a17ae 903 if (RIB_SYSTEM_ROUTE(re) || (family == AFI_IP && p->family != AF_INET)
904 || (family == AFI_IP6 && p->family != AF_INET6))
905 return CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
906
907 /* The original code didn't determine the family correctly
908 * e.g. for NEXTHOP_TYPE_IFINDEX. Retrieve the correct afi
909 * from the rib_table_info in those cases.
910 * Possibly it may be better to use only the rib_table_info
911 * in every case.
912 */
913 if (!family) {
914 rib_table_info_t *info;
915
916 info = srcdest_rnode_table_info(rn);
917 family = info->afi;
718e3744 918 }
c52ef59f 919
d62a17ae 920 memset(&nexthop->rmap_src.ipv6, 0, sizeof(union g_addr));
921
ac6eebce 922 zvrf = zebra_vrf_lookup_by_id(nexthop->vrf_id);
923 if (!zvrf) {
924 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
925 zlog_debug("\t%s: zvrf is NULL", __PRETTY_FUNCTION__);
926 return CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
927 }
928
d62a17ae 929 /* It'll get set if required inside */
ac6eebce 930 ret = zebra_route_map_check(family, re->type, re->instance, p,
931 nexthop, zvrf, re->tag);
d62a17ae 932 if (ret == RMAP_DENYMATCH) {
933 if (IS_ZEBRA_DEBUG_RIB) {
934 srcdest_rnode2str(rn, buf, sizeof(buf));
935 zlog_debug(
936 "%u:%s: Filtering out with NH out %s due to route map",
937 re->vrf_id, buf,
99b9d960 938 ifindex2ifname(nexthop->ifindex,
4a7371e9 939 nexthop->vrf_id));
d62a17ae 940 }
941 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
518f0eb1 942 }
d62a17ae 943 return CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
718e3744 944}
945
03e232a4 946/* Iterate over all nexthops of the given RIB entry and refresh their
f0f77c9a
DS
947 * ACTIVE flag. re->nexthop_active_num is updated accordingly. If any
948 * nexthop is found to toggle the ACTIVE flag, the whole re structure
949 * is flagged with ROUTE_ENTRY_CHANGED. The 4th 'set' argument is
03e232a4
DO
950 * transparently passed to nexthop_active_check().
951 *
952 * Return value is the new number of active nexthops.
953 */
954
d62a17ae 955static int nexthop_active_update(struct route_node *rn, struct route_entry *re,
956 int set)
957{
958 struct nexthop *nexthop;
959 union g_addr prev_src;
960 unsigned int prev_active, new_active, old_num_nh;
961 ifindex_t prev_index;
ac6eebce 962
d62a17ae 963 old_num_nh = re->nexthop_active_num;
964
965 re->nexthop_active_num = 0;
966 UNSET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
967
7ee30f28 968 for (nexthop = re->ng.nexthop; nexthop; nexthop = nexthop->next) {
d62a17ae 969 /* No protocol daemon provides src and so we're skipping
970 * tracking it */
971 prev_src = nexthop->rmap_src;
972 prev_active = CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
973 prev_index = nexthop->ifindex;
974 if ((new_active = nexthop_active_check(rn, re, nexthop, set)))
975 re->nexthop_active_num++;
976 /* Don't allow src setting on IPv6 addr for now */
977 if (prev_active != new_active || prev_index != nexthop->ifindex
978 || ((nexthop->type >= NEXTHOP_TYPE_IFINDEX
979 && nexthop->type < NEXTHOP_TYPE_IPV6)
980 && prev_src.ipv4.s_addr
981 != nexthop->rmap_src.ipv4.s_addr)
982 || ((nexthop->type >= NEXTHOP_TYPE_IPV6
983 && nexthop->type < NEXTHOP_TYPE_BLACKHOLE)
984 && !(IPV6_ADDR_SAME(&prev_src.ipv6,
985 &nexthop->rmap_src.ipv6)))) {
986 SET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
987 SET_FLAG(re->status, ROUTE_ENTRY_NEXTHOPS_CHANGED);
988 }
989 }
990
991 if (old_num_nh != re->nexthop_active_num)
992 SET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
6e26278c 993
d62a17ae 994 if (CHECK_FLAG(re->status, ROUTE_ENTRY_CHANGED)) {
995 SET_FLAG(re->status, ROUTE_ENTRY_NEXTHOPS_CHANGED);
996 }
997
998 return re->nexthop_active_num;
718e3744 999}
6baeb988 1000
a64448ba
DS
1001/*
1002 * Is this RIB labeled-unicast? It must be of type BGP and all paths
1003 * (nexthops) must have a label.
1004 */
d62a17ae 1005int zebra_rib_labeled_unicast(struct route_entry *re)
a64448ba 1006{
d62a17ae 1007 struct nexthop *nexthop = NULL;
a64448ba 1008
d62a17ae 1009 if (re->type != ZEBRA_ROUTE_BGP)
1010 return 0;
a64448ba 1011
7ee30f28 1012 for (ALL_NEXTHOPS(re->ng, nexthop))
d62a17ae 1013 if (!nexthop->nh_label || !nexthop->nh_label->num_labels)
1014 return 0;
6b0655a2 1015
d62a17ae 1016 return 1;
a64448ba 1017}
718e3744 1018
6ae24471
DS
1019/* Update flag indicates whether this is a "replace" or not. Currently, this
1020 * is only used for IPv4.
1021 */
0c555cc6
DS
1022void rib_install_kernel(struct route_node *rn, struct route_entry *re,
1023 struct route_entry *old)
718e3744 1024{
d62a17ae 1025 struct nexthop *nexthop;
1026 rib_table_info_t *info = srcdest_rnode_table_info(rn);
d62a17ae 1027 struct zebra_vrf *zvrf = vrf_info_lookup(re->vrf_id);
97f5b441
MS
1028 const struct prefix *p, *src_p;
1029 enum zebra_dplane_result ret;
1030
1031 rib_dest_t *dest = rib_dest_from_rnode(rn);
718e3744 1032
d62a17ae 1033 srcdest_rnode_prefixes(rn, &p, &src_p);
416ec78d 1034
d62a17ae 1035 if (info->safi != SAFI_UNICAST) {
7ee30f28 1036 for (ALL_NEXTHOPS(re->ng, nexthop))
d62a17ae 1037 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
0c555cc6 1038 return;
25b9cb0c
DL
1039 } else {
1040 struct nexthop *prev;
1041
7ee30f28 1042 for (ALL_NEXTHOPS(re->ng, nexthop)) {
25b9cb0c 1043 UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_DUPLICATE);
7ee30f28 1044 for (ALL_NEXTHOPS(re->ng, prev)) {
25b9cb0c
DL
1045 if (prev == nexthop)
1046 break;
996c9314
LB
1047 if (nexthop_same_firsthop(nexthop, prev)) {
1048 SET_FLAG(nexthop->flags,
1049 NEXTHOP_FLAG_DUPLICATE);
25b9cb0c
DL
1050 break;
1051 }
1052 }
1053 }
d62a17ae 1054 }
718e3744 1055
2063a814
DS
1056 /*
1057 * If this is a replace to a new RE let the originator of the RE
1058 * know that they've lost
1059 */
9a9f8926 1060 if (old && (old != re) && (old->type != re->type))
28610f7e 1061 zsend_route_notify_owner(old, p, ZAPI_ROUTE_BETTER_ADMIN_WON);
25b9cb0c 1062
97f5b441
MS
1063 /* Update fib selection */
1064 dest->selected_fib = re;
1065
d62a17ae 1066 /*
1067 * Make sure we update the FPM any time we send new information to
1068 * the kernel.
1069 */
1070 hook_call(rib_update, rn, "installing in kernel");
97f5b441
MS
1071
1072 /* Send add or update */
5709131c 1073 if (old && (old != re))
97f5b441 1074 ret = dplane_route_update(rn, re, old);
5709131c 1075 else
97f5b441 1076 ret = dplane_route_add(rn, re);
97f5b441
MS
1077
1078 switch (ret) {
ea1c14f6 1079 case ZEBRA_DPLANE_REQUEST_QUEUED:
97f5b441
MS
1080 if (zvrf)
1081 zvrf->installs_queued++;
1e885672 1082 break;
ea1c14f6 1083 case ZEBRA_DPLANE_REQUEST_FAILURE:
97f5b441
MS
1084 {
1085 char str[SRCDEST2STR_BUFFER];
1086
1087 srcdest_rnode2str(rn, str, sizeof(str));
1088 flog_err(EC_ZEBRA_DP_INSTALL_FAIL,
1089 "%u:%s: Failed to enqueue dataplane install",
1090 re->vrf_id, str);
1e885672 1091 break;
97f5b441 1092 }
ea1c14f6 1093 case ZEBRA_DPLANE_REQUEST_SUCCESS:
97f5b441
MS
1094 if (zvrf)
1095 zvrf->installs++;
1e885672
DS
1096 break;
1097 }
d62a17ae 1098
0c555cc6 1099 return;
718e3744 1100}
1101
1102/* Uninstall the route from kernel. */
0c555cc6 1103void rib_uninstall_kernel(struct route_node *rn, struct route_entry *re)
718e3744 1104{
d62a17ae 1105 struct nexthop *nexthop;
1106 rib_table_info_t *info = srcdest_rnode_table_info(rn);
d62a17ae 1107 struct zebra_vrf *zvrf = vrf_info_lookup(re->vrf_id);
05737783 1108
d62a17ae 1109 if (info->safi != SAFI_UNICAST) {
7ee30f28 1110 for (ALL_NEXTHOPS(re->ng, nexthop))
d6792f9d 1111 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
0c555cc6 1112 return;
d62a17ae 1113 }
416ec78d 1114
d62a17ae 1115 /*
1116 * Make sure we update the FPM any time we send new information to
97f5b441 1117 * the dataplane.
d62a17ae 1118 */
1119 hook_call(rib_update, rn, "uninstalling from kernel");
97f5b441
MS
1120
1121 switch (dplane_route_delete(rn, re)) {
ea1c14f6 1122 case ZEBRA_DPLANE_REQUEST_QUEUED:
97f5b441
MS
1123 if (zvrf)
1124 zvrf->removals_queued++;
1e885672 1125 break;
ea1c14f6 1126 case ZEBRA_DPLANE_REQUEST_FAILURE:
97f5b441
MS
1127 {
1128 char str[SRCDEST2STR_BUFFER];
1129
1130 srcdest_rnode2str(rn, str, sizeof(str));
1131 flog_err(EC_ZEBRA_DP_INSTALL_FAIL,
1132 "%u:%s: Failed to enqueue dataplane uninstall",
1133 re->vrf_id, str);
1e885672 1134 break;
97f5b441 1135 }
ea1c14f6 1136 case ZEBRA_DPLANE_REQUEST_SUCCESS:
1e885672
DS
1137 if (zvrf)
1138 zvrf->removals++;
1139 break;
1140 }
718e3744 1141
0c555cc6 1142 return;
718e3744 1143}
1144
1145/* Uninstall the route from kernel. */
d62a17ae 1146static void rib_uninstall(struct route_node *rn, struct route_entry *re)
718e3744 1147{
d62a17ae 1148 rib_table_info_t *info = srcdest_rnode_table_info(rn);
5f7a4718 1149 rib_dest_t *dest = rib_dest_from_rnode(rn);
97f5b441 1150 struct nexthop *nexthop;
416ec78d 1151
5f7a4718 1152 if (dest && dest->selected_fib == re) {
d62a17ae 1153 if (info->safi == SAFI_UNICAST)
1154 hook_call(rib_update, rn, "rib_uninstall");
5adc2528 1155
d62a17ae 1156 /* If labeled-unicast route, uninstall transit LSP. */
1157 if (zebra_rib_labeled_unicast(re))
1158 zebra_mpls_lsp_uninstall(info->zvrf, rn, re);
7cdb1a84
MS
1159
1160 if (!RIB_SYSTEM_ROUTE(re))
1161 rib_uninstall_kernel(rn, re);
97f5b441
MS
1162
1163 dest->selected_fib = NULL;
1164
1165 for (ALL_NEXTHOPS(re->ng, nexthop))
1166 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
d62a17ae 1167 }
446bb95e 1168
d62a17ae 1169 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)) {
86391e56
MS
1170 const struct prefix *p, *src_p;
1171
d62a17ae 1172 srcdest_rnode_prefixes(rn, &p, &src_p);
05737783 1173
d62a17ae 1174 redistribute_delete(p, src_p, re);
1175 UNSET_FLAG(re->flags, ZEBRA_FLAG_SELECTED);
1176 }
718e3744 1177}
1178
9fd92e3c
AS
1179/*
1180 * rib_can_delete_dest
1181 *
1182 * Returns TRUE if the given dest can be deleted from the table.
1183 */
d62a17ae 1184static int rib_can_delete_dest(rib_dest_t *dest)
9fd92e3c 1185{
d62a17ae 1186 if (dest->routes) {
1187 return 0;
1188 }
9fd92e3c 1189
d62a17ae 1190 /*
1191 * Don't delete the dest if we have to update the FPM about this
1192 * prefix.
1193 */
1194 if (CHECK_FLAG(dest->flags, RIB_DEST_UPDATE_FPM)
1195 || CHECK_FLAG(dest->flags, RIB_DEST_SENT_TO_FPM))
1196 return 0;
5adc2528 1197
d62a17ae 1198 return 1;
9fd92e3c
AS
1199}
1200
1201/*
1202 * rib_gc_dest
1203 *
1204 * Garbage collect the rib dest corresponding to the given route node
1205 * if appropriate.
1206 *
1207 * Returns TRUE if the dest was deleted, FALSE otherwise.
1208 */
d62a17ae 1209int rib_gc_dest(struct route_node *rn)
9fd92e3c 1210{
d62a17ae 1211 rib_dest_t *dest;
9fd92e3c 1212
d62a17ae 1213 dest = rib_dest_from_rnode(rn);
1214 if (!dest)
1215 return 0;
9fd92e3c 1216
d62a17ae 1217 if (!rib_can_delete_dest(dest))
1218 return 0;
9fd92e3c 1219
c9abf558
DS
1220 if (IS_ZEBRA_DEBUG_RIB) {
1221 struct zebra_vrf *zvrf;
1222
1223 zvrf = rib_dest_vrf(dest);
d62a17ae 1224 rnode_debug(rn, zvrf_id(zvrf), "removing dest from table");
c9abf558 1225 }
9fd92e3c 1226
d62a17ae 1227 dest->rnode = NULL;
1228 XFREE(MTYPE_RIB_DEST, dest);
1229 rn->info = NULL;
9fd92e3c 1230
d62a17ae 1231 /*
1232 * Release the one reference that we keep on the route node.
1233 */
1234 route_unlock_node(rn);
1235 return 1;
9fd92e3c
AS
1236}
1237
d62a17ae 1238static void rib_process_add_fib(struct zebra_vrf *zvrf, struct route_node *rn,
1239 struct route_entry *new)
3e5c6e00 1240{
5f7a4718
DS
1241 rib_dest_t *dest = rib_dest_from_rnode(rn);
1242
d62a17ae 1243 hook_call(rib_update, rn, "new route selected");
3e5c6e00 1244
d62a17ae 1245 /* Update real nexthop. This may actually determine if nexthop is active
1246 * or not. */
1247 if (!nexthop_active_update(rn, new, 1)) {
1248 UNSET_FLAG(new->status, ROUTE_ENTRY_CHANGED);
1249 return;
1250 }
3e5c6e00 1251
d62a17ae 1252 if (IS_ZEBRA_DEBUG_RIB) {
1253 char buf[SRCDEST2STR_BUFFER];
1254 srcdest_rnode2str(rn, buf, sizeof(buf));
1255 zlog_debug("%u:%s: Adding route rn %p, re %p (type %d)",
1256 zvrf_id(zvrf), buf, rn, new, new->type);
1257 }
3e5c6e00 1258
d62a17ae 1259 /* If labeled-unicast route, install transit LSP. */
1260 if (zebra_rib_labeled_unicast(new))
1261 zebra_mpls_lsp_install(zvrf, rn, new);
a64448ba 1262
0c555cc6
DS
1263 if (!RIB_SYSTEM_ROUTE(new))
1264 rib_install_kernel(rn, new, NULL);
ed216282
DS
1265 else
1266 dest->selected_fib = new;
3e5c6e00 1267
d62a17ae 1268 UNSET_FLAG(new->status, ROUTE_ENTRY_CHANGED);
3e5c6e00 1269}
1270
d62a17ae 1271static void rib_process_del_fib(struct zebra_vrf *zvrf, struct route_node *rn,
1272 struct route_entry *old)
3e5c6e00 1273{
5f7a4718 1274 rib_dest_t *dest = rib_dest_from_rnode(rn);
d62a17ae 1275 hook_call(rib_update, rn, "removing existing route");
3e5c6e00 1276
d62a17ae 1277 /* Uninstall from kernel. */
1278 if (IS_ZEBRA_DEBUG_RIB) {
1279 char buf[SRCDEST2STR_BUFFER];
1280 srcdest_rnode2str(rn, buf, sizeof(buf));
1281 zlog_debug("%u:%s: Deleting route rn %p, re %p (type %d)",
1282 zvrf_id(zvrf), buf, rn, old, old->type);
1283 }
3e5c6e00 1284
d62a17ae 1285 /* If labeled-unicast route, uninstall transit LSP. */
1286 if (zebra_rib_labeled_unicast(old))
1287 zebra_mpls_lsp_uninstall(zvrf, rn, old);
1288
1289 if (!RIB_SYSTEM_ROUTE(old))
1290 rib_uninstall_kernel(rn, old);
ed216282
DS
1291 else {
1292 /*
1293 * We are setting this to NULL here
1294 * because that is what we traditionally
1295 * have been doing. I am not positive
1296 * that this is the right thing to do
1297 * but let's leave the code alone
1298 * for the RIB_SYSTEM_ROUTE case
1299 */
1300 dest->selected_fib = NULL;
1301 }
d62a17ae 1302
1303 /* Update nexthop for route, reset changed flag. */
ef57f35f
DL
1304 /* Note: this code also handles the Linux case when an interface goes
1305 * down, causing the kernel to delete routes without sending DELROUTE
1306 * notifications
1307 */
212df1de
PG
1308 if (!nexthop_active_update(rn, old, 1) &&
1309 (RIB_KERNEL_ROUTE(old)))
1310 SET_FLAG(old->status, ROUTE_ENTRY_REMOVED);
1311 else
1312 UNSET_FLAG(old->status, ROUTE_ENTRY_CHANGED);
d62a17ae 1313}
1314
1315static void rib_process_update_fib(struct zebra_vrf *zvrf,
1316 struct route_node *rn,
1317 struct route_entry *old,
1318 struct route_entry *new)
1319{
1320 struct nexthop *nexthop = NULL;
1321 int nh_active = 0;
5f7a4718 1322 rib_dest_t *dest = rib_dest_from_rnode(rn);
d62a17ae 1323
1324 /*
1325 * We have to install or update if a new route has been selected or
1326 * something has changed.
1327 */
1328 if (new != old || CHECK_FLAG(new->status, ROUTE_ENTRY_CHANGED)) {
1329 hook_call(rib_update, rn, "updating existing route");
1330
1331 /* Update the nexthop; we could determine here that nexthop is
1332 * inactive. */
1333 if (nexthop_active_update(rn, new, 1))
1334 nh_active = 1;
1335
1336 /* If nexthop is active, install the selected route, if
1337 * appropriate. If
1338 * the install succeeds, cleanup flags for prior route, if
1339 * different from
1340 * newly selected.
1341 */
1342 if (nh_active) {
1343 if (IS_ZEBRA_DEBUG_RIB) {
1344 char buf[SRCDEST2STR_BUFFER];
1345 srcdest_rnode2str(rn, buf, sizeof(buf));
1346 if (new != old)
1347 zlog_debug(
1348 "%u:%s: Updating route rn %p, re %p (type %d) "
1349 "old %p (type %d)",
1350 zvrf_id(zvrf), buf, rn, new,
1351 new->type, old, old->type);
1352 else
1353 zlog_debug(
1354 "%u:%s: Updating route rn %p, re %p (type %d)",
1355 zvrf_id(zvrf), buf, rn, new,
1356 new->type);
1357 }
1358
1359 /* If labeled-unicast route, uninstall transit LSP. */
1360 if (zebra_rib_labeled_unicast(old))
1361 zebra_mpls_lsp_uninstall(zvrf, rn, old);
1362
1363 /* Non-system route should be installed. */
1364 if (!RIB_SYSTEM_ROUTE(new)) {
1365 /* If labeled-unicast route, install transit
1366 * LSP. */
1367 if (zebra_rib_labeled_unicast(new))
1368 zebra_mpls_lsp_install(zvrf, rn, new);
1369
0c555cc6 1370 rib_install_kernel(rn, new, old);
ed216282
DS
1371 } else {
1372 /*
1373 * We do not need to install the
1374 * selected route because it
1375 * is already isntalled by
1376 * the system( ie not us )
1377 * so just mark it as winning
1378 * we do need to ensure that
1379 * if we uninstall a route
1380 * from ourselves we don't
1381 * over write this pointer
1382 */
1383 dest->selected_fib = NULL;
d62a17ae 1384 }
d62a17ae 1385 /* If install succeeded or system route, cleanup flags
1386 * for prior route. */
ed216282 1387 if (new != old) {
d62a17ae 1388 if (RIB_SYSTEM_ROUTE(new)) {
1389 if (!RIB_SYSTEM_ROUTE(old))
1390 rib_uninstall_kernel(rn, old);
1391 } else {
7ee30f28 1392 for (nexthop = old->ng.nexthop; nexthop;
d62a17ae 1393 nexthop = nexthop->next)
1394 UNSET_FLAG(nexthop->flags,
1395 NEXTHOP_FLAG_FIB);
1396 }
1397 }
d62a17ae 1398 }
a64448ba 1399
d62a17ae 1400 /*
1401 * If nexthop for selected route is not active or install
1402 * failed, we
1403 * may need to uninstall and delete for redistribution.
1404 */
ed216282 1405 if (!nh_active) {
d62a17ae 1406 if (IS_ZEBRA_DEBUG_RIB) {
1407 char buf[SRCDEST2STR_BUFFER];
1408 srcdest_rnode2str(rn, buf, sizeof(buf));
1409 if (new != old)
1410 zlog_debug(
1411 "%u:%s: Deleting route rn %p, re %p (type %d) "
0cfbff74 1412 "old %p (type %d) - nexthop inactive",
d62a17ae 1413 zvrf_id(zvrf), buf, rn, new,
0cfbff74 1414 new->type, old, old->type);
d62a17ae 1415 else
1416 zlog_debug(
0cfbff74 1417 "%u:%s: Deleting route rn %p, re %p (type %d) - nexthop inactive",
d62a17ae 1418 zvrf_id(zvrf), buf, rn, new,
0cfbff74 1419 new->type);
d62a17ae 1420 }
1421
1422 /* If labeled-unicast route, uninstall transit LSP. */
1423 if (zebra_rib_labeled_unicast(old))
1424 zebra_mpls_lsp_uninstall(zvrf, rn, old);
1425
1426 if (!RIB_SYSTEM_ROUTE(old))
1427 rib_uninstall_kernel(rn, old);
ed216282
DS
1428 else
1429 dest->selected_fib = NULL;
d62a17ae 1430 }
1431 } else {
1432 /*
1433 * Same route selected; check if in the FIB and if not,
1434 * re-install. This
1435 * is housekeeping code to deal with race conditions in kernel
1436 * with linux
1437 * netlink reporting interface up before IPv4 or IPv6 protocol
1438 * is ready
1439 * to add routes.
1440 */
1441 if (!RIB_SYSTEM_ROUTE(new)) {
ed216282 1442 bool in_fib = false;
d62a17ae 1443
7ee30f28 1444 for (ALL_NEXTHOPS(new->ng, nexthop))
d62a17ae 1445 if (CHECK_FLAG(nexthop->flags,
1446 NEXTHOP_FLAG_FIB)) {
ed216282 1447 in_fib = true;
d62a17ae 1448 break;
1449 }
1450 if (!in_fib)
1451 rib_install_kernel(rn, new, NULL);
1452 }
1453 }
1454
1455 /* Update prior route. */
1456 if (new != old) {
d62a17ae 1457 /* Set real nexthop. */
1458 nexthop_active_update(rn, old, 1);
1459 UNSET_FLAG(old->status, ROUTE_ENTRY_CHANGED);
1460 }
3e5c6e00 1461
d62a17ae 1462 /* Clear changed flag. */
1463 UNSET_FLAG(new->status, ROUTE_ENTRY_CHANGED);
3e5c6e00 1464}
1465
d62a17ae 1466/* Check if 'alternate' RIB entry is better than 'current'. */
1467static struct route_entry *rib_choose_best(struct route_entry *current,
1468 struct route_entry *alternate)
1469{
1470 if (current == NULL)
1471 return alternate;
1472
1473 /* filter route selection in following order:
1474 * - connected beats other types
fec4ca19 1475 * - if both connected, loopback or vrf wins
d62a17ae 1476 * - lower distance beats higher
1477 * - lower metric beats higher for equal distance
1478 * - last, hence oldest, route wins tie break.
1479 */
1480
fec4ca19
DS
1481 /* Connected routes. Check to see if either are a vrf
1482 * or loopback interface. If not, pick the last connected
d62a17ae 1483 * route of the set of lowest metric connected routes.
1484 */
1485 if (alternate->type == ZEBRA_ROUTE_CONNECT) {
fec4ca19
DS
1486 if (current->type != ZEBRA_ROUTE_CONNECT)
1487 return alternate;
1488
1489 /* both are connected. are either loop or vrf? */
1490 struct nexthop *nexthop = NULL;
1491
1492 for (ALL_NEXTHOPS(alternate->ng, nexthop)) {
1493 if (if_is_loopback_or_vrf(if_lookup_by_index(
1494 nexthop->ifindex, alternate->vrf_id)))
1495 return alternate;
1496 }
1497
1498 for (ALL_NEXTHOPS(current->ng, nexthop)) {
1499 if (if_is_loopback_or_vrf(if_lookup_by_index(
1500 nexthop->ifindex, current->vrf_id)))
1501 return current;
1502 }
1503
1504 /* Neither are loop or vrf so pick best metric */
1505 if (alternate->metric <= current->metric)
d62a17ae 1506 return alternate;
1507
1508 return current;
1509 }
3e5c6e00 1510
d62a17ae 1511 if (current->type == ZEBRA_ROUTE_CONNECT)
1512 return current;
3e5c6e00 1513
d62a17ae 1514 /* higher distance loses */
1515 if (alternate->distance < current->distance)
1516 return alternate;
1517 if (current->distance < alternate->distance)
1518 return current;
3e5c6e00 1519
d62a17ae 1520 /* metric tie-breaks equal distance */
1521 if (alternate->metric <= current->metric)
1522 return alternate;
3e5c6e00 1523
d62a17ae 1524 return current;
3e5c6e00 1525}
1526
d62a17ae 1527/* Core function for processing routing information base. */
1528static void rib_process(struct route_node *rn)
1529{
1530 struct route_entry *re;
1531 struct route_entry *next;
1532 struct route_entry *old_selected = NULL;
1533 struct route_entry *new_selected = NULL;
1534 struct route_entry *old_fib = NULL;
1535 struct route_entry *new_fib = NULL;
1536 struct route_entry *best = NULL;
1537 char buf[SRCDEST2STR_BUFFER];
1538 rib_dest_t *dest;
1539 struct zebra_vrf *zvrf = NULL;
86391e56
MS
1540 const struct prefix *p, *src_p;
1541
d62a17ae 1542 srcdest_rnode_prefixes(rn, &p, &src_p);
1543 vrf_id_t vrf_id = VRF_UNKNOWN;
1544
1545 assert(rn);
1546
1547 dest = rib_dest_from_rnode(rn);
1548 if (dest) {
1549 zvrf = rib_dest_vrf(dest);
1550 vrf_id = zvrf_id(zvrf);
1551 }
bab85d4f 1552
d62a17ae 1553 if (IS_ZEBRA_DEBUG_RIB)
1554 srcdest_rnode2str(rn, buf, sizeof(buf));
bab85d4f 1555
d62a17ae 1556 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
1557 zlog_debug("%u:%s: Processing rn %p", vrf_id, buf, rn);
bab85d4f 1558
607425e5
DS
1559 /*
1560 * we can have rn's that have a NULL info pointer
1561 * (dest). As such let's not let the deref happen
1562 * additionally we know RNODE_FOREACH_RE_SAFE
1563 * will not iterate so we are ok.
1564 */
1565 if (dest)
1566 old_fib = dest->selected_fib;
5f7a4718 1567
a2addae8 1568 RNODE_FOREACH_RE_SAFE (rn, re, next) {
d62a17ae 1569 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
1570 zlog_debug(
1571 "%u:%s: Examine re %p (type %d) status %x flags %x "
1572 "dist %d metric %d",
1573 vrf_id, buf, re, re->type, re->status,
1574 re->flags, re->distance, re->metric);
1575
1576 UNSET_FLAG(re->status, ROUTE_ENTRY_NEXTHOPS_CHANGED);
1577
1578 /* Currently selected re. */
1579 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)) {
1580 assert(old_selected == NULL);
1581 old_selected = re;
1582 }
bab85d4f 1583
d62a17ae 1584 /* Skip deleted entries from selection */
1585 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
1586 continue;
1587
1588 /* Skip unreachable nexthop. */
1589 /* This first call to nexthop_active_update is merely to
1590 * determine if
1591 * there's any change to nexthops associated with this RIB
1592 * entry. Now,
1593 * rib_process() can be invoked due to an external event such as
1594 * link
1595 * down or due to next-hop-tracking evaluation. In the latter
1596 * case,
1597 * a decision has already been made that the NHs have changed.
1598 * So, no
1599 * need to invoke a potentially expensive call again. Further,
1600 * since
1601 * the change might be in a recursive NH which is not caught in
1602 * the nexthop_active_update() code. Thus, we might miss changes
1603 * to
1604 * recursive NHs.
1605 */
1606 if (!CHECK_FLAG(re->status, ROUTE_ENTRY_CHANGED)
1607 && !nexthop_active_update(rn, re, 0)) {
1608 if (re->type == ZEBRA_ROUTE_TABLE) {
1609 /* XXX: HERE BE DRAGONS!!!!!
1610 * In all honesty, I have not yet figured out
1611 * what this part
1612 * does or why the ROUTE_ENTRY_CHANGED test
1613 * above is correct
1614 * or why we need to delete a route here, and
1615 * also not whether
1616 * this concerns both selected and fib route, or
1617 * only selected
1618 * or only fib */
1619 /* This entry was denied by the 'ip protocol
1620 * table' route-map, we
1621 * need to delete it */
1622 if (re != old_selected) {
1623 if (IS_ZEBRA_DEBUG_RIB)
1624 zlog_debug(
32391aff 1625 "%s: %u:%s: imported via import-table but denied "
d62a17ae 1626 "by the ip protocol table route-map",
32391aff 1627 __func__, vrf_id, buf);
d62a17ae 1628 rib_unlink(rn, re);
1629 } else
1630 SET_FLAG(re->status,
1631 ROUTE_ENTRY_REMOVED);
1632 }
1633
1634 continue;
1635 }
bab85d4f 1636
d62a17ae 1637 /* Infinite distance. */
1638 if (re->distance == DISTANCE_INFINITY) {
1639 UNSET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
1640 continue;
1641 }
bab85d4f 1642
d62a17ae 1643 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_FIB_OVERRIDE)) {
1644 best = rib_choose_best(new_fib, re);
1645 if (new_fib && best != new_fib)
1646 UNSET_FLAG(new_fib->status,
1647 ROUTE_ENTRY_CHANGED);
1648 new_fib = best;
1649 } else {
1650 best = rib_choose_best(new_selected, re);
1651 if (new_selected && best != new_selected)
1652 UNSET_FLAG(new_selected->status,
1653 ROUTE_ENTRY_CHANGED);
1654 new_selected = best;
1655 }
1656 if (best != re)
1657 UNSET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
1658 } /* RNODE_FOREACH_RE */
1659
1660 /* If no FIB override route, use the selected route also for FIB */
1661 if (new_fib == NULL)
1662 new_fib = new_selected;
1663
1664 /* After the cycle is finished, the following pointers will be set:
1665 * old_selected --- RE entry currently having SELECTED
1666 * new_selected --- RE entry that is newly SELECTED
1667 * old_fib --- RE entry currently in kernel FIB
1668 * new_fib --- RE entry that is newly to be in kernel FIB
1669 *
1670 * new_selected will get SELECTED flag, and is going to be redistributed
1671 * the zclients. new_fib (which can be new_selected) will be installed
1672 * in kernel.
1673 */
1674
1675 if (IS_ZEBRA_DEBUG_RIB_DETAILED) {
1676 zlog_debug(
1677 "%u:%s: After processing: old_selected %p new_selected %p old_fib %p new_fib %p",
1678 vrf_id, buf, (void *)old_selected, (void *)new_selected,
1679 (void *)old_fib, (void *)new_fib);
1680 }
446bb95e 1681
d62a17ae 1682 /* Buffer ROUTE_ENTRY_CHANGED here, because it will get cleared if
1683 * fib == selected */
9d303b37
DL
1684 bool selected_changed = new_selected && CHECK_FLAG(new_selected->status,
1685 ROUTE_ENTRY_CHANGED);
d62a17ae 1686
1687 /* Update fib according to selection results */
1688 if (new_fib && old_fib)
1689 rib_process_update_fib(zvrf, rn, old_fib, new_fib);
1690 else if (new_fib)
1691 rib_process_add_fib(zvrf, rn, new_fib);
1692 else if (old_fib)
1693 rib_process_del_fib(zvrf, rn, old_fib);
1694
8cb41cd6 1695 /* Update SELECTED entry */
d62a17ae 1696 if (old_selected != new_selected || selected_changed) {
93bdadae 1697
d62a17ae 1698 if (new_selected && new_selected != new_fib) {
1699 nexthop_active_update(rn, new_selected, 1);
1700 UNSET_FLAG(new_selected->status, ROUTE_ENTRY_CHANGED);
1701 }
41ec9222 1702
5af4b346
MS
1703 if (new_selected) {
1704 SET_FLAG(new_selected->flags, ZEBRA_FLAG_SELECTED);
1705
1706 /* Special case: new route is system route, so
1707 * dataplane update will not be done - ensure we
1708 * redistribute the route.
1709 */
1710 if (RIB_SYSTEM_ROUTE(new_selected))
1711 redistribute_update(p, src_p, new_selected,
1712 old_selected);
1713 }
1714
d62a17ae 1715 if (old_selected) {
1716 if (!new_selected)
1717 redistribute_delete(p, src_p, old_selected);
1718 if (old_selected != new_selected)
1719 UNSET_FLAG(old_selected->flags,
1720 ZEBRA_FLAG_SELECTED);
f857321e 1721 }
d62a17ae 1722 }
3e5c6e00 1723
d62a17ae 1724 /* Remove all RE entries queued for removal */
a2addae8 1725 RNODE_FOREACH_RE_SAFE (rn, re, next) {
d62a17ae 1726 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED)) {
1727 if (IS_ZEBRA_DEBUG_RIB) {
1728 rnode_debug(rn, vrf_id, "rn %p, removing re %p",
1729 (void *)rn, (void *)re);
1730 }
1731 rib_unlink(rn, re);
1732 }
1733 }
4d38fdb4 1734
d62a17ae 1735 /*
1736 * Check if the dest can be deleted now.
1737 */
1738 rib_gc_dest(rn);
e96f9203
DO
1739}
1740
e5ac2adf
MS
1741/*
1742 * Utility to match route with dplane context data
1743 */
1744static bool rib_route_match_ctx(const struct route_entry *re,
25779064
MS
1745 const struct zebra_dplane_ctx *ctx,
1746 bool is_update)
e5ac2adf
MS
1747{
1748 bool result = false;
1749
1750 if (is_update) {
1751 /*
1752 * In 'update' case, we test info about the 'previous' or
1753 * 'old' route
1754 */
1755 if ((re->type == dplane_ctx_get_old_type(ctx)) &&
1756 (re->instance == dplane_ctx_get_old_instance(ctx))) {
1757 result = true;
1758
1759 /* TODO -- we're using this extra test, but it's not
1760 * exactly clear why.
1761 */
1762 if (re->type == ZEBRA_ROUTE_STATIC &&
1763 (re->distance != dplane_ctx_get_old_distance(ctx) ||
1764 re->tag != dplane_ctx_get_old_tag(ctx))) {
1765 result = false;
1766 }
1767 }
1768
1769 } else {
1770 /*
1771 * Ordinary, single-route case using primary context info
1772 */
1773 if ((dplane_ctx_get_op(ctx) != DPLANE_OP_ROUTE_DELETE) &&
1774 CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED)) {
1775 /* Skip route that's been deleted */
1776 goto done;
1777 }
1778
1779 if ((re->type == dplane_ctx_get_type(ctx)) &&
1780 (re->instance == dplane_ctx_get_instance(ctx))) {
1781 result = true;
1782
1783 /* TODO -- we're using this extra test, but it's not
1784 * exactly clear why.
1785 */
1786 if (re->type == ZEBRA_ROUTE_STATIC &&
1787 (re->distance != dplane_ctx_get_distance(ctx) ||
1788 re->tag != dplane_ctx_get_tag(ctx))) {
1789 result = false;
1790 }
1791 }
1792 }
1793
1794done:
1795
1796 return (result);
1797}
1798
1799/*
91f16812 1800 * Route-update results processing after async dataplane update.
e5ac2adf 1801 */
25779064 1802static void rib_process_after(struct zebra_dplane_ctx *ctx)
e5ac2adf
MS
1803{
1804 struct route_table *table = NULL;
97f5b441 1805 struct zebra_vrf *zvrf = NULL;
e5ac2adf
MS
1806 struct route_node *rn = NULL;
1807 struct route_entry *re = NULL, *old_re = NULL, *rib;
1808 bool is_update = false;
f183e380 1809 struct nexthop *nexthop, *ctx_nexthop;
97f5b441 1810 char dest_str[PREFIX_STRLEN] = "";
5709131c 1811 enum dplane_op_e op;
e5ac2adf
MS
1812 enum zebra_dplane_result status;
1813 const struct prefix *dest_pfx, *src_pfx;
1814
1815 /* Locate rn and re(s) from ctx */
1816
1817 table = zebra_vrf_table_with_table_id(dplane_ctx_get_afi(ctx),
1818 dplane_ctx_get_safi(ctx),
1819 dplane_ctx_get_vrf(ctx),
1820 dplane_ctx_get_table(ctx));
1821 if (table == NULL) {
1822 if (IS_ZEBRA_DEBUG_DPLANE) {
fe2c53d4 1823 zlog_debug("Failed to process dplane results: no table for afi %d, safi %d, vrf %u",
e5ac2adf
MS
1824 dplane_ctx_get_afi(ctx),
1825 dplane_ctx_get_safi(ctx),
1826 dplane_ctx_get_vrf(ctx));
1827 }
1828 goto done;
1829 }
1830
97f5b441
MS
1831 zvrf = vrf_info_lookup(dplane_ctx_get_vrf(ctx));
1832
e5ac2adf
MS
1833 dest_pfx = dplane_ctx_get_dest(ctx);
1834
1835 /* Note well: only capturing the prefix string if debug is enabled here;
1836 * unconditional log messages will have to generate the string.
1837 */
5709131c 1838 if (IS_ZEBRA_DEBUG_DPLANE)
e5ac2adf 1839 prefix2str(dest_pfx, dest_str, sizeof(dest_str));
e5ac2adf
MS
1840
1841 src_pfx = dplane_ctx_get_src(ctx);
1842 rn = srcdest_rnode_get(table, dplane_ctx_get_dest(ctx),
5709131c 1843 src_pfx ? (struct prefix_ipv6 *)src_pfx : NULL);
e5ac2adf
MS
1844 if (rn == NULL) {
1845 if (IS_ZEBRA_DEBUG_DPLANE) {
fe2c53d4 1846 zlog_debug("Failed to process dplane results: no route for %u:%s",
e5ac2adf
MS
1847 dplane_ctx_get_vrf(ctx), dest_str);
1848 }
1849 goto done;
1850 }
1851
1852 srcdest_rnode_prefixes(rn, &dest_pfx, &src_pfx);
1853
1854 op = dplane_ctx_get_op(ctx);
1855 status = dplane_ctx_get_status(ctx);
1856
c831033f 1857 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL)
f183e380 1858 zlog_debug("%u:%s Processing dplane ctx %p, op %s result %s",
e5ac2adf 1859 dplane_ctx_get_vrf(ctx), dest_str, ctx,
f183e380 1860 dplane_op2str(op), dplane_res2str(status));
e5ac2adf
MS
1861
1862 if (op == DPLANE_OP_ROUTE_DELETE) {
1863 /*
1864 * In the delete case, the zebra core datastructs were
1865 * updated (or removed) at the time the delete was issued,
1866 * so we're just notifying the route owner.
1867 */
1868 if (status == ZEBRA_DPLANE_REQUEST_SUCCESS) {
1869 zsend_route_notify_owner_ctx(ctx, ZAPI_ROUTE_REMOVED);
97f5b441 1870
5709131c 1871 if (zvrf)
97f5b441 1872 zvrf->removals++;
e5ac2adf
MS
1873 } else {
1874 zsend_route_notify_owner_ctx(ctx,
1875 ZAPI_ROUTE_FAIL_INSTALL);
1876
1877 zlog_warn("%u:%s: Route Deletion failure",
1878 dplane_ctx_get_vrf(ctx),
1879 prefix2str(dest_pfx,
1880 dest_str, sizeof(dest_str)));
1881 }
1882
1883 /* Nothing more to do in delete case */
1884 goto done;
1885 }
1886
1887 /*
1888 * Update is a bit of a special case, where we may have both old and new
1889 * routes to post-process.
1890 */
1891 is_update = dplane_ctx_is_update(ctx);
1892
1893 /*
1894 * Take a pass through the routes, look for matches with the context
1895 * info.
1896 */
1897 RNODE_FOREACH_RE(rn, rib) {
1898
1899 if (re == NULL) {
5709131c 1900 if (rib_route_match_ctx(rib, ctx, false))
e5ac2adf 1901 re = rib;
e5ac2adf
MS
1902 }
1903
1904 /* Check for old route match */
1905 if (is_update && (old_re == NULL)) {
5709131c 1906 if (rib_route_match_ctx(rib, ctx, true /*is_update*/))
e5ac2adf 1907 old_re = rib;
e5ac2adf
MS
1908 }
1909
1910 /* Have we found the routes we need to work on? */
5709131c 1911 if (re && ((!is_update || old_re)))
e5ac2adf 1912 break;
e5ac2adf
MS
1913 }
1914
1915 /*
1916 * Check sequence number(s) to detect stale results before continuing
1917 */
1918 if (re && (re->dplane_sequence != dplane_ctx_get_seq(ctx))) {
1919 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL) {
1920 zlog_debug("%u:%s Stale dplane result for re %p",
1921 dplane_ctx_get_vrf(ctx), dest_str, re);
1922 }
1923 re = NULL;
1924 }
1925
1926 if (old_re &&
1927 (old_re->dplane_sequence != dplane_ctx_get_old_seq(ctx))) {
1928 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL) {
1929 zlog_debug("%u:%s Stale dplane result for old_re %p",
1930 dplane_ctx_get_vrf(ctx), dest_str, old_re);
1931 }
1932 old_re = NULL;
1933 }
1934
1935 /*
1936 * Here's sort of a tough one: the route update result is stale.
1937 * Is it better to use the context block info to generate
1938 * redist and owner notification, or is it better to wait
1939 * for the up-to-date result to arrive?
1940 */
1941 if (re == NULL) {
1942 /* TODO -- for now, only expose up-to-date results */
1943 goto done;
1944 }
1945
1946 if (status == ZEBRA_DPLANE_REQUEST_SUCCESS) {
f183e380
MS
1947 /* Update zebra nexthop FIB flag for each
1948 * nexthop that was installed.
1949 */
1950 for (ALL_NEXTHOPS_PTR(dplane_ctx_get_ng(ctx), ctx_nexthop)) {
1951
1952 for (ALL_NEXTHOPS(re->ng, nexthop)) {
1953 if (nexthop_same(ctx_nexthop, nexthop))
1954 break;
1955 }
1956
1957 if (nexthop == NULL)
1958 continue;
1959
e5ac2adf
MS
1960 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
1961 continue;
1962
f183e380
MS
1963 if (CHECK_FLAG(ctx_nexthop->flags,
1964 NEXTHOP_FLAG_FIB))
e5ac2adf
MS
1965 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
1966 else
1967 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
1968 }
1969
f183e380 1970 if (zvrf) {
97f5b441 1971 zvrf->installs++;
f183e380
MS
1972 /* Set flag for nexthop tracking processing */
1973 zvrf->flags |= ZEBRA_VRF_RIB_SCHEDULED;
1974 }
97f5b441 1975
e5ac2adf
MS
1976 /* Redistribute */
1977 /* TODO -- still calling the redist api using the route_entries,
1978 * and there's a corner-case here: if there's no client
1979 * for the 'new' route, a redist deleting the 'old' route
1980 * will be sent. But if the 'old' context info was stale,
1981 * 'old_re' will be NULL here and that delete will not be sent.
1982 */
1983 redistribute_update(dest_pfx, src_pfx, re, old_re);
1984
1985 /* Notify route owner */
1986 zsend_route_notify_owner(re,
1987 dest_pfx, ZAPI_ROUTE_INSTALLED);
1988
1989 } else {
1990 zsend_route_notify_owner(re, dest_pfx,
1991 ZAPI_ROUTE_FAIL_INSTALL);
1992
1993 zlog_warn("%u:%s: Route install failed",
1994 dplane_ctx_get_vrf(ctx),
1995 prefix2str(dest_pfx,
1996 dest_str, sizeof(dest_str)));
1997 }
1998
1999done:
2000
2001 /* Return context to dataplane module */
2002 dplane_ctx_fini(&ctx);
2003}
2004
5110a0c6 2005/* Take a list of route_node structs and return 1, if there was a record
d62a17ae 2006 * picked from it and processed by rib_process(). Don't process more,
5110a0c6 2007 * than one RN record; operate only in the specified sub-queue.
e96f9203 2008 */
d7c0a89a 2009static unsigned int process_subq(struct list *subq, uint8_t qindex)
e96f9203 2010{
d62a17ae 2011 struct listnode *lnode = listhead(subq);
2012 struct route_node *rnode;
2013 rib_dest_t *dest;
2014 struct zebra_vrf *zvrf = NULL;
5110a0c6 2015
d62a17ae 2016 if (!lnode)
2017 return 0;
5110a0c6 2018
d62a17ae 2019 rnode = listgetdata(lnode);
2020 dest = rib_dest_from_rnode(rnode);
2021 if (dest)
2022 zvrf = rib_dest_vrf(dest);
41ec9222 2023
d62a17ae 2024 rib_process(rnode);
5110a0c6 2025
d62a17ae 2026 if (IS_ZEBRA_DEBUG_RIB_DETAILED) {
2027 char buf[SRCDEST2STR_BUFFER];
2028 srcdest_rnode2str(rnode, buf, sizeof(buf));
2029 zlog_debug("%u:%s: rn %p dequeued from sub-queue %u",
2030 zvrf ? zvrf_id(zvrf) : 0, buf, rnode, qindex);
2031 }
41ec9222 2032
d62a17ae 2033 if (rnode->info)
2034 UNSET_FLAG(rib_dest_from_rnode(rnode)->flags,
2035 RIB_ROUTE_QUEUED(qindex));
9fd92e3c 2036
67b9467f 2037#if 0
5110a0c6
SH
2038 else
2039 {
2040 zlog_debug ("%s: called for route_node (%p, %d) with no ribs",
2041 __func__, rnode, rnode->lock);
2042 zlog_backtrace(LOG_DEBUG);
2043 }
67b9467f 2044#endif
d62a17ae 2045 route_unlock_node(rnode);
2046 list_delete_node(subq, lnode);
2047 return 1;
e96f9203
DO
2048}
2049
fb018d25 2050/*
f183e380 2051 * Perform next-hop tracking processing after RIB updates.
fb018d25 2052 */
f183e380 2053static void do_nht_processing(void)
fb018d25 2054{
d62a17ae 2055 struct vrf *vrf;
2056 struct zebra_vrf *zvrf;
9ec6b0bb 2057
d62a17ae 2058 /* Evaluate nexthops for those VRFs which underwent route processing.
2059 * This
2060 * should limit the evaluation to the necessary VRFs in most common
2061 * situations.
2062 */
a2addae8 2063 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
d62a17ae 2064 zvrf = vrf->info;
2065 if (zvrf == NULL || !(zvrf->flags & ZEBRA_VRF_RIB_SCHEDULED))
2066 continue;
2067
f183e380
MS
2068 if (IS_ZEBRA_DEBUG_RIB_DETAILED || IS_ZEBRA_DEBUG_NHT)
2069 zlog_debug("NHT processing check for zvrf %s",
2070 zvrf_name(zvrf));
2071
d62a17ae 2072 zvrf->flags &= ~ZEBRA_VRF_RIB_SCHEDULED;
6d53d7b1 2073 zebra_evaluate_rnh(zvrf, AF_INET, 0, RNH_NEXTHOP_TYPE, NULL);
2074 zebra_evaluate_rnh(zvrf, AF_INET, 0, RNH_IMPORT_CHECK_TYPE,
d62a17ae 2075 NULL);
6d53d7b1 2076 zebra_evaluate_rnh(zvrf, AF_INET6, 0, RNH_NEXTHOP_TYPE, NULL);
2077 zebra_evaluate_rnh(zvrf, AF_INET6, 0, RNH_IMPORT_CHECK_TYPE,
d62a17ae 2078 NULL);
d62a17ae 2079 }
939fba27 2080
d62a17ae 2081 /* Schedule LSPs for processing, if needed. */
2082 zvrf = vrf_info_lookup(VRF_DEFAULT);
2083 if (mpls_should_lsps_be_processed(zvrf)) {
2084 if (IS_ZEBRA_DEBUG_MPLS)
2085 zlog_debug(
2086 "%u: Scheduling all LSPs upon RIB completion",
2087 zvrf_id(zvrf));
2088 zebra_mpls_lsp_schedule(zvrf);
2089 mpls_unmark_lsps_for_processing(zvrf);
2090 }
fb018d25
DS
2091}
2092
f183e380
MS
2093/*
2094 * All meta queues have been processed. Trigger next-hop evaluation.
2095 */
2096static void meta_queue_process_complete(struct work_queue *dummy)
2097{
2098 do_nht_processing();
2099}
2100
e96f9203 2101/* Dispatch the meta queue by picking, processing and unlocking the next RN from
d62a17ae 2102 * a non-empty sub-queue with lowest priority. wq is equal to zebra->ribq and
2103 * data
e96f9203
DO
2104 * is pointed to the meta queue structure.
2105 */
d62a17ae 2106static wq_item_status meta_queue_process(struct work_queue *dummy, void *data)
e96f9203 2107{
d62a17ae 2108 struct meta_queue *mq = data;
2109 unsigned i;
91f16812
MS
2110 uint32_t queue_len, queue_limit;
2111
2112 /* Ensure there's room for more dataplane updates */
2113 queue_limit = dplane_get_in_queue_limit();
2114 queue_len = dplane_get_in_queue_len();
2115 if (queue_len > queue_limit) {
2116 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
8b962e77
MS
2117 zlog_debug("rib queue: dplane queue len %u, limit %u, retrying",
2118 queue_len, queue_limit);
91f16812
MS
2119
2120 /* Ensure that the meta-queue is actually enqueued */
2121 if (work_queue_empty(zebrad.ribq))
2122 work_queue_add(zebrad.ribq, zebrad.mq);
2123
2124 return WQ_QUEUE_BLOCKED;
2125 }
5110a0c6 2126
d62a17ae 2127 for (i = 0; i < MQ_SIZE; i++)
2128 if (process_subq(mq->subq[i], i)) {
2129 mq->size--;
2130 break;
2131 }
2132 return mq->size ? WQ_REQUEUE : WQ_SUCCESS;
e96f9203
DO
2133}
2134
9fd92e3c
AS
2135/*
2136 * Map from rib types to queue type (priority) in meta queue
2137 */
d7c0a89a
QY
2138static const uint8_t meta_queue_map[ZEBRA_ROUTE_MAX] = {
2139 [ZEBRA_ROUTE_SYSTEM] = 4,
2140 [ZEBRA_ROUTE_KERNEL] = 0,
2141 [ZEBRA_ROUTE_CONNECT] = 0,
2142 [ZEBRA_ROUTE_STATIC] = 1,
2143 [ZEBRA_ROUTE_RIP] = 2,
2144 [ZEBRA_ROUTE_RIPNG] = 2,
2145 [ZEBRA_ROUTE_OSPF] = 2,
2146 [ZEBRA_ROUTE_OSPF6] = 2,
2147 [ZEBRA_ROUTE_ISIS] = 2,
2148 [ZEBRA_ROUTE_BGP] = 3,
2149 [ZEBRA_ROUTE_PIM] = 4, // Shouldn't happen but for safety
2150 [ZEBRA_ROUTE_EIGRP] = 2,
2151 [ZEBRA_ROUTE_NHRP] = 2,
2152 [ZEBRA_ROUTE_HSLS] = 4,
2153 [ZEBRA_ROUTE_OLSR] = 4,
2154 [ZEBRA_ROUTE_TABLE] = 1,
2155 [ZEBRA_ROUTE_LDP] = 4,
2156 [ZEBRA_ROUTE_VNC] = 3,
2157 [ZEBRA_ROUTE_VNC_DIRECT] = 3,
2158 [ZEBRA_ROUTE_VNC_DIRECT_RH] = 3,
2159 [ZEBRA_ROUTE_BGP_DIRECT] = 3,
2160 [ZEBRA_ROUTE_BGP_DIRECT_EXT] = 3,
2161 [ZEBRA_ROUTE_BABEL] = 2,
2162 [ZEBRA_ROUTE_ALL] = 4, // Shouldn't happen but for safety
5110a0c6
SH
2163};
2164
2165/* Look into the RN and queue it into one or more priority queues,
2166 * increasing the size for each data push done.
e96f9203 2167 */
d62a17ae 2168static void rib_meta_queue_add(struct meta_queue *mq, struct route_node *rn)
e96f9203 2169{
d62a17ae 2170 struct route_entry *re;
5110a0c6 2171
a2addae8 2172 RNODE_FOREACH_RE (rn, re) {
d7c0a89a 2173 uint8_t qindex = meta_queue_map[re->type];
d62a17ae 2174 struct zebra_vrf *zvrf;
2175
2176 /* Invariant: at this point we always have rn->info set. */
2177 if (CHECK_FLAG(rib_dest_from_rnode(rn)->flags,
2178 RIB_ROUTE_QUEUED(qindex))) {
2179 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
2180 rnode_debug(
2181 rn, re->vrf_id,
2182 "rn %p is already queued in sub-queue %u",
2183 (void *)rn, qindex);
2184 continue;
2185 }
5110a0c6 2186
d62a17ae 2187 SET_FLAG(rib_dest_from_rnode(rn)->flags,
2188 RIB_ROUTE_QUEUED(qindex));
2189 listnode_add(mq->subq[qindex], rn);
2190 route_lock_node(rn);
2191 mq->size++;
5110a0c6 2192
d62a17ae 2193 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
2194 rnode_debug(rn, re->vrf_id,
2195 "queued rn %p into sub-queue %u",
2196 (void *)rn, qindex);
9ec6b0bb 2197
d62a17ae 2198 zvrf = zebra_vrf_lookup_by_id(re->vrf_id);
2199 if (zvrf)
2200 zvrf->flags |= ZEBRA_VRF_RIB_SCHEDULED;
2201 }
4d38fdb4 2202}
2203
6d691129 2204/* Add route_node to work queue and schedule processing */
d62a17ae 2205void rib_queue_add(struct route_node *rn)
4d38fdb4 2206{
d62a17ae 2207 assert(rn);
fc328ac9 2208
d62a17ae 2209 /* Pointless to queue a route_node with no RIB entries to add or remove
2210 */
2211 if (!rnode_to_ribs(rn)) {
2212 zlog_debug("%s: called for route_node (%p, %d) with no ribs",
2213 __func__, (void *)rn, rn->lock);
2214 zlog_backtrace(LOG_DEBUG);
2215 return;
2216 }
4d38fdb4 2217
d62a17ae 2218 if (zebrad.ribq == NULL) {
e914ccbe 2219 flog_err(EC_ZEBRA_WQ_NONEXISTENT,
1c50c1c0 2220 "%s: work_queue does not exist!", __func__);
d62a17ae 2221 return;
2222 }
2223
2224 /*
2225 * The RIB queue should normally be either empty or holding the only
2226 * work_queue_item element. In the latter case this element would
2227 * hold a pointer to the meta queue structure, which must be used to
2228 * actually queue the route nodes to process. So create the MQ
2229 * holder, if necessary, then push the work into it in any case.
2230 * This semantics was introduced after 0.99.9 release.
2231 */
f104f6c1 2232 if (work_queue_empty(zebrad.ribq))
d62a17ae 2233 work_queue_add(zebrad.ribq, zebrad.mq);
e96f9203 2234
d62a17ae 2235 rib_meta_queue_add(zebrad.mq, rn);
fc328ac9 2236
d62a17ae 2237 return;
4d38fdb4 2238}
2239
5110a0c6
SH
2240/* Create new meta queue.
2241 A destructor function doesn't seem to be necessary here.
2242 */
d62a17ae 2243static struct meta_queue *meta_queue_new(void)
e96f9203 2244{
d62a17ae 2245 struct meta_queue *new;
2246 unsigned i;
5110a0c6 2247
d62a17ae 2248 new = XCALLOC(MTYPE_WORK_QUEUE, sizeof(struct meta_queue));
e96f9203 2249
d62a17ae 2250 for (i = 0; i < MQ_SIZE; i++) {
2251 new->subq[i] = list_new();
2252 assert(new->subq[i]);
2253 }
5110a0c6 2254
d62a17ae 2255 return new;
e96f9203
DO
2256}
2257
d62a17ae 2258void meta_queue_free(struct meta_queue *mq)
5a8dfcd8 2259{
d62a17ae 2260 unsigned i;
5a8dfcd8 2261
d62a17ae 2262 for (i = 0; i < MQ_SIZE; i++)
6a154c88 2263 list_delete(&mq->subq[i]);
5a8dfcd8 2264
d62a17ae 2265 XFREE(MTYPE_WORK_QUEUE, mq);
5a8dfcd8
RW
2266}
2267
4d38fdb4 2268/* initialise zebra rib work queue */
d62a17ae 2269static void rib_queue_init(struct zebra_t *zebra)
4d38fdb4 2270{
d62a17ae 2271 assert(zebra);
2272
2273 if (!(zebra->ribq =
2274 work_queue_new(zebra->master, "route_node processing"))) {
e914ccbe 2275 flog_err(EC_ZEBRA_WQ_NONEXISTENT,
1c50c1c0 2276 "%s: could not initialise work queue!", __func__);
d62a17ae 2277 return;
2278 }
4d38fdb4 2279
d62a17ae 2280 /* fill in the work queue spec */
2281 zebra->ribq->spec.workfunc = &meta_queue_process;
2282 zebra->ribq->spec.errorfunc = NULL;
2283 zebra->ribq->spec.completion_func = &meta_queue_process_complete;
2284 /* XXX: TODO: These should be runtime configurable via vty */
2285 zebra->ribq->spec.max_retries = 3;
3a30f50f 2286 zebra->ribq->spec.hold = ZEBRA_RIB_PROCESS_HOLD_TIME;
d62a17ae 2287
2288 if (!(zebra->mq = meta_queue_new())) {
e914ccbe 2289 flog_err(EC_ZEBRA_WQ_NONEXISTENT,
1c50c1c0 2290 "%s: could not initialise meta queue!", __func__);
d62a17ae 2291 return;
2292 }
2293 return;
718e3744 2294}
2295
6d691129
PJ
2296/* RIB updates are processed via a queue of pointers to route_nodes.
2297 *
2298 * The queue length is bounded by the maximal size of the routing table,
2299 * as a route_node will not be requeued, if already queued.
2300 *
f0f77c9a
DS
2301 * REs are submitted via rib_addnode or rib_delnode which set minimal
2302 * state, or static_install_route (when an existing RE is updated)
3c0755dc 2303 * and then submit route_node to queue for best-path selection later.
f0f77c9a 2304 * Order of add/delete state changes are preserved for any given RE.
6d691129 2305 *
f0f77c9a 2306 * Deleted REs are reaped during best-path selection.
6d691129
PJ
2307 *
2308 * rib_addnode
f0f77c9a
DS
2309 * |-> rib_link or unset ROUTE_ENTRY_REMOVE |->Update kernel with
2310 * |-------->| | best RE, if required
3c0755dc
PJ
2311 * | |
2312 * static_install->|->rib_addqueue...... -> rib_process
2313 * | |
2314 * |-------->| |-> rib_unlink
f0f77c9a
DS
2315 * |-> set ROUTE_ENTRY_REMOVE |
2316 * rib_delnode (RE freed)
6d691129 2317 *
9fd92e3c
AS
2318 * The 'info' pointer of a route_node points to a rib_dest_t
2319 * ('dest'). Queueing state for a route_node is kept on the dest. The
2320 * dest is created on-demand by rib_link() and is kept around at least
2321 * as long as there are ribs hanging off it (@see rib_gc_dest()).
d62a17ae 2322 *
6d691129
PJ
2323 * Refcounting (aka "locking" throughout the GNU Zebra and Quagga code):
2324 *
2325 * - route_nodes: refcounted by:
9fd92e3c
AS
2326 * - dest attached to route_node:
2327 * - managed by: rib_link/rib_gc_dest
6d691129
PJ
2328 * - route_node processing queue
2329 * - managed by: rib_addqueue, rib_process.
2330 *
2331 */
d62a17ae 2332
f0f77c9a 2333/* Add RE to head of the route node. */
d62a17ae 2334static void rib_link(struct route_node *rn, struct route_entry *re, int process)
2335{
2336 struct route_entry *head;
2337 rib_dest_t *dest;
2338 afi_t afi;
2339 const char *rmap_name;
9fd92e3c 2340
d62a17ae 2341 assert(re && rn);
9fd92e3c 2342
d62a17ae 2343 dest = rib_dest_from_rnode(rn);
2344 if (!dest) {
2345 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
2346 rnode_debug(rn, re->vrf_id, "rn %p adding dest", rn);
7a4bb9c5 2347
d62a17ae 2348 dest = XCALLOC(MTYPE_RIB_DEST, sizeof(rib_dest_t));
2349 route_lock_node(rn); /* rn route table reference */
2350 rn->info = dest;
2351 dest->rnode = rn;
2352 }
2263a412 2353
d62a17ae 2354 head = dest->routes;
2355 if (head) {
2356 head->prev = re;
2357 }
2358 re->next = head;
2359 dest->routes = re;
2360
2361 afi = (rn->p.family == AF_INET)
2362 ? AFI_IP
2363 : (rn->p.family == AF_INET6) ? AFI_IP6 : AFI_MAX;
2364 if (is_zebra_import_table_enabled(afi, re->table)) {
2365 rmap_name = zebra_get_import_table_route_map(afi, re->table);
2366 zebra_add_import_table_entry(rn, re, rmap_name);
2367 } else if (process)
2368 rib_queue_add(rn);
2369}
2370
7e24fdf3
DS
2371static void rib_addnode(struct route_node *rn,
2372 struct route_entry *re, int process)
d62a17ae 2373{
2374 /* RE node has been un-removed before route-node is processed.
2375 * route_node must hence already be on the queue for processing..
2376 */
2377 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED)) {
2378 if (IS_ZEBRA_DEBUG_RIB)
2379 rnode_debug(rn, re->vrf_id, "rn %p, un-removed re %p",
2380 (void *)rn, (void *)re);
2381
2382 UNSET_FLAG(re->status, ROUTE_ENTRY_REMOVED);
2383 return;
2384 }
2385 rib_link(rn, re, process);
6d691129
PJ
2386}
2387
9fd92e3c
AS
2388/*
2389 * rib_unlink
2390 *
2391 * Detach a rib structure from a route_node.
2392 *
2393 * Note that a call to rib_unlink() should be followed by a call to
2394 * rib_gc_dest() at some point. This allows a rib_dest_t that is no
2395 * longer required to be deleted.
2396 */
d62a17ae 2397void rib_unlink(struct route_node *rn, struct route_entry *re)
6d691129 2398{
d62a17ae 2399 rib_dest_t *dest;
9fd92e3c 2400
d62a17ae 2401 assert(rn && re);
6d691129 2402
d62a17ae 2403 if (IS_ZEBRA_DEBUG_RIB)
2404 rnode_debug(rn, re->vrf_id, "rn %p, re %p", (void *)rn,
2405 (void *)re);
6d691129 2406
d62a17ae 2407 dest = rib_dest_from_rnode(rn);
6d691129 2408
d62a17ae 2409 if (re->next)
2410 re->next->prev = re->prev;
6d691129 2411
d62a17ae 2412 if (re->prev)
2413 re->prev->next = re->next;
2414 else {
2415 dest->routes = re->next;
2416 }
7a4bb9c5 2417
2eb07de3
DS
2418 if (dest->selected_fib == re)
2419 dest->selected_fib = NULL;
2420
7ee30f28 2421 nexthops_free(re->ng.nexthop);
d62a17ae 2422 XFREE(MTYPE_RE, re);
2423}
2424
2425void rib_delnode(struct route_node *rn, struct route_entry *re)
2426{
2427 afi_t afi;
2428
2429 if (IS_ZEBRA_DEBUG_RIB)
2430 rnode_debug(rn, re->vrf_id, "rn %p, re %p, removing",
2431 (void *)rn, (void *)re);
2432 SET_FLAG(re->status, ROUTE_ENTRY_REMOVED);
2433
2434 afi = (rn->p.family == AF_INET)
2435 ? AFI_IP
2436 : (rn->p.family == AF_INET6) ? AFI_IP6 : AFI_MAX;
2437 if (is_zebra_import_table_enabled(afi, re->table)) {
2438 zebra_del_import_table_entry(rn, re);
2439 /* Just clean up if non main table */
2440 if (IS_ZEBRA_DEBUG_RIB) {
2441 char buf[SRCDEST2STR_BUFFER];
2442 srcdest_rnode2str(rn, buf, sizeof(buf));
2443 zlog_debug(
2444 "%u:%s: Freeing route rn %p, re %p (type %d)",
2445 re->vrf_id, buf, rn, re, re->type);
2446 }
7a4bb9c5 2447
d62a17ae 2448 rib_unlink(rn, re);
2449 } else {
2450 rib_queue_add(rn);
2451 }
718e3744 2452}
2453
f0f77c9a 2454/* This function dumps the contents of a given RE entry into
dc95824a
DO
2455 * standard debug log. Calling function name and IP prefix in
2456 * question are passed as 1st and 2nd arguments.
2457 */
2458
d62a17ae 2459void _route_entry_dump(const char *func, union prefixconstptr pp,
2460 union prefixconstptr src_pp,
2461 const struct route_entry *re)
2462{
d62a17ae 2463 const struct prefix *src_p = src_pp.p;
2464 bool is_srcdst = src_p && src_p->prefixlen;
2465 char straddr[PREFIX_STRLEN];
2466 char srcaddr[PREFIX_STRLEN];
2467 struct nexthop *nexthop;
2468
2469 zlog_debug("%s: dumping RE entry %p for %s%s%s vrf %u", func,
2470 (const void *)re, prefix2str(pp, straddr, sizeof(straddr)),
2471 is_srcdst ? " from " : "",
2472 is_srcdst ? prefix2str(src_pp, srcaddr, sizeof(srcaddr))
2473 : "",
2474 re->vrf_id);
cc54cfee
RW
2475 zlog_debug("%s: uptime == %lu, type == %u, instance == %d, table == %d",
2476 func, (unsigned long)re->uptime, re->type, re->instance,
2477 re->table);
d62a17ae 2478 zlog_debug(
2479 "%s: metric == %u, mtu == %u, distance == %u, flags == %u, status == %u",
2480 func, re->metric, re->mtu, re->distance, re->flags, re->status);
2481 zlog_debug("%s: nexthop_num == %u, nexthop_active_num == %u", func,
2482 re->nexthop_num, re->nexthop_active_num);
2483
7ee30f28 2484 for (ALL_NEXTHOPS(re->ng, nexthop)) {
2d68a0f2
DS
2485 struct interface *ifp;
2486 struct vrf *vrf = vrf_lookup_by_id(nexthop->vrf_id);
2487
2488 switch (nexthop->type) {
2489 case NEXTHOP_TYPE_BLACKHOLE:
2490 sprintf(straddr, "Blackhole");
2491 break;
2492 case NEXTHOP_TYPE_IFINDEX:
2493 ifp = if_lookup_by_index(nexthop->ifindex,
2494 nexthop->vrf_id);
2495 sprintf(straddr, "%s", ifp ? ifp->name : "Unknown");
2496 break;
2497 case NEXTHOP_TYPE_IPV4:
2498 /* fallthrough */
2499 case NEXTHOP_TYPE_IPV4_IFINDEX:
2500 inet_ntop(AF_INET, &nexthop->gate, straddr,
2501 INET6_ADDRSTRLEN);
2502 break;
2503 case NEXTHOP_TYPE_IPV6:
2504 case NEXTHOP_TYPE_IPV6_IFINDEX:
2505 inet_ntop(AF_INET6, &nexthop->gate, straddr,
2506 INET6_ADDRSTRLEN);
2507 break;
2508 }
2509 zlog_debug("%s: %s %s[%u] vrf %s(%u) with flags %s%s%s", func,
d62a17ae 2510 (nexthop->rparent ? " NH" : "NH"), straddr,
2d68a0f2
DS
2511 nexthop->ifindex, vrf ? vrf->name : "Unknown",
2512 nexthop->vrf_id,
d62a17ae 2513 (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)
2514 ? "ACTIVE "
2515 : ""),
2516 (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)
2517 ? "FIB "
2518 : ""),
2519 (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE)
2520 ? "RECURSIVE"
2521 : ""));
2522 }
2523 zlog_debug("%s: dump complete", func);
dc95824a
DO
2524}
2525
2526/* This is an exported helper to rtm_read() to dump the strange
f0f77c9a 2527 * RE entry found by rib_lookup_ipv4_route()
dc95824a
DO
2528 */
2529
d62a17ae 2530void rib_lookup_and_dump(struct prefix_ipv4 *p, vrf_id_t vrf_id)
2531{
2532 struct route_table *table;
2533 struct route_node *rn;
2534 struct route_entry *re;
2535 char prefix_buf[INET_ADDRSTRLEN];
2536
2537 /* Lookup table. */
2538 table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id);
2539 if (!table) {
e914ccbe 2540 flog_err(EC_ZEBRA_TABLE_LOOKUP_FAILED,
1c50c1c0
QY
2541 "%s:%u zebra_vrf_table() returned NULL", __func__,
2542 vrf_id);
d62a17ae 2543 return;
2544 }
2545
2546 /* Scan the RIB table for exactly matching RE entry. */
2547 rn = route_node_lookup(table, (struct prefix *)p);
2548
2549 /* No route for this prefix. */
2550 if (!rn) {
32391aff 2551 zlog_debug("%s:%u lookup failed for %s", __func__, vrf_id,
d62a17ae 2552 prefix2str((struct prefix *)p, prefix_buf,
2553 sizeof(prefix_buf)));
2554 return;
2555 }
2556
2557 /* Unlock node. */
2558 route_unlock_node(rn);
2559
2560 /* let's go */
a2addae8 2561 RNODE_FOREACH_RE (rn, re) {
32391aff
DS
2562 zlog_debug("%s:%u rn %p, re %p: %s, %s",
2563 __func__, vrf_id,
2564 (void *)rn, (void *)re,
d62a17ae 2565 (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED)
2566 ? "removed"
2567 : "NOT removed"),
2568 (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)
2569 ? "selected"
2570 : "NOT selected"));
2571 route_entry_dump(p, NULL, re);
2572 }
dc95824a
DO
2573}
2574
20e5ff0a
DO
2575/* Check if requested address assignment will fail due to another
2576 * route being installed by zebra in FIB already. Take necessary
2577 * actions, if needed: remove such a route from FIB and deSELECT
f0f77c9a 2578 * corresponding RE entry. Then put affected RN into RIBQ head.
20e5ff0a 2579 */
d62a17ae 2580void rib_lookup_and_pushup(struct prefix_ipv4 *p, vrf_id_t vrf_id)
2581{
2582 struct route_table *table;
2583 struct route_node *rn;
d62a17ae 2584 unsigned changed = 0;
5f7a4718 2585 rib_dest_t *dest;
d62a17ae 2586
2587 if (NULL == (table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id))) {
e914ccbe 2588 flog_err(EC_ZEBRA_TABLE_LOOKUP_FAILED,
1c50c1c0
QY
2589 "%s:%u zebra_vrf_table() returned NULL", __func__,
2590 vrf_id);
d62a17ae 2591 return;
2592 }
2593
2594 /* No matches would be the simplest case. */
2595 if (NULL == (rn = route_node_lookup(table, (struct prefix *)p)))
2596 return;
2597
2598 /* Unlock node. */
2599 route_unlock_node(rn);
2600
5f7a4718 2601 dest = rib_dest_from_rnode(rn);
d62a17ae 2602 /* Check all RE entries. In case any changes have to be done, requeue
2603 * the RN into RIBQ head. If the routing message about the new connected
2604 * route (generated by the IP address we are going to assign very soon)
2605 * comes before the RIBQ is processed, the new RE entry will join
2606 * RIBQ record already on head. This is necessary for proper
2607 * revalidation
2608 * of the rest of the RE.
2609 */
5f7a4718
DS
2610 if (dest->selected_fib && !RIB_SYSTEM_ROUTE(dest->selected_fib)) {
2611 changed = 1;
2612 if (IS_ZEBRA_DEBUG_RIB) {
2613 char buf[PREFIX_STRLEN];
2614
2615 zlog_debug("%u:%s: freeing way for connected prefix",
2616 dest->selected_fib->vrf_id,
2617 prefix2str(&rn->p, buf, sizeof(buf)));
2618 route_entry_dump(&rn->p, NULL, dest->selected_fib);
d62a17ae 2619 }
5f7a4718 2620 rib_uninstall(rn, dest->selected_fib);
d62a17ae 2621 }
2622 if (changed)
2623 rib_queue_add(rn);
20e5ff0a
DO
2624}
2625
d62a17ae 2626int rib_add_multipath(afi_t afi, safi_t safi, struct prefix *p,
2627 struct prefix_ipv6 *src_p, struct route_entry *re)
718e3744 2628{
d62a17ae 2629 struct route_table *table;
2630 struct route_node *rn;
40ecd8e4 2631 struct route_entry *same = NULL;
d62a17ae 2632 struct nexthop *nexthop;
2633 int ret = 0;
b4c034b0 2634
d62a17ae 2635 if (!re)
2636 return 0;
b4c034b0 2637
1f610a1f 2638 assert(!src_p || !src_p->prefixlen || afi == AFI_IP6);
05737783 2639
d62a17ae 2640 /* Lookup table. */
7865c65d
RW
2641 table = zebra_vrf_table_with_table_id(afi, safi, re->vrf_id, re->table);
2642 if (!table) {
2643 XFREE(MTYPE_RE, re);
d62a17ae 2644 return 0;
7865c65d 2645 }
cddf391b 2646
d62a17ae 2647 /* Make it sure prefixlen is applied to the prefix. */
2648 apply_mask(p);
2649 if (src_p)
2650 apply_mask_ipv6(src_p);
718e3744 2651
d62a17ae 2652 /* Set default distance by route type. */
2653 if (re->distance == 0) {
0492eea0 2654 re->distance = route_distance(re->type);
718e3744 2655
d62a17ae 2656 /* iBGP distance is 200. */
2657 if (re->type == ZEBRA_ROUTE_BGP
2658 && CHECK_FLAG(re->flags, ZEBRA_FLAG_IBGP))
2659 re->distance = 200;
2660 }
718e3744 2661
d62a17ae 2662 /* Lookup route node.*/
2663 rn = srcdest_rnode_get(table, p, src_p);
718e3744 2664
40ecd8e4
DS
2665 /*
2666 * If same type of route are installed, treat it as a implicit
2667 * withdraw.
2668 * If the user has specified the No route replace semantics
2669 * for the install don't do a route replace.
2670 */
a2addae8 2671 RNODE_FOREACH_RE (rn, same) {
d62a17ae 2672 if (CHECK_FLAG(same->status, ROUTE_ENTRY_REMOVED))
2673 continue;
41ec9222 2674
eb327fa5
RW
2675 if (same->type != re->type)
2676 continue;
2677 if (same->instance != re->instance)
2678 continue;
996c9314
LB
2679 if (same->type == ZEBRA_ROUTE_KERNEL
2680 && same->metric != re->metric)
eb327fa5 2681 continue;
40ecd8e4
DS
2682
2683 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_RR_USE_DISTANCE) &&
2684 same->distance != re->distance)
2685 continue;
2686
844b3a87 2687 /*
40ecd8e4
DS
2688 * We should allow duplicate connected routes
2689 * because of IPv6 link-local routes and unnumbered
2690 * interfaces on Linux.
844b3a87
RW
2691 */
2692 if (same->type != ZEBRA_ROUTE_CONNECT)
d62a17ae 2693 break;
2694 }
718e3744 2695
d62a17ae 2696 /* If this route is kernel route, set FIB flag to the route. */
8628fc61 2697 if (RIB_SYSTEM_ROUTE(re))
7ee30f28 2698 for (nexthop = re->ng.nexthop; nexthop; nexthop = nexthop->next)
d62a17ae 2699 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
718e3744 2700
d62a17ae 2701 /* Link new re to node.*/
2702 if (IS_ZEBRA_DEBUG_RIB) {
2703 rnode_debug(
2704 rn, re->vrf_id,
2705 "Inserting route rn %p, re %p (type %d) existing %p",
2706 (void *)rn, (void *)re, re->type, (void *)same);
718e3744 2707
d62a17ae 2708 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
2709 route_entry_dump(p, src_p, re);
718e3744 2710 }
d62a17ae 2711 rib_addnode(rn, re, 1);
2712 ret = 1;
6b0655a2 2713
d62a17ae 2714 /* Free implicit route.*/
2715 if (same) {
2716 rib_delnode(rn, same);
2717 ret = -1;
2718 }
718e3744 2719
d62a17ae 2720 route_unlock_node(rn);
2721 return ret;
2722}
2723
2724void rib_delete(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
d7c0a89a 2725 unsigned short instance, int flags, struct prefix *p,
fd36be7e 2726 struct prefix_ipv6 *src_p, const struct nexthop *nh,
40ecd8e4
DS
2727 uint32_t table_id, uint32_t metric, uint8_t distance,
2728 bool fromkernel)
d62a17ae 2729{
2730 struct route_table *table;
2731 struct route_node *rn;
2732 struct route_entry *re;
2733 struct route_entry *fib = NULL;
2734 struct route_entry *same = NULL;
fd36be7e 2735 struct nexthop *rtnh;
d62a17ae 2736 char buf2[INET6_ADDRSTRLEN];
5f7a4718 2737 rib_dest_t *dest;
d62a17ae 2738
1f610a1f 2739 assert(!src_p || !src_p->prefixlen || afi == AFI_IP6);
d62a17ae 2740
2741 /* Lookup table. */
2742 table = zebra_vrf_table_with_table_id(afi, safi, vrf_id, table_id);
2743 if (!table)
2744 return;
2745
2746 /* Apply mask. */
2747 apply_mask(p);
2748 if (src_p)
2749 apply_mask_ipv6(src_p);
2750
2751 /* Lookup route node. */
2752 rn = srcdest_rnode_lookup(table, p, src_p);
2753 if (!rn) {
2754 char dst_buf[PREFIX_STRLEN], src_buf[PREFIX_STRLEN];
2755
2756 prefix2str(p, dst_buf, sizeof(dst_buf));
2757 if (src_p && src_p->prefixlen)
2758 prefix2str(src_p, src_buf, sizeof(src_buf));
2759 else
2760 src_buf[0] = '\0';
2761
2762 if (IS_ZEBRA_DEBUG_RIB)
2763 zlog_debug("%u:%s%s%s doesn't exist in rib", vrf_id,
2764 dst_buf,
2765 (src_buf[0] != '\0') ? " from " : "",
2766 src_buf);
2767 return;
2768 }
718e3744 2769
5f7a4718
DS
2770 dest = rib_dest_from_rnode(rn);
2771 fib = dest->selected_fib;
2772
d62a17ae 2773 /* Lookup same type route. */
a2addae8 2774 RNODE_FOREACH_RE (rn, re) {
d62a17ae 2775 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
2776 continue;
2777
d62a17ae 2778 if (re->type != type)
2779 continue;
2780 if (re->instance != instance)
2781 continue;
40ecd8e4
DS
2782 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_RR_USE_DISTANCE) &&
2783 distance != re->distance)
2784 continue;
2785
996c9314 2786 if (re->type == ZEBRA_ROUTE_KERNEL && re->metric != metric)
f19435a8 2787 continue;
7ee30f28 2788 if (re->type == ZEBRA_ROUTE_CONNECT && (rtnh = re->ng.nexthop)
fd36be7e
DL
2789 && rtnh->type == NEXTHOP_TYPE_IFINDEX && nh) {
2790 if (rtnh->ifindex != nh->ifindex)
d62a17ae 2791 continue;
d62a17ae 2792 same = re;
2793 break;
2794 }
2795 /* Make sure that the route found has the same gateway. */
2796 else {
fd36be7e 2797 if (nh == NULL) {
d62a17ae 2798 same = re;
2799 break;
2800 }
7ee30f28 2801 for (ALL_NEXTHOPS(re->ng, rtnh))
fd36be7e 2802 if (nexthop_same_no_recurse(rtnh, nh)) {
d62a17ae 2803 same = re;
2804 break;
2805 }
2806 if (same)
2807 break;
2808 }
2809 }
2810 /* If same type of route can't be found and this message is from
2811 kernel. */
2812 if (!same) {
5dfeba19
DS
2813 /*
2814 * In the past(HA!) we could get here because
2815 * we were receiving a route delete from the
2816 * kernel and we're not marking the proto
2817 * as coming from it's appropriate originator.
2818 * Now that we are properly noticing the fact
2819 * that the kernel has deleted our route we
2820 * are not going to get called in this path
2821 * I am going to leave this here because
2822 * this might still work this way on non-linux
2823 * platforms as well as some weird state I have
2824 * not properly thought of yet.
2825 * If we can show that this code path is
2826 * dead then we can remove it.
2827 */
b8faa875 2828 if (fib && CHECK_FLAG(flags, ZEBRA_FLAG_SELFROUTE)) {
d62a17ae 2829 if (IS_ZEBRA_DEBUG_RIB) {
2830 rnode_debug(
2831 rn, vrf_id,
2832 "rn %p, re %p (type %d) was deleted from kernel, adding",
2833 rn, fib, fib->type);
2834 }
2835 if (allow_delete) {
2836 /* Unset flags. */
7ee30f28 2837 for (rtnh = fib->ng.nexthop; rtnh;
fd36be7e
DL
2838 rtnh = rtnh->next)
2839 UNSET_FLAG(rtnh->flags,
d62a17ae 2840 NEXTHOP_FLAG_FIB);
2841
ed216282
DS
2842 /*
2843 * This is a non FRR route
2844 * as such we should mark
2845 * it as deleted
2846 */
5f7a4718 2847 dest->selected_fib = NULL;
d62a17ae 2848 } else {
2849 /* This means someone else, other than Zebra,
2850 * has deleted
2851 * a Zebra router from the kernel. We will add
2852 * it back */
2853 rib_install_kernel(rn, fib, NULL);
2854 }
2855 } else {
2856 if (IS_ZEBRA_DEBUG_RIB) {
fd36be7e 2857 if (nh)
d62a17ae 2858 rnode_debug(
2859 rn, vrf_id,
2860 "via %s ifindex %d type %d "
2861 "doesn't exist in rib",
36228974 2862 inet_ntop(afi2family(afi),
2863 &nh->gate, buf2,
2864 sizeof(buf2)),
2865 nh->ifindex, type);
d62a17ae 2866 else
2867 rnode_debug(
2868 rn, vrf_id,
fd36be7e
DL
2869 "type %d doesn't exist in rib",
2870 type);
d62a17ae 2871 }
2872 route_unlock_node(rn);
2873 return;
2874 }
2875 }
718e3744 2876
5dfeba19 2877 if (same) {
996c9314
LB
2878 if (fromkernel && CHECK_FLAG(flags, ZEBRA_FLAG_SELFROUTE)
2879 && !allow_delete) {
5dfeba19
DS
2880 rib_install_kernel(rn, same, NULL);
2881 route_unlock_node(rn);
2882
2883 return;
2884 }
6134fd82 2885
90264d64 2886 if (CHECK_FLAG(flags, ZEBRA_FLAG_EVPN_ROUTE)) {
6134fd82 2887 struct nexthop *tmp_nh;
2888
7ee30f28 2889 for (ALL_NEXTHOPS(re->ng, tmp_nh)) {
6134fd82 2890 struct ipaddr vtep_ip;
2891
2892 memset(&vtep_ip, 0, sizeof(struct ipaddr));
1ec31309 2893 if (afi == AFI_IP) {
2894 vtep_ip.ipa_type = IPADDR_V4;
2895 memcpy(&(vtep_ip.ipaddr_v4),
2896 &(tmp_nh->gate.ipv4),
2897 sizeof(struct in_addr));
2898 } else {
2899 vtep_ip.ipa_type = IPADDR_V6;
2900 memcpy(&(vtep_ip.ipaddr_v6),
2901 &(tmp_nh->gate.ipv6),
2902 sizeof(struct in6_addr));
2903 }
a317a9b9 2904 zebra_vxlan_evpn_vrf_route_del(re->vrf_id,
6134fd82 2905 &vtep_ip, p);
2906 }
2907 }
d62a17ae 2908 rib_delnode(rn, same);
5dfeba19 2909 }
05737783 2910
d62a17ae 2911 route_unlock_node(rn);
2912 return;
2913}
718e3744 2914
718e3744 2915
d7c0a89a
QY
2916int rib_add(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
2917 unsigned short instance, int flags, struct prefix *p,
2918 struct prefix_ipv6 *src_p, const struct nexthop *nh,
2919 uint32_t table_id, uint32_t metric, uint32_t mtu, uint8_t distance,
2920 route_tag_t tag)
d62a17ae 2921{
2922 struct route_entry *re;
66af6845 2923 struct nexthop *nexthop;
718e3744 2924
66af6845 2925 /* Allocate new route_entry structure. */
d62a17ae 2926 re = XCALLOC(MTYPE_RE, sizeof(struct route_entry));
d62a17ae 2927 re->type = type;
2928 re->instance = instance;
2929 re->distance = distance;
2930 re->flags = flags;
2931 re->metric = metric;
2932 re->mtu = mtu;
2933 re->table = table_id;
2934 re->vrf_id = vrf_id;
2935 re->nexthop_num = 0;
2936 re->uptime = time(NULL);
4e40b6d6 2937 re->tag = tag;
d62a17ae 2938
66af6845
RW
2939 /* Add nexthop. */
2940 nexthop = nexthop_new();
2941 *nexthop = *nh;
2942 route_entry_nexthop_add(re, nexthop);
718e3744 2943
66af6845 2944 return rib_add_multipath(afi, safi, p, src_p, re);
718e3744 2945}
2946
1c848137 2947/* Schedule routes of a particular table (address-family) based on event. */
d5b8c216 2948void rib_update_table(struct route_table *table, rib_update_event_t event)
d62a17ae 2949{
2950 struct route_node *rn;
2951 struct route_entry *re, *next;
2952
2953 /* Walk all routes and queue for processing, if appropriate for
2954 * the trigger event.
2955 */
2956 for (rn = route_top(table); rn; rn = srcdest_route_next(rn)) {
1ca60f2c
DS
2957 /*
2958 * If we are looking at a route node and the node
2959 * has already been queued we don't
2960 * need to queue it up again
2961 */
996c9314
LB
2962 if (rn->info && CHECK_FLAG(rib_dest_from_rnode(rn)->flags,
2963 RIB_ROUTE_ANY_QUEUED))
1ca60f2c 2964 continue;
d62a17ae 2965 switch (event) {
2966 case RIB_UPDATE_IF_CHANGE:
2967 /* Examine all routes that won't get processed by the
2968 * protocol or
2969 * triggered by nexthop evaluation (NHT). This would be
2970 * system,
2971 * kernel and certain static routes. Note that NHT will
2972 * get
2973 * triggered upon an interface event as connected routes
2974 * always
2975 * get queued for processing.
2976 */
a2addae8 2977 RNODE_FOREACH_RE_SAFE (rn, re, next) {
0a16efff
DS
2978 struct nexthop *nh;
2979
996c9314
LB
2980 if (re->type != ZEBRA_ROUTE_SYSTEM
2981 && re->type != ZEBRA_ROUTE_KERNEL
2982 && re->type != ZEBRA_ROUTE_CONNECT
2983 && re->type != ZEBRA_ROUTE_STATIC)
0a16efff
DS
2984 continue;
2985
2986 if (re->type != ZEBRA_ROUTE_STATIC) {
2987 rib_queue_add(rn);
2988 continue;
2989 }
2990
7ee30f28 2991 for (nh = re->ng.nexthop; nh; nh = nh->next)
0a16efff
DS
2992 if (!(nh->type == NEXTHOP_TYPE_IPV4
2993 || nh->type == NEXTHOP_TYPE_IPV6))
2994 break;
2995
2996 /* If we only have nexthops to a
2997 * gateway, NHT will
2998 * take care.
2999 */
3000 if (nh)
d62a17ae 3001 rib_queue_add(rn);
3002 }
3003 break;
3004
3005 case RIB_UPDATE_RMAP_CHANGE:
3006 case RIB_UPDATE_OTHER:
3007 /* Right now, examine all routes. Can restrict to a
3008 * protocol in
3009 * some cases (TODO).
3010 */
3011 if (rnode_to_ribs(rn))
3012 rib_queue_add(rn);
3013 break;
3014
3015 default:
3016 break;
3017 }
3018 }
b84c7253 3019}
3020
718e3744 3021/* RIB update function. */
d62a17ae 3022void rib_update(vrf_id_t vrf_id, rib_update_event_t event)
718e3744 3023{
d62a17ae 3024 struct route_table *table;
1c848137 3025
d62a17ae 3026 /* Process routes of interested address-families. */
3027 table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id);
d5b8c216 3028 if (table) {
3029 if (IS_ZEBRA_DEBUG_EVENT)
3030 zlog_debug("%s : AFI_IP event %d", __func__, event);
d62a17ae 3031 rib_update_table(table, event);
d5b8c216 3032 }
718e3744 3033
d62a17ae 3034 table = zebra_vrf_table(AFI_IP6, SAFI_UNICAST, vrf_id);
d5b8c216 3035 if (table) {
3036 if (IS_ZEBRA_DEBUG_EVENT)
3037 zlog_debug("%s : AFI_IP6 event %d", __func__, event);
d62a17ae 3038 rib_update_table(table, event);
d5b8c216 3039 }
718e3744 3040}
3041
718e3744 3042/* Delete self installed routes after zebra is relaunched. */
95a29032 3043void rib_sweep_table(struct route_table *table)
d62a17ae 3044{
3045 struct route_node *rn;
3046 struct route_entry *re;
3047 struct route_entry *next;
915902cb 3048 struct nexthop *nexthop;
d62a17ae 3049
915902cb
DS
3050 if (!table)
3051 return;
d62a17ae 3052
915902cb 3053 for (rn = route_top(table); rn; rn = srcdest_route_next(rn)) {
a2addae8 3054 RNODE_FOREACH_RE_SAFE (rn, re, next) {
915902cb
DS
3055 if (IS_ZEBRA_DEBUG_RIB)
3056 route_entry_dump(&rn->p, NULL, re);
3057
3058 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
3059 continue;
3060
3061 if (!CHECK_FLAG(re->flags, ZEBRA_FLAG_SELFROUTE))
3062 continue;
3063
3064 /*
3065 * So we are starting up and have received
3066 * routes from the kernel that we have installed
3067 * from a previous run of zebra but not cleaned
3068 * up ( say a kill -9 )
3069 * But since we haven't actually installed
3070 * them yet( we received them from the kernel )
3071 * we don't think they are active.
3072 * So let's pretend they are active to actually
3073 * remove them.
3074 * In all honesty I'm not sure if we should
3075 * mark them as active when we receive them
3076 * This is startup only so probably ok.
3077 *
3078 * If we ever decide to move rib_sweep_table
3079 * to a different spot (ie startup )
3080 * this decision needs to be revisited
3081 */
7ee30f28 3082 for (ALL_NEXTHOPS(re->ng, nexthop))
915902cb
DS
3083 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
3084
0c555cc6
DS
3085 rib_uninstall_kernel(rn, re);
3086 rib_delnode(rn, re);
915902cb
DS
3087 }
3088 }
718e3744 3089}
3090
3091/* Sweep all RIB tables. */
d62a17ae 3092void rib_sweep_route(void)
718e3744 3093{
d62a17ae 3094 struct vrf *vrf;
3095 struct zebra_vrf *zvrf;
78104b9b 3096
a2addae8 3097 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
915902cb
DS
3098 if ((zvrf = vrf->info) == NULL)
3099 continue;
3100
d62a17ae 3101 rib_sweep_table(zvrf->table[AFI_IP][SAFI_UNICAST]);
3102 rib_sweep_table(zvrf->table[AFI_IP6][SAFI_UNICAST]);
3103 }
95a29032 3104
89272910 3105 zebra_router_sweep_route();
718e3744 3106}
2ea1ab1c
VT
3107
3108/* Remove specific by protocol routes from 'table'. */
d7c0a89a 3109unsigned long rib_score_proto_table(uint8_t proto, unsigned short instance,
47a08aa9 3110 struct route_table *table)
d62a17ae 3111{
3112 struct route_node *rn;
3113 struct route_entry *re;
3114 struct route_entry *next;
3115 unsigned long n = 0;
3116
3117 if (table)
3118 for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
a2addae8 3119 RNODE_FOREACH_RE_SAFE (rn, re, next) {
d62a17ae 3120 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
3121 continue;
3122 if (re->type == proto
3123 && re->instance == instance) {
3124 rib_delnode(rn, re);
3125 n++;
3126 }
3127 }
3128 return n;
2ea1ab1c
VT
3129}
3130
3131/* Remove specific by protocol routes. */
d7c0a89a 3132unsigned long rib_score_proto(uint8_t proto, unsigned short instance)
2ea1ab1c 3133{
d62a17ae 3134 struct vrf *vrf;
3135 struct zebra_vrf *zvrf;
3136 unsigned long cnt = 0;
78104b9b 3137
a2addae8
RW
3138 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)
3139 if ((zvrf = vrf->info) != NULL)
3140 cnt += rib_score_proto_table(
3141 proto, instance,
3142 zvrf->table[AFI_IP][SAFI_UNICAST])
3143 + rib_score_proto_table(
3144 proto, instance,
3145 zvrf->table[AFI_IP6][SAFI_UNICAST]);
78104b9b 3146
89272910 3147 cnt += zebra_router_score_proto(proto, instance);
47a08aa9 3148
d62a17ae 3149 return cnt;
2ea1ab1c
VT
3150}
3151
718e3744 3152/* Close RIB and clean up kernel routes. */
d62a17ae 3153void rib_close_table(struct route_table *table)
718e3744 3154{
d62a17ae 3155 struct route_node *rn;
1e9f448f 3156 rib_table_info_t *info;
5f7a4718 3157 rib_dest_t *dest;
718e3744 3158
1e9f448f
DS
3159 if (!table)
3160 return;
9fd92e3c 3161
6ca30e9e 3162 info = route_table_get_info(table);
5adc2528 3163
5f7a4718
DS
3164 for (rn = route_top(table); rn; rn = srcdest_route_next(rn)) {
3165 dest = rib_dest_from_rnode(rn);
1e9f448f 3166
5f7a4718 3167 if (dest && dest->selected_fib) {
1e9f448f
DS
3168 if (info->safi == SAFI_UNICAST)
3169 hook_call(rib_update, rn, NULL);
3170
258c07e4 3171 if (!RIB_SYSTEM_ROUTE(dest->selected_fib)) {
5f7a4718 3172 rib_uninstall_kernel(rn, dest->selected_fib);
258c07e4
MS
3173 dest->selected_fib = NULL;
3174 }
1e9f448f 3175 }
5f7a4718 3176 }
718e3744 3177}
3178
7cdb1a84
MS
3179/*
3180 *
3181 */
3182static int rib_process_dplane_results(struct thread *thread)
3183{
25779064 3184 struct zebra_dplane_ctx *ctx;
7cdb1a84
MS
3185
3186 do {
3187 /* Take lock controlling queue of results */
3188 pthread_mutex_lock(&dplane_mutex);
3189 {
3190 /* Dequeue context block */
68b375e0 3191 ctx = dplane_ctx_dequeue(&rib_dplane_q);
7cdb1a84
MS
3192 }
3193 pthread_mutex_unlock(&dplane_mutex);
3194
5709131c 3195 if (ctx)
e5ac2adf 3196 rib_process_after(ctx);
5709131c 3197 else
7cdb1a84 3198 break;
7cdb1a84 3199
5709131c 3200 } while (1);
7cdb1a84 3201
f183e380
MS
3202 /* Check for nexthop tracking processing after finishing with results */
3203 do_nht_processing();
3204
5709131c 3205 return 0;
7cdb1a84
MS
3206}
3207
3208/*
3209 * Results are returned from the dataplane subsystem, in the context of
1bcea841 3210 * the dataplane pthread. We enqueue the results here for processing by
7cdb1a84
MS
3211 * the main thread later.
3212 */
c831033f 3213static int rib_dplane_results(struct zebra_dplane_ctx *ctx)
7cdb1a84
MS
3214{
3215 /* Take lock controlling queue of results */
3216 pthread_mutex_lock(&dplane_mutex);
3217 {
3218 /* Enqueue context block */
3219 dplane_ctx_enqueue_tail(&rib_dplane_q, ctx);
3220 }
3221 pthread_mutex_unlock(&dplane_mutex);
3222
3223 /* Ensure event is signalled to zebra main thread */
3224 thread_add_event(zebrad.master, rib_process_dplane_results, NULL, 0,
3225 &t_dplane);
3226
5709131c 3227 return 0;
7cdb1a84
MS
3228}
3229
718e3744 3230/* Routing information base initialize. */
d62a17ae 3231void rib_init(void)
718e3744 3232{
d62a17ae 3233 rib_queue_init(&zebrad);
7cdb1a84
MS
3234
3235 /* Init dataplane, and register for results */
3236 pthread_mutex_init(&dplane_mutex, NULL);
3237 TAILQ_INIT(&rib_dplane_q);
3238 zebra_dplane_init();
3239 dplane_results_register(rib_dplane_results);
718e3744 3240}
0915bb0c
AS
3241
3242/*
3243 * vrf_id_get_next
3244 *
3245 * Get the first vrf id that is greater than the given vrf id if any.
3246 *
3247 * Returns TRUE if a vrf id was found, FALSE otherwise.
3248 */
d62a17ae 3249static inline int vrf_id_get_next(vrf_id_t vrf_id, vrf_id_t *next_id_p)
0915bb0c 3250{
d62a17ae 3251 struct vrf *vrf;
b72ede27 3252
d62a17ae 3253 vrf = vrf_lookup_by_id(vrf_id);
3254 if (vrf) {
3255 vrf = RB_NEXT(vrf_id_head, vrf);
3256 if (vrf) {
3257 *next_id_p = vrf->vrf_id;
3258 return 1;
3259 }
3260 }
0915bb0c 3261
d62a17ae 3262 return 0;
0915bb0c
AS
3263}
3264
3265/*
3266 * rib_tables_iter_next
3267 *
3268 * Returns the next table in the iteration.
3269 */
d62a17ae 3270struct route_table *rib_tables_iter_next(rib_tables_iter_t *iter)
3271{
3272 struct route_table *table;
3273
3274 /*
3275 * Array that helps us go over all AFI/SAFI combinations via one
3276 * index.
3277 */
3278 static struct {
3279 afi_t afi;
3280 safi_t safi;
3281 } afi_safis[] = {
3282 {AFI_IP, SAFI_UNICAST}, {AFI_IP, SAFI_MULTICAST},
3283 {AFI_IP, SAFI_LABELED_UNICAST}, {AFI_IP6, SAFI_UNICAST},
3284 {AFI_IP6, SAFI_MULTICAST}, {AFI_IP6, SAFI_LABELED_UNICAST},
3285 };
3286
3287 table = NULL;
3288
3289 switch (iter->state) {
3290
3291 case RIB_TABLES_ITER_S_INIT:
3292 iter->vrf_id = VRF_DEFAULT;
3293 iter->afi_safi_ix = -1;
3294
3295 /* Fall through */
3296
3297 case RIB_TABLES_ITER_S_ITERATING:
3298 iter->afi_safi_ix++;
3299 while (1) {
3300
3301 while (iter->afi_safi_ix
3302 < (int)ZEBRA_NUM_OF(afi_safis)) {
3303 table = zebra_vrf_table(
3304 afi_safis[iter->afi_safi_ix].afi,
3305 afi_safis[iter->afi_safi_ix].safi,
3306 iter->vrf_id);
3307 if (table)
3308 break;
3309
3310 iter->afi_safi_ix++;
3311 }
3312
3313 /*
3314 * Found another table in this vrf.
3315 */
3316 if (table)
3317 break;
3318
3319 /*
3320 * Done with all tables in the current vrf, go to the
3321 * next
3322 * one.
3323 */
3324 if (!vrf_id_get_next(iter->vrf_id, &iter->vrf_id))
3325 break;
3326
3327 iter->afi_safi_ix = 0;
3328 }
0915bb0c 3329
0915bb0c
AS
3330 break;
3331
d62a17ae 3332 case RIB_TABLES_ITER_S_DONE:
3333 return NULL;
0915bb0c
AS
3334 }
3335
d62a17ae 3336 if (table)
3337 iter->state = RIB_TABLES_ITER_S_ITERATING;
3338 else
3339 iter->state = RIB_TABLES_ITER_S_DONE;
0915bb0c 3340
d62a17ae 3341 return table;
0915bb0c 3342}