]> 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
Merge pull request #3032 from donaldsharp/bgp_info
[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,
ea1c14f6 1063 enum zebra_dplane_status 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) {
ea1c14f6 1072 case ZEBRA_DPLANE_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;
ea1c14f6 1085 case ZEBRA_DPLANE_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);
e914ccbe 1094 flog_err(EC_ZEBRA_DP_INSTALL_FAIL,
9df414fe
QY		 1095 "%u:%s: Route install failed", re->vrf_id,
1096 prefix2str(p, buf, sizeof(buf)));
0c555cc6 1097 break;
ea1c14f6 1098 case ZEBRA_DPLANE_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;
ea1c14f6 1113 case ZEBRA_DPLANE_DELETE_FAILURE:
ed216282
DS		 1114 /*
1115 * Should we set this to NULL if the
1116 * delete fails?
1117 */
1118 dest->selected_fib = NULL;
e914ccbe 1119 flog_err(EC_ZEBRA_DP_DELETE_FAIL,
9df414fe
QY		 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 1124 break;
ea1c14f6
MS		 1125 case ZEBRA_DPLANE_STATUS_NONE:
1126 break;
0c555cc6
DS		 1127 }
1128}
1129
6ae24471
DS		 1130/* Update flag indicates whether this is a "replace" or not. Currently, this
1131 * is only used for IPv4.
1132 */
0c555cc6
DS		 1133void rib_install_kernel(struct route_node *rn, struct route_entry *re,
1134 struct route_entry *old)
718e3744 1135{
d62a17ae 1136 struct nexthop *nexthop;
1137 rib_table_info_t *info = srcdest_rnode_table_info(rn);
86391e56 1138 const struct prefix *p, *src_p;
d62a17ae 1139 struct zebra_vrf *zvrf = vrf_info_lookup(re->vrf_id);
718e3744 1140
d62a17ae 1141 srcdest_rnode_prefixes(rn, &p, &src_p);
416ec78d 1142
d62a17ae 1143 if (info->safi != SAFI_UNICAST) {
7ee30f28 1144 for (ALL_NEXTHOPS(re->ng, nexthop))
d62a17ae 1145 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
0c555cc6 1146 return;
25b9cb0c
DL		 1147 } else {
1148 struct nexthop *prev;
1149
7ee30f28 1150 for (ALL_NEXTHOPS(re->ng, nexthop)) {
25b9cb0c 1151 UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_DUPLICATE);
7ee30f28 1152 for (ALL_NEXTHOPS(re->ng, prev)) {
25b9cb0c
DL		 1153 if (prev == nexthop)
1154 break;
996c9314
LB		 1155 if (nexthop_same_firsthop(nexthop, prev)) {
1156 SET_FLAG(nexthop->flags,
1157 NEXTHOP_FLAG_DUPLICATE);
25b9cb0c
DL		 1158 break;
1159 }
1160 }
1161 }
d62a17ae 1162 }
718e3744 1163
2063a814
DS		 1164 /*
1165 * If this is a replace to a new RE let the originator of the RE
1166 * know that they've lost
1167 */
9a9f8926 1168 if (old && (old != re) && (old->type != re->type))
28610f7e 1169 zsend_route_notify_owner(old, p, ZAPI_ROUTE_BETTER_ADMIN_WON);
25b9cb0c 1170
d62a17ae 1171 /*
1172 * Make sure we update the FPM any time we send new information to
1173 * the kernel.
1174 */
1175 hook_call(rib_update, rn, "installing in kernel");
1e885672 1176 switch (kernel_route_rib(rn, p, src_p, old, re)) {
ea1c14f6 1177 case ZEBRA_DPLANE_REQUEST_QUEUED:
af4c2728 1178 flog_err(
e914ccbe 1179 EC_ZEBRA_DP_INVALID_RC,
43e52561 1180 "No current known DataPlane interfaces can return this, please fix");
1e885672 1181 break;
ea1c14f6 1182 case ZEBRA_DPLANE_REQUEST_FAILURE:
af4c2728 1183 flog_err(
e914ccbe 1184 EC_ZEBRA_DP_INSTALL_FAIL,
43e52561 1185 "No current known Rib Install Failure cases, please fix");
1e885672 1186 break;
ea1c14f6 1187 case ZEBRA_DPLANE_REQUEST_SUCCESS:
1e885672
DS		 1188 zvrf->installs++;
1189 break;
1190 }
d62a17ae 1191
0c555cc6 1192 return;
718e3744 1193}
1194
1195/* Uninstall the route from kernel. */
0c555cc6 1196void rib_uninstall_kernel(struct route_node *rn, struct route_entry *re)
718e3744 1197{
d62a17ae 1198 struct nexthop *nexthop;
1199 rib_table_info_t *info = srcdest_rnode_table_info(rn);
86391e56 1200 const struct prefix *p, *src_p;
d62a17ae 1201 struct zebra_vrf *zvrf = vrf_info_lookup(re->vrf_id);
05737783 1202
d62a17ae 1203 srcdest_rnode_prefixes(rn, &p, &src_p);
718e3744 1204
d62a17ae 1205 if (info->safi != SAFI_UNICAST) {
7ee30f28 1206 for (ALL_NEXTHOPS(re->ng, nexthop))
d6792f9d 1207 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
0c555cc6 1208 return;
d62a17ae 1209 }
416ec78d 1210
d62a17ae 1211 /*
1212 * Make sure we update the FPM any time we send new information to
1213 * the kernel.
1214 */
1215 hook_call(rib_update, rn, "uninstalling from kernel");
1e885672 1216 switch (kernel_route_rib(rn, p, src_p, re, NULL)) {
ea1c14f6 1217 case ZEBRA_DPLANE_REQUEST_QUEUED:
af4c2728 1218 flog_err(
e914ccbe 1219 EC_ZEBRA_DP_INVALID_RC,
43e52561 1220 "No current known DataPlane interfaces can return this, please fix");
1e885672 1221 break;
ea1c14f6 1222 case ZEBRA_DPLANE_REQUEST_FAILURE:
af4c2728 1223 flog_err(
e914ccbe 1224 EC_ZEBRA_DP_INSTALL_FAIL,
43e52561 1225 "No current known RIB Install Failure cases, please fix");
1e885672 1226 break;
ea1c14f6 1227 case ZEBRA_DPLANE_REQUEST_SUCCESS:
1e885672
DS		 1228 if (zvrf)
1229 zvrf->removals++;
1230 break;
1231 }
718e3744 1232
0c555cc6 1233 return;
718e3744 1234}
1235
1236/* Uninstall the route from kernel. */
d62a17ae 1237static void rib_uninstall(struct route_node *rn, struct route_entry *re)
718e3744 1238{
d62a17ae 1239 rib_table_info_t *info = srcdest_rnode_table_info(rn);
5f7a4718 1240 rib_dest_t *dest = rib_dest_from_rnode(rn);
416ec78d 1241
5f7a4718 1242 if (dest && dest->selected_fib == re) {
d62a17ae 1243 if (info->safi == SAFI_UNICAST)
1244 hook_call(rib_update, rn, "rib_uninstall");
5adc2528 1245
d62a17ae 1246 if (!RIB_SYSTEM_ROUTE(re))
1247 rib_uninstall_kernel(rn, re);
a64448ba 1248
d62a17ae 1249 /* If labeled-unicast route, uninstall transit LSP. */
1250 if (zebra_rib_labeled_unicast(re))
1251 zebra_mpls_lsp_uninstall(info->zvrf, rn, re);
d62a17ae 1252 }
446bb95e 1253
d62a17ae 1254 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)) {
86391e56
MS		 1255 const struct prefix *p, *src_p;
1256
d62a17ae 1257 srcdest_rnode_prefixes(rn, &p, &src_p);
05737783 1258
d62a17ae 1259 redistribute_delete(p, src_p, re);
1260 UNSET_FLAG(re->flags, ZEBRA_FLAG_SELECTED);
1261 }
718e3744 1262}
1263
9fd92e3c
AS		 1264/*
1265 * rib_can_delete_dest
1266 *
1267 * Returns TRUE if the given dest can be deleted from the table.
1268 */
d62a17ae 1269static int rib_can_delete_dest(rib_dest_t *dest)
9fd92e3c 1270{
d62a17ae 1271 if (dest->routes) {
1272 return 0;
1273 }
9fd92e3c 1274
d62a17ae 1275 /*
1276 * Don't delete the dest if we have to update the FPM about this
1277 * prefix.
1278 */
1279 if (CHECK_FLAG(dest->flags, RIB_DEST_UPDATE_FPM)
1280 || CHECK_FLAG(dest->flags, RIB_DEST_SENT_TO_FPM))
1281 return 0;
5adc2528 1282
d62a17ae 1283 return 1;
9fd92e3c
AS		 1284}
1285
1286/*
1287 * rib_gc_dest
1288 *
1289 * Garbage collect the rib dest corresponding to the given route node
1290 * if appropriate.
1291 *
1292 * Returns TRUE if the dest was deleted, FALSE otherwise.
1293 */
d62a17ae 1294int rib_gc_dest(struct route_node *rn)
9fd92e3c 1295{
d62a17ae 1296 rib_dest_t *dest;
9fd92e3c 1297
d62a17ae 1298 dest = rib_dest_from_rnode(rn);
1299 if (!dest)
1300 return 0;
9fd92e3c 1301
d62a17ae 1302 if (!rib_can_delete_dest(dest))
1303 return 0;
9fd92e3c 1304
c9abf558
DS		 1305 if (IS_ZEBRA_DEBUG_RIB) {
1306 struct zebra_vrf *zvrf;
1307
1308 zvrf = rib_dest_vrf(dest);
d62a17ae 1309 rnode_debug(rn, zvrf_id(zvrf), "removing dest from table");
c9abf558 1310 }
9fd92e3c 1311
d62a17ae 1312 dest->rnode = NULL;
1313 XFREE(MTYPE_RIB_DEST, dest);
1314 rn->info = NULL;
9fd92e3c 1315
d62a17ae 1316 /*
1317 * Release the one reference that we keep on the route node.
1318 */
1319 route_unlock_node(rn);
1320 return 1;
9fd92e3c
AS		 1321}
1322
d62a17ae 1323static void rib_process_add_fib(struct zebra_vrf *zvrf, struct route_node *rn,
1324 struct route_entry *new)
3e5c6e00 1325{
5f7a4718
DS		 1326 rib_dest_t *dest = rib_dest_from_rnode(rn);
1327
d62a17ae 1328 hook_call(rib_update, rn, "new route selected");
3e5c6e00 1329
d62a17ae 1330 /* Update real nexthop. This may actually determine if nexthop is active
1331 * or not. */
1332 if (!nexthop_active_update(rn, new, 1)) {
1333 UNSET_FLAG(new->status, ROUTE_ENTRY_CHANGED);
1334 return;
1335 }
3e5c6e00 1336
d62a17ae 1337 if (IS_ZEBRA_DEBUG_RIB) {
1338 char buf[SRCDEST2STR_BUFFER];
1339 srcdest_rnode2str(rn, buf, sizeof(buf));
1340 zlog_debug("%u:%s: Adding route rn %p, re %p (type %d)",
1341 zvrf_id(zvrf), buf, rn, new, new->type);
1342 }
3e5c6e00 1343
d62a17ae 1344 /* If labeled-unicast route, install transit LSP. */
1345 if (zebra_rib_labeled_unicast(new))
1346 zebra_mpls_lsp_install(zvrf, rn, new);
a64448ba 1347
0c555cc6
DS		 1348 if (!RIB_SYSTEM_ROUTE(new))
1349 rib_install_kernel(rn, new, NULL);
ed216282
DS		 1350 else
1351 dest->selected_fib = new;
3e5c6e00 1352
d62a17ae 1353 UNSET_FLAG(new->status, ROUTE_ENTRY_CHANGED);
3e5c6e00 1354}
1355
d62a17ae 1356static void rib_process_del_fib(struct zebra_vrf *zvrf, struct route_node *rn,
1357 struct route_entry *old)
3e5c6e00 1358{
5f7a4718 1359 rib_dest_t *dest = rib_dest_from_rnode(rn);
d62a17ae 1360 hook_call(rib_update, rn, "removing existing route");
3e5c6e00 1361
d62a17ae 1362 /* Uninstall from kernel. */
1363 if (IS_ZEBRA_DEBUG_RIB) {
1364 char buf[SRCDEST2STR_BUFFER];
1365 srcdest_rnode2str(rn, buf, sizeof(buf));
1366 zlog_debug("%u:%s: Deleting route rn %p, re %p (type %d)",
1367 zvrf_id(zvrf), buf, rn, old, old->type);
1368 }
3e5c6e00 1369
d62a17ae 1370 /* If labeled-unicast route, uninstall transit LSP. */
1371 if (zebra_rib_labeled_unicast(old))
1372 zebra_mpls_lsp_uninstall(zvrf, rn, old);
1373
1374 if (!RIB_SYSTEM_ROUTE(old))
1375 rib_uninstall_kernel(rn, old);
ed216282
DS		 1376 else {
1377 /*
1378 * We are setting this to NULL here
1379 * because that is what we traditionally
1380 * have been doing. I am not positive
1381 * that this is the right thing to do
1382 * but let's leave the code alone
1383 * for the RIB_SYSTEM_ROUTE case
1384 */
1385 dest->selected_fib = NULL;
1386 }
d62a17ae 1387
1388 /* Update nexthop for route, reset changed flag. */
1389 nexthop_active_update(rn, old, 1);
1390 UNSET_FLAG(old->status, ROUTE_ENTRY_CHANGED);
1391}
1392
1393static void rib_process_update_fib(struct zebra_vrf *zvrf,
1394 struct route_node *rn,
1395 struct route_entry *old,
1396 struct route_entry *new)
1397{
1398 struct nexthop *nexthop = NULL;
1399 int nh_active = 0;
5f7a4718 1400 rib_dest_t *dest = rib_dest_from_rnode(rn);
d62a17ae 1401
1402 /*
1403 * We have to install or update if a new route has been selected or
1404 * something has changed.
1405 */
1406 if (new != old || CHECK_FLAG(new->status, ROUTE_ENTRY_CHANGED)) {
1407 hook_call(rib_update, rn, "updating existing route");
1408
1409 /* Update the nexthop; we could determine here that nexthop is
1410 * inactive. */
1411 if (nexthop_active_update(rn, new, 1))
1412 nh_active = 1;
1413
1414 /* If nexthop is active, install the selected route, if
1415 * appropriate. If
1416 * the install succeeds, cleanup flags for prior route, if
1417 * different from
1418 * newly selected.
1419 */
1420 if (nh_active) {
1421 if (IS_ZEBRA_DEBUG_RIB) {
1422 char buf[SRCDEST2STR_BUFFER];
1423 srcdest_rnode2str(rn, buf, sizeof(buf));
1424 if (new != old)
1425 zlog_debug(
1426 "%u:%s: Updating route rn %p, re %p (type %d) "
1427 "old %p (type %d)",
1428 zvrf_id(zvrf), buf, rn, new,
1429 new->type, old, old->type);
1430 else
1431 zlog_debug(
1432 "%u:%s: Updating route rn %p, re %p (type %d)",
1433 zvrf_id(zvrf), buf, rn, new,
1434 new->type);
1435 }
1436
1437 /* If labeled-unicast route, uninstall transit LSP. */
1438 if (zebra_rib_labeled_unicast(old))
1439 zebra_mpls_lsp_uninstall(zvrf, rn, old);
1440
1441 /* Non-system route should be installed. */
1442 if (!RIB_SYSTEM_ROUTE(new)) {
1443 /* If labeled-unicast route, install transit
1444 * LSP. */
1445 if (zebra_rib_labeled_unicast(new))
1446 zebra_mpls_lsp_install(zvrf, rn, new);
1447
0c555cc6 1448 rib_install_kernel(rn, new, old);
ed216282
DS		 1449 } else {
1450 /*
1451 * We do not need to install the
1452 * selected route because it
1453 * is already isntalled by
1454 * the system( ie not us )
1455 * so just mark it as winning
1456 * we do need to ensure that
1457 * if we uninstall a route
1458 * from ourselves we don't
1459 * over write this pointer
1460 */
1461 dest->selected_fib = NULL;
d62a17ae 1462 }
d62a17ae 1463 /* If install succeeded or system route, cleanup flags
1464 * for prior route. */
ed216282 1465 if (new != old) {
d62a17ae 1466 if (RIB_SYSTEM_ROUTE(new)) {
1467 if (!RIB_SYSTEM_ROUTE(old))
1468 rib_uninstall_kernel(rn, old);
1469 } else {
7ee30f28 1470 for (nexthop = old->ng.nexthop; nexthop;
d62a17ae 1471 nexthop = nexthop->next)
1472 UNSET_FLAG(nexthop->flags,
1473 NEXTHOP_FLAG_FIB);
1474 }
1475 }
d62a17ae 1476 }
a64448ba 1477
d62a17ae 1478 /*
1479 * If nexthop for selected route is not active or install
1480 * failed, we
1481 * may need to uninstall and delete for redistribution.
1482 */
ed216282 1483 if (!nh_active) {
d62a17ae 1484 if (IS_ZEBRA_DEBUG_RIB) {
1485 char buf[SRCDEST2STR_BUFFER];
1486 srcdest_rnode2str(rn, buf, sizeof(buf));
1487 if (new != old)
1488 zlog_debug(
1489 "%u:%s: Deleting route rn %p, re %p (type %d) "
0cfbff74 1490 "old %p (type %d) - nexthop inactive",
d62a17ae 1491 zvrf_id(zvrf), buf, rn, new,
0cfbff74 1492 new->type, old, old->type);
d62a17ae 1493 else
1494 zlog_debug(
0cfbff74 1495 "%u:%s: Deleting route rn %p, re %p (type %d) - nexthop inactive",
d62a17ae 1496 zvrf_id(zvrf), buf, rn, new,
0cfbff74 1497 new->type);
d62a17ae 1498 }
1499
1500 /* If labeled-unicast route, uninstall transit LSP. */
1501 if (zebra_rib_labeled_unicast(old))
1502 zebra_mpls_lsp_uninstall(zvrf, rn, old);
1503
1504 if (!RIB_SYSTEM_ROUTE(old))
1505 rib_uninstall_kernel(rn, old);
ed216282
DS		 1506 else
1507 dest->selected_fib = NULL;
d62a17ae 1508 }
1509 } else {
1510 /*
1511 * Same route selected; check if in the FIB and if not,
1512 * re-install. This
1513 * is housekeeping code to deal with race conditions in kernel
1514 * with linux
1515 * netlink reporting interface up before IPv4 or IPv6 protocol
1516 * is ready
1517 * to add routes.
1518 */
1519 if (!RIB_SYSTEM_ROUTE(new)) {
ed216282 1520 bool in_fib = false;
d62a17ae 1521
7ee30f28 1522 for (ALL_NEXTHOPS(new->ng, nexthop))
d62a17ae 1523 if (CHECK_FLAG(nexthop->flags,
1524 NEXTHOP_FLAG_FIB)) {
ed216282 1525 in_fib = true;
d62a17ae 1526 break;
1527 }
1528 if (!in_fib)
1529 rib_install_kernel(rn, new, NULL);
1530 }
1531 }
1532
1533 /* Update prior route. */
1534 if (new != old) {
d62a17ae 1535 /* Set real nexthop. */
1536 nexthop_active_update(rn, old, 1);
1537 UNSET_FLAG(old->status, ROUTE_ENTRY_CHANGED);
1538 }
3e5c6e00 1539
d62a17ae 1540 /* Clear changed flag. */
1541 UNSET_FLAG(new->status, ROUTE_ENTRY_CHANGED);
3e5c6e00 1542}
1543
d62a17ae 1544/* Check if 'alternate' RIB entry is better than 'current'. */
1545static struct route_entry *rib_choose_best(struct route_entry *current,
1546 struct route_entry *alternate)
1547{
1548 if (current == NULL)
1549 return alternate;
1550
1551 /* filter route selection in following order:
1552 * - connected beats other types
fec4ca19 1553 * - if both connected, loopback or vrf wins
d62a17ae 1554 * - lower distance beats higher
1555 * - lower metric beats higher for equal distance
1556 * - last, hence oldest, route wins tie break.
1557 */
1558
fec4ca19
DS		 1559 /* Connected routes. Check to see if either are a vrf
1560 * or loopback interface. If not, pick the last connected
d62a17ae 1561 * route of the set of lowest metric connected routes.
1562 */
1563 if (alternate->type == ZEBRA_ROUTE_CONNECT) {
fec4ca19
DS		 1564 if (current->type != ZEBRA_ROUTE_CONNECT)
1565 return alternate;
1566
1567 /* both are connected. are either loop or vrf? */
1568 struct nexthop *nexthop = NULL;
1569
1570 for (ALL_NEXTHOPS(alternate->ng, nexthop)) {
1571 if (if_is_loopback_or_vrf(if_lookup_by_index(
1572 nexthop->ifindex, alternate->vrf_id)))
1573 return alternate;
1574 }
1575
1576 for (ALL_NEXTHOPS(current->ng, nexthop)) {
1577 if (if_is_loopback_or_vrf(if_lookup_by_index(
1578 nexthop->ifindex, current->vrf_id)))
1579 return current;
1580 }
1581
1582 /* Neither are loop or vrf so pick best metric */
1583 if (alternate->metric <= current->metric)
d62a17ae 1584 return alternate;
1585
1586 return current;
1587 }
3e5c6e00 1588
d62a17ae 1589 if (current->type == ZEBRA_ROUTE_CONNECT)
1590 return current;
3e5c6e00 1591
d62a17ae 1592 /* higher distance loses */
1593 if (alternate->distance < current->distance)
1594 return alternate;
1595 if (current->distance < alternate->distance)
1596 return current;
3e5c6e00 1597
d62a17ae 1598 /* metric tie-breaks equal distance */
1599 if (alternate->metric <= current->metric)
1600 return alternate;
3e5c6e00 1601
d62a17ae 1602 return current;
3e5c6e00 1603}
1604
d62a17ae 1605/* Core function for processing routing information base. */
1606static void rib_process(struct route_node *rn)
1607{
1608 struct route_entry *re;
1609 struct route_entry *next;
1610 struct route_entry *old_selected = NULL;
1611 struct route_entry *new_selected = NULL;
1612 struct route_entry *old_fib = NULL;
1613 struct route_entry *new_fib = NULL;
1614 struct route_entry *best = NULL;
1615 char buf[SRCDEST2STR_BUFFER];
1616 rib_dest_t *dest;
1617 struct zebra_vrf *zvrf = NULL;
86391e56
MS		 1618 const struct prefix *p, *src_p;
1619
d62a17ae 1620 srcdest_rnode_prefixes(rn, &p, &src_p);
1621 vrf_id_t vrf_id = VRF_UNKNOWN;
1622
1623 assert(rn);
1624
1625 dest = rib_dest_from_rnode(rn);
1626 if (dest) {
1627 zvrf = rib_dest_vrf(dest);
1628 vrf_id = zvrf_id(zvrf);
1629 }
bab85d4f 1630
d62a17ae 1631 if (IS_ZEBRA_DEBUG_RIB)
1632 srcdest_rnode2str(rn, buf, sizeof(buf));
bab85d4f 1633
d62a17ae 1634 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
1635 zlog_debug("%u:%s: Processing rn %p", vrf_id, buf, rn);
bab85d4f 1636
607425e5
DS		 1637 /*
1638 * we can have rn's that have a NULL info pointer
1639 * (dest). As such let's not let the deref happen
1640 * additionally we know RNODE_FOREACH_RE_SAFE
1641 * will not iterate so we are ok.
1642 */
1643 if (dest)
1644 old_fib = dest->selected_fib;
5f7a4718 1645
a2addae8 1646 RNODE_FOREACH_RE_SAFE (rn, re, next) {
d62a17ae 1647 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
1648 zlog_debug(
1649 "%u:%s: Examine re %p (type %d) status %x flags %x "
1650 "dist %d metric %d",
1651 vrf_id, buf, re, re->type, re->status,
1652 re->flags, re->distance, re->metric);
1653
1654 UNSET_FLAG(re->status, ROUTE_ENTRY_NEXTHOPS_CHANGED);
1655
1656 /* Currently selected re. */
1657 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)) {
1658 assert(old_selected == NULL);
1659 old_selected = re;
1660 }
bab85d4f 1661
d62a17ae 1662 /* Skip deleted entries from selection */
1663 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
1664 continue;
1665
1666 /* Skip unreachable nexthop. */
1667 /* This first call to nexthop_active_update is merely to
1668 * determine if
1669 * there's any change to nexthops associated with this RIB
1670 * entry. Now,
1671 * rib_process() can be invoked due to an external event such as
1672 * link
1673 * down or due to next-hop-tracking evaluation. In the latter
1674 * case,
1675 * a decision has already been made that the NHs have changed.
1676 * So, no
1677 * need to invoke a potentially expensive call again. Further,
1678 * since
1679 * the change might be in a recursive NH which is not caught in
1680 * the nexthop_active_update() code. Thus, we might miss changes
1681 * to
1682 * recursive NHs.
1683 */
1684 if (!CHECK_FLAG(re->status, ROUTE_ENTRY_CHANGED)
1685 && !nexthop_active_update(rn, re, 0)) {
1686 if (re->type == ZEBRA_ROUTE_TABLE) {
1687 /* XXX: HERE BE DRAGONS!!!!!
1688 * In all honesty, I have not yet figured out
1689 * what this part
1690 * does or why the ROUTE_ENTRY_CHANGED test
1691 * above is correct
1692 * or why we need to delete a route here, and
1693 * also not whether
1694 * this concerns both selected and fib route, or
1695 * only selected
1696 * or only fib */
1697 /* This entry was denied by the 'ip protocol
1698 * table' route-map, we
1699 * need to delete it */
1700 if (re != old_selected) {
1701 if (IS_ZEBRA_DEBUG_RIB)
1702 zlog_debug(
32391aff 1703 "%s: %u:%s: imported via import-table but denied "
d62a17ae 1704 "by the ip protocol table route-map",
32391aff 1705 __func__, vrf_id, buf);
d62a17ae 1706 rib_unlink(rn, re);
1707 } else
1708 SET_FLAG(re->status,
1709 ROUTE_ENTRY_REMOVED);
1710 }
1711
1712 continue;
1713 }
bab85d4f 1714
d62a17ae 1715 /* Infinite distance. */
1716 if (re->distance == DISTANCE_INFINITY) {
1717 UNSET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
1718 continue;
1719 }
bab85d4f 1720
d62a17ae 1721 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_FIB_OVERRIDE)) {
1722 best = rib_choose_best(new_fib, re);
1723 if (new_fib && best != new_fib)
1724 UNSET_FLAG(new_fib->status,
1725 ROUTE_ENTRY_CHANGED);
1726 new_fib = best;
1727 } else {
1728 best = rib_choose_best(new_selected, re);
1729 if (new_selected && best != new_selected)
1730 UNSET_FLAG(new_selected->status,
1731 ROUTE_ENTRY_CHANGED);
1732 new_selected = best;
1733 }
1734 if (best != re)
1735 UNSET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
1736 } /* RNODE_FOREACH_RE */
1737
1738 /* If no FIB override route, use the selected route also for FIB */
1739 if (new_fib == NULL)
1740 new_fib = new_selected;
1741
1742 /* After the cycle is finished, the following pointers will be set:
1743 * old_selected --- RE entry currently having SELECTED
1744 * new_selected --- RE entry that is newly SELECTED
1745 * old_fib --- RE entry currently in kernel FIB
1746 * new_fib --- RE entry that is newly to be in kernel FIB
1747 *
1748 * new_selected will get SELECTED flag, and is going to be redistributed
1749 * the zclients. new_fib (which can be new_selected) will be installed
1750 * in kernel.
1751 */
1752
1753 if (IS_ZEBRA_DEBUG_RIB_DETAILED) {
1754 zlog_debug(
1755 "%u:%s: After processing: old_selected %p new_selected %p old_fib %p new_fib %p",
1756 vrf_id, buf, (void *)old_selected, (void *)new_selected,
1757 (void *)old_fib, (void *)new_fib);
1758 }
446bb95e 1759
d62a17ae 1760 /* Buffer ROUTE_ENTRY_CHANGED here, because it will get cleared if
1761 * fib == selected */
9d303b37
DL		 1762 bool selected_changed = new_selected && CHECK_FLAG(new_selected->status,
1763 ROUTE_ENTRY_CHANGED);
d62a17ae 1764
1765 /* Update fib according to selection results */
1766 if (new_fib && old_fib)
1767 rib_process_update_fib(zvrf, rn, old_fib, new_fib);
1768 else if (new_fib)
1769 rib_process_add_fib(zvrf, rn, new_fib);
1770 else if (old_fib)
1771 rib_process_del_fib(zvrf, rn, old_fib);
1772
1773 /* Redistribute SELECTED entry */
1774 if (old_selected != new_selected || selected_changed) {
7ee30f28 1775 struct nexthop *nexthop = NULL;
d62a17ae 1776
1777 /* Check if we have a FIB route for the destination, otherwise,
1778 * don't redistribute it */
7ee30f28
DS		 1779 if (new_fib) {
1780 for (ALL_NEXTHOPS(new_fib->ng, nexthop)) {
1781 if (CHECK_FLAG(nexthop->flags,
1782 NEXTHOP_FLAG_FIB)) {
1783 break;
1784 }
d62a17ae 1785 }
1786 }
1787 if (!nexthop)
1788 new_selected = NULL;
93bdadae 1789
d62a17ae 1790 if (new_selected && new_selected != new_fib) {
1791 nexthop_active_update(rn, new_selected, 1);
1792 UNSET_FLAG(new_selected->status, ROUTE_ENTRY_CHANGED);
1793 }
41ec9222 1794
d62a17ae 1795 if (old_selected) {
1796 if (!new_selected)
1797 redistribute_delete(p, src_p, old_selected);
1798 if (old_selected != new_selected)
1799 UNSET_FLAG(old_selected->flags,
1800 ZEBRA_FLAG_SELECTED);
f857321e 1801 }
446bb95e 1802
d62a17ae 1803 if (new_selected) {
1804 /* Install new or replace existing redistributed entry
1805 */
1806 SET_FLAG(new_selected->flags, ZEBRA_FLAG_SELECTED);
1807 redistribute_update(p, src_p, new_selected,
1808 old_selected);
1809 }
1810 }
3e5c6e00 1811
d62a17ae 1812 /* Remove all RE entries queued for removal */
a2addae8 1813 RNODE_FOREACH_RE_SAFE (rn, re, next) {
d62a17ae 1814 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED)) {
1815 if (IS_ZEBRA_DEBUG_RIB) {
1816 rnode_debug(rn, vrf_id, "rn %p, removing re %p",
1817 (void *)rn, (void *)re);
1818 }
1819 rib_unlink(rn, re);
1820 }
1821 }
4d38fdb4 1822
d62a17ae 1823 /*
1824 * Check if the dest can be deleted now.
1825 */
1826 rib_gc_dest(rn);
e96f9203
DO		 1827}
1828
5110a0c6 1829/* Take a list of route_node structs and return 1, if there was a record
d62a17ae 1830 * picked from it and processed by rib_process(). Don't process more,
5110a0c6 1831 * than one RN record; operate only in the specified sub-queue.
e96f9203 1832 */
d7c0a89a 1833static unsigned int process_subq(struct list *subq, uint8_t qindex)
e96f9203 1834{
d62a17ae 1835 struct listnode *lnode = listhead(subq);
1836 struct route_node *rnode;
1837 rib_dest_t *dest;
1838 struct zebra_vrf *zvrf = NULL;
5110a0c6 1839
d62a17ae 1840 if (!lnode)
1841 return 0;
5110a0c6 1842
d62a17ae 1843 rnode = listgetdata(lnode);
1844 dest = rib_dest_from_rnode(rnode);
1845 if (dest)
1846 zvrf = rib_dest_vrf(dest);
41ec9222 1847
d62a17ae 1848 rib_process(rnode);
5110a0c6 1849
d62a17ae 1850 if (IS_ZEBRA_DEBUG_RIB_DETAILED) {
1851 char buf[SRCDEST2STR_BUFFER];
1852 srcdest_rnode2str(rnode, buf, sizeof(buf));
1853 zlog_debug("%u:%s: rn %p dequeued from sub-queue %u",
1854 zvrf ? zvrf_id(zvrf) : 0, buf, rnode, qindex);
1855 }
41ec9222 1856
d62a17ae 1857 if (rnode->info)
1858 UNSET_FLAG(rib_dest_from_rnode(rnode)->flags,
1859 RIB_ROUTE_QUEUED(qindex));
9fd92e3c 1860
67b9467f 1861#if 0
5110a0c6
SH		 1862 else
1863 {
1864 zlog_debug ("%s: called for route_node (%p, %d) with no ribs",
1865 __func__, rnode, rnode->lock);
1866 zlog_backtrace(LOG_DEBUG);
1867 }
67b9467f 1868#endif
d62a17ae 1869 route_unlock_node(rnode);
1870 list_delete_node(subq, lnode);
1871 return 1;
e96f9203
DO		 1872}
1873
fb018d25
DS		 1874/*
1875 * All meta queues have been processed. Trigger next-hop evaluation.
1876 */
d62a17ae 1877static void meta_queue_process_complete(struct work_queue *dummy)
fb018d25 1878{
d62a17ae 1879 struct vrf *vrf;
1880 struct zebra_vrf *zvrf;
9ec6b0bb 1881
d62a17ae 1882 /* Evaluate nexthops for those VRFs which underwent route processing.
1883 * This
1884 * should limit the evaluation to the necessary VRFs in most common
1885 * situations.
1886 */
a2addae8 1887 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
d62a17ae 1888 zvrf = vrf->info;
1889 if (zvrf == NULL || !(zvrf->flags & ZEBRA_VRF_RIB_SCHEDULED))
1890 continue;
1891
1892 zvrf->flags &= ~ZEBRA_VRF_RIB_SCHEDULED;
1893 zebra_evaluate_rnh(zvrf_id(zvrf), AF_INET, 0, RNH_NEXTHOP_TYPE,
1894 NULL);
1895 zebra_evaluate_rnh(zvrf_id(zvrf), AF_INET, 0,
1896 RNH_IMPORT_CHECK_TYPE, NULL);
1897 zebra_evaluate_rnh(zvrf_id(zvrf), AF_INET6, 0, RNH_NEXTHOP_TYPE,
1898 NULL);
1899 zebra_evaluate_rnh(zvrf_id(zvrf), AF_INET6, 0,
1900 RNH_IMPORT_CHECK_TYPE, NULL);
1901 }
939fba27 1902
d62a17ae 1903 /* Schedule LSPs for processing, if needed. */
1904 zvrf = vrf_info_lookup(VRF_DEFAULT);
1905 if (mpls_should_lsps_be_processed(zvrf)) {
1906 if (IS_ZEBRA_DEBUG_MPLS)
1907 zlog_debug(
1908 "%u: Scheduling all LSPs upon RIB completion",
1909 zvrf_id(zvrf));
1910 zebra_mpls_lsp_schedule(zvrf);
1911 mpls_unmark_lsps_for_processing(zvrf);
1912 }
fb018d25
DS		 1913}
1914
e96f9203 1915/* Dispatch the meta queue by picking, processing and unlocking the next RN from
d62a17ae 1916 * a non-empty sub-queue with lowest priority. wq is equal to zebra->ribq and
1917 * data
e96f9203
DO		 1918 * is pointed to the meta queue structure.
1919 */
d62a17ae 1920static wq_item_status meta_queue_process(struct work_queue *dummy, void *data)
e96f9203 1921{
d62a17ae 1922 struct meta_queue *mq = data;
1923 unsigned i;
5110a0c6 1924
d62a17ae 1925 for (i = 0; i < MQ_SIZE; i++)
1926 if (process_subq(mq->subq[i], i)) {
1927 mq->size--;
1928 break;
1929 }
1930 return mq->size ? WQ_REQUEUE : WQ_SUCCESS;
e96f9203
DO		 1931}
1932
9fd92e3c
AS		 1933/*
1934 * Map from rib types to queue type (priority) in meta queue
1935 */
d7c0a89a
QY		 1936static const uint8_t meta_queue_map[ZEBRA_ROUTE_MAX] = {
1937 [ZEBRA_ROUTE_SYSTEM] = 4,
1938 [ZEBRA_ROUTE_KERNEL] = 0,
1939 [ZEBRA_ROUTE_CONNECT] = 0,
1940 [ZEBRA_ROUTE_STATIC] = 1,
1941 [ZEBRA_ROUTE_RIP] = 2,
1942 [ZEBRA_ROUTE_RIPNG] = 2,
1943 [ZEBRA_ROUTE_OSPF] = 2,
1944 [ZEBRA_ROUTE_OSPF6] = 2,
1945 [ZEBRA_ROUTE_ISIS] = 2,
1946 [ZEBRA_ROUTE_BGP] = 3,
1947 [ZEBRA_ROUTE_PIM] = 4, // Shouldn't happen but for safety
1948 [ZEBRA_ROUTE_EIGRP] = 2,
1949 [ZEBRA_ROUTE_NHRP] = 2,
1950 [ZEBRA_ROUTE_HSLS] = 4,
1951 [ZEBRA_ROUTE_OLSR] = 4,
1952 [ZEBRA_ROUTE_TABLE] = 1,
1953 [ZEBRA_ROUTE_LDP] = 4,
1954 [ZEBRA_ROUTE_VNC] = 3,
1955 [ZEBRA_ROUTE_VNC_DIRECT] = 3,
1956 [ZEBRA_ROUTE_VNC_DIRECT_RH] = 3,
1957 [ZEBRA_ROUTE_BGP_DIRECT] = 3,
1958 [ZEBRA_ROUTE_BGP_DIRECT_EXT] = 3,
1959 [ZEBRA_ROUTE_BABEL] = 2,
1960 [ZEBRA_ROUTE_ALL] = 4, // Shouldn't happen but for safety
5110a0c6
SH		 1961};
1962
1963/* Look into the RN and queue it into one or more priority queues,
1964 * increasing the size for each data push done.
e96f9203 1965 */
d62a17ae 1966static void rib_meta_queue_add(struct meta_queue *mq, struct route_node *rn)
e96f9203 1967{
d62a17ae 1968 struct route_entry *re;
5110a0c6 1969
a2addae8 1970 RNODE_FOREACH_RE (rn, re) {
d7c0a89a 1971 uint8_t qindex = meta_queue_map[re->type];
d62a17ae 1972 struct zebra_vrf *zvrf;
1973
1974 /* Invariant: at this point we always have rn->info set. */
1975 if (CHECK_FLAG(rib_dest_from_rnode(rn)->flags,
1976 RIB_ROUTE_QUEUED(qindex))) {
1977 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
1978 rnode_debug(
1979 rn, re->vrf_id,
1980 "rn %p is already queued in sub-queue %u",
1981 (void *)rn, qindex);
1982 continue;
1983 }
5110a0c6 1984
d62a17ae 1985 SET_FLAG(rib_dest_from_rnode(rn)->flags,
1986 RIB_ROUTE_QUEUED(qindex));
1987 listnode_add(mq->subq[qindex], rn);
1988 route_lock_node(rn);
1989 mq->size++;
5110a0c6 1990
d62a17ae 1991 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
1992 rnode_debug(rn, re->vrf_id,
1993 "queued rn %p into sub-queue %u",
1994 (void *)rn, qindex);
9ec6b0bb 1995
d62a17ae 1996 zvrf = zebra_vrf_lookup_by_id(re->vrf_id);
1997 if (zvrf)
1998 zvrf->flags |= ZEBRA_VRF_RIB_SCHEDULED;
1999 }
4d38fdb4 2000}
2001
6d691129 2002/* Add route_node to work queue and schedule processing */
d62a17ae 2003void rib_queue_add(struct route_node *rn)
4d38fdb4 2004{
d62a17ae 2005 assert(rn);
fc328ac9 2006
d62a17ae 2007 /* Pointless to queue a route_node with no RIB entries to add or remove
2008 */
2009 if (!rnode_to_ribs(rn)) {
2010 zlog_debug("%s: called for route_node (%p, %d) with no ribs",
2011 __func__, (void *)rn, rn->lock);
2012 zlog_backtrace(LOG_DEBUG);
2013 return;
2014 }
4d38fdb4 2015
d62a17ae 2016 if (zebrad.ribq == NULL) {
e914ccbe 2017 flog_err(EC_ZEBRA_WQ_NONEXISTENT,
1c50c1c0 2018 "%s: work_queue does not exist!", __func__);
d62a17ae 2019 return;
2020 }
2021
2022 /*
2023 * The RIB queue should normally be either empty or holding the only
2024 * work_queue_item element. In the latter case this element would
2025 * hold a pointer to the meta queue structure, which must be used to
2026 * actually queue the route nodes to process. So create the MQ
2027 * holder, if necessary, then push the work into it in any case.
2028 * This semantics was introduced after 0.99.9 release.
2029 */
f104f6c1 2030 if (work_queue_empty(zebrad.ribq))
d62a17ae 2031 work_queue_add(zebrad.ribq, zebrad.mq);
e96f9203 2032
d62a17ae 2033 rib_meta_queue_add(zebrad.mq, rn);
fc328ac9 2034
d62a17ae 2035 return;
4d38fdb4 2036}
2037
5110a0c6
SH		 2038/* Create new meta queue.
2039 A destructor function doesn't seem to be necessary here.
2040 */
d62a17ae 2041static struct meta_queue *meta_queue_new(void)
e96f9203 2042{
d62a17ae 2043 struct meta_queue *new;
2044 unsigned i;
5110a0c6 2045
d62a17ae 2046 new = XCALLOC(MTYPE_WORK_QUEUE, sizeof(struct meta_queue));
e96f9203 2047
d62a17ae 2048 for (i = 0; i < MQ_SIZE; i++) {
2049 new->subq[i] = list_new();
2050 assert(new->subq[i]);
2051 }
5110a0c6 2052
d62a17ae 2053 return new;
e96f9203
DO		 2054}
2055
d62a17ae 2056void meta_queue_free(struct meta_queue *mq)
5a8dfcd8 2057{
d62a17ae 2058 unsigned i;
5a8dfcd8 2059
d62a17ae 2060 for (i = 0; i < MQ_SIZE; i++)
6a154c88 2061 list_delete(&mq->subq[i]);
5a8dfcd8 2062
d62a17ae 2063 XFREE(MTYPE_WORK_QUEUE, mq);
5a8dfcd8
RW		 2064}
2065
4d38fdb4 2066/* initialise zebra rib work queue */
d62a17ae 2067static void rib_queue_init(struct zebra_t *zebra)
4d38fdb4 2068{
d62a17ae 2069 assert(zebra);
2070
2071 if (!(zebra->ribq =
2072 work_queue_new(zebra->master, "route_node processing"))) {
e914ccbe 2073 flog_err(EC_ZEBRA_WQ_NONEXISTENT,
1c50c1c0 2074 "%s: could not initialise work queue!", __func__);
d62a17ae 2075 return;
2076 }
4d38fdb4 2077
d62a17ae 2078 /* fill in the work queue spec */
2079 zebra->ribq->spec.workfunc = &meta_queue_process;
2080 zebra->ribq->spec.errorfunc = NULL;
2081 zebra->ribq->spec.completion_func = &meta_queue_process_complete;
2082 /* XXX: TODO: These should be runtime configurable via vty */
2083 zebra->ribq->spec.max_retries = 3;
3a30f50f 2084 zebra->ribq->spec.hold = ZEBRA_RIB_PROCESS_HOLD_TIME;
d62a17ae 2085
2086 if (!(zebra->mq = meta_queue_new())) {
e914ccbe 2087 flog_err(EC_ZEBRA_WQ_NONEXISTENT,
1c50c1c0 2088 "%s: could not initialise meta queue!", __func__);
d62a17ae 2089 return;
2090 }
2091 return;
718e3744 2092}
2093
6d691129
PJ		 2094/* RIB updates are processed via a queue of pointers to route_nodes.
2095 *
2096 * The queue length is bounded by the maximal size of the routing table,
2097 * as a route_node will not be requeued, if already queued.
2098 *
f0f77c9a
DS		 2099 * REs are submitted via rib_addnode or rib_delnode which set minimal
2100 * state, or static_install_route (when an existing RE is updated)
3c0755dc 2101 * and then submit route_node to queue for best-path selection later.
f0f77c9a 2102 * Order of add/delete state changes are preserved for any given RE.
6d691129 2103 *
f0f77c9a 2104 * Deleted REs are reaped during best-path selection.
6d691129
PJ		 2105 *
2106 * rib_addnode
f0f77c9a
DS		 2107 * |-> rib_link or unset ROUTE_ENTRY_REMOVE |->Update kernel with
2108 * |-------->| | best RE, if required
3c0755dc
PJ		 2109 * | |
2110 * static_install->|->rib_addqueue...... -> rib_process
2111 * | |
2112 * |-------->| |-> rib_unlink
f0f77c9a
DS		 2113 * |-> set ROUTE_ENTRY_REMOVE |
2114 * rib_delnode (RE freed)
6d691129 2115 *
9fd92e3c
AS		 2116 * The 'info' pointer of a route_node points to a rib_dest_t
2117 * ('dest'). Queueing state for a route_node is kept on the dest. The
2118 * dest is created on-demand by rib_link() and is kept around at least
2119 * as long as there are ribs hanging off it (@see rib_gc_dest()).
d62a17ae 2120 *
6d691129
PJ		 2121 * Refcounting (aka "locking" throughout the GNU Zebra and Quagga code):
2122 *
2123 * - route_nodes: refcounted by:
9fd92e3c
AS		 2124 * - dest attached to route_node:
2125 * - managed by: rib_link/rib_gc_dest
6d691129
PJ		 2126 * - route_node processing queue
2127 * - managed by: rib_addqueue, rib_process.
2128 *
2129 */
d62a17ae 2130
f0f77c9a 2131/* Add RE to head of the route node. */
d62a17ae 2132static void rib_link(struct route_node *rn, struct route_entry *re, int process)
2133{
2134 struct route_entry *head;
2135 rib_dest_t *dest;
2136 afi_t afi;
2137 const char *rmap_name;
9fd92e3c 2138
d62a17ae 2139 assert(re && rn);
9fd92e3c 2140
d62a17ae 2141 dest = rib_dest_from_rnode(rn);
2142 if (!dest) {
2143 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
2144 rnode_debug(rn, re->vrf_id, "rn %p adding dest", rn);
7a4bb9c5 2145
d62a17ae 2146 dest = XCALLOC(MTYPE_RIB_DEST, sizeof(rib_dest_t));
2147 route_lock_node(rn); /* rn route table reference */
2148 rn->info = dest;
2149 dest->rnode = rn;
2150 }
2263a412 2151
d62a17ae 2152 head = dest->routes;
2153 if (head) {
2154 head->prev = re;
2155 }
2156 re->next = head;
2157 dest->routes = re;
2158
2159 afi = (rn->p.family == AF_INET)
2160 ? AFI_IP
2161 : (rn->p.family == AF_INET6) ? AFI_IP6 : AFI_MAX;
2162 if (is_zebra_import_table_enabled(afi, re->table)) {
2163 rmap_name = zebra_get_import_table_route_map(afi, re->table);
2164 zebra_add_import_table_entry(rn, re, rmap_name);
2165 } else if (process)
2166 rib_queue_add(rn);
2167}
2168
7e24fdf3
DS		 2169static void rib_addnode(struct route_node *rn,
2170 struct route_entry *re, int process)
d62a17ae 2171{
2172 /* RE node has been un-removed before route-node is processed.
2173 * route_node must hence already be on the queue for processing..
2174 */
2175 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED)) {
2176 if (IS_ZEBRA_DEBUG_RIB)
2177 rnode_debug(rn, re->vrf_id, "rn %p, un-removed re %p",
2178 (void *)rn, (void *)re);
2179
2180 UNSET_FLAG(re->status, ROUTE_ENTRY_REMOVED);
2181 return;
2182 }
2183 rib_link(rn, re, process);
6d691129
PJ		 2184}
2185
9fd92e3c
AS		 2186/*
2187 * rib_unlink
2188 *
2189 * Detach a rib structure from a route_node.
2190 *
2191 * Note that a call to rib_unlink() should be followed by a call to
2192 * rib_gc_dest() at some point. This allows a rib_dest_t that is no
2193 * longer required to be deleted.
2194 */
d62a17ae 2195void rib_unlink(struct route_node *rn, struct route_entry *re)
6d691129 2196{
d62a17ae 2197 rib_dest_t *dest;
9fd92e3c 2198
d62a17ae 2199 assert(rn && re);
6d691129 2200
d62a17ae 2201 if (IS_ZEBRA_DEBUG_RIB)
2202 rnode_debug(rn, re->vrf_id, "rn %p, re %p", (void *)rn,
2203 (void *)re);
6d691129 2204
d62a17ae 2205 dest = rib_dest_from_rnode(rn);
6d691129 2206
d62a17ae 2207 if (re->next)
2208 re->next->prev = re->prev;
6d691129 2209
d62a17ae 2210 if (re->prev)
2211 re->prev->next = re->next;
2212 else {
2213 dest->routes = re->next;
2214 }
7a4bb9c5 2215
2eb07de3
DS		 2216 if (dest->selected_fib == re)
2217 dest->selected_fib = NULL;
2218
7ee30f28 2219 nexthops_free(re->ng.nexthop);
d62a17ae 2220 XFREE(MTYPE_RE, re);
2221}
2222
2223void rib_delnode(struct route_node *rn, struct route_entry *re)
2224{
2225 afi_t afi;
2226
2227 if (IS_ZEBRA_DEBUG_RIB)
2228 rnode_debug(rn, re->vrf_id, "rn %p, re %p, removing",
2229 (void *)rn, (void *)re);
2230 SET_FLAG(re->status, ROUTE_ENTRY_REMOVED);
2231
2232 afi = (rn->p.family == AF_INET)
2233 ? AFI_IP
2234 : (rn->p.family == AF_INET6) ? AFI_IP6 : AFI_MAX;
2235 if (is_zebra_import_table_enabled(afi, re->table)) {
2236 zebra_del_import_table_entry(rn, re);
2237 /* Just clean up if non main table */
2238 if (IS_ZEBRA_DEBUG_RIB) {
2239 char buf[SRCDEST2STR_BUFFER];
2240 srcdest_rnode2str(rn, buf, sizeof(buf));
2241 zlog_debug(
2242 "%u:%s: Freeing route rn %p, re %p (type %d)",
2243 re->vrf_id, buf, rn, re, re->type);
2244 }
7a4bb9c5 2245
d62a17ae 2246 rib_unlink(rn, re);
2247 } else {
2248 rib_queue_add(rn);
2249 }
718e3744 2250}
2251
f0f77c9a 2252/* This function dumps the contents of a given RE entry into
dc95824a
DO		 2253 * standard debug log. Calling function name and IP prefix in
2254 * question are passed as 1st and 2nd arguments.
2255 */
2256
d62a17ae 2257void _route_entry_dump(const char *func, union prefixconstptr pp,
2258 union prefixconstptr src_pp,
2259 const struct route_entry *re)
2260{
d62a17ae 2261 const struct prefix *src_p = src_pp.p;
2262 bool is_srcdst = src_p && src_p->prefixlen;
2263 char straddr[PREFIX_STRLEN];
2264 char srcaddr[PREFIX_STRLEN];
2265 struct nexthop *nexthop;
2266
2267 zlog_debug("%s: dumping RE entry %p for %s%s%s vrf %u", func,
2268 (const void *)re, prefix2str(pp, straddr, sizeof(straddr)),
2269 is_srcdst ? " from " : "",
2270 is_srcdst ? prefix2str(src_pp, srcaddr, sizeof(srcaddr))
2271 : "",
2272 re->vrf_id);
cc54cfee
RW		 2273 zlog_debug("%s: uptime == %lu, type == %u, instance == %d, table == %d",
2274 func, (unsigned long)re->uptime, re->type, re->instance,
2275 re->table);
d62a17ae 2276 zlog_debug(
2277 "%s: metric == %u, mtu == %u, distance == %u, flags == %u, status == %u",
2278 func, re->metric, re->mtu, re->distance, re->flags, re->status);
2279 zlog_debug("%s: nexthop_num == %u, nexthop_active_num == %u", func,
2280 re->nexthop_num, re->nexthop_active_num);
2281
7ee30f28 2282 for (ALL_NEXTHOPS(re->ng, nexthop)) {
2d68a0f2
DS		 2283 struct interface *ifp;
2284 struct vrf *vrf = vrf_lookup_by_id(nexthop->vrf_id);
2285
2286 switch (nexthop->type) {
2287 case NEXTHOP_TYPE_BLACKHOLE:
2288 sprintf(straddr, "Blackhole");
2289 break;
2290 case NEXTHOP_TYPE_IFINDEX:
2291 ifp = if_lookup_by_index(nexthop->ifindex,
2292 nexthop->vrf_id);
2293 sprintf(straddr, "%s", ifp ? ifp->name : "Unknown");
2294 break;
2295 case NEXTHOP_TYPE_IPV4:
2296 /* fallthrough */
2297 case NEXTHOP_TYPE_IPV4_IFINDEX:
2298 inet_ntop(AF_INET, &nexthop->gate, straddr,
2299 INET6_ADDRSTRLEN);
2300 break;
2301 case NEXTHOP_TYPE_IPV6:
2302 case NEXTHOP_TYPE_IPV6_IFINDEX:
2303 inet_ntop(AF_INET6, &nexthop->gate, straddr,
2304 INET6_ADDRSTRLEN);
2305 break;
2306 }
2307 zlog_debug("%s: %s %s[%u] vrf %s(%u) with flags %s%s%s", func,
d62a17ae 2308 (nexthop->rparent ? " NH" : "NH"), straddr,
2d68a0f2
DS		 2309 nexthop->ifindex, vrf ? vrf->name : "Unknown",
2310 nexthop->vrf_id,
d62a17ae 2311 (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)
2312 ? "ACTIVE "
2313 : ""),
2314 (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)
2315 ? "FIB "
2316 : ""),
2317 (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE)
2318 ? "RECURSIVE"
2319 : ""));
2320 }
2321 zlog_debug("%s: dump complete", func);
dc95824a
DO		 2322}
2323
2324/* This is an exported helper to rtm_read() to dump the strange
f0f77c9a 2325 * RE entry found by rib_lookup_ipv4_route()
dc95824a
DO		 2326 */
2327
d62a17ae 2328void rib_lookup_and_dump(struct prefix_ipv4 *p, vrf_id_t vrf_id)
2329{
2330 struct route_table *table;
2331 struct route_node *rn;
2332 struct route_entry *re;
2333 char prefix_buf[INET_ADDRSTRLEN];
2334
2335 /* Lookup table. */
2336 table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id);
2337 if (!table) {
e914ccbe 2338 flog_err(EC_ZEBRA_TABLE_LOOKUP_FAILED,
1c50c1c0
QY		 2339 "%s:%u zebra_vrf_table() returned NULL", __func__,
2340 vrf_id);
d62a17ae 2341 return;
2342 }
2343
2344 /* Scan the RIB table for exactly matching RE entry. */
2345 rn = route_node_lookup(table, (struct prefix *)p);
2346
2347 /* No route for this prefix. */
2348 if (!rn) {
32391aff 2349 zlog_debug("%s:%u lookup failed for %s", __func__, vrf_id,
d62a17ae 2350 prefix2str((struct prefix *)p, prefix_buf,
2351 sizeof(prefix_buf)));
2352 return;
2353 }
2354
2355 /* Unlock node. */
2356 route_unlock_node(rn);
2357
2358 /* let's go */
a2addae8 2359 RNODE_FOREACH_RE (rn, re) {
32391aff
DS		 2360 zlog_debug("%s:%u rn %p, re %p: %s, %s",
2361 __func__, vrf_id,
2362 (void *)rn, (void *)re,
d62a17ae 2363 (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED)
2364 ? "removed"
2365 : "NOT removed"),
2366 (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)
2367 ? "selected"
2368 : "NOT selected"));
2369 route_entry_dump(p, NULL, re);
2370 }
dc95824a
DO		 2371}
2372
20e5ff0a
DO		 2373/* Check if requested address assignment will fail due to another
2374 * route being installed by zebra in FIB already. Take necessary
2375 * actions, if needed: remove such a route from FIB and deSELECT
f0f77c9a 2376 * corresponding RE entry. Then put affected RN into RIBQ head.
20e5ff0a 2377 */
d62a17ae 2378void rib_lookup_and_pushup(struct prefix_ipv4 *p, vrf_id_t vrf_id)
2379{
2380 struct route_table *table;
2381 struct route_node *rn;
d62a17ae 2382 unsigned changed = 0;
5f7a4718 2383 rib_dest_t *dest;
d62a17ae 2384
2385 if (NULL == (table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id))) {
e914ccbe 2386 flog_err(EC_ZEBRA_TABLE_LOOKUP_FAILED,
1c50c1c0
QY		 2387 "%s:%u zebra_vrf_table() returned NULL", __func__,
2388 vrf_id);
d62a17ae 2389 return;
2390 }
2391
2392 /* No matches would be the simplest case. */
2393 if (NULL == (rn = route_node_lookup(table, (struct prefix *)p)))
2394 return;
2395
2396 /* Unlock node. */
2397 route_unlock_node(rn);
2398
5f7a4718 2399 dest = rib_dest_from_rnode(rn);
d62a17ae 2400 /* Check all RE entries. In case any changes have to be done, requeue
2401 * the RN into RIBQ head. If the routing message about the new connected
2402 * route (generated by the IP address we are going to assign very soon)
2403 * comes before the RIBQ is processed, the new RE entry will join
2404 * RIBQ record already on head. This is necessary for proper
2405 * revalidation
2406 * of the rest of the RE.
2407 */
5f7a4718
DS		 2408 if (dest->selected_fib && !RIB_SYSTEM_ROUTE(dest->selected_fib)) {
2409 changed = 1;
2410 if (IS_ZEBRA_DEBUG_RIB) {
2411 char buf[PREFIX_STRLEN];
2412
2413 zlog_debug("%u:%s: freeing way for connected prefix",
2414 dest->selected_fib->vrf_id,
2415 prefix2str(&rn->p, buf, sizeof(buf)));
2416 route_entry_dump(&rn->p, NULL, dest->selected_fib);
d62a17ae 2417 }
5f7a4718 2418 rib_uninstall(rn, dest->selected_fib);
d62a17ae 2419 }
2420 if (changed)
2421 rib_queue_add(rn);
20e5ff0a
DO		 2422}
2423
d62a17ae 2424int rib_add_multipath(afi_t afi, safi_t safi, struct prefix *p,
2425 struct prefix_ipv6 *src_p, struct route_entry *re)
718e3744 2426{
d62a17ae 2427 struct route_table *table;
2428 struct route_node *rn;
40ecd8e4 2429 struct route_entry *same = NULL;
d62a17ae 2430 struct nexthop *nexthop;
2431 int ret = 0;
b4c034b0 2432
d62a17ae 2433 if (!re)
2434 return 0;
b4c034b0 2435
1f610a1f 2436 assert(!src_p || !src_p->prefixlen || afi == AFI_IP6);
05737783 2437
d62a17ae 2438 /* Lookup table. */
7865c65d
RW		 2439 table = zebra_vrf_table_with_table_id(afi, safi, re->vrf_id, re->table);
2440 if (!table) {
2441 XFREE(MTYPE_RE, re);
d62a17ae 2442 return 0;
7865c65d 2443 }
cddf391b 2444
d62a17ae 2445 /* Make it sure prefixlen is applied to the prefix. */
2446 apply_mask(p);
2447 if (src_p)
2448 apply_mask_ipv6(src_p);
718e3744 2449
d62a17ae 2450 /* Set default distance by route type. */
2451 if (re->distance == 0) {
0492eea0 2452 re->distance = route_distance(re->type);
718e3744 2453
d62a17ae 2454 /* iBGP distance is 200. */
2455 if (re->type == ZEBRA_ROUTE_BGP
2456 && CHECK_FLAG(re->flags, ZEBRA_FLAG_IBGP))
2457 re->distance = 200;
2458 }
718e3744 2459
d62a17ae 2460 /* Lookup route node.*/
2461 rn = srcdest_rnode_get(table, p, src_p);
718e3744 2462
40ecd8e4
DS		 2463 /*
2464 * If same type of route are installed, treat it as a implicit
2465 * withdraw.
2466 * If the user has specified the No route replace semantics
2467 * for the install don't do a route replace.
2468 */
a2addae8 2469 RNODE_FOREACH_RE (rn, same) {
d62a17ae 2470 if (CHECK_FLAG(same->status, ROUTE_ENTRY_REMOVED))
2471 continue;
41ec9222 2472
eb327fa5
RW		 2473 if (same->type != re->type)
2474 continue;
2475 if (same->instance != re->instance)
2476 continue;
996c9314
LB		 2477 if (same->type == ZEBRA_ROUTE_KERNEL
2478 && same->metric != re->metric)
eb327fa5 2479 continue;
40ecd8e4
DS		 2480
2481 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_RR_USE_DISTANCE) &&
2482 same->distance != re->distance)
2483 continue;
2484
844b3a87 2485 /*
40ecd8e4
DS		 2486 * We should allow duplicate connected routes
2487 * because of IPv6 link-local routes and unnumbered
2488 * interfaces on Linux.
844b3a87
RW		 2489 */
2490 if (same->type != ZEBRA_ROUTE_CONNECT)
d62a17ae 2491 break;
2492 }
718e3744 2493
d62a17ae 2494 /* If this route is kernel route, set FIB flag to the route. */
8628fc61 2495 if (RIB_SYSTEM_ROUTE(re))
7ee30f28 2496 for (nexthop = re->ng.nexthop; nexthop; nexthop = nexthop->next)
d62a17ae 2497 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
718e3744 2498
d62a17ae 2499 /* Link new re to node.*/
2500 if (IS_ZEBRA_DEBUG_RIB) {
2501 rnode_debug(
2502 rn, re->vrf_id,
2503 "Inserting route rn %p, re %p (type %d) existing %p",
2504 (void *)rn, (void *)re, re->type, (void *)same);
718e3744 2505
d62a17ae 2506 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
2507 route_entry_dump(p, src_p, re);
718e3744 2508 }
d62a17ae 2509 rib_addnode(rn, re, 1);
2510 ret = 1;
6b0655a2 2511
d62a17ae 2512 /* Free implicit route.*/
2513 if (same) {
2514 rib_delnode(rn, same);
2515 ret = -1;
2516 }
718e3744 2517
d62a17ae 2518 route_unlock_node(rn);
2519 return ret;
2520}
2521
2522void rib_delete(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
d7c0a89a 2523 unsigned short instance, int flags, struct prefix *p,
fd36be7e 2524 struct prefix_ipv6 *src_p, const struct nexthop *nh,
40ecd8e4
DS		 2525 uint32_t table_id, uint32_t metric, uint8_t distance,
2526 bool fromkernel)
d62a17ae 2527{
2528 struct route_table *table;
2529 struct route_node *rn;
2530 struct route_entry *re;
2531 struct route_entry *fib = NULL;
2532 struct route_entry *same = NULL;
fd36be7e 2533 struct nexthop *rtnh;
d62a17ae 2534 char buf2[INET6_ADDRSTRLEN];
5f7a4718 2535 rib_dest_t *dest;
d62a17ae 2536
1f610a1f 2537 assert(!src_p || !src_p->prefixlen || afi == AFI_IP6);
d62a17ae 2538
2539 /* Lookup table. */
2540 table = zebra_vrf_table_with_table_id(afi, safi, vrf_id, table_id);
2541 if (!table)
2542 return;
2543
2544 /* Apply mask. */
2545 apply_mask(p);
2546 if (src_p)
2547 apply_mask_ipv6(src_p);
2548
2549 /* Lookup route node. */
2550 rn = srcdest_rnode_lookup(table, p, src_p);
2551 if (!rn) {
2552 char dst_buf[PREFIX_STRLEN], src_buf[PREFIX_STRLEN];
2553
2554 prefix2str(p, dst_buf, sizeof(dst_buf));
2555 if (src_p && src_p->prefixlen)
2556 prefix2str(src_p, src_buf, sizeof(src_buf));
2557 else
2558 src_buf[0] = '\0';
2559
2560 if (IS_ZEBRA_DEBUG_RIB)
2561 zlog_debug("%u:%s%s%s doesn't exist in rib", vrf_id,
2562 dst_buf,
2563 (src_buf[0] != '\0') ? " from " : "",
2564 src_buf);
2565 return;
2566 }
718e3744 2567
5f7a4718
DS		 2568 dest = rib_dest_from_rnode(rn);
2569 fib = dest->selected_fib;
2570
d62a17ae 2571 /* Lookup same type route. */
a2addae8 2572 RNODE_FOREACH_RE (rn, re) {
d62a17ae 2573 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
2574 continue;
2575
d62a17ae 2576 if (re->type != type)
2577 continue;
2578 if (re->instance != instance)
2579 continue;
40ecd8e4
DS		 2580 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_RR_USE_DISTANCE) &&
2581 distance != re->distance)
2582 continue;
2583
996c9314 2584 if (re->type == ZEBRA_ROUTE_KERNEL && re->metric != metric)
f19435a8 2585 continue;
7ee30f28 2586 if (re->type == ZEBRA_ROUTE_CONNECT && (rtnh = re->ng.nexthop)
fd36be7e
DL		 2587 && rtnh->type == NEXTHOP_TYPE_IFINDEX && nh) {
2588 if (rtnh->ifindex != nh->ifindex)
d62a17ae 2589 continue;
d62a17ae 2590 same = re;
2591 break;
2592 }
2593 /* Make sure that the route found has the same gateway. */
2594 else {
fd36be7e 2595 if (nh == NULL) {
d62a17ae 2596 same = re;
2597 break;
2598 }
7ee30f28 2599 for (ALL_NEXTHOPS(re->ng, rtnh))
fd36be7e 2600 if (nexthop_same_no_recurse(rtnh, nh)) {
d62a17ae 2601 same = re;
2602 break;
2603 }
2604 if (same)
2605 break;
2606 }
2607 }
2608 /* If same type of route can't be found and this message is from
2609 kernel. */
2610 if (!same) {
5dfeba19
DS		 2611 /*
2612 * In the past(HA!) we could get here because
2613 * we were receiving a route delete from the
2614 * kernel and we're not marking the proto
2615 * as coming from it's appropriate originator.
2616 * Now that we are properly noticing the fact
2617 * that the kernel has deleted our route we
2618 * are not going to get called in this path
2619 * I am going to leave this here because
2620 * this might still work this way on non-linux
2621 * platforms as well as some weird state I have
2622 * not properly thought of yet.
2623 * If we can show that this code path is
2624 * dead then we can remove it.
2625 */
b8faa875 2626 if (fib && CHECK_FLAG(flags, ZEBRA_FLAG_SELFROUTE)) {
d62a17ae 2627 if (IS_ZEBRA_DEBUG_RIB) {
2628 rnode_debug(
2629 rn, vrf_id,
2630 "rn %p, re %p (type %d) was deleted from kernel, adding",
2631 rn, fib, fib->type);
2632 }
2633 if (allow_delete) {
2634 /* Unset flags. */
7ee30f28 2635 for (rtnh = fib->ng.nexthop; rtnh;
fd36be7e
DL		 2636 rtnh = rtnh->next)
2637 UNSET_FLAG(rtnh->flags,
d62a17ae 2638 NEXTHOP_FLAG_FIB);
2639
ed216282
DS		 2640 /*
2641 * This is a non FRR route
2642 * as such we should mark
2643 * it as deleted
2644 */
5f7a4718 2645 dest->selected_fib = NULL;
d62a17ae 2646 } else {
2647 /* This means someone else, other than Zebra,
2648 * has deleted
2649 * a Zebra router from the kernel. We will add
2650 * it back */
2651 rib_install_kernel(rn, fib, NULL);
2652 }
2653 } else {
2654 if (IS_ZEBRA_DEBUG_RIB) {
fd36be7e 2655 if (nh)
d62a17ae 2656 rnode_debug(
2657 rn, vrf_id,
2658 "via %s ifindex %d type %d "
2659 "doesn't exist in rib",
36228974 2660 inet_ntop(afi2family(afi),
2661 &nh->gate, buf2,
2662 sizeof(buf2)),
2663 nh->ifindex, type);
d62a17ae 2664 else
2665 rnode_debug(
2666 rn, vrf_id,
fd36be7e
DL		 2667 "type %d doesn't exist in rib",
2668 type);
d62a17ae 2669 }
2670 route_unlock_node(rn);
2671 return;
2672 }
2673 }
718e3744 2674
5dfeba19 2675 if (same) {
996c9314
LB		 2676 if (fromkernel && CHECK_FLAG(flags, ZEBRA_FLAG_SELFROUTE)
2677 && !allow_delete) {
5dfeba19
DS		 2678 rib_install_kernel(rn, same, NULL);
2679 route_unlock_node(rn);
2680
2681 return;
2682 }
6134fd82 2683
90264d64 2684 if (CHECK_FLAG(flags, ZEBRA_FLAG_EVPN_ROUTE)) {
6134fd82 2685 struct nexthop *tmp_nh;
2686
7ee30f28 2687 for (ALL_NEXTHOPS(re->ng, tmp_nh)) {
6134fd82 2688 struct ipaddr vtep_ip;
2689
2690 memset(&vtep_ip, 0, sizeof(struct ipaddr));
1ec31309 2691 if (afi == AFI_IP) {
2692 vtep_ip.ipa_type = IPADDR_V4;
2693 memcpy(&(vtep_ip.ipaddr_v4),
2694 &(tmp_nh->gate.ipv4),
2695 sizeof(struct in_addr));
2696 } else {
2697 vtep_ip.ipa_type = IPADDR_V6;
2698 memcpy(&(vtep_ip.ipaddr_v6),
2699 &(tmp_nh->gate.ipv6),
2700 sizeof(struct in6_addr));
2701 }
a317a9b9 2702 zebra_vxlan_evpn_vrf_route_del(re->vrf_id,
6134fd82 2703 &vtep_ip, p);
2704 }
2705 }
d62a17ae 2706 rib_delnode(rn, same);
5dfeba19 2707 }
05737783 2708
d62a17ae 2709 route_unlock_node(rn);
2710 return;
2711}
718e3744 2712
718e3744 2713
d7c0a89a
QY		 2714int rib_add(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
2715 unsigned short instance, int flags, struct prefix *p,
2716 struct prefix_ipv6 *src_p, const struct nexthop *nh,
2717 uint32_t table_id, uint32_t metric, uint32_t mtu, uint8_t distance,
2718 route_tag_t tag)
d62a17ae 2719{
2720 struct route_entry *re;
66af6845 2721 struct nexthop *nexthop;
718e3744 2722
66af6845 2723 /* Allocate new route_entry structure. */
d62a17ae 2724 re = XCALLOC(MTYPE_RE, sizeof(struct route_entry));
d62a17ae 2725 re->type = type;
2726 re->instance = instance;
2727 re->distance = distance;
2728 re->flags = flags;
2729 re->metric = metric;
2730 re->mtu = mtu;
2731 re->table = table_id;
2732 re->vrf_id = vrf_id;
2733 re->nexthop_num = 0;
2734 re->uptime = time(NULL);
4e40b6d6 2735 re->tag = tag;
d62a17ae 2736
66af6845
RW		 2737 /* Add nexthop. */
2738 nexthop = nexthop_new();
2739 *nexthop = *nh;
2740 route_entry_nexthop_add(re, nexthop);
718e3744 2741
66af6845 2742 return rib_add_multipath(afi, safi, p, src_p, re);
718e3744 2743}
2744
1c848137 2745/* Schedule routes of a particular table (address-family) based on event. */
d5b8c216 2746void rib_update_table(struct route_table *table, rib_update_event_t event)
d62a17ae 2747{
2748 struct route_node *rn;
2749 struct route_entry *re, *next;
2750
2751 /* Walk all routes and queue for processing, if appropriate for
2752 * the trigger event.
2753 */
2754 for (rn = route_top(table); rn; rn = srcdest_route_next(rn)) {
1ca60f2c
DS		 2755 /*
2756 * If we are looking at a route node and the node
2757 * has already been queued we don't
2758 * need to queue it up again
2759 */
996c9314
LB		 2760 if (rn->info && CHECK_FLAG(rib_dest_from_rnode(rn)->flags,
2761 RIB_ROUTE_ANY_QUEUED))
1ca60f2c 2762 continue;
d62a17ae 2763 switch (event) {
2764 case RIB_UPDATE_IF_CHANGE:
2765 /* Examine all routes that won't get processed by the
2766 * protocol or
2767 * triggered by nexthop evaluation (NHT). This would be
2768 * system,
2769 * kernel and certain static routes. Note that NHT will
2770 * get
2771 * triggered upon an interface event as connected routes
2772 * always
2773 * get queued for processing.
2774 */
a2addae8 2775 RNODE_FOREACH_RE_SAFE (rn, re, next) {
0a16efff
DS		 2776 struct nexthop *nh;
2777
996c9314
LB		 2778 if (re->type != ZEBRA_ROUTE_SYSTEM
2779 && re->type != ZEBRA_ROUTE_KERNEL
2780 && re->type != ZEBRA_ROUTE_CONNECT
2781 && re->type != ZEBRA_ROUTE_STATIC)
0a16efff
DS		 2782 continue;
2783
2784 if (re->type != ZEBRA_ROUTE_STATIC) {
2785 rib_queue_add(rn);
2786 continue;
2787 }
2788
7ee30f28 2789 for (nh = re->ng.nexthop; nh; nh = nh->next)
0a16efff
DS		 2790 if (!(nh->type == NEXTHOP_TYPE_IPV4
2791 || nh->type == NEXTHOP_TYPE_IPV6))
2792 break;
2793
2794 /* If we only have nexthops to a
2795 * gateway, NHT will
2796 * take care.
2797 */
2798 if (nh)
d62a17ae 2799 rib_queue_add(rn);
2800 }
2801 break;
2802
2803 case RIB_UPDATE_RMAP_CHANGE:
2804 case RIB_UPDATE_OTHER:
2805 /* Right now, examine all routes. Can restrict to a
2806 * protocol in
2807 * some cases (TODO).
2808 */
2809 if (rnode_to_ribs(rn))
2810 rib_queue_add(rn);
2811 break;
2812
2813 default:
2814 break;
2815 }
2816 }
b84c7253 2817}
2818
718e3744 2819/* RIB update function. */
d62a17ae 2820void rib_update(vrf_id_t vrf_id, rib_update_event_t event)
718e3744 2821{
d62a17ae 2822 struct route_table *table;
1c848137 2823
d62a17ae 2824 /* Process routes of interested address-families. */
2825 table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id);
d5b8c216 2826 if (table) {
2827 if (IS_ZEBRA_DEBUG_EVENT)
2828 zlog_debug("%s : AFI_IP event %d", __func__, event);
d62a17ae 2829 rib_update_table(table, event);
d5b8c216 2830 }
718e3744 2831
d62a17ae 2832 table = zebra_vrf_table(AFI_IP6, SAFI_UNICAST, vrf_id);
d5b8c216 2833 if (table) {
2834 if (IS_ZEBRA_DEBUG_EVENT)
2835 zlog_debug("%s : AFI_IP6 event %d", __func__, event);
d62a17ae 2836 rib_update_table(table, event);
d5b8c216 2837 }
718e3744 2838}
2839
718e3744 2840/* Delete self installed routes after zebra is relaunched. */
95a29032 2841void rib_sweep_table(struct route_table *table)
d62a17ae 2842{
2843 struct route_node *rn;
2844 struct route_entry *re;
2845 struct route_entry *next;
915902cb 2846 struct nexthop *nexthop;
d62a17ae 2847
915902cb
DS		 2848 if (!table)
2849 return;
d62a17ae 2850
915902cb 2851 for (rn = route_top(table); rn; rn = srcdest_route_next(rn)) {
a2addae8 2852 RNODE_FOREACH_RE_SAFE (rn, re, next) {
915902cb
DS		 2853 if (IS_ZEBRA_DEBUG_RIB)
2854 route_entry_dump(&rn->p, NULL, re);
2855
2856 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
2857 continue;
2858
2859 if (!CHECK_FLAG(re->flags, ZEBRA_FLAG_SELFROUTE))
2860 continue;
2861
2862 /*
2863 * So we are starting up and have received
2864 * routes from the kernel that we have installed
2865 * from a previous run of zebra but not cleaned
2866 * up ( say a kill -9 )
2867 * But since we haven't actually installed
2868 * them yet( we received them from the kernel )
2869 * we don't think they are active.
2870 * So let's pretend they are active to actually
2871 * remove them.
2872 * In all honesty I'm not sure if we should
2873 * mark them as active when we receive them
2874 * This is startup only so probably ok.
2875 *
2876 * If we ever decide to move rib_sweep_table
2877 * to a different spot (ie startup )
2878 * this decision needs to be revisited
2879 */
7ee30f28 2880 for (ALL_NEXTHOPS(re->ng, nexthop))
915902cb
DS		 2881 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
2882
0c555cc6
DS		 2883 rib_uninstall_kernel(rn, re);
2884 rib_delnode(rn, re);
915902cb
DS		 2885 }
2886 }
718e3744 2887}
2888
2889/* Sweep all RIB tables. */
d62a17ae 2890void rib_sweep_route(void)
718e3744 2891{
d62a17ae 2892 struct vrf *vrf;
2893 struct zebra_vrf *zvrf;
78104b9b 2894
a2addae8 2895 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
915902cb
DS		 2896 if ((zvrf = vrf->info) == NULL)
2897 continue;
2898
d62a17ae 2899 rib_sweep_table(zvrf->table[AFI_IP][SAFI_UNICAST]);
2900 rib_sweep_table(zvrf->table[AFI_IP6][SAFI_UNICAST]);
2901 }
95a29032
DS		 2902
2903 zebra_ns_sweep_route();
718e3744 2904}
2ea1ab1c
VT		 2905
2906/* Remove specific by protocol routes from 'table'. */
d7c0a89a 2907unsigned long rib_score_proto_table(uint8_t proto, unsigned short instance,
47a08aa9 2908 struct route_table *table)
d62a17ae 2909{
2910 struct route_node *rn;
2911 struct route_entry *re;
2912 struct route_entry *next;
2913 unsigned long n = 0;
2914
2915 if (table)
2916 for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
a2addae8 2917 RNODE_FOREACH_RE_SAFE (rn, re, next) {
d62a17ae 2918 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
2919 continue;
2920 if (re->type == proto
2921 && re->instance == instance) {
2922 rib_delnode(rn, re);
2923 n++;
2924 }
2925 }
2926 return n;
2ea1ab1c
VT		 2927}
2928
2929/* Remove specific by protocol routes. */
d7c0a89a 2930unsigned long rib_score_proto(uint8_t proto, unsigned short instance)
2ea1ab1c 2931{
d62a17ae 2932 struct vrf *vrf;
2933 struct zebra_vrf *zvrf;
2934 unsigned long cnt = 0;
78104b9b 2935
a2addae8
RW		 2936 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)
2937 if ((zvrf = vrf->info) != NULL)
2938 cnt += rib_score_proto_table(
2939 proto, instance,
2940 zvrf->table[AFI_IP][SAFI_UNICAST])
2941 + rib_score_proto_table(
2942 proto, instance,
2943 zvrf->table[AFI_IP6][SAFI_UNICAST]);
78104b9b 2944
47a08aa9
DS		 2945 cnt += zebra_ns_score_proto(proto, instance);
2946
d62a17ae 2947 return cnt;
2ea1ab1c
VT		 2948}
2949
718e3744 2950/* Close RIB and clean up kernel routes. */
d62a17ae 2951void rib_close_table(struct route_table *table)
718e3744 2952{
d62a17ae 2953 struct route_node *rn;
1e9f448f 2954 rib_table_info_t *info;
5f7a4718 2955 rib_dest_t *dest;
718e3744 2956
1e9f448f
DS		 2957 if (!table)
2958 return;
9fd92e3c 2959
6ca30e9e 2960 info = route_table_get_info(table);
5adc2528 2961
5f7a4718
DS		 2962 for (rn = route_top(table); rn; rn = srcdest_route_next(rn)) {
2963 dest = rib_dest_from_rnode(rn);
1e9f448f 2964
5f7a4718 2965 if (dest && dest->selected_fib) {
1e9f448f
DS		 2966 if (info->safi == SAFI_UNICAST)
2967 hook_call(rib_update, rn, NULL);
2968
5f7a4718
DS		 2969 if (!RIB_SYSTEM_ROUTE(dest->selected_fib))
2970 rib_uninstall_kernel(rn, dest->selected_fib);
1e9f448f 2971 }
5f7a4718 2972 }
718e3744 2973}
2974
718e3744 2975/* Routing information base initialize. */
d62a17ae 2976void rib_init(void)
718e3744 2977{
d62a17ae 2978 rib_queue_init(&zebrad);
718e3744 2979}
0915bb0c
AS		 2980
2981/*
2982 * vrf_id_get_next
2983 *
2984 * Get the first vrf id that is greater than the given vrf id if any.
2985 *
2986 * Returns TRUE if a vrf id was found, FALSE otherwise.
2987 */
d62a17ae 2988static inline int vrf_id_get_next(vrf_id_t vrf_id, vrf_id_t *next_id_p)
0915bb0c 2989{
d62a17ae 2990 struct vrf *vrf;
b72ede27 2991
d62a17ae 2992 vrf = vrf_lookup_by_id(vrf_id);
2993 if (vrf) {
2994 vrf = RB_NEXT(vrf_id_head, vrf);
2995 if (vrf) {
2996 *next_id_p = vrf->vrf_id;
2997 return 1;
2998 }
2999 }
0915bb0c 3000
d62a17ae 3001 return 0;
0915bb0c
AS		 3002}
3003
3004/*
3005 * rib_tables_iter_next
3006 *
3007 * Returns the next table in the iteration.
3008 */
d62a17ae 3009struct route_table *rib_tables_iter_next(rib_tables_iter_t *iter)
3010{
3011 struct route_table *table;
3012
3013 /*
3014 * Array that helps us go over all AFI/SAFI combinations via one
3015 * index.
3016 */
3017 static struct {
3018 afi_t afi;
3019 safi_t safi;
3020 } afi_safis[] = {
3021 {AFI_IP, SAFI_UNICAST}, {AFI_IP, SAFI_MULTICAST},
3022 {AFI_IP, SAFI_LABELED_UNICAST}, {AFI_IP6, SAFI_UNICAST},
3023 {AFI_IP6, SAFI_MULTICAST}, {AFI_IP6, SAFI_LABELED_UNICAST},
3024 };
3025
3026 table = NULL;
3027
3028 switch (iter->state) {
3029
3030 case RIB_TABLES_ITER_S_INIT:
3031 iter->vrf_id = VRF_DEFAULT;
3032 iter->afi_safi_ix = -1;
3033
3034 /* Fall through */
3035
3036 case RIB_TABLES_ITER_S_ITERATING:
3037 iter->afi_safi_ix++;
3038 while (1) {
3039
3040 while (iter->afi_safi_ix
3041 < (int)ZEBRA_NUM_OF(afi_safis)) {
3042 table = zebra_vrf_table(
3043 afi_safis[iter->afi_safi_ix].afi,
3044 afi_safis[iter->afi_safi_ix].safi,
3045 iter->vrf_id);
3046 if (table)
3047 break;
3048
3049 iter->afi_safi_ix++;
3050 }
3051
3052 /*
3053 * Found another table in this vrf.
3054 */
3055 if (table)
3056 break;
3057
3058 /*
3059 * Done with all tables in the current vrf, go to the
3060 * next
3061 * one.
3062 */
3063 if (!vrf_id_get_next(iter->vrf_id, &iter->vrf_id))
3064 break;
3065
3066 iter->afi_safi_ix = 0;
3067 }
0915bb0c 3068
0915bb0c
AS		 3069 break;
3070
d62a17ae 3071 case RIB_TABLES_ITER_S_DONE:
3072 return NULL;
0915bb0c
AS		 3073 }
3074
d62a17ae 3075 if (table)
3076 iter->state = RIB_TABLES_ITER_S_ITERATING;
3077 else
3078 iter->state = RIB_TABLES_ITER_S_DONE;
0915bb0c 3079
d62a17ae 3080 return table;
0915bb0c 3081}
FRRouting mirror