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