]> git.proxmox.com Git - mirror_frr.git/blame - bgpd/bgp_zebra.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lib: add label_type as field in zapi_nexthop
[mirror_frr.git] / bgpd / bgp_zebra.c
CommitLineData
718e3744 1/* zebra client
896014f4
DL		 2 * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
718e3744 20
21#include <zebra.h>
22
23#include "command.h"
24#include "stream.h"
25#include "network.h"
26#include "prefix.h"
27#include "log.h"
28#include "sockunion.h"
29#include "zclient.h"
30#include "routemap.h"
31#include "thread.h"
3f9c7369 32#include "queue.h"
6e919709 33#include "memory.h"
856ca177 34#include "lib/json.h"
2376c3f2 35#include "lib/bfd.h"
94effaf0 36#include "lib/route_opaque.h"
039f3a34 37#include "filter.h"
cd1964ff 38#include "mpls.h"
128ea8ab 39#include "vxlan.h"
6cfe5d15 40#include "pbr.h"
718e3744 41
42#include "bgpd/bgpd.h"
43#include "bgpd/bgp_route.h"
44#include "bgpd/bgp_attr.h"
e46723a5 45#include "bgpd/bgp_aspath.h"
718e3744 46#include "bgpd/bgp_nexthop.h"
47#include "bgpd/bgp_zebra.h"
48#include "bgpd/bgp_fsm.h"
a39275d7 49#include "bgpd/bgp_debug.h"
14454c9f 50#include "bgpd/bgp_errors.h"
8196f13d 51#include "bgpd/bgp_mpath.h"
fb018d25 52#include "bgpd/bgp_nexthop.h"
ffd0c037 53#include "bgpd/bgp_nht.h"
8c4f6381 54#include "bgpd/bgp_bfd.h"
cd1964ff 55#include "bgpd/bgp_label.h"
49e5a4a0 56#ifdef ENABLE_BGP_VNC
d62a17ae 57#include "bgpd/rfapi/rfapi_backend.h"
58#include "bgpd/rfapi/vnc_export_bgp.h"
65efcfce 59#endif
128ea8ab 60#include "bgpd/bgp_evpn.h"
ddb5b488 61#include "bgpd/bgp_mplsvpn.h"
955bfd98 62#include "bgpd/bgp_labelpool.h"
30d50e6d 63#include "bgpd/bgp_pbr.h"
0b9d9cd0 64#include "bgpd/bgp_evpn_private.h"
c44ab6f1 65#include "bgpd/bgp_evpn_mh.h"
6a69ac51 66#include "bgpd/bgp_mac.h"
a383bfc7 67#include "bgpd/bgp_trace.h"
959331a3
RW		 68#include "bgpd/bgp_community.h"
69#include "bgpd/bgp_lcommunity.h"
6b0655a2 70
718e3744 71/* All information about zebra. */
228da428 72struct zclient *zclient = NULL;
718e3744 73
0d020cd6
PR		 74/* hook to indicate vrf status change for SNMP */
75DEFINE_HOOK(bgp_vrf_status_changed, (struct bgp *bgp, struct interface *ifp),
8451921b 76 (bgp, ifp));
0d020cd6 77
4cd690ae
PG		 78DEFINE_MTYPE_STATIC(BGPD, BGP_IF_INFO, "BGP interface context");
79
ad4cbda1 80/* Can we install into zebra? */
3dc339cd 81static inline bool bgp_install_info_to_zebra(struct bgp *bgp)
ad4cbda1 82{
d62a17ae 83 if (zclient->sock <= 0)
3dc339cd 84 return false;
ad4cbda1 85
bb4ef1ae 86 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) {
15569c58
DA		 87 zlog_debug(
88 "%s: No zebra instance to talk to, not installing information",
89 __func__);
3dc339cd 90 return false;
bb4ef1ae 91 }
ad4cbda1 92
3dc339cd 93 return true;
ad4cbda1 94}
95
afbb1c59
LB		 96int zclient_num_connects;
97
18a6dce6 98/* Router-id update message from zebra. */
121f9dee 99static int bgp_router_id_update(ZAPI_CALLBACK_ARGS)
718e3744 100{
d62a17ae 101 struct prefix router_id;
718e3744 102
d62a17ae 103 zebra_router_id_update_read(zclient->ibuf, &router_id);
a39275d7 104
2dbe669b
DA		 105 if (BGP_DEBUG(zebra, ZEBRA))
106 zlog_debug("Rx Router Id update VRF %u Id %pFX", vrf_id,
107 &router_id);
a39275d7 108
d62a17ae 109 bgp_router_id_zebra_bump(vrf_id, &router_id);
110 return 0;
718e3744 111}
112
fb018d25 113/* Nexthop update message from zebra. */
121f9dee 114static int bgp_read_nexthop_update(ZAPI_CALLBACK_ARGS)
fb018d25 115{
121f9dee 116 bgp_parse_nexthop_update(cmd, vrf_id);
d62a17ae 117 return 0;
078430f6
DS		 118}
119
4a04e5f7 120/* Set or clear interface on which unnumbered neighbor is configured. This
121 * would in turn cause BGP to initiate or turn off IPv6 RAs on this
122 * interface.
123 */
d62a17ae 124static void bgp_update_interface_nbrs(struct bgp *bgp, struct interface *ifp,
125 struct interface *upd_ifp)
4a04e5f7 126{
d62a17ae 127 struct listnode *node, *nnode;
128 struct peer *peer;
129
130 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
131 if (peer->conf_if && (strcmp(peer->conf_if, ifp->name) == 0)) {
132 if (upd_ifp) {
133 peer->ifp = upd_ifp;
134 bgp_zebra_initiate_radv(bgp, peer);
135 } else {
136 bgp_zebra_terminate_radv(bgp, peer);
137 peer->ifp = upd_ifp;
138 }
139 }
140 }
4a04e5f7 141}
142
a243d1db 143static int bgp_read_fec_update(ZAPI_CALLBACK_ARGS)
cd1964ff 144{
d62a17ae 145 bgp_parse_fec_update();
146 return 0;
cd1964ff
DS		 147}
148
d62a17ae 149static void bgp_start_interface_nbrs(struct bgp *bgp, struct interface *ifp)
a80beece 150{
d62a17ae 151 struct listnode *node, *nnode;
152 struct peer *peer;
153
154 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
155 if (peer->conf_if && (strcmp(peer->conf_if, ifp->name) == 0)
feb17238 156 && !peer_established(peer)) {
d62a17ae 157 if (peer_active(peer))
158 BGP_EVENT_ADD(peer, BGP_Stop);
159 BGP_EVENT_ADD(peer, BGP_Start);
160 }
161 }
a80beece
DS		 162}
163
d62a17ae 164static void bgp_nbr_connected_add(struct bgp *bgp, struct nbr_connected *ifc)
a197c47c 165{
d62a17ae 166 struct listnode *node;
167 struct connected *connected;
168 struct interface *ifp;
169 struct prefix *p;
170
171 /* Kick-off the FSM for any relevant peers only if there is a
172 * valid local address on the interface.
173 */
174 ifp = ifc->ifp;
175 for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, connected)) {
176 p = connected->address;
177 if (p->family == AF_INET6
178 && IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
179 break;
180 }
181 if (!connected)
182 return;
183
184 bgp_start_interface_nbrs(bgp, ifp);
a197c47c
DS		 185}
186
d62a17ae 187static void bgp_nbr_connected_delete(struct bgp *bgp, struct nbr_connected *ifc,
188 int del)
a80beece 189{
d62a17ae 190 struct listnode *node, *nnode;
191 struct peer *peer;
192 struct interface *ifp;
193
194 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
195 if (peer->conf_if
196 && (strcmp(peer->conf_if, ifc->ifp->name) == 0)) {
197 peer->last_reset = PEER_DOWN_NBR_ADDR_DEL;
198 BGP_EVENT_ADD(peer, BGP_Stop);
199 }
200 }
201 /* Free neighbor also, if we're asked to. */
202 if (del) {
203 ifp = ifc->ifp;
204 listnode_delete(ifp->nbr_connected, ifc);
205 nbr_connected_free(ifc);
206 }
a80beece
DS		 207}
208
3c3c3252 209static int bgp_ifp_destroy(struct interface *ifp)
718e3744 210{
d62a17ae 211 struct bgp *bgp;
718e3744 212
096f7609 213 bgp = ifp->vrf->info;
a4499b83 214
d62a17ae 215 if (BGP_DEBUG(zebra, ZEBRA))
096f7609
IR		 216 zlog_debug("Rx Intf del VRF %u IF %s", ifp->vrf->vrf_id,
217 ifp->name);
a39275d7 218
0d020cd6 219 if (bgp) {
85751d1d 220 bgp_update_interface_nbrs(bgp, ifp, NULL);
0d020cd6
PR		 221 hook_call(bgp_vrf_status_changed, bgp, ifp);
222 }
64745052 223
6a69ac51
DS		 224 bgp_mac_del_mac_entry(ifp);
225
d62a17ae 226 return 0;
718e3744 227}
228
ddbf3e60 229static int bgp_ifp_up(struct interface *ifp)
718e3744 230{
d62a17ae 231 struct connected *c;
232 struct nbr_connected *nc;
233 struct listnode *node, *nnode;
234 struct bgp *bgp;
6aeb9e78 235
096f7609 236 bgp = ifp->vrf->info;
718e3744 237
6a69ac51
DS		 238 bgp_mac_add_mac_entry(ifp);
239
d62a17ae 240 if (BGP_DEBUG(zebra, ZEBRA))
096f7609
IR		 241 zlog_debug("Rx Intf up VRF %u IF %s", ifp->vrf->vrf_id,
242 ifp->name);
ad4cbda1 243
85751d1d
DS		 244 if (!bgp)
245 return 0;
246
d62a17ae 247 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, c))
248 bgp_connected_add(bgp, c);
718e3744 249
d62a17ae 250 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, node, nnode, nc))
251 bgp_nbr_connected_add(bgp, nc);
a80beece 252
0d020cd6 253 hook_call(bgp_vrf_status_changed, bgp, ifp);
8761cd6d
DS		 254 bgp_nht_ifp_up(ifp);
255
d62a17ae 256 return 0;
718e3744 257}
258
b0b69e59 259static int bgp_ifp_down(struct interface *ifp)
718e3744 260{
d62a17ae 261 struct connected *c;
262 struct nbr_connected *nc;
263 struct listnode *node, *nnode;
264 struct bgp *bgp;
c19fe3c7 265 struct peer *peer;
6aeb9e78 266
096f7609 267 bgp = ifp->vrf->info;
718e3744 268
6a69ac51
DS		 269 bgp_mac_del_mac_entry(ifp);
270
d62a17ae 271 if (BGP_DEBUG(zebra, ZEBRA))
096f7609
IR		 272 zlog_debug("Rx Intf down VRF %u IF %s", ifp->vrf->vrf_id,
273 ifp->name);
ad4cbda1 274
85751d1d
DS		 275 if (!bgp)
276 return 0;
277
d62a17ae 278 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, c))
279 bgp_connected_delete(bgp, c);
718e3744 280
d62a17ae 281 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, node, nnode, nc))
282 bgp_nbr_connected_delete(bgp, nc, 1);
a80beece 283
d62a17ae 284 /* Fast external-failover */
c19fe3c7 285 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER)) {
718e3744 286
d62a17ae 287 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
50bd8995 288 /* Take down directly connected peers. */
c8d6f0d6 289 if ((peer->ttl != BGP_DEFAULT_TTL)
e2521429 290 && (peer->gtsm_hops != BGP_GTSM_HOPS_CONNECTED))
d62a17ae 291 continue;
718e3744 292
d62a17ae 293 if (ifp == peer->nexthop.ifp) {
294 BGP_EVENT_ADD(peer, BGP_Stop);
295 peer->last_reset = PEER_DOWN_IF_DOWN;
296 }
297 }
298 }
718e3744 299
0d020cd6 300 hook_call(bgp_vrf_status_changed, bgp, ifp);
8761cd6d
DS		 301 bgp_nht_ifp_down(ifp);
302
d62a17ae 303 return 0;
718e3744 304}
305
121f9dee 306static int bgp_interface_address_add(ZAPI_CALLBACK_ARGS)
718e3744 307{
d62a17ae 308 struct connected *ifc;
2f9123e0 309 struct bgp *bgp;
bc6d1b15
P		 310 struct peer *peer;
311 struct prefix *addr;
312 struct listnode *node, *nnode;
313 afi_t afi;
314 safi_t safi;
2f9123e0
DS		 315
316 bgp = bgp_lookup_by_vrf_id(vrf_id);
d62a17ae 317
121f9dee 318 ifc = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
d62a17ae 319
320 if (ifc == NULL)
321 return 0;
322
2dbe669b
DA		 323 if (bgp_debug_zebra(ifc->address))
324 zlog_debug("Rx Intf address add VRF %u IF %s addr %pFX", vrf_id,
325 ifc->ifp->name, ifc->address);
d62a17ae 326
85751d1d
DS		 327 if (!bgp)
328 return 0;
329
d62a17ae 330 if (if_is_operative(ifc->ifp)) {
d62a17ae 331 bgp_connected_add(bgp, ifc);
2f9123e0 332
d62a17ae 333 /* If we have learnt of any neighbors on this interface,
334 * check to kick off any BGP interface-based neighbors,
335 * but only if this is a link-local address.
336 */
337 if (IN6_IS_ADDR_LINKLOCAL(&ifc->address->u.prefix6)
338 && !list_isempty(ifc->ifp->nbr_connected))
339 bgp_start_interface_nbrs(bgp, ifc->ifp);
bc6d1b15
P		 340 else {
341 addr = ifc->address;
342
343 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
344 if (addr->family == AF_INET)
345 continue;
346
347 /*
348 * If the Peer's interface name matches the
349 * interface name for which BGP received the
350 * update and if the received interface address
351 * is a globalV6 and if the peer is currently
352 * using a v4-mapped-v6 addr or a link local
353 * address, then copy the Rxed global v6 addr
354 * into peer's v6_global and send updates out
355 * with new nexthop addr.
356 */
357 if ((peer->conf_if &&
358 (strcmp(peer->conf_if, ifc->ifp->name) ==
359 0)) &&
360 !IN6_IS_ADDR_LINKLOCAL(&addr->u.prefix6) &&
361 ((IS_MAPPED_IPV6(
362 &peer->nexthop.v6_global)) ||
363 IN6_IS_ADDR_LINKLOCAL(
364 &peer->nexthop.v6_global))) {
365
366 if (bgp_debug_zebra(ifc->address)) {
367 zlog_debug(
368 "Update peer %pBP's current intf addr %pI6 and send updates",
369 peer,
370 &peer->nexthop
371 .v6_global);
372 }
373 memcpy(&peer->nexthop.v6_global,
374 &addr->u.prefix6,
375 IPV6_MAX_BYTELEN);
376 FOREACH_AFI_SAFI (afi, safi)
377 bgp_announce_route(peer, afi,
378 safi, true);
379 }
380 }
381 }
d62a17ae 382 }
383
384 return 0;
718e3744 385}
386
121f9dee 387static int bgp_interface_address_delete(ZAPI_CALLBACK_ARGS)
718e3744 388{
f3d20a2a 389 struct listnode *node, *nnode;
d62a17ae 390 struct connected *ifc;
f3d20a2a 391 struct peer *peer;
2bb8b49c 392 struct bgp *bgp;
f3d20a2a 393 struct prefix *addr;
6aeb9e78 394
2f9123e0 395 bgp = bgp_lookup_by_vrf_id(vrf_id);
2f9123e0 396
121f9dee 397 ifc = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
718e3744 398
d62a17ae 399 if (ifc == NULL)
400 return 0;
718e3744 401
2dbe669b
DA		 402 if (bgp_debug_zebra(ifc->address))
403 zlog_debug("Rx Intf address del VRF %u IF %s addr %pFX", vrf_id,
404 ifc->ifp->name, ifc->address);
a39275d7 405
85751d1d 406 if (bgp && if_is_operative(ifc->ifp)) {
2f9123e0 407 bgp_connected_delete(bgp, ifc);
d62a17ae 408 }
718e3744 409
f3d20a2a
DS		 410 addr = ifc->address;
411
412 if (bgp) {
413 /*
414 * When we are using the v6 global as part of the peering
415 * nexthops and we are removing it, then we need to
416 * clear the peer data saved for that nexthop and
417 * cause a re-announcement of the route. Since
418 * we do not want the peering to bounce.
419 */
420 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
2bb8b49c
DS		 421 afi_t afi;
422 safi_t safi;
423
f3d20a2a
DS		 424 if (addr->family == AF_INET)
425 continue;
426
427 if (!IN6_IS_ADDR_LINKLOCAL(&addr->u.prefix6)
428 && memcmp(&peer->nexthop.v6_global,
429 &addr->u.prefix6, 16)
430 == 0) {
431 memset(&peer->nexthop.v6_global, 0, 16);
432 FOREACH_AFI_SAFI (afi, safi)
433 bgp_announce_route(peer, afi, safi,
434 true);
435 }
436 }
437 }
438
721c0857 439 connected_free(&ifc);
718e3744 440
d62a17ae 441 return 0;
718e3744 442}
443
121f9dee 444static int bgp_interface_nbr_address_add(ZAPI_CALLBACK_ARGS)
a80beece 445{
d62a17ae 446 struct nbr_connected *ifc = NULL;
447 struct bgp *bgp;
448
121f9dee 449 ifc = zebra_interface_nbr_address_read(cmd, zclient->ibuf, vrf_id);
d62a17ae 450
451 if (ifc == NULL)
452 return 0;
453
2dbe669b
DA		 454 if (bgp_debug_zebra(ifc->address))
455 zlog_debug("Rx Intf neighbor add VRF %u IF %s addr %pFX",
456 vrf_id, ifc->ifp->name, ifc->address);
d62a17ae 457
458 if (if_is_operative(ifc->ifp)) {
459 bgp = bgp_lookup_by_vrf_id(vrf_id);
460 if (bgp)
461 bgp_nbr_connected_add(bgp, ifc);
462 }
463
464 return 0;
a80beece
DS		 465}
466
121f9dee 467static int bgp_interface_nbr_address_delete(ZAPI_CALLBACK_ARGS)
a80beece 468{
d62a17ae 469 struct nbr_connected *ifc = NULL;
470 struct bgp *bgp;
6aeb9e78 471
121f9dee 472 ifc = zebra_interface_nbr_address_read(cmd, zclient->ibuf, vrf_id);
a80beece 473
d62a17ae 474 if (ifc == NULL)
475 return 0;
a80beece 476
2dbe669b
DA		 477 if (bgp_debug_zebra(ifc->address))
478 zlog_debug("Rx Intf neighbor del VRF %u IF %s addr %pFX",
479 vrf_id, ifc->ifp->name, ifc->address);
a80beece 480
d62a17ae 481 if (if_is_operative(ifc->ifp)) {
482 bgp = bgp_lookup_by_vrf_id(vrf_id);
483 if (bgp)
484 bgp_nbr_connected_delete(bgp, ifc, 0);
485 }
a80beece 486
d62a17ae 487 nbr_connected_free(ifc);
a80beece 488
d62a17ae 489 return 0;
a80beece
DS		 490}
491
bfcd43b2 492/* VRF update for an interface. */
121f9dee 493static int bgp_interface_vrf_update(ZAPI_CALLBACK_ARGS)
bfcd43b2 494{
d62a17ae 495 struct interface *ifp;
496 vrf_id_t new_vrf_id;
497 struct connected *c;
498 struct nbr_connected *nc;
499 struct listnode *node, *nnode;
500 struct bgp *bgp;
c19fe3c7 501 struct peer *peer;
bfcd43b2 502
d62a17ae 503 ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
504 &new_vrf_id);
505 if (!ifp)
506 return 0;
bfcd43b2 507
253b7158 508 if (BGP_DEBUG(zebra, ZEBRA))
d62a17ae 509 zlog_debug("Rx Intf VRF change VRF %u IF %s NewVRF %u", vrf_id,
510 ifp->name, new_vrf_id);
bfcd43b2 511
d62a17ae 512 bgp = bgp_lookup_by_vrf_id(vrf_id);
bfcd43b2 513
85751d1d
DS		 514 if (bgp) {
515 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, c))
516 bgp_connected_delete(bgp, c);
bfcd43b2 517
85751d1d
DS		 518 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, node, nnode, nc))
519 bgp_nbr_connected_delete(bgp, nc, 1);
bfcd43b2 520
85751d1d
DS		 521 /* Fast external-failover */
522 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER)) {
523 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
c8d6f0d6 524 if ((peer->ttl != BGP_DEFAULT_TTL)
e2521429
DA		 525 && (peer->gtsm_hops
526 != BGP_GTSM_HOPS_CONNECTED))
85751d1d 527 continue;
bfcd43b2 528
85751d1d
DS		 529 if (ifp == peer->nexthop.ifp)
530 BGP_EVENT_ADD(peer, BGP_Stop);
531 }
d62a17ae 532 }
533 }
bfcd43b2 534
a36898e7 535 if_update_to_new_vrf(ifp, new_vrf_id);
bfcd43b2 536
d62a17ae 537 bgp = bgp_lookup_by_vrf_id(new_vrf_id);
538 if (!bgp)
539 return 0;
bfcd43b2 540
d62a17ae 541 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, c))
542 bgp_connected_add(bgp, c);
bfcd43b2 543
d62a17ae 544 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, node, nnode, nc))
545 bgp_nbr_connected_add(bgp, nc);
0d020cd6
PR		 546
547 hook_call(bgp_vrf_status_changed, bgp, ifp);
d62a17ae 548 return 0;
bfcd43b2 549}
550
718e3744 551/* Zebra route add and delete treatment. */
121f9dee 552static int zebra_read_route(ZAPI_CALLBACK_ARGS)
718e3744 553{
9de1f7ff 554 enum nexthop_types_t nhtype;
0789eb69 555 enum blackhole_type bhtype = BLACKHOLE_UNSPEC;
74489921 556 struct zapi_route api;
0789eb69 557 union g_addr nexthop = {};
9de1f7ff 558 ifindex_t ifindex;
74489921 559 int add, i;
d62a17ae 560 struct bgp *bgp;
561
562 bgp = bgp_lookup_by_vrf_id(vrf_id);
563 if (!bgp)
564 return 0;
565
74489921
RW		 566 if (zapi_route_decode(zclient->ibuf, &api) < 0)
567 return -1;
d62a17ae 568
74489921
RW		 569 /* we completely ignore srcdest routes for now. */
570 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX))
571 return 0;
d62a17ae 572
74489921
RW		 573 /* ignore link-local address. */
574 if (api.prefix.family == AF_INET6
575 && IN6_IS_ADDR_LINKLOCAL(&api.prefix.u.prefix6))
576 return 0;
d62a17ae 577
74489921 578 ifindex = api.nexthops[0].ifindex;
9de1f7ff 579 nhtype = api.nexthops[0].type;
d62a17ae 580
0789eb69
KM		 581 /* api_nh structure has union of gate and bh_type */
582 if (nhtype == NEXTHOP_TYPE_BLACKHOLE) {
583 /* bh_type is only applicable if NEXTHOP_TYPE_BLACKHOLE*/
584 bhtype = api.nexthops[0].bh_type;
585 } else
586 nexthop = api.nexthops[0].gate;
587
121f9dee 588 add = (cmd == ZEBRA_REDISTRIBUTE_ROUTE_ADD);
74489921 589 if (add) {
d62a17ae 590 /*
591 * The ADD message is actually an UPDATE and there is no
592 * explicit DEL
593 * for a prior redistributed route, if any. So, perform an
594 * implicit
595 * DEL processing for the same redistributed route from any
596 * other
597 * source type.
598 */
599 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
600 if (i != api.type)
74489921 601 bgp_redistribute_delete(bgp, &api.prefix, i,
d62a17ae 602 api.instance);
603 }
604
605 /* Now perform the add/update. */
74489921 606 bgp_redistribute_add(bgp, &api.prefix, &nexthop, ifindex,
0789eb69
KM		 607 nhtype, bhtype, api.distance, api.metric,
608 api.type, api.instance, api.tag);
d62a17ae 609 } else {
74489921
RW		 610 bgp_redistribute_delete(bgp, &api.prefix, api.type,
611 api.instance);
a39275d7 612 }
d62a17ae 613
74489921 614 if (bgp_debug_zebra(&api.prefix)) {
2dbe669b 615 char buf[PREFIX_STRLEN];
74489921 616
77e62f2b 617 if (add) {
2dbe669b
DA		 618 inet_ntop(api.prefix.family, &nexthop, buf,
619 sizeof(buf));
77e62f2b 620 zlog_debug(
801bb996 621 "Rx route ADD VRF %u %s[%d] %pFX nexthop %s (type %d if %u) metric %u distance %u tag %" ROUTE_TAG_PRI,
77e62f2b 622 vrf_id, zebra_route_string(api.type),
2dbe669b 623 api.instance, &api.prefix, buf, nhtype, ifindex,
801bb996 624 api.metric, api.distance, api.tag);
77e62f2b 625 } else {
6bdbcbf1 626 zlog_debug("Rx route DEL VRF %u %s[%d] %pFX", vrf_id,
2dbe669b 627 zebra_route_string(api.type), api.instance,
6bdbcbf1 628 &api.prefix);
77e62f2b 629 }
d62a17ae 630 }
631
632 return 0;
718e3744 633}
6b0655a2 634
d62a17ae 635struct interface *if_lookup_by_ipv4(struct in_addr *addr, vrf_id_t vrf_id)
718e3744 636{
f4e14fdb 637 struct vrf *vrf;
d62a17ae 638 struct listnode *cnode;
639 struct interface *ifp;
640 struct connected *connected;
641 struct prefix_ipv4 p;
642 struct prefix *cp;
643
f4e14fdb
RW		 644 vrf = vrf_lookup_by_id(vrf_id);
645 if (!vrf)
646 return NULL;
647
d62a17ae 648 p.family = AF_INET;
649 p.prefix = *addr;
650 p.prefixlen = IPV4_MAX_BITLEN;
651
451fda4f 652 FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae 653 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
654 cp = connected->address;
655
656 if (cp->family == AF_INET)
657 if (prefix_match(cp, (struct prefix *)&p))
658 return ifp;
659 }
718e3744 660 }
d62a17ae 661 return NULL;
718e3744 662}
663
d62a17ae 664struct interface *if_lookup_by_ipv4_exact(struct in_addr *addr, vrf_id_t vrf_id)
718e3744 665{
f4e14fdb 666 struct vrf *vrf;
d62a17ae 667 struct listnode *cnode;
668 struct interface *ifp;
669 struct connected *connected;
670 struct prefix *cp;
671
f4e14fdb
RW		 672 vrf = vrf_lookup_by_id(vrf_id);
673 if (!vrf)
674 return NULL;
675
451fda4f 676 FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae 677 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
678 cp = connected->address;
679
680 if (cp->family == AF_INET)
681 if (IPV4_ADDR_SAME(&cp->u.prefix4, addr))
682 return ifp;
683 }
718e3744 684 }
d62a17ae 685 return NULL;
718e3744 686}
687
d62a17ae 688struct interface *if_lookup_by_ipv6(struct in6_addr *addr, ifindex_t ifindex,
689 vrf_id_t vrf_id)
718e3744 690{
f4e14fdb 691 struct vrf *vrf;
d62a17ae 692 struct listnode *cnode;
693 struct interface *ifp;
694 struct connected *connected;
695 struct prefix_ipv6 p;
696 struct prefix *cp;
697
f4e14fdb
RW		 698 vrf = vrf_lookup_by_id(vrf_id);
699 if (!vrf)
700 return NULL;
701
d62a17ae 702 p.family = AF_INET6;
703 p.prefix = *addr;
704 p.prefixlen = IPV6_MAX_BITLEN;
705
451fda4f 706 FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae 707 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
708 cp = connected->address;
709
710 if (cp->family == AF_INET6)
711 if (prefix_match(cp, (struct prefix *)&p)) {
712 if (IN6_IS_ADDR_LINKLOCAL(
713 &cp->u.prefix6)) {
714 if (ifindex == ifp->ifindex)
715 return ifp;
716 } else
717 return ifp;
718 }
719 }
718e3744 720 }
d62a17ae 721 return NULL;
718e3744 722}
723
d62a17ae 724struct interface *if_lookup_by_ipv6_exact(struct in6_addr *addr,
725 ifindex_t ifindex, vrf_id_t vrf_id)
718e3744 726{
f4e14fdb 727 struct vrf *vrf;
d62a17ae 728 struct listnode *cnode;
729 struct interface *ifp;
730 struct connected *connected;
731 struct prefix *cp;
732
f4e14fdb
RW		 733 vrf = vrf_lookup_by_id(vrf_id);
734 if (!vrf)
735 return NULL;
736
451fda4f 737 FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae 738 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
739 cp = connected->address;
740
741 if (cp->family == AF_INET6)
742 if (IPV6_ADDR_SAME(&cp->u.prefix6, addr)) {
743 if (IN6_IS_ADDR_LINKLOCAL(
744 &cp->u.prefix6)) {
745 if (ifindex == ifp->ifindex)
746 return ifp;
747 } else
748 return ifp;
749 }
750 }
718e3744 751 }
d62a17ae 752 return NULL;
718e3744 753}
754
d62a17ae 755static int if_get_ipv6_global(struct interface *ifp, struct in6_addr *addr)
718e3744 756{
d62a17ae 757 struct listnode *cnode;
758 struct connected *connected;
759 struct prefix *cp;
760
761 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
762 cp = connected->address;
763
764 if (cp->family == AF_INET6)
765 if (!IN6_IS_ADDR_LINKLOCAL(&cp->u.prefix6)) {
766 memcpy(addr, &cp->u.prefix6, IPV6_MAX_BYTELEN);
767 return 1;
768 }
769 }
770 return 0;
718e3744 771}
772
dac42f2e 773static bool if_get_ipv6_local(struct interface *ifp, struct in6_addr *addr)
718e3744 774{
d62a17ae 775 struct listnode *cnode;
776 struct connected *connected;
777 struct prefix *cp;
778
779 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
780 cp = connected->address;
781
782 if (cp->family == AF_INET6)
783 if (IN6_IS_ADDR_LINKLOCAL(&cp->u.prefix6)) {
784 memcpy(addr, &cp->u.prefix6, IPV6_MAX_BYTELEN);
dac42f2e 785 return true;
d62a17ae 786 }
787 }
dac42f2e 788 return false;
718e3744 789}
718e3744 790
d62a17ae 791static int if_get_ipv4_address(struct interface *ifp, struct in_addr *addr)
6ee06fa9 792{
d62a17ae 793 struct listnode *cnode;
794 struct connected *connected;
795 struct prefix *cp;
796
797 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
798 cp = connected->address;
799 if ((cp->family == AF_INET)
800 && !ipv4_martian(&(cp->u.prefix4))) {
801 *addr = cp->u.prefix4;
802 return 1;
803 }
804 }
805 return 0;
6ee06fa9
PM		 806}
807
17cdd31e
DS		 808
809bool bgp_zebra_nexthop_set(union sockunion *local, union sockunion *remote,
810 struct bgp_nexthop *nexthop, struct peer *peer)
718e3744 811{
d62a17ae 812 int ret = 0;
813 struct interface *ifp = NULL;
dac42f2e 814 bool v6_ll_avail = true;
d62a17ae 815
816 memset(nexthop, 0, sizeof(struct bgp_nexthop));
817
818 if (!local)
17cdd31e 819 return false;
d62a17ae 820 if (!remote)
17cdd31e 821 return false;
d62a17ae 822
823 if (local->sa.sa_family == AF_INET) {
824 nexthop->v4 = local->sin.sin_addr;
825 if (peer->update_if)
826 ifp = if_lookup_by_name(peer->update_if,
a36898e7 827 peer->bgp->vrf_id);
d62a17ae 828 else
829 ifp = if_lookup_by_ipv4_exact(&local->sin.sin_addr,
830 peer->bgp->vrf_id);
718e3744 831 }
d62a17ae 832 if (local->sa.sa_family == AF_INET6) {
8f2b2139 833 memcpy(&nexthop->v6_global, &local->sin6.sin6_addr, IPV6_MAX_BYTELEN);
d62a17ae 834 if (IN6_IS_ADDR_LINKLOCAL(&local->sin6.sin6_addr)) {
835 if (peer->conf_if || peer->ifname)
836 ifp = if_lookup_by_name(peer->conf_if
837 ? peer->conf_if
838 : peer->ifname,
a36898e7 839 peer->bgp->vrf_id);
abe68054
PG		 840 else if (peer->update_if)
841 ifp = if_lookup_by_name(peer->update_if,
842 peer->bgp->vrf_id);
d62a17ae 843 } else if (peer->update_if)
844 ifp = if_lookup_by_name(peer->update_if,
a36898e7 845 peer->bgp->vrf_id);
d62a17ae 846 else
847 ifp = if_lookup_by_ipv6_exact(&local->sin6.sin6_addr,
848 local->sin6.sin6_scope_id,
849 peer->bgp->vrf_id);
718e3744 850 }
d62a17ae 851
17cdd31e
DS		 852 if (!ifp) {
853 /*
854 * BGP views do not currently get proper data
855 * from zebra( when attached ) to be able to
856 * properly resolve nexthops, so give this
857 * instance type a pass.
858 */
859 if (peer->bgp->inst_type == BGP_INSTANCE_TYPE_VIEW)
860 return true;
861 /*
862 * If we have no interface data but we have established
863 * some connection w/ zebra than something has gone
864 * terribly terribly wrong here, so say this failed
865 * If we do not any zebra connection then not
866 * having a ifp pointer is ok.
867 */
868 return zclient_num_connects ? false : true;
869 }
d62a17ae 870
871 nexthop->ifp = ifp;
872
873 /* IPv4 connection, fetch and store IPv6 local address(es) if any. */
874 if (local->sa.sa_family == AF_INET) {
875 /* IPv6 nexthop*/
876 ret = if_get_ipv6_global(ifp, &nexthop->v6_global);
877
878 if (!ret) {
879 /* There is no global nexthop. Use link-local address as
880 * both the
881 * global and link-local nexthop. In this scenario, the
882 * expectation
883 * for interop is that the network admin would use a
884 * route-map to
885 * specify the global IPv6 nexthop.
886 */
dac42f2e
DS		 887 v6_ll_avail =
888 if_get_ipv6_local(ifp, &nexthop->v6_global);
d62a17ae 889 memcpy(&nexthop->v6_local, &nexthop->v6_global,
890 IPV6_MAX_BYTELEN);
891 } else
dac42f2e
DS		 892 v6_ll_avail =
893 if_get_ipv6_local(ifp, &nexthop->v6_local);
d62a17ae 894
dac42f2e
DS		 895 /*
896 * If we are a v4 connection and we are not doing unnumbered
897 * not having a v6 LL address is ok
898 */
899 if (!v6_ll_avail && !peer->conf_if)
900 v6_ll_avail = true;
d62a17ae 901 if (if_lookup_by_ipv4(&remote->sin.sin_addr, peer->bgp->vrf_id))
902 peer->shared_network = 1;
903 else
904 peer->shared_network = 0;
718e3744 905 }
718e3744 906
d62a17ae 907 /* IPv6 connection, fetch and store IPv4 local address if any. */
908 if (local->sa.sa_family == AF_INET6) {
909 struct interface *direct = NULL;
910
911 /* IPv4 nexthop. */
912 ret = if_get_ipv4_address(ifp, &nexthop->v4);
975a328e 913 if (!ret && peer->local_id.s_addr != INADDR_ANY)
d62a17ae 914 nexthop->v4 = peer->local_id;
915
916 /* Global address*/
917 if (!IN6_IS_ADDR_LINKLOCAL(&local->sin6.sin6_addr)) {
918 memcpy(&nexthop->v6_global, &local->sin6.sin6_addr,
919 IPV6_MAX_BYTELEN);
920
382c3b08 921 /* If directly connected set link-local address. */
d62a17ae 922 direct = if_lookup_by_ipv6(&remote->sin6.sin6_addr,
923 remote->sin6.sin6_scope_id,
924 peer->bgp->vrf_id);
925 if (direct)
dac42f2e
DS		 926 v6_ll_avail = if_get_ipv6_local(
927 ifp, &nexthop->v6_local);
2ebb354c
IR		 928 /*
929 * It's fine to not have a v6 LL when using
930 * update-source loopback/vrf
931 */
608c8870 932 if (!v6_ll_avail && if_is_loopback(ifp))
2ebb354c 933 v6_ll_avail = true;
382c3b08 934 else if (!v6_ll_avail) {
75ba864c
DS		 935 flog_warn(
936 EC_BGP_NO_LL_ADDRESS_AVAILABLE,
937 "Interface: %s does not have a v6 LL address associated with it, waiting until one is created for it",
938 ifp->name);
939 }
d62a17ae 940 } else
941 /* Link-local address. */
942 {
943 ret = if_get_ipv6_global(ifp, &nexthop->v6_global);
944
945 /* If there is no global address. Set link-local
946 address as
947 global. I know this break RFC specification... */
948 /* In this scenario, the expectation for interop is that
949 * the
950 * network admin would use a route-map to specify the
951 * global
952 * IPv6 nexthop.
953 */
954 if (!ret)
955 memcpy(&nexthop->v6_global,
956 &local->sin6.sin6_addr,
957 IPV6_MAX_BYTELEN);
958 /* Always set the link-local address */
959 memcpy(&nexthop->v6_local, &local->sin6.sin6_addr,
960 IPV6_MAX_BYTELEN);
961 }
962
963 if (IN6_IS_ADDR_LINKLOCAL(&local->sin6.sin6_addr)
964 || if_lookup_by_ipv6(&remote->sin6.sin6_addr,
965 remote->sin6.sin6_scope_id,
966 peer->bgp->vrf_id))
967 peer->shared_network = 1;
968 else
969 peer->shared_network = 0;
970 }
718e3744 971
d62a17ae 972/* KAME stack specific treatment. */
718e3744 973#ifdef KAME
d62a17ae 974 if (IN6_IS_ADDR_LINKLOCAL(&nexthop->v6_global)
975 && IN6_LINKLOCAL_IFINDEX(nexthop->v6_global)) {
976 SET_IN6_LINKLOCAL_IFINDEX(nexthop->v6_global, 0);
977 }
978 if (IN6_IS_ADDR_LINKLOCAL(&nexthop->v6_local)
979 && IN6_LINKLOCAL_IFINDEX(nexthop->v6_local)) {
980 SET_IN6_LINKLOCAL_IFINDEX(nexthop->v6_local, 0);
981 }
718e3744 982#endif /* KAME */
e33a4880 983
d62a17ae 984 /* If we have identified the local interface, there is no error for now.
985 */
dac42f2e 986 return v6_ll_avail;
718e3744 987}
988
18ee8310 989static struct in6_addr *
40381db7 990bgp_path_info_to_ipv6_nexthop(struct bgp_path_info *path, ifindex_t *ifindex)
73ac8160 991{
d62a17ae 992 struct in6_addr *nexthop = NULL;
993
994 /* Only global address nexthop exists. */
dc94fe42
RW		 995 if (path->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL
996 || path->attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL) {
40381db7 997 nexthop = &path->attr->mp_nexthop_global;
77e62f2b 998 if (IN6_IS_ADDR_LINKLOCAL(nexthop))
40381db7 999 *ifindex = path->attr->nh_ifindex;
77e62f2b 1000 }
d62a17ae 1001
1002 /* If both global and link-local address present. */
dc94fe42
RW		 1003 if (path->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
1004 || path->attr->mp_nexthop_len
1005 == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL) {
d62a17ae 1006 /* Check if route-map is set to prefer global over link-local */
2bb8b49c 1007 if (path->attr->mp_nexthop_prefer_global) {
40381db7 1008 nexthop = &path->attr->mp_nexthop_global;
77e62f2b 1009 if (IN6_IS_ADDR_LINKLOCAL(nexthop))
40381db7 1010 *ifindex = path->attr->nh_ifindex;
77e62f2b 1011 } else {
d62a17ae 1012 /* Workaround for Cisco's nexthop bug. */
1013 if (IN6_IS_ADDR_UNSPECIFIED(
40381db7 1014 &path->attr->mp_nexthop_global)
ab0e0f73 1015 && path->peer->su_remote
40381db7 1016 && path->peer->su_remote->sa.sa_family
59a0f1cb 1017 == AF_INET6) {
d62a17ae 1018 nexthop =
40381db7 1019 &path->peer->su_remote->sin6.sin6_addr;
77e62f2b 1020 if (IN6_IS_ADDR_LINKLOCAL(nexthop))
40381db7 1021 *ifindex = path->peer->nexthop.ifp
59a0f1cb 1022 ->ifindex;
77e62f2b 1023 } else {
40381db7 1024 nexthop = &path->attr->mp_nexthop_local;
77e62f2b 1025 if (IN6_IS_ADDR_LINKLOCAL(nexthop))
40381db7 1026 *ifindex = path->attr->nh_lla_ifindex;
77e62f2b 1027 }
d62a17ae 1028 }
1029 }
1030
1031 return nexthop;
73ac8160
DS		 1032}
1033
b8685f9b 1034static bool bgp_table_map_apply(struct route_map *map, const struct prefix *p,
3dc339cd 1035 struct bgp_path_info *path)
73ac8160 1036{
b4cb15c6
DL		 1037 route_map_result_t ret;
1038
1782514f 1039 ret = route_map_apply(map, p, path);
40381db7 1040 bgp_attr_flush(path->attr);
b4cb15c6
DL		 1041
1042 if (ret != RMAP_DENYMATCH)
3dc339cd 1043 return true;
d62a17ae 1044
1045 if (bgp_debug_zebra(p)) {
1046 if (p->family == AF_INET) {
d62a17ae 1047 zlog_debug(
c0d72166
DS		 1048 "Zebra rmap deny: IPv4 route %pFX nexthop %pI4",
1049 p, &path->attr->nexthop);
d62a17ae 1050 }
1051 if (p->family == AF_INET6) {
77e62f2b 1052 ifindex_t ifindex;
1053 struct in6_addr *nexthop;
1054
40381db7 1055 nexthop = bgp_path_info_to_ipv6_nexthop(path, &ifindex);
d62a17ae 1056 zlog_debug(
7b6cee89
DS		 1057 "Zebra rmap deny: IPv6 route %pFX nexthop %pI6",
1058 p, nexthop);
d62a17ae 1059 }
1060 }
3dc339cd 1061 return false;
73ac8160
DS		 1062}
1063
b98f7728
PG		 1064static struct thread *bgp_tm_thread_connect;
1065static bool bgp_tm_status_connected;
31c28cd7
PG		 1066static bool bgp_tm_chunk_obtained;
1067#define BGP_FLOWSPEC_TABLE_CHUNK 100000
1068static uint32_t bgp_tm_min, bgp_tm_max, bgp_tm_chunk_size;
6818e7e5 1069struct bgp *bgp_tm_bgp;
b98f7728 1070
cc9f21da 1071static void bgp_zebra_tm_connect(struct thread *t)
b98f7728
PG		 1072{
1073 struct zclient *zclient;
1074 int delay = 10, ret = 0;
1075
1076 zclient = THREAD_ARG(t);
1077 if (bgp_tm_status_connected && zclient->sock > 0)
1078 delay = 60;
1079 else {
1080 bgp_tm_status_connected = false;
1081 ret = tm_table_manager_connect(zclient);
1082 }
1083 if (ret < 0) {
b7cd3069 1084 zlog_info("Error connecting to table manager!");
b98f7728
PG		 1085 bgp_tm_status_connected = false;
1086 } else {
1087 if (!bgp_tm_status_connected)
1088 zlog_debug("Connecting to table manager. Success");
1089 bgp_tm_status_connected = true;
31c28cd7
PG		 1090 if (!bgp_tm_chunk_obtained) {
1091 if (bgp_zebra_get_table_range(bgp_tm_chunk_size,
1092 &bgp_tm_min,
6818e7e5 1093 &bgp_tm_max) >= 0) {
31c28cd7 1094 bgp_tm_chunk_obtained = true;
6818e7e5
PG		 1095 /* parse non installed entries */
1096 bgp_zebra_announce_table(bgp_tm_bgp, AFI_IP, SAFI_FLOWSPEC);
1097 }
31c28cd7 1098 }
b98f7728
PG		 1099 }
1100 thread_add_timer(bm->master, bgp_zebra_tm_connect, zclient, delay,
1101 &bgp_tm_thread_connect);
b98f7728
PG		 1102}
1103
6818e7e5
PG		 1104bool bgp_zebra_tm_chunk_obtained(void)
1105{
1106 return bgp_tm_chunk_obtained;
1107}
1108
31c28cd7
PG		 1109uint32_t bgp_zebra_tm_get_id(void)
1110{
1111 static int table_id;
1112
1113 if (!bgp_tm_chunk_obtained)
1114 return ++table_id;
1115 return bgp_tm_min++;
1116}
1117
6818e7e5 1118void bgp_zebra_init_tm_connect(struct bgp *bgp)
b98f7728
PG		 1119{
1120 int delay = 1;
1121
1122 /* if already set, do nothing
1123 */
1124 if (bgp_tm_thread_connect != NULL)
1125 return;
1126 bgp_tm_status_connected = false;
31c28cd7
PG		 1127 bgp_tm_chunk_obtained = false;
1128 bgp_tm_min = bgp_tm_max = 0;
1129 bgp_tm_chunk_size = BGP_FLOWSPEC_TABLE_CHUNK;
6818e7e5 1130 bgp_tm_bgp = bgp;
b98f7728
PG		 1131 thread_add_timer(bm->master, bgp_zebra_tm_connect, zclient, delay,
1132 &bgp_tm_thread_connect);
1133}
1134
1135int bgp_zebra_get_table_range(uint32_t chunk_size,
1136 uint32_t *start, uint32_t *end)
1137{
1138 int ret;
1139
1140 if (!bgp_tm_status_connected)
1141 return -1;
1142 ret = tm_get_table_chunk(zclient, chunk_size, start, end);
1143 if (ret < 0) {
e50f7cfd 1144 flog_err(EC_BGP_TABLE_CHUNK,
1c50c1c0 1145 "BGP: Error getting table chunk %u", chunk_size);
b98f7728
PG		 1146 return -1;
1147 }
1148 zlog_info("BGP: Table Manager returns range from chunk %u is [%u %u]",
1149 chunk_size, *start, *end);
1150 return 0;
1151}
1152
3dc339cd
DA		 1153static bool update_ipv4nh_for_route_install(int nh_othervrf, struct bgp *nh_bgp,
1154 struct in_addr *nexthop,
1155 struct attr *attr, bool is_evpn,
1156 struct zapi_nexthop *api_nh)
77e62f2b 1157{
1158 api_nh->gate.ipv4 = *nexthop;
e1e71450 1159 api_nh->vrf_id = nh_bgp->vrf_id;
77e62f2b 1160
1161 /* Need to set fields appropriately for EVPN routes imported into
1162 * a VRF (which are programmed as onlink on l3-vni SVI) as well as
1163 * connected routes leaked into a VRF.
1164 */
0789eb69
KM		 1165 if (attr->nh_type == NEXTHOP_TYPE_BLACKHOLE) {
1166 api_nh->type = attr->nh_type;
1167 api_nh->bh_type = attr->bh_type;
1168 } else if (is_evpn) {
a2299aba
AD		 1169 /*
1170 * If the nexthop is EVPN overlay index gateway IP,
1171 * treat the nexthop as NEXTHOP_TYPE_IPV4
1172 * Else, mark the nexthop as onlink.
1173 */
1174 if (attr->evpn_overlay.type == OVERLAY_INDEX_GATEWAY_IP)
1175 api_nh->type = NEXTHOP_TYPE_IPV4;
1176 else {
1177 api_nh->type = NEXTHOP_TYPE_IPV4_IFINDEX;
5609e70f 1178 SET_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_EVPN);
a2299aba
AD		 1179 SET_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_ONLINK);
1180 api_nh->ifindex = nh_bgp->l3vni_svi_ifindex;
1181 }
0789eb69 1182 } else if (nh_othervrf && api_nh->gate.ipv4.s_addr == INADDR_ANY) {
77e62f2b 1183 api_nh->type = NEXTHOP_TYPE_IFINDEX;
1184 api_nh->ifindex = attr->nh_ifindex;
1185 } else
1186 api_nh->type = NEXTHOP_TYPE_IPV4;
1187
3dc339cd 1188 return true;
77e62f2b 1189}
1190
3dc339cd
DA		 1191static bool update_ipv6nh_for_route_install(int nh_othervrf, struct bgp *nh_bgp,
1192 struct in6_addr *nexthop,
1193 ifindex_t ifindex,
1194 struct bgp_path_info *pi,
1195 struct bgp_path_info *best_pi,
1196 bool is_evpn,
1197 struct zapi_nexthop *api_nh)
77e62f2b 1198{
1199 struct attr *attr;
1200
40381db7 1201 attr = pi->attr;
e1e71450 1202 api_nh->vrf_id = nh_bgp->vrf_id;
77e62f2b 1203
0789eb69
KM		 1204 if (attr->nh_type == NEXTHOP_TYPE_BLACKHOLE) {
1205 api_nh->type = attr->nh_type;
1206 api_nh->bh_type = attr->bh_type;
1207 } else if (is_evpn) {
a2299aba
AD		 1208 /*
1209 * If the nexthop is EVPN overlay index gateway IP,
1210 * treat the nexthop as NEXTHOP_TYPE_IPV4
1211 * Else, mark the nexthop as onlink.
1212 */
1213 if (attr->evpn_overlay.type == OVERLAY_INDEX_GATEWAY_IP)
1214 api_nh->type = NEXTHOP_TYPE_IPV6;
1215 else {
1216 api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
5609e70f 1217 SET_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_EVPN);
a2299aba
AD		 1218 SET_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_ONLINK);
1219 api_nh->ifindex = nh_bgp->l3vni_svi_ifindex;
1220 }
e1e71450 1221 } else if (nh_othervrf) {
77e62f2b 1222 if (IN6_IS_ADDR_UNSPECIFIED(nexthop)) {
1223 api_nh->type = NEXTHOP_TYPE_IFINDEX;
1224 api_nh->ifindex = attr->nh_ifindex;
1225 } else if (IN6_IS_ADDR_LINKLOCAL(nexthop)) {
1226 if (ifindex == 0)
3dc339cd 1227 return false;
77e62f2b 1228 api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
1229 api_nh->ifindex = ifindex;
1230 } else {
1231 api_nh->type = NEXTHOP_TYPE_IPV6;
1232 api_nh->ifindex = 0;
1233 }
1234 } else {
1235 if (IN6_IS_ADDR_LINKLOCAL(nexthop)) {
40381db7
DS		 1236 if (pi == best_pi
1237 && attr->mp_nexthop_len
1238 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL)
1239 if (pi->peer->nexthop.ifp)
1240 ifindex =
1241 pi->peer->nexthop.ifp->ifindex;
77e62f2b 1242 if (!ifindex) {
40381db7
DS		 1243 if (pi->peer->conf_if)
1244 ifindex = pi->peer->ifp->ifindex;
1245 else if (pi->peer->ifname)
77e62f2b 1246 ifindex = ifname2ifindex(
40381db7
DS		 1247 pi->peer->ifname,
1248 pi->peer->bgp->vrf_id);
1249 else if (pi->peer->nexthop.ifp)
1250 ifindex =
1251 pi->peer->nexthop.ifp->ifindex;
77e62f2b 1252 }
1253
1254 if (ifindex == 0)
3dc339cd 1255 return false;
77e62f2b 1256 api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
1257 api_nh->ifindex = ifindex;
1258 } else {
1259 api_nh->type = NEXTHOP_TYPE_IPV6;
1260 api_nh->ifindex = 0;
1261 }
1262 }
0789eb69
KM		 1263 /* api_nh structure has union of gate and bh_type */
1264 if (nexthop && api_nh->type != NEXTHOP_TYPE_BLACKHOLE)
c2ca3e25 1265 api_nh->gate.ipv6 = *nexthop;
77e62f2b 1266
3dc339cd 1267 return true;
77e62f2b 1268}
1269
f7e1c681 1270static bool bgp_zebra_use_nhop_weighted(struct bgp *bgp, struct attr *attr,
1271 uint64_t tot_bw, uint32_t *nh_weight)
4e30bc2b 1272{
f7e1c681 1273 uint32_t bw;
1274 uint64_t tmp;
1275
1276 bw = attr->link_bw;
1277 /* zero link-bandwidth and link-bandwidth not present are treated
1278 * as the same situation.
1279 */
1280 if (!bw) {
1281 /* the only situations should be if we're either told
1282 * to skip or use default weight.
1283 */
1284 if (bgp->lb_handling == BGP_LINK_BW_SKIP_MISSING)
1285 return false;
1286 *nh_weight = BGP_ZEBRA_DEFAULT_NHOP_WEIGHT;
1287 } else {
1288 tmp = (uint64_t)bw * 100;
1289 *nh_weight = ((uint32_t)(tmp / tot_bw));
1290 }
1291
1292 return true;
4e30bc2b 1293}
1294
9bcb3eef 1295void bgp_zebra_announce(struct bgp_dest *dest, const struct prefix *p,
4b7e6066 1296 struct bgp_path_info *info, struct bgp *bgp, afi_t afi,
d62a17ae 1297 safi_t safi)
718e3744 1298{
7cc27d41 1299 struct zapi_route api = { 0 };
9913029c 1300 struct zapi_nexthop *api_nh;
2ad4f093 1301 int nh_family;
a74e593b 1302 unsigned int valid_nh_count = 0;
1a9cb083 1303 bool allow_recursion = false;
d7c0a89a 1304 uint8_t distance;
d62a17ae 1305 struct peer *peer;
4b7e6066 1306 struct bgp_path_info *mpinfo;
ad1844f7 1307 struct bgp *bgp_orig;
d7c0a89a 1308 uint32_t metric;
b4cb15c6 1309 struct attr local_attr;
4b7e6066
DS		 1310 struct bgp_path_info local_info;
1311 struct bgp_path_info *mpinfo_cp = &local_info;
d62a17ae 1312 route_tag_t tag;
1313 mpls_label_t label;
ea7cd161 1314 struct bgp_sid_info *sid_info;
ddb5b488 1315 int nh_othervrf = 0;
06f16b2c 1316 bool nh_updated = false;
4e30bc2b 1317 bool do_wt_ecmp;
1318 uint64_t cum_bw = 0;
6348981a
AK		 1319 uint32_t nhg_id = 0;
1320 bool is_add;
67f67ba4
DA		 1321 uint32_t ttl = 0;
1322 uint32_t bos = 0;
1323 uint32_t exp = 0;
d62a17ae 1324
1325 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1326 * know of this instance.
1327 */
1328 if (!bgp_install_info_to_zebra(bgp))
1329 return;
1330
d62a17ae 1331 if (bgp->main_zebra_update_hold)
1332 return;
1333
d90b788e 1334 if (safi == SAFI_FLOWSPEC) {
9bcb3eef
DS		 1335 bgp_pbr_update_entry(bgp, bgp_dest_get_prefix(dest), info, afi,
1336 safi, true);
d90b788e
A		 1337 return;
1338 }
529efa23 1339
ddb5b488
PZ		 1340 /*
1341 * vrf leaking support (will have only one nexthop)
1342 */
1343 if (info->extra && info->extra->bgp_orig)
1344 nh_othervrf = 1;
1345
9913029c 1346 /* Make Zebra API structure. */
9913029c
RW		 1347 api.vrf_id = bgp->vrf_id;
1348 api.type = ZEBRA_ROUTE_BGP;
1349 api.safi = safi;
1350 api.prefix = *p;
1351 SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
1352
d62a17ae 1353 peer = info->peer;
1354
2bb8b49c
DS		 1355 if (info->type == ZEBRA_ROUTE_BGP
1356 && info->sub_type == BGP_ROUTE_IMPORTED) {
1357
1358 /* Obtain peer from parent */
1359 if (info->extra && info->extra->parent)
1360 peer = ((struct bgp_path_info *)(info->extra->parent))
1361 ->peer;
ddb5b488
PZ		 1362 }
1363
d62a17ae 1364 tag = info->attr->tag;
1365
d62a17ae 1366 if (peer->sort == BGP_PEER_IBGP || peer->sort == BGP_PEER_CONFED
1367 || info->sub_type == BGP_ROUTE_AGGREGATE) {
9913029c 1368 SET_FLAG(api.flags, ZEBRA_FLAG_IBGP);
4e8b02f4 1369 SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
718e3744 1370 }
a39275d7 1371
c8d6f0d6 1372 if ((peer->sort == BGP_PEER_EBGP && peer->ttl != BGP_DEFAULT_TTL)
d62a17ae 1373 || CHECK_FLAG(peer->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK)
892fedb6 1374 || CHECK_FLAG(bgp->flags, BGP_FLAG_DISABLE_NH_CONNECTED_CHK))
d62a17ae 1375
1a9cb083 1376 allow_recursion = true;
d62a17ae 1377
951745bd
PG		 1378 if (info->attr->rmap_table_id) {
1379 SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
1380 api.tableid = info->attr->rmap_table_id;
1381 }
1382
ef3e0d04
SM		 1383 if (CHECK_FLAG(info->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_SRTE_COLOR)))
1384 SET_FLAG(api.message, ZAPI_MESSAGE_SRTE);
1385
2ad4f093
RW		 1386 /* Metric is currently based on the best-path only */
1387 metric = info->attr->med;
4e30bc2b 1388
1389 /* Determine if we're doing weighted ECMP or not */
f7e1c681 1390 do_wt_ecmp = bgp_path_info_mpath_chkwtd(bgp, info);
4e30bc2b 1391 if (do_wt_ecmp)
1392 cum_bw = bgp_path_info_mpath_cumbw(info);
1393
6348981a 1394 /* EVPN MAC-IP routes are installed with a L3 NHG id */
8bcb09a1 1395 if (bgp_evpn_path_es_use_nhg(bgp, info, &nhg_id)) {
6348981a 1396 mpinfo = NULL;
8bcb09a1
AK		 1397 api.nhgid = nhg_id;
1398 if (nhg_id)
1399 SET_FLAG(api.message, ZAPI_MESSAGE_NHG);
1400 } else {
6348981a 1401 mpinfo = info;
8bcb09a1 1402 }
6348981a
AK		 1403
1404 for (; mpinfo; mpinfo = bgp_path_info_mpath_next(mpinfo)) {
f7e1c681 1405 uint32_t nh_weight;
5609e70f 1406 bool is_evpn;
f7e1c681 1407
a74e593b
RW		 1408 if (valid_nh_count >= multipath_num)
1409 break;
1410
b4cb15c6 1411 *mpinfo_cp = *mpinfo;
f7e1c681 1412 nh_weight = 0;
b4cb15c6 1413
d0d695f4 1414 /* Get nexthop address-family */
7226bc40
TA		 1415 if (p->family == AF_INET &&
1416 !BGP_ATTR_MP_NEXTHOP_LEN_IP6(mpinfo_cp->attr))
d0d695f4 1417 nh_family = AF_INET;
7226bc40
TA		 1418 else if (p->family == AF_INET6 ||
1419 (p->family == AF_INET &&
1420 BGP_ATTR_MP_NEXTHOP_LEN_IP6(mpinfo_cp->attr)))
d0d695f4
RW		 1421 nh_family = AF_INET6;
1422 else
1423 continue;
1424
f7e1c681 1425 /* If processing for weighted ECMP, determine the next hop's
1426 * weight. Based on user setting, we may skip the next hop
1427 * in some situations.
1428 */
1429 if (do_wt_ecmp) {
1430 if (!bgp_zebra_use_nhop_weighted(bgp, mpinfo->attr,
1431 cum_bw, &nh_weight))
1432 continue;
1433 }
1374aec9 1434 api_nh = &api.nexthops[valid_nh_count];
ef3e0d04
SM		 1435
1436 if (CHECK_FLAG(info->attr->flag,
1437 ATTR_FLAG_BIT(BGP_ATTR_SRTE_COLOR)))
1438 api_nh->srte_color = info->attr->srte_color;
1439
257b7b6e
DS		 1440 if (bgp_debug_zebra(&api.prefix)) {
1441 if (mpinfo->extra) {
70492dea
DS		 1442 zlog_debug("%s: p=%pFX, bgp_is_valid_label: %d",
1443 __func__, p,
257b7b6e
DS		 1444 bgp_is_valid_label(
1445 &mpinfo->extra->label[0]));
1446 } else {
70492dea
DS		 1447 zlog_debug(
1448 "%s: p=%pFX, extra is NULL, no label",
1449 __func__, p);
ddb5b488 1450 }
257b7b6e 1451 }
ddb5b488 1452
257b7b6e
DS		 1453 if (bgp->table_map[afi][safi].name) {
1454 /* Copy info and attributes, so the route-map
1455 apply doesn't modify the BGP route info. */
1456 local_attr = *mpinfo->attr;
1457 mpinfo_cp->attr = &local_attr;
1458 if (!bgp_table_map_apply(bgp->table_map[afi][safi].map,
1459 p, mpinfo_cp))
1460 continue;
b4cb15c6 1461
257b7b6e
DS		 1462 /* metric/tag is only allowed to be
1463 * overridden on 1st nexthop */
1464 if (mpinfo == info) {
1465 metric = mpinfo_cp->attr->med;
1466 tag = mpinfo_cp->attr->tag;
b4cb15c6 1467 }
257b7b6e 1468 }
d62a17ae 1469
ad1844f7
IS		 1470 BGP_ORIGINAL_UPDATE(bgp_orig, mpinfo, bgp);
1471
257b7b6e 1472 if (nh_family == AF_INET) {
5609e70f
XL		 1473 is_evpn = is_route_parent_evpn(mpinfo);
1474
77e62f2b 1475 nh_updated = update_ipv4nh_for_route_install(
ad1844f7
IS		 1476 nh_othervrf, bgp_orig,
1477 &mpinfo_cp->attr->nexthop, mpinfo_cp->attr,
1478 is_evpn, api_nh);
2ad4f093 1479 } else {
f220da99 1480 ifindex_t ifindex = IFINDEX_INTERNAL;
2ad4f093 1481 struct in6_addr *nexthop;
9913029c 1482
18ee8310
DS		 1483 nexthop = bgp_path_info_to_ipv6_nexthop(mpinfo_cp,
1484 &ifindex);
00c10664 1485
5609e70f
XL		 1486 is_evpn = is_route_parent_evpn(mpinfo);
1487
00c10664
DA		 1488 if (!nexthop)
1489 nh_updated = update_ipv4nh_for_route_install(
ad1844f7 1490 nh_othervrf, bgp_orig,
00c10664
DA		 1491 &mpinfo_cp->attr->nexthop,
1492 mpinfo_cp->attr, is_evpn, api_nh);
1493 else
1494 nh_updated = update_ipv6nh_for_route_install(
ad1844f7
IS		 1495 nh_othervrf, bgp_orig, nexthop, ifindex,
1496 mpinfo, info, is_evpn, api_nh);
2ad4f093 1497 }
d62a17ae 1498
77e62f2b 1499 /* Did we get proper nexthop info to update zebra? */
1500 if (!nh_updated)
1501 continue;
1502
1a9cb083
JM		 1503 /* Allow recursion if it is a multipath group with both
1504 * eBGP and iBGP paths.
1505 */
1506 if (!allow_recursion
1507 && CHECK_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX)
1508 && (mpinfo->peer->sort == BGP_PEER_IBGP
1509 || mpinfo->peer->sort == BGP_PEER_CONFED))
1510 allow_recursion = true;
1511
5609e70f
XL		 1512 if (mpinfo->extra &&
1513 bgp_is_valid_label(&mpinfo->extra->label[0]) &&
1514 !CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_EVPN)) {
67f67ba4
DA		 1515 mpls_lse_decode(mpinfo->extra->label[0], &label, &ttl,
1516 &exp, &bos);
9913029c 1517
68a02e06
MS		 1518 SET_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_LABEL);
1519
2ad4f093
RW		 1520 api_nh->label_num = 1;
1521 api_nh->labels[0] = label;
d62a17ae 1522 }
a2299aba
AD		 1523
1524 if (is_evpn
1525 && mpinfo->attr->evpn_overlay.type
1526 != OVERLAY_INDEX_GATEWAY_IP)
1527 memcpy(&api_nh->rmac, &(mpinfo->attr->rmac),
1528 sizeof(struct ethaddr));
1529
f7e1c681 1530 api_nh->weight = nh_weight;
4e30bc2b 1531
db656439
RS		 1532 if (mpinfo->extra &&
1533 bgp_is_valid_label(&mpinfo->extra->label[0]) &&
1534 !sid_zero(&mpinfo->extra->sid[0].sid) &&
5609e70f 1535 !CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_EVPN)) {
ea7cd161
RS		 1536 sid_info = &mpinfo->extra->sid[0];
1537
1538 memcpy(&api_nh->seg6_segs, &sid_info->sid,
53a4de82 1539 sizeof(api_nh->seg6_segs));
09e06fcf 1540
ea7cd161 1541 if (sid_info->transposition_len != 0) {
67f67ba4
DA		 1542 mpls_lse_decode(mpinfo->extra->label[0], &label,
1543 &ttl, &exp, &bos);
db656439
RS		 1544
1545 if (label < MPLS_LABEL_UNRESERVED_MIN) {
1546 if (bgp_debug_zebra(&api.prefix))
1547 zlog_debug(
1548 "skip invalid SRv6 routes: transposition scheme is used, but label is too small");
1549 continue;
1550 }
1551
ea7cd161
RS		 1552 transpose_sid(&api_nh->seg6_segs, label,
1553 sid_info->transposition_offset,
1554 sid_info->transposition_len);
1555 }
1556
09e06fcf 1557 SET_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_SEG6);
53a4de82
HS		 1558 }
1559
2ad4f093
RW		 1560 valid_nh_count++;
1561 }
d62a17ae 1562
6348981a
AK		 1563 is_add = (valid_nh_count || nhg_id) ? true : false;
1564
ec0acb80 1565 if (is_add && CHECK_FLAG(bm->flags, BM_FLAG_SEND_EXTRA_DATA_TO_ZEBRA)) {
94effaf0 1566 struct bgp_zebra_opaque bzo = {};
1d7260a1
DA		 1567 const char *reason =
1568 bgp_path_selection_reason2str(dest->reason);
94effaf0
DA		 1569
1570 strlcpy(bzo.aspath, info->attr->aspath->str,
1571 sizeof(bzo.aspath));
1572
1573 if (info->attr->flag & ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES))
9a706b42
DA		 1574 strlcpy(bzo.community,
1575 bgp_attr_get_community(info->attr)->str,
94effaf0
DA		 1576 sizeof(bzo.community));
1577
1578 if (info->attr->flag
1579 & ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES))
1bcf3a96
DA		 1580 strlcpy(bzo.lcommunity,
1581 bgp_attr_get_lcommunity(info->attr)->str,
94effaf0 1582 sizeof(bzo.lcommunity));
e46723a5 1583
1d7260a1
DA		 1584 strlcpy(bzo.selection_reason, reason,
1585 sizeof(bzo.selection_reason));
1586
e46723a5 1587 SET_FLAG(api.message, ZAPI_MESSAGE_OPAQUE);
94effaf0
DA		 1588 api.opaque.length = MIN(sizeof(struct bgp_zebra_opaque),
1589 ZAPI_MESSAGE_OPAQUE_LENGTH);
1590 memcpy(api.opaque.data, &bzo, api.opaque.length);
e46723a5
DS		 1591 }
1592
1a9cb083
JM		 1593 if (allow_recursion)
1594 SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
1595
5cc347c4
DS		 1596 /*
1597 * When we create an aggregate route we must also
1598 * install a Null0 route in the RIB, so overwrite
1599 * what was written into api with a blackhole route
1600 */
1601 if (info->sub_type == BGP_ROUTE_AGGREGATE)
1602 zapi_route_set_blackhole(&api, BLACKHOLE_NULL);
1603 else
2ad4f093 1604 api.nexthop_num = valid_nh_count;
d62a17ae 1605
2ad4f093
RW		 1606 SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
1607 api.metric = metric;
d62a17ae 1608
2ad4f093
RW		 1609 if (tag) {
1610 SET_FLAG(api.message, ZAPI_MESSAGE_TAG);
1611 api.tag = tag;
1612 }
d62a17ae 1613
2ad4f093
RW		 1614 distance = bgp_distance_apply(p, info, afi, safi, bgp);
1615 if (distance) {
1616 SET_FLAG(api.message, ZAPI_MESSAGE_DISTANCE);
1617 api.distance = distance;
1618 }
d62a17ae 1619
2ad4f093 1620 if (bgp_debug_zebra(p)) {
2ad4f093 1621 char nh_buf[INET6_ADDRSTRLEN];
d8744f72
CS		 1622 char eth_buf[ETHER_ADDR_STRLEN + 7] = {'\0'};
1623 char buf1[ETHER_ADDR_STRLEN];
2ad4f093 1624 char label_buf[20];
53a4de82
HS		 1625 char sid_buf[20];
1626 char segs_buf[256];
2ad4f093
RW		 1627 int i;
1628
2dbe669b
DA		 1629 zlog_debug(
1630 "Tx route %s VRF %u %pFX metric %u tag %" ROUTE_TAG_PRI
6348981a 1631 " count %d nhg %d",
4d67f4fc 1632 is_add ? "add" : "delete", bgp->vrf_id, &api.prefix,
1633 api.metric, api.tag, api.nexthop_num, nhg_id);
2ad4f093
RW		 1634 for (i = 0; i < api.nexthop_num; i++) {
1635 api_nh = &api.nexthops[i];
1636
1ee069db
CS		 1637 switch (api_nh->type) {
1638 case NEXTHOP_TYPE_IFINDEX:
77e62f2b 1639 nh_buf[0] = '\0';
1ee069db
CS		 1640 break;
1641 case NEXTHOP_TYPE_IPV4:
1642 case NEXTHOP_TYPE_IPV4_IFINDEX:
1643 nh_family = AF_INET;
77e62f2b 1644 inet_ntop(nh_family, &api_nh->gate, nh_buf,
1645 sizeof(nh_buf));
1ee069db
CS		 1646 break;
1647 case NEXTHOP_TYPE_IPV6:
1648 case NEXTHOP_TYPE_IPV6_IFINDEX:
1649 nh_family = AF_INET6;
1650 inet_ntop(nh_family, &api_nh->gate, nh_buf,
1651 sizeof(nh_buf));
1652 break;
1653 case NEXTHOP_TYPE_BLACKHOLE:
1654 strlcpy(nh_buf, "blackhole", sizeof(nh_buf));
1655 break;
1656 default:
1657 /* Note: add new nexthop case */
1658 assert(0);
1659 break;
77e62f2b 1660 }
2ad4f093
RW		 1661
1662 label_buf[0] = '\0';
d8744f72 1663 eth_buf[0] = '\0';
bbf32574 1664 segs_buf[0] = '\0';
5609e70f
XL		 1665 if (CHECK_FLAG(api_nh->flags,
1666 ZAPI_NEXTHOP_FLAG_LABEL) &&
1667 !CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_EVPN))
a7799788
CS		 1668 snprintf(label_buf, sizeof(label_buf),
1669 "label %u", api_nh->labels[0]);
5609e70f
XL		 1670 if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_SEG6) &&
1671 !CHECK_FLAG(api_nh->flags,
1672 ZAPI_NEXTHOP_FLAG_EVPN)) {
53a4de82
HS		 1673 inet_ntop(AF_INET6, &api_nh->seg6_segs,
1674 sid_buf, sizeof(sid_buf));
1675 snprintf(segs_buf, sizeof(segs_buf), "segs %s",
1676 sid_buf);
1677 }
5609e70f
XL		 1678 if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_EVPN) &&
1679 !is_zero_mac(&api_nh->rmac))
a7799788
CS		 1680 snprintf(eth_buf, sizeof(eth_buf), " RMAC %s",
1681 prefix_mac2str(&api_nh->rmac,
1682 buf1, sizeof(buf1)));
53a4de82 1683 zlog_debug(" nhop [%d]: %s if %u VRF %u wt %u %s %s %s",
77e62f2b 1684 i + 1, nh_buf, api_nh->ifindex,
4e30bc2b 1685 api_nh->vrf_id, api_nh->weight,
53a4de82 1686 label_buf, segs_buf, eth_buf);
d62a17ae 1687 }
2ad4f093 1688
960035b2
PZ		 1689 int recursion_flag = 0;
1690
1691 if (CHECK_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION))
1692 recursion_flag = 1;
1693
70492dea
DS		 1694 zlog_debug("%s: %pFX: announcing to zebra (recursion %sset)",
1695 __func__, p, (recursion_flag ? "" : "NOT "));
960035b2 1696 }
6348981a 1697 zclient_route_send(is_add ? ZEBRA_ROUTE_ADD : ZEBRA_ROUTE_DELETE,
2ad4f093 1698 zclient, &api);
718e3744 1699}
1700
73ac8160 1701/* Announce all routes of a table to zebra */
d62a17ae 1702void bgp_zebra_announce_table(struct bgp *bgp, afi_t afi, safi_t safi)
73ac8160 1703{
9bcb3eef 1704 struct bgp_dest *dest;
d62a17ae 1705 struct bgp_table *table;
40381db7 1706 struct bgp_path_info *pi;
d62a17ae 1707
1708 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1709 * know of this instance.
1710 */
1711 if (!bgp_install_info_to_zebra(bgp))
1712 return;
1713
1714 table = bgp->rib[afi][safi];
1715 if (!table)
1716 return;
1717
9bcb3eef
DS		 1718 for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest))
1719 for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
40381db7 1720 if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED) &&
ddb5b488 1721
40381db7
DS		 1722 (pi->type == ZEBRA_ROUTE_BGP
1723 && (pi->sub_type == BGP_ROUTE_NORMAL
1724 || pi->sub_type == BGP_ROUTE_IMPORTED)))
ddb5b488 1725
9bcb3eef
DS		 1726 bgp_zebra_announce(dest,
1727 bgp_dest_get_prefix(dest),
b54892e0 1728 pi, bgp, afi, safi);
73ac8160
DS		 1729}
1730
c163f297
DS		 1731/* Announce routes of any bgp subtype of a table to zebra */
1732void bgp_zebra_announce_table_all_subtypes(struct bgp *bgp, afi_t afi,
1733 safi_t safi)
1734{
1735 struct bgp_dest *dest;
1736 struct bgp_table *table;
1737 struct bgp_path_info *pi;
1738
1739 if (!bgp_install_info_to_zebra(bgp))
1740 return;
1741
1742 table = bgp->rib[afi][safi];
1743 if (!table)
1744 return;
1745
1746 for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest))
1747 for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
1748 if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED) &&
1749 pi->type == ZEBRA_ROUTE_BGP)
1750 bgp_zebra_announce(dest,
1751 bgp_dest_get_prefix(dest),
1752 pi, bgp, afi, safi);
1753}
1754
5a1ae2c2 1755void bgp_zebra_withdraw(const struct prefix *p, struct bgp_path_info *info,
568e10ca 1756 struct bgp *bgp, safi_t safi)
718e3744 1757{
2ad4f093 1758 struct zapi_route api;
f7df1907 1759 struct peer *peer;
ddb5b488 1760
d62a17ae 1761 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1762 * know of this instance.
1763 */
568e10ca 1764 if (!bgp_install_info_to_zebra(bgp))
d62a17ae 1765 return;
1766
f7df1907
PG		 1767 if (safi == SAFI_FLOWSPEC) {
1768 peer = info->peer;
d90b788e
A		 1769 bgp_pbr_update_entry(peer->bgp, p, info, AFI_IP, safi, false);
1770 return;
f7df1907 1771 }
529efa23 1772
2ad4f093 1773 memset(&api, 0, sizeof(api));
568e10ca 1774 api.vrf_id = bgp->vrf_id;
2ad4f093
RW		 1775 api.type = ZEBRA_ROUTE_BGP;
1776 api.safi = safi;
1777 api.prefix = *p;
d62a17ae 1778
1276ce38
PG		 1779 if (info->attr->rmap_table_id) {
1780 SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
1781 api.tableid = info->attr->rmap_table_id;
1782 }
1783
2dbe669b
DA		 1784 if (bgp_debug_zebra(p))
1785 zlog_debug("Tx route delete VRF %u %pFX", bgp->vrf_id,
1786 &api.prefix);
d62a17ae 1787
2ad4f093 1788 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
718e3744 1789}
56c1f7d8 1790
c163f297
DS		 1791/* Withdraw all entries in a BGP instances RIB table from Zebra */
1792void bgp_zebra_withdraw_table_all_subtypes(struct bgp *bgp, afi_t afi, safi_t safi)
1793{
1794 struct bgp_dest *dest;
1795 struct bgp_table *table;
1796 struct bgp_path_info *pi;
1797
1798 if (!bgp_install_info_to_zebra(bgp))
1799 return;
1800
1801 table = bgp->rib[afi][safi];
1802 if (!table)
1803 return;
1804
1805 for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
1806 for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
1807 if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED)
1808 && (pi->type == ZEBRA_ROUTE_BGP))
1809 bgp_zebra_withdraw(bgp_dest_get_prefix(dest),
1810 pi, bgp, safi);
1811 }
1812 }
1813}
1814
d7c0a89a
QY		 1815struct bgp_redist *bgp_redist_lookup(struct bgp *bgp, afi_t afi, uint8_t type,
1816 unsigned short instance)
7c8ff89e 1817{
d62a17ae 1818 struct list *red_list;
1819 struct listnode *node;
1820 struct bgp_redist *red;
7c8ff89e 1821
d62a17ae 1822 red_list = bgp->redist[afi][type];
1823 if (!red_list)
1824 return (NULL);
7c8ff89e 1825
d62a17ae 1826 for (ALL_LIST_ELEMENTS_RO(red_list, node, red))
1827 if (red->instance == instance)
1828 return red;
7c8ff89e 1829
d62a17ae 1830 return NULL;
7c8ff89e
DS		 1831}
1832
d7c0a89a
QY		 1833struct bgp_redist *bgp_redist_add(struct bgp *bgp, afi_t afi, uint8_t type,
1834 unsigned short instance)
7c8ff89e 1835{
d62a17ae 1836 struct list *red_list;
1837 struct bgp_redist *red;
7c8ff89e 1838
d62a17ae 1839 red = bgp_redist_lookup(bgp, afi, type, instance);
1840 if (red)
1841 return red;
7c8ff89e 1842
d62a17ae 1843 if (!bgp->redist[afi][type])
1844 bgp->redist[afi][type] = list_new();
7c8ff89e 1845
d62a17ae 1846 red_list = bgp->redist[afi][type];
9f5dc319 1847 red = XCALLOC(MTYPE_BGP_REDIST, sizeof(struct bgp_redist));
d62a17ae 1848 red->instance = instance;
7c8ff89e 1849
d62a17ae 1850 listnode_add(red_list, red);
7c8ff89e 1851
d62a17ae 1852 return red;
7c8ff89e
DS		 1853}
1854
d7c0a89a
QY		 1855static void bgp_redist_del(struct bgp *bgp, afi_t afi, uint8_t type,
1856 unsigned short instance)
7c8ff89e 1857{
d62a17ae 1858 struct bgp_redist *red;
1859
1860 red = bgp_redist_lookup(bgp, afi, type, instance);
1861
1862 if (red) {
1863 listnode_delete(bgp->redist[afi][type], red);
1864 XFREE(MTYPE_BGP_REDIST, red);
acdf5e25 1865 if (!bgp->redist[afi][type]->count)
6a154c88 1866 list_delete(&bgp->redist[afi][type]);
d62a17ae 1867 }
7c8ff89e 1868}
6b0655a2 1869
718e3744 1870/* Other routes redistribution into BGP. */
d7c0a89a 1871int bgp_redistribute_set(struct bgp *bgp, afi_t afi, int type,
e923dd62 1872 unsigned short instance, bool changed)
718e3744 1873{
e923dd62 1874 /* If redistribute options are changed call
1875 * bgp_redistribute_unreg() to reset the option and withdraw
1876 * the routes
1877 */
1878 if (changed)
1879 bgp_redistribute_unreg(bgp, afi, type, instance);
718e3744 1880
d62a17ae 1881 /* Return if already redistribute flag is set. */
1882 if (instance) {
1883 if (redist_check_instance(&zclient->mi_redist[afi][type],
1884 instance))
1885 return CMD_WARNING;
718e3744 1886
d62a17ae 1887 redist_add_instance(&zclient->mi_redist[afi][type], instance);
1888 } else {
d9083050
IR		 1889 if (vrf_bitmap_check(zclient->redist[afi][type], bgp->vrf_id))
1890 return CMD_WARNING;
1891
49e5a4a0 1892#ifdef ENABLE_BGP_VNC
f920dd6d 1893 if (EVPN_ENABLED(bgp) && type == ZEBRA_ROUTE_VNC_DIRECT) {
d62a17ae 1894 vnc_export_bgp_enable(
1895 bgp, afi); /* only enables if mode bits cfg'd */
1896 }
65efcfce
LB		 1897#endif
1898
d62a17ae 1899 vrf_bitmap_set(zclient->redist[afi][type], bgp->vrf_id);
1900 }
718e3744 1901
ea12cf11
DS		 1902 /*
1903 * Don't try to register if we're not connected to Zebra or Zebra
1904 * doesn't know of this instance.
1905 *
1906 * When we come up later well resend if needed.
d62a17ae 1907 */
1908 if (!bgp_install_info_to_zebra(bgp))
ea12cf11 1909 return CMD_SUCCESS;
a39275d7 1910
d62a17ae 1911 if (BGP_DEBUG(zebra, ZEBRA))
1912 zlog_debug("Tx redistribute add VRF %u afi %d %s %d",
1913 bgp->vrf_id, afi, zebra_route_string(type),
1914 instance);
518f0eb1 1915
d62a17ae 1916 /* Send distribute add message to zebra. */
1917 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, afi, type,
1918 instance, bgp->vrf_id);
718e3744 1919
d62a17ae 1920 return CMD_SUCCESS;
718e3744 1921}
1922
d62a17ae 1923int bgp_redistribute_resend(struct bgp *bgp, afi_t afi, int type,
d7c0a89a 1924 unsigned short instance)
518f0eb1 1925{
d62a17ae 1926 /* Don't try to send if we're not connected to Zebra or Zebra doesn't
1927 * know of this instance.
1928 */
1929 if (!bgp_install_info_to_zebra(bgp))
1930 return -1;
1931
1932 if (BGP_DEBUG(zebra, ZEBRA))
1933 zlog_debug("Tx redistribute del/add VRF %u afi %d %s %d",
1934 bgp->vrf_id, afi, zebra_route_string(type),
1935 instance);
1936
1937 /* Send distribute add message to zebra. */
1938 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, zclient, afi, type,
1939 instance, bgp->vrf_id);
1940 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, afi, type,
1941 instance, bgp->vrf_id);
1942
1943 return 0;
518f0eb1
DS		 1944}
1945
718e3744 1946/* Redistribute with route-map specification. */
3dc339cd
DA		 1947bool bgp_redistribute_rmap_set(struct bgp_redist *red, const char *name,
1948 struct route_map *route_map)
718e3744 1949{
d62a17ae 1950 if (red->rmap.name && (strcmp(red->rmap.name, name) == 0))
3dc339cd 1951 return false;
718e3744 1952
0a22ddfb 1953 XFREE(MTYPE_ROUTE_MAP_NAME, red->rmap.name);
b4897fa5 1954 /* Decrement the count for existing routemap and
1955 * increment the count for new route map.
1956 */
1957 route_map_counter_decrement(red->rmap.map);
d62a17ae 1958 red->rmap.name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, name);
1de27621 1959 red->rmap.map = route_map;
b4897fa5 1960 route_map_counter_increment(red->rmap.map);
718e3744 1961
3dc339cd 1962 return true;
718e3744 1963}
1964
1965/* Redistribute with metric specification. */
3dc339cd
DA		 1966bool bgp_redistribute_metric_set(struct bgp *bgp, struct bgp_redist *red,
1967 afi_t afi, int type, uint32_t metric)
718e3744 1968{
9bcb3eef 1969 struct bgp_dest *dest;
40381db7 1970 struct bgp_path_info *pi;
d62a17ae 1971
1972 if (red->redist_metric_flag && red->redist_metric == metric)
3dc339cd 1973 return false;
d62a17ae 1974
1975 red->redist_metric_flag = 1;
1976 red->redist_metric = metric;
1977
9bcb3eef
DS		 1978 for (dest = bgp_table_top(bgp->rib[afi][SAFI_UNICAST]); dest;
1979 dest = bgp_route_next(dest)) {
1980 for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
40381db7
DS		 1981 if (pi->sub_type == BGP_ROUTE_REDISTRIBUTE
1982 && pi->type == type
1983 && pi->instance == red->instance) {
d62a17ae 1984 struct attr *old_attr;
1985 struct attr new_attr;
1986
6f4f49b2 1987 new_attr = *pi->attr;
d62a17ae 1988 new_attr.med = red->redist_metric;
40381db7
DS		 1989 old_attr = pi->attr;
1990 pi->attr = bgp_attr_intern(&new_attr);
d62a17ae 1991 bgp_attr_unintern(&old_attr);
1992
9bcb3eef 1993 bgp_path_info_set_flag(dest, pi,
18ee8310 1994 BGP_PATH_ATTR_CHANGED);
9bcb3eef 1995 bgp_process(bgp, dest, afi, SAFI_UNICAST);
d62a17ae 1996 }
1997 }
1998 }
1999
3dc339cd 2000 return true;
718e3744 2001}
2002
2003/* Unset redistribution. */
d62a17ae 2004int bgp_redistribute_unreg(struct bgp *bgp, afi_t afi, int type,
d7c0a89a 2005 unsigned short instance)
718e3744 2006{
d62a17ae 2007 struct bgp_redist *red;
2008
2009 red = bgp_redist_lookup(bgp, afi, type, instance);
2010 if (!red)
2011 return CMD_SUCCESS;
2012
2013 /* Return if zebra connection is disabled. */
2014 if (instance) {
2015 if (!redist_check_instance(&zclient->mi_redist[afi][type],
2016 instance))
2017 return CMD_WARNING;
2018 redist_del_instance(&zclient->mi_redist[afi][type], instance);
2019 } else {
2020 if (!vrf_bitmap_check(zclient->redist[afi][type], bgp->vrf_id))
2021 return CMD_WARNING;
2022 vrf_bitmap_unset(zclient->redist[afi][type], bgp->vrf_id);
2023 }
718e3744 2024
d62a17ae 2025 if (bgp_install_info_to_zebra(bgp)) {
2026 /* Send distribute delete message to zebra. */
2027 if (BGP_DEBUG(zebra, ZEBRA))
2028 zlog_debug("Tx redistribute del VRF %u afi %d %s %d",
2029 bgp->vrf_id, afi, zebra_route_string(type),
2030 instance);
2031 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, zclient, afi,
2032 type, instance, bgp->vrf_id);
2033 }
2034
2035 /* Withdraw redistributed routes from current BGP's routing table. */
2036 bgp_redistribute_withdraw(bgp, afi, type, instance);
2037
2038 return CMD_SUCCESS;
718e3744 2039}
2040
6aeb9e78 2041/* Unset redistribution. */
d62a17ae 2042int bgp_redistribute_unset(struct bgp *bgp, afi_t afi, int type,
d7c0a89a 2043 unsigned short instance)
6aeb9e78 2044{
d62a17ae 2045 struct bgp_redist *red;
6aeb9e78 2046
ddb5b488
PZ		 2047/*
2048 * vnc and vpn->vrf checks must be before red check because
2049 * they operate within bgpd irrespective of zebra connection
2050 * status. red lookup fails if there is no zebra connection.
2051 */
49e5a4a0 2052#ifdef ENABLE_BGP_VNC
f920dd6d 2053 if (EVPN_ENABLED(bgp) && type == ZEBRA_ROUTE_VNC_DIRECT) {
ddb5b488
PZ		 2054 vnc_export_bgp_disable(bgp, afi);
2055 }
2056#endif
ddb5b488 2057
d62a17ae 2058 red = bgp_redist_lookup(bgp, afi, type, instance);
2059 if (!red)
2060 return CMD_SUCCESS;
6aeb9e78 2061
d62a17ae 2062 bgp_redistribute_unreg(bgp, afi, type, instance);
6aeb9e78 2063
d62a17ae 2064 /* Unset route-map. */
0a22ddfb 2065 XFREE(MTYPE_ROUTE_MAP_NAME, red->rmap.name);
b4897fa5 2066 route_map_counter_decrement(red->rmap.map);
d62a17ae 2067 red->rmap.map = NULL;
6aeb9e78 2068
d62a17ae 2069 /* Unset metric. */
2070 red->redist_metric_flag = 0;
2071 red->redist_metric = 0;
6aeb9e78 2072
d62a17ae 2073 bgp_redist_del(bgp, afi, type, instance);
6aeb9e78 2074
d62a17ae 2075 return CMD_SUCCESS;
6aeb9e78
DS		 2076}
2077
fc2408ec
DS		 2078void bgp_redistribute_redo(struct bgp *bgp)
2079{
2080 afi_t afi;
2081 int i;
2082 struct list *red_list;
2083 struct listnode *node;
2084 struct bgp_redist *red;
2085
2086 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
2087 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
2088
2089 red_list = bgp->redist[afi][i];
2090 if (!red_list)
2091 continue;
2092
2093 for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
2094 bgp_redistribute_resend(bgp, afi, i,
2095 red->instance);
2096 }
2097 }
2098 }
2099}
2100
d62a17ae 2101void bgp_zclient_reset(void)
718e3744 2102{
d62a17ae 2103 zclient_reset(zclient);
718e3744 2104}
2105
ad4cbda1 2106/* Register this instance with Zebra. Invoked upon connect (for
2107 * default instance) and when other VRFs are learnt (or created and
2108 * already learnt).
2109 */
d62a17ae 2110void bgp_zebra_instance_register(struct bgp *bgp)
ad4cbda1 2111{
d62a17ae 2112 /* Don't try to register if we're not connected to Zebra */
2113 if (!zclient || zclient->sock < 0)
2114 return;
ad4cbda1 2115
d62a17ae 2116 if (BGP_DEBUG(zebra, ZEBRA))
2117 zlog_debug("Registering VRF %u", bgp->vrf_id);
ad4cbda1 2118
d62a17ae 2119 /* Register for router-id, interfaces, redistributed routes. */
2120 zclient_send_reg_requests(zclient, bgp->vrf_id);
7724c0a1 2121
e2f3a930
T		 2122 /* For EVPN instance, register to learn about VNIs, if appropriate. */
2123 if (bgp->advertise_all_vni)
d62a17ae 2124 bgp_zebra_advertise_all_vni(bgp, 1);
1ee0a2df
DS		 2125
2126 bgp_nht_register_nexthops(bgp);
ad4cbda1 2127}
2128
2129/* Deregister this instance with Zebra. Invoked upon the instance
2130 * being deleted (default or VRF) and it is already registered.
2131 */
d62a17ae 2132void bgp_zebra_instance_deregister(struct bgp *bgp)
ad4cbda1 2133{
d62a17ae 2134 /* Don't try to deregister if we're not connected to Zebra */
2135 if (zclient->sock < 0)
2136 return;
ad4cbda1 2137
d62a17ae 2138 if (BGP_DEBUG(zebra, ZEBRA))
2139 zlog_debug("Deregistering VRF %u", bgp->vrf_id);
ad4cbda1 2140
e2f3a930
T		 2141 /* For EVPN instance, unregister learning about VNIs, if appropriate. */
2142 if (bgp->advertise_all_vni)
d62a17ae 2143 bgp_zebra_advertise_all_vni(bgp, 0);
7724c0a1 2144
d62a17ae 2145 /* Deregister for router-id, interfaces, redistributed routes. */
2146 zclient_send_dereg_requests(zclient, bgp->vrf_id);
ad4cbda1 2147}
2148
d62a17ae 2149void bgp_zebra_initiate_radv(struct bgp *bgp, struct peer *peer)
4a04e5f7 2150{
bbad0276 2151 uint32_t ra_interval = BGP_UNNUM_DEFAULT_RA_INTERVAL;
5c81b96a 2152
d62a17ae 2153 /* Don't try to initiate if we're not connected to Zebra */
2154 if (zclient->sock < 0)
2155 return;
4a04e5f7 2156
d62a17ae 2157 if (BGP_DEBUG(zebra, ZEBRA))
2158 zlog_debug("%u: Initiating RA for peer %s", bgp->vrf_id,
2159 peer->host);
4a04e5f7 2160
b3a3290e
DS		 2161 /*
2162 * If unnumbered peer (peer->ifp) call thru zapi to start RAs.
2163 * If we don't have an ifp pointer, call function to find the
2164 * ifps for a numbered enhe peer to turn RAs on.
2165 */
2166 peer->ifp ? zclient_send_interface_radv_req(zclient, bgp->vrf_id,
2167 peer->ifp, 1, ra_interval)
2168 : bgp_nht_reg_enhe_cap_intfs(peer);
4a04e5f7 2169}
2170
d62a17ae 2171void bgp_zebra_terminate_radv(struct bgp *bgp, struct peer *peer)
4a04e5f7 2172{
d62a17ae 2173 /* Don't try to terminate if we're not connected to Zebra */
2174 if (zclient->sock < 0)
2175 return;
4a04e5f7 2176
d62a17ae 2177 if (BGP_DEBUG(zebra, ZEBRA))
2178 zlog_debug("%u: Terminating RA for peer %s", bgp->vrf_id,
2179 peer->host);
4a04e5f7 2180
b3a3290e
DS		 2181 /*
2182 * If unnumbered peer (peer->ifp) call thru zapi to stop RAs.
2183 * If we don't have an ifp pointer, call function to find the
2184 * ifps for a numbered enhe peer to turn RAs off.
2185 */
2186 peer->ifp ? zclient_send_interface_radv_req(zclient, bgp->vrf_id,
2187 peer->ifp, 0, 0)
2188 : bgp_nht_dereg_enhe_cap_intfs(peer);
4a04e5f7 2189}
2190
31310b25
MK		 2191int bgp_zebra_advertise_subnet(struct bgp *bgp, int advertise, vni_t vni)
2192{
2193 struct stream *s = NULL;
2194
2195 /* Check socket. */
2196 if (!zclient || zclient->sock < 0)
2197 return 0;
2198
2199 /* Don't try to register if Zebra doesn't know of this instance. */
bb4ef1ae
DS		 2200 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) {
2201 if (BGP_DEBUG(zebra, ZEBRA))
15569c58
DA		 2202 zlog_debug(
2203 "%s: No zebra instance to talk to, cannot advertise subnet",
2204 __func__);
31310b25 2205 return 0;
bb4ef1ae 2206 }
31310b25
MK		 2207
2208 s = zclient->obuf;
2209 stream_reset(s);
2210
2211 zclient_create_header(s, ZEBRA_ADVERTISE_SUBNET, bgp->vrf_id);
2212 stream_putc(s, advertise);
2213 stream_put3(s, vni);
2214 stream_putw_at(s, 0, stream_get_endp(s));
2215
2216 return zclient_send_message(zclient);
2217}
2218
a8016157
CS		 2219int bgp_zebra_advertise_svi_macip(struct bgp *bgp, int advertise, vni_t vni)
2220{
2221 struct stream *s = NULL;
2222
2223 /* Check socket. */
2224 if (!zclient || zclient->sock < 0)
2225 return 0;
2226
2227 /* Don't try to register if Zebra doesn't know of this instance. */
2228 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp))
2229 return 0;
2230
2231 s = zclient->obuf;
2232 stream_reset(s);
2233
2234 zclient_create_header(s, ZEBRA_ADVERTISE_SVI_MACIP, bgp->vrf_id);
2235 stream_putc(s, advertise);
2236 stream_putl(s, vni);
2237 stream_putw_at(s, 0, stream_get_endp(s));
2238
2239 return zclient_send_message(zclient);
2240}
2241
1a98c087
MK		 2242int bgp_zebra_advertise_gw_macip(struct bgp *bgp, int advertise, vni_t vni)
2243{
2244 struct stream *s = NULL;
2245
2246 /* Check socket. */
2247 if (!zclient || zclient->sock < 0)
2248 return 0;
2249
2250 /* Don't try to register if Zebra doesn't know of this instance. */
bb4ef1ae
DS		 2251 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) {
2252 if (BGP_DEBUG(zebra, ZEBRA))
15569c58
DA		 2253 zlog_debug(
2254 "%s: No zebra instance to talk to, not installing gw_macip",
2255 __func__);
1a98c087 2256 return 0;
bb4ef1ae 2257 }
1a98c087
MK		 2258
2259 s = zclient->obuf;
2260 stream_reset(s);
2261
2262 zclient_create_header(s, ZEBRA_ADVERTISE_DEFAULT_GW, bgp->vrf_id);
2263 stream_putc(s, advertise);
cc6d5476 2264 stream_putl(s, vni);
1a98c087
MK		 2265 stream_putw_at(s, 0, stream_get_endp(s));
2266
2267 return zclient_send_message(zclient);
2268}
2269
fd069644
DS		 2270int bgp_zebra_vxlan_flood_control(struct bgp *bgp,
2271 enum vxlan_flood_control flood_ctrl)
2272{
2273 struct stream *s;
2274
2275 /* Check socket. */
2276 if (!zclient || zclient->sock < 0)
2277 return 0;
2278
2279 /* Don't try to register if Zebra doesn't know of this instance. */
bb4ef1ae
DS		 2280 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) {
2281 if (BGP_DEBUG(zebra, ZEBRA))
15569c58
DA		 2282 zlog_debug(
2283 "%s: No zebra instance to talk to, not installing all vni",
2284 __func__);
fd069644 2285 return 0;
bb4ef1ae 2286 }
fd069644
DS		 2287
2288 s = zclient->obuf;
2289 stream_reset(s);
2290
2291 zclient_create_header(s, ZEBRA_VXLAN_FLOOD_CONTROL, bgp->vrf_id);
2292 stream_putc(s, flood_ctrl);
2293 stream_putw_at(s, 0, stream_get_endp(s));
2294
2295 return zclient_send_message(zclient);
2296}
2297
d62a17ae 2298int bgp_zebra_advertise_all_vni(struct bgp *bgp, int advertise)
7724c0a1 2299{
d62a17ae 2300 struct stream *s;
7724c0a1 2301
d62a17ae 2302 /* Check socket. */
2303 if (!zclient || zclient->sock < 0)
2304 return 0;
7724c0a1 2305
d62a17ae 2306 /* Don't try to register if Zebra doesn't know of this instance. */
2307 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp))
2308 return 0;
7724c0a1 2309
d62a17ae 2310 s = zclient->obuf;
2311 stream_reset(s);
7724c0a1 2312
d62a17ae 2313 zclient_create_header(s, ZEBRA_ADVERTISE_ALL_VNI, bgp->vrf_id);
2314 stream_putc(s, advertise);
fbac9605
DS		 2315 /* Also inform current BUM handling setting. This is really
2316 * relevant only when 'advertise' is set.
2317 */
fd069644 2318 stream_putc(s, bgp->vxlan_flood_ctrl);
d62a17ae 2319 stream_putw_at(s, 0, stream_get_endp(s));
7724c0a1 2320
d62a17ae 2321 return zclient_send_message(zclient);
7724c0a1 2322}
2323
0b9d9cd0
CS		 2324int bgp_zebra_dup_addr_detection(struct bgp *bgp)
2325{
2326 struct stream *s;
2327
2328 /* Check socket. */
2329 if (!zclient || zclient->sock < 0)
2330 return 0;
2331
2332 /* Don't try to register if Zebra doesn't know of this instance. */
2333 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp))
2334 return 0;
2335
2336 if (BGP_DEBUG(zebra, ZEBRA))
2337 zlog_debug("dup addr detect %s max_moves %u time %u freeze %s freeze_time %u",
2338 bgp->evpn_info->dup_addr_detect ?
2339 "enable" : "disable",
2340 bgp->evpn_info->dad_max_moves,
2341 bgp->evpn_info->dad_time,
2342 bgp->evpn_info->dad_freeze ?
2343 "enable" : "disable",
2344 bgp->evpn_info->dad_freeze_time);
2345
2346 s = zclient->obuf;
2347 stream_reset(s);
2348 zclient_create_header(s, ZEBRA_DUPLICATE_ADDR_DETECTION,
2349 bgp->vrf_id);
2350 stream_putl(s, bgp->evpn_info->dup_addr_detect);
2351 stream_putl(s, bgp->evpn_info->dad_time);
2352 stream_putl(s, bgp->evpn_info->dad_max_moves);
2353 stream_putl(s, bgp->evpn_info->dad_freeze);
2354 stream_putl(s, bgp->evpn_info->dad_freeze_time);
2355 stream_putw_at(s, 0, stream_get_endp(s));
2356
2357 return zclient_send_message(zclient);
2358}
2359
121f9dee 2360static int rule_notify_owner(ZAPI_CALLBACK_ARGS)
30d50e6d
PG		 2361{
2362 uint32_t seqno, priority, unique;
2363 enum zapi_rule_notify_owner note;
2364 struct bgp_pbr_action *bgp_pbra;
ffee150e 2365 struct bgp_pbr_rule *bgp_pbr = NULL;
58a1d249 2366 char ifname[INTERFACE_NAMSIZ + 1];
30d50e6d
PG		 2367
2368 if (!zapi_rule_notify_decode(zclient->ibuf, &seqno, &priority, &unique,
58a1d249 2369 ifname, &note))
30d50e6d
PG		 2370 return -1;
2371
70eabd12 2372 bgp_pbra = bgp_pbr_action_rule_lookup(vrf_id, unique);
30d50e6d 2373 if (!bgp_pbra) {
ffee150e
PG		 2374 /* look in bgp pbr rule */
2375 bgp_pbr = bgp_pbr_rule_lookup(vrf_id, unique);
2376 if (!bgp_pbr && note != ZAPI_RULE_REMOVED) {
2377 if (BGP_DEBUG(zebra, ZEBRA))
2378 zlog_debug("%s: Fail to look BGP rule (%u)",
15569c58 2379 __func__, unique);
ffee150e
PG		 2380 return 0;
2381 }
30d50e6d
PG		 2382 }
2383
2384 switch (note) {
2385 case ZAPI_RULE_FAIL_INSTALL:
2386 if (BGP_DEBUG(zebra, ZEBRA))
15569c58 2387 zlog_debug("%s: Received RULE_FAIL_INSTALL", __func__);
ffee150e
PG		 2388 if (bgp_pbra) {
2389 bgp_pbra->installed = false;
2390 bgp_pbra->install_in_progress = false;
2391 } else {
2392 bgp_pbr->installed = false;
2393 bgp_pbr->install_in_progress = false;
2394 }
30d50e6d
PG		 2395 break;
2396 case ZAPI_RULE_INSTALLED:
ffee150e
PG		 2397 if (bgp_pbra) {
2398 bgp_pbra->installed = true;
2399 bgp_pbra->install_in_progress = false;
2400 } else {
ce3c0614
PG		 2401 struct bgp_path_info *path;
2402 struct bgp_path_info_extra *extra;
2403
ffee150e
PG		 2404 bgp_pbr->installed = true;
2405 bgp_pbr->install_in_progress = false;
2406 bgp_pbr->action->refcnt++;
ce3c0614
PG		 2407 /* link bgp_info to bgp_pbr */
2408 path = (struct bgp_path_info *)bgp_pbr->path;
2409 extra = bgp_path_info_extra_get(path);
f5925234
PG		 2410 listnode_add_force(&extra->bgp_fs_iprule,
2411 bgp_pbr);
ffee150e 2412 }
30d50e6d 2413 if (BGP_DEBUG(zebra, ZEBRA))
15569c58 2414 zlog_debug("%s: Received RULE_INSTALLED", __func__);
30d50e6d 2415 break;
f18a08f5 2416 case ZAPI_RULE_FAIL_REMOVE:
30d50e6d
PG		 2417 case ZAPI_RULE_REMOVED:
2418 if (BGP_DEBUG(zebra, ZEBRA))
15569c58 2419 zlog_debug("%s: Received RULE REMOVED", __func__);
30d50e6d
PG		 2420 break;
2421 }
2422
2423 return 0;
2424}
2425
121f9dee 2426static int ipset_notify_owner(ZAPI_CALLBACK_ARGS)
30d50e6d
PG		 2427{
2428 uint32_t unique;
2429 enum zapi_ipset_notify_owner note;
2430 struct bgp_pbr_match *bgp_pbim;
2431
2432 if (!zapi_ipset_notify_decode(zclient->ibuf,
2433 &unique,
2434 &note))
2435 return -1;
2436
2437 bgp_pbim = bgp_pbr_match_ipset_lookup(vrf_id, unique);
2438 if (!bgp_pbim) {
2439 if (BGP_DEBUG(zebra, ZEBRA))
88055124 2440 zlog_debug("%s: Fail to look BGP match ( %u, ID %u)",
15569c58 2441 __func__, note, unique);
30d50e6d
PG		 2442 return 0;
2443 }
2444
2445 switch (note) {
2446 case ZAPI_IPSET_FAIL_INSTALL:
2447 if (BGP_DEBUG(zebra, ZEBRA))
15569c58 2448 zlog_debug("%s: Received IPSET_FAIL_INSTALL", __func__);
30d50e6d
PG		 2449 bgp_pbim->installed = false;
2450 bgp_pbim->install_in_progress = false;
2451 break;
2452 case ZAPI_IPSET_INSTALLED:
2453 bgp_pbim->installed = true;
2454 bgp_pbim->install_in_progress = false;
2455 if (BGP_DEBUG(zebra, ZEBRA))
15569c58 2456 zlog_debug("%s: Received IPSET_INSTALLED", __func__);
30d50e6d 2457 break;
f18a08f5 2458 case ZAPI_IPSET_FAIL_REMOVE:
30d50e6d
PG		 2459 case ZAPI_IPSET_REMOVED:
2460 if (BGP_DEBUG(zebra, ZEBRA))
15569c58 2461 zlog_debug("%s: Received IPSET REMOVED", __func__);
30d50e6d
PG		 2462 break;
2463 }
2464
2465 return 0;
2466}
2467
121f9dee 2468static int ipset_entry_notify_owner(ZAPI_CALLBACK_ARGS)
30d50e6d
PG		 2469{
2470 uint32_t unique;
2471 char ipset_name[ZEBRA_IPSET_NAME_SIZE];
2472 enum zapi_ipset_entry_notify_owner note;
2473 struct bgp_pbr_match_entry *bgp_pbime;
2474
2475 if (!zapi_ipset_entry_notify_decode(
2476 zclient->ibuf,
2477 &unique,
2478 ipset_name,
2479 &note))
2480 return -1;
2481 bgp_pbime = bgp_pbr_match_ipset_entry_lookup(vrf_id,
2482 ipset_name,
2483 unique);
2484 if (!bgp_pbime) {
2485 if (BGP_DEBUG(zebra, ZEBRA))
15569c58
DA		 2486 zlog_debug(
2487 "%s: Fail to look BGP match entry (%u, ID %u)",
2488 __func__, note, unique);
30d50e6d
PG		 2489 return 0;
2490 }
2491
2492 switch (note) {
2493 case ZAPI_IPSET_ENTRY_FAIL_INSTALL:
2494 if (BGP_DEBUG(zebra, ZEBRA))
2495 zlog_debug("%s: Received IPSET_ENTRY_FAIL_INSTALL",
15569c58 2496 __func__);
30d50e6d
PG		 2497 bgp_pbime->installed = false;
2498 bgp_pbime->install_in_progress = false;
2499 break;
2500 case ZAPI_IPSET_ENTRY_INSTALLED:
b588b642 2501 {
9b6d8fcf 2502 struct bgp_path_info *path;
4b7e6066
DS		 2503 struct bgp_path_info_extra *extra;
2504
2505 bgp_pbime->installed = true;
2506 bgp_pbime->install_in_progress = false;
2507 if (BGP_DEBUG(zebra, ZEBRA))
2508 zlog_debug("%s: Received IPSET_ENTRY_INSTALLED",
15569c58 2509 __func__);
9b6d8fcf
DS		 2510 /* link bgp_path_info to bpme */
2511 path = (struct bgp_path_info *)bgp_pbime->path;
2512 extra = bgp_path_info_extra_get(path);
f5925234 2513 listnode_add_force(&extra->bgp_fs_pbr, bgp_pbime);
b588b642 2514 }
30d50e6d 2515 break;
f18a08f5 2516 case ZAPI_IPSET_ENTRY_FAIL_REMOVE:
30d50e6d
PG		 2517 case ZAPI_IPSET_ENTRY_REMOVED:
2518 if (BGP_DEBUG(zebra, ZEBRA))
2519 zlog_debug("%s: Received IPSET_ENTRY_REMOVED",
15569c58 2520 __func__);
30d50e6d
PG		 2521 break;
2522 }
2523 return 0;
2524}
2525
121f9dee 2526static int iptable_notify_owner(ZAPI_CALLBACK_ARGS)
c16a0a62
PG		 2527{
2528 uint32_t unique;
2529 enum zapi_iptable_notify_owner note;
2530 struct bgp_pbr_match *bgpm;
2531
2532 if (!zapi_iptable_notify_decode(
2533 zclient->ibuf,
2534 &unique,
2535 &note))
2536 return -1;
2537 bgpm = bgp_pbr_match_iptable_lookup(vrf_id, unique);
2538 if (!bgpm) {
2539 if (BGP_DEBUG(zebra, ZEBRA))
82e194ed 2540 zlog_debug("%s: Fail to look BGP iptable (%u %u)",
15569c58 2541 __func__, note, unique);
c16a0a62
PG		 2542 return 0;
2543 }
2544 switch (note) {
2545 case ZAPI_IPTABLE_FAIL_INSTALL:
2546 if (BGP_DEBUG(zebra, ZEBRA))
2547 zlog_debug("%s: Received IPTABLE_FAIL_INSTALL",
15569c58 2548 __func__);
c16a0a62
PG		 2549 bgpm->installed_in_iptable = false;
2550 bgpm->install_iptable_in_progress = false;
2551 break;
2552 case ZAPI_IPTABLE_INSTALLED:
2553 bgpm->installed_in_iptable = true;
2554 bgpm->install_iptable_in_progress = false;
2555 if (BGP_DEBUG(zebra, ZEBRA))
15569c58 2556 zlog_debug("%s: Received IPTABLE_INSTALLED", __func__);
a6b07429 2557 bgpm->action->refcnt++;
c16a0a62 2558 break;
f18a08f5 2559 case ZAPI_IPTABLE_FAIL_REMOVE:
c16a0a62
PG		 2560 case ZAPI_IPTABLE_REMOVED:
2561 if (BGP_DEBUG(zebra, ZEBRA))
15569c58 2562 zlog_debug("%s: Received IPTABLE REMOVED", __func__);
c16a0a62
PG		 2563 break;
2564 }
2565 return 0;
2566}
2567
a77e2f4b
S		 2568/* Process route notification messages from RIB */
2569static int bgp_zebra_route_notify_owner(int command, struct zclient *zclient,
2570 zebra_size_t length, vrf_id_t vrf_id)
2571{
2572 struct prefix p;
2573 enum zapi_route_notify_owner note;
2574 uint32_t table_id;
a77e2f4b
S		 2575 afi_t afi;
2576 safi_t safi;
2577 struct bgp_dest *dest;
2578 struct bgp *bgp;
2579 struct bgp_path_info *pi, *new_select;
2580
2581 if (!zapi_route_notify_decode(zclient->ibuf, &p, &table_id, &note,
2582 &afi, &safi)) {
cc42c4f0 2583 zlog_err("%s : error in msg decode", __func__);
a77e2f4b
S		 2584 return -1;
2585 }
2586
2587 /* Get the bgp instance */
2588 bgp = bgp_lookup_by_vrf_id(vrf_id);
2589 if (!bgp) {
2590 flog_err(EC_BGP_INVALID_BGP_INSTANCE,
cc42c4f0
DS		 2591 "%s : bgp instance not found vrf %d", __func__,
2592 vrf_id);
a77e2f4b
S		 2593 return -1;
2594 }
2595
a77e2f4b
S		 2596 /* Find the bgp route node */
2597 dest = bgp_afi_node_lookup(bgp->rib[afi][safi], afi, safi, &p,
2598 &bgp->vrf_prd);
2599 if (!dest)
2600 return -1;
2601
a77e2f4b
S		 2602 switch (note) {
2603 case ZAPI_ROUTE_INSTALLED:
2604 new_select = NULL;
2605 /* Clear the flags so that route can be processed */
be785e35
DS		 2606 UNSET_FLAG(dest->flags, BGP_NODE_FIB_INSTALL_PENDING);
2607 SET_FLAG(dest->flags, BGP_NODE_FIB_INSTALLED);
2608 if (BGP_DEBUG(zebra, ZEBRA))
2609 zlog_debug("route %pRN : INSTALLED", dest);
2610 /* Find the best route */
2611 for (pi = dest->info; pi; pi = pi->next) {
2612 /* Process aggregate route */
2613 bgp_aggregate_increment(bgp, &p, pi, afi, safi);
2614 if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
2615 new_select = pi;
2616 }
2617 /* Advertise the route */
2618 if (new_select)
2619 group_announce_route(bgp, afi, safi, dest, new_select);
2620 else {
2621 flog_err(EC_BGP_INVALID_ROUTE,
2622 "selected route %pRN not found", dest);
2623
2624 bgp_dest_unlock_node(dest);
2625 return -1;
a77e2f4b
S		 2626 }
2627 break;
2628 case ZAPI_ROUTE_REMOVED:
2629 /* Route deleted from dataplane, reset the installed flag
2630 * so that route can be reinstalled when client sends
2631 * route add later
2632 */
2633 UNSET_FLAG(dest->flags, BGP_NODE_FIB_INSTALLED);
1a3519b6
DS		 2634 if (BGP_DEBUG(zebra, ZEBRA))
2635 zlog_debug("route %pRN: Removed from Fib", dest);
a77e2f4b
S		 2636 break;
2637 case ZAPI_ROUTE_FAIL_INSTALL:
be785e35 2638 new_select = NULL;
1a3519b6
DS		 2639 if (BGP_DEBUG(zebra, ZEBRA))
2640 zlog_debug("route: %pRN Failed to Install into Fib",
2641 dest);
be785e35
DS		 2642 UNSET_FLAG(dest->flags, BGP_NODE_FIB_INSTALL_PENDING);
2643 UNSET_FLAG(dest->flags, BGP_NODE_FIB_INSTALLED);
2644 for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
2645 if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
2646 new_select = pi;
2647 }
2648 if (new_select)
2649 group_announce_route(bgp, afi, safi, dest, new_select);
a77e2f4b
S		 2650 /* Error will be logged by zebra module */
2651 break;
2652 case ZAPI_ROUTE_BETTER_ADMIN_WON:
1a3519b6
DS		 2653 if (BGP_DEBUG(zebra, ZEBRA))
2654 zlog_debug("route: %pRN removed due to better admin won",
2655 dest);
be785e35
DS		 2656 new_select = NULL;
2657 UNSET_FLAG(dest->flags, BGP_NODE_FIB_INSTALL_PENDING);
2658 UNSET_FLAG(dest->flags, BGP_NODE_FIB_INSTALLED);
2659 for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
2660 bgp_aggregate_decrement(bgp, &p, pi, afi, safi);
2661 if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
2662 new_select = pi;
2663 }
2664 if (new_select)
2665 group_announce_route(bgp, afi, safi, dest, new_select);
a77e2f4b
S		 2666 /* No action required */
2667 break;
2668 case ZAPI_ROUTE_REMOVE_FAIL:
1a3519b6
DS		 2669 zlog_warn("%s: Route %pRN failure to remove",
2670 __func__, dest);
a77e2f4b
S		 2671 break;
2672 }
e71ad4b6
DA		 2673
2674 bgp_dest_unlock_node(dest);
a77e2f4b
S		 2675 return 0;
2676}
2677
6cfe5d15
PG		 2678/* this function is used to forge ip rule,
2679 * - either for iptable/ipset using fwmark id
121f9dee 2680 * - or for sample ip rule cmd
6cfe5d15 2681 */
30d50e6d 2682static void bgp_encode_pbr_rule_action(struct stream *s,
6cfe5d15
PG		 2683 struct bgp_pbr_action *pbra,
2684 struct bgp_pbr_rule *pbr)
30d50e6d 2685{
6cfe5d15 2686 struct prefix pfx;
f01e580f 2687 uint8_t fam = AF_INET;
e95666cb 2688 char ifname[INTERFACE_NAMSIZ];
30d50e6d 2689
9f1f03ec 2690 if (pbra->nh.type == NEXTHOP_TYPE_IPV6)
f01e580f 2691 fam = AF_INET6;
30d50e6d 2692 stream_putl(s, 0); /* seqno unused */
8112a7a0
PG		 2693 if (pbr)
2694 stream_putl(s, pbr->priority);
2695 else
2696 stream_putl(s, 0);
2697 /* ruleno unused - priority change
2698 * ruleno permits distinguishing various FS PBR entries
2699 * - FS PBR entries based on ipset/iptables
2700 * - FS PBR entries based on iprule
2701 * the latter may contain default routing information injected by FS
2702 */
6cfe5d15
PG		 2703 if (pbr)
2704 stream_putl(s, pbr->unique);
2705 else
2706 stream_putl(s, pbra->unique);
f56697ef 2707 stream_putc(s, 0); /* ip protocol being used */
6cfe5d15
PG		 2708 if (pbr && pbr->flags & MATCH_IP_SRC_SET)
2709 memcpy(&pfx, &(pbr->src), sizeof(struct prefix));
2710 else {
2711 memset(&pfx, 0, sizeof(pfx));
f01e580f 2712 pfx.family = fam;
6cfe5d15
PG		 2713 }
2714 stream_putc(s, pfx.family);
2715 stream_putc(s, pfx.prefixlen);
2716 stream_put(s, &pfx.u.prefix, prefix_blen(&pfx));
30d50e6d
PG		 2717
2718 stream_putw(s, 0); /* src port */
2719
6cfe5d15
PG		 2720 if (pbr && pbr->flags & MATCH_IP_DST_SET)
2721 memcpy(&pfx, &(pbr->dst), sizeof(struct prefix));
2722 else {
2723 memset(&pfx, 0, sizeof(pfx));
f01e580f 2724 pfx.family = fam;
6cfe5d15
PG		 2725 }
2726 stream_putc(s, pfx.family);
2727 stream_putc(s, pfx.prefixlen);
2728 stream_put(s, &pfx.u.prefix, prefix_blen(&pfx));
30d50e6d
PG		 2729
2730 stream_putw(s, 0); /* dst port */
e95666cb 2731 stream_putc(s, 0); /* dsfield */
6cfe5d15
PG		 2732 /* if pbr present, fwmark is not used */
2733 if (pbr)
2734 stream_putl(s, 0);
2735 else
2736 stream_putl(s, pbra->fwmark); /* fwmark */
30d50e6d 2737
62bf6b42
DS		 2738 stream_putl(s, 0); /* queue id */
2739 stream_putw(s, 0); /* vlan_id */
2740 stream_putw(s, 0); /* vlan_flags */
2741 stream_putw(s, 0); /* pcp */
2742
30d50e6d
PG		 2743 stream_putl(s, pbra->table_id);
2744
e95666cb
DS		 2745 memset(ifname, 0, sizeof(ifname));
2746 stream_put(s, ifname, INTERFACE_NAMSIZ); /* ifname unused */
30d50e6d
PG		 2747}
2748
2749static void bgp_encode_pbr_ipset_match(struct stream *s,
2750 struct bgp_pbr_match *pbim)
2751{
2752 stream_putl(s, pbim->unique);
2753 stream_putl(s, pbim->type);
a60b7031 2754 stream_putc(s, pbim->family);
30d50e6d
PG		 2755 stream_put(s, pbim->ipset_name,
2756 ZEBRA_IPSET_NAME_SIZE);
30d50e6d
PG		 2757}
2758
2759static void bgp_encode_pbr_ipset_entry_match(struct stream *s,
2760 struct bgp_pbr_match_entry *pbime)
2761{
2762 stream_putl(s, pbime->unique);
2763 /* check that back pointer is not null */
2764 stream_put(s, pbime->backpointer->ipset_name,
2765 ZEBRA_IPSET_NAME_SIZE);
2766
2767 stream_putc(s, pbime->src.family);
2768 stream_putc(s, pbime->src.prefixlen);
2769 stream_put(s, &pbime->src.u.prefix, prefix_blen(&pbime->src));
2770
2771 stream_putc(s, pbime->dst.family);
2772 stream_putc(s, pbime->dst.prefixlen);
2773 stream_put(s, &pbime->dst.u.prefix, prefix_blen(&pbime->dst));
f730e566
PG		 2774
2775 stream_putw(s, pbime->src_port_min);
2776 stream_putw(s, pbime->src_port_max);
2777 stream_putw(s, pbime->dst_port_min);
2778 stream_putw(s, pbime->dst_port_max);
2779 stream_putc(s, pbime->proto);
30d50e6d
PG		 2780}
2781
c16a0a62
PG		 2782static void bgp_encode_pbr_iptable_match(struct stream *s,
2783 struct bgp_pbr_action *bpa,
2784 struct bgp_pbr_match *pbm)
2785{
2786 stream_putl(s, pbm->unique2);
2787
2788 stream_putl(s, pbm->type);
2789
2790 stream_putl(s, pbm->flags);
2791
2792 /* TODO: correlate with what is contained
2793 * into bgp_pbr_action.
2794 * currently only forward supported
2795 */
2796 if (bpa->nh.type == NEXTHOP_TYPE_BLACKHOLE)
2797 stream_putl(s, ZEBRA_IPTABLES_DROP);
2798 else
2799 stream_putl(s, ZEBRA_IPTABLES_FORWARD);
2800 stream_putl(s, bpa->fwmark);
2801 stream_put(s, pbm->ipset_name,
2802 ZEBRA_IPSET_NAME_SIZE);
a60b7031 2803 stream_putc(s, pbm->family);
83360720
PG		 2804 stream_putw(s, pbm->pkt_len_min);
2805 stream_putw(s, pbm->pkt_len_max);
2da7d62e
PG		 2806 stream_putw(s, pbm->tcp_flags);
2807 stream_putw(s, pbm->tcp_mask_flags);
4977bd6c 2808 stream_putc(s, pbm->dscp_value);
6f5617d8 2809 stream_putc(s, pbm->fragment);
f449d223 2810 stream_putc(s, pbm->protocol);
a60b7031 2811 stream_putw(s, pbm->flow_label);
c16a0a62
PG		 2812}
2813
ad4cbda1 2814/* BGP has established connection with Zebra. */
d62a17ae 2815static void bgp_zebra_connected(struct zclient *zclient)
7076bb2f 2816{
d62a17ae 2817 struct bgp *bgp;
7076bb2f 2818
d62a17ae 2819 zclient_num_connects++; /* increment even if not responding */
afbb1c59 2820
6bfcd0f1
IR		 2821 /* Send the client registration */
2822 bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER, VRF_DEFAULT);
2823
d62a17ae 2824 /* At this point, we may or may not have BGP instances configured, but
2825 * we're only interested in the default VRF (others wouldn't have learnt
2826 * the VRF from Zebra yet.)
2827 */
2828 bgp = bgp_get_default();
2829 if (!bgp)
2830 return;
ad4cbda1 2831
d62a17ae 2832 bgp_zebra_instance_register(bgp);
ad4cbda1 2833
955bfd98 2834 /* tell label pool that zebra is connected */
e70e9f8e 2835 bgp_lp_event_zebra_up();
955bfd98 2836
d62a17ae 2837 /* TODO - What if we have peers and networks configured, do we have to
2838 * kick-start them?
2839 */
85ef4179 2840 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer);
7076bb2f
FL		 2841}
2842
c44ab6f1
AK		 2843static int bgp_zebra_process_local_es_add(ZAPI_CALLBACK_ARGS)
2844{
2845 esi_t esi;
2846 struct bgp *bgp = NULL;
2847 struct stream *s = NULL;
2848 char buf[ESI_STR_LEN];
2849 struct in_addr originator_ip;
2850 uint8_t active;
74be8313 2851 uint8_t bypass;
74e2bd89 2852 uint16_t df_pref;
c44ab6f1
AK		 2853
2854 bgp = bgp_lookup_by_vrf_id(vrf_id);
2855 if (!bgp)
2856 return 0;
2857
2858 s = zclient->ibuf;
2859 stream_get(&esi, s, sizeof(esi_t));
2860 originator_ip.s_addr = stream_get_ipv4(s);
2861 active = stream_getc(s);
74e2bd89 2862 df_pref = stream_getw(s);
74be8313 2863 bypass = stream_getc(s);
c44ab6f1
AK		 2864
2865 if (BGP_DEBUG(zebra, ZEBRA))
74e2bd89 2866 zlog_debug(
74be8313
AK		 2867 "Rx add ESI %s originator-ip %pI4 active %u df_pref %u %s",
2868 esi_to_str(&esi, buf, sizeof(buf)), &originator_ip,
2869 active, df_pref, bypass ? "bypass" : "");
c44ab6f1 2870
a383bfc7
AK		 2871 frrtrace(5, frr_bgp, evpn_mh_local_es_add_zrecv, &esi, originator_ip,
2872 active, bypass, df_pref);
2873
74be8313
AK		 2874 bgp_evpn_local_es_add(bgp, &esi, originator_ip, active, df_pref,
2875 !!bypass);
c44ab6f1
AK		 2876
2877 return 0;
2878}
2879
2880static int bgp_zebra_process_local_es_del(ZAPI_CALLBACK_ARGS)
50f74cf1 2881{
2882 esi_t esi;
2883 struct bgp *bgp = NULL;
2884 struct stream *s = NULL;
2885 char buf[ESI_STR_LEN];
50f74cf1 2886
2887 memset(&esi, 0, sizeof(esi_t));
c44ab6f1
AK		 2888 bgp = bgp_lookup_by_vrf_id(vrf_id);
2889 if (!bgp)
2890 return 0;
2891
2892 s = zclient->ibuf;
2893 stream_get(&esi, s, sizeof(esi_t));
2894
2895 if (BGP_DEBUG(zebra, ZEBRA))
2896 zlog_debug("Rx del ESI %s",
2897 esi_to_str(&esi, buf, sizeof(buf)));
2898
a383bfc7
AK		 2899 frrtrace(1, frr_bgp, evpn_mh_local_es_del_zrecv, &esi);
2900
c44ab6f1
AK		 2901 bgp_evpn_local_es_del(bgp, &esi);
2902
2903 return 0;
2904}
2905
2906static int bgp_zebra_process_local_es_evi(ZAPI_CALLBACK_ARGS)
2907{
2908 esi_t esi;
2909 vni_t vni;
2910 struct bgp *bgp;
2911 struct stream *s;
2912 char buf[ESI_STR_LEN];
50f74cf1 2913
2914 bgp = bgp_lookup_by_vrf_id(vrf_id);
2915 if (!bgp)
2916 return 0;
2917
2918 s = zclient->ibuf;
2919 stream_get(&esi, s, sizeof(esi_t));
c44ab6f1 2920 vni = stream_getl(s);
50f74cf1 2921
2922 if (BGP_DEBUG(zebra, ZEBRA))
c44ab6f1 2923 zlog_debug("Rx %s ESI %s VNI %u",
3756b9ac
IS		 2924 (cmd == ZEBRA_VNI_ADD) ? "add" : "del",
2925 esi_to_str(&esi, buf, sizeof(buf)), vni);
50f74cf1 2926
a383bfc7
AK		 2927 if (cmd == ZEBRA_LOCAL_ES_EVI_ADD) {
2928 frrtrace(2, frr_bgp, evpn_mh_local_es_evi_add_zrecv, &esi, vni);
2929
c44ab6f1 2930 bgp_evpn_local_es_evi_add(bgp, &esi, vni);
a383bfc7
AK		 2931 } else {
2932 frrtrace(2, frr_bgp, evpn_mh_local_es_evi_del_zrecv, &esi, vni);
2933
c44ab6f1 2934 bgp_evpn_local_es_evi_del(bgp, &esi, vni);
a383bfc7 2935 }
c44ab6f1 2936
50f74cf1 2937 return 0;
2938}
2939
121f9dee 2940static int bgp_zebra_process_local_l3vni(ZAPI_CALLBACK_ARGS)
fe1dc5a3 2941{
c48d9f5f 2942 int filter = 0;
b67a60d2 2943 vni_t l3vni = 0;
14e814ea 2944 struct ethaddr svi_rmac, vrr_rmac = {.octet = {0} };
b67a60d2 2945 struct in_addr originator_ip;
fe1dc5a3 2946 struct stream *s;
0483af6e 2947 ifindex_t svi_ifindex;
14e814ea 2948 bool is_anycast_mac = false;
fe1dc5a3 2949
6006b807
DA		 2950 memset(&svi_rmac, 0, sizeof(svi_rmac));
2951 memset(&originator_ip, 0, sizeof(originator_ip));
fe1dc5a3
MK		 2952 s = zclient->ibuf;
2953 l3vni = stream_getl(s);
b67a60d2 2954 if (cmd == ZEBRA_L3VNI_ADD) {
14e814ea 2955 stream_get(&svi_rmac, s, sizeof(struct ethaddr));
b67a60d2 2956 originator_ip.s_addr = stream_get_ipv4(s);
c48d9f5f 2957 stream_get(&filter, s, sizeof(int));
0483af6e 2958 svi_ifindex = stream_getl(s);
14e814ea
CS		 2959 stream_get(&vrr_rmac, s, sizeof(struct ethaddr));
2960 is_anycast_mac = stream_getl(s);
fe1dc5a3 2961
0483af6e 2962 if (BGP_DEBUG(zebra, ZEBRA))
c0d72166
DS		 2963 zlog_debug(
2964 "Rx L3-VNI ADD VRF %s VNI %u RMAC svi-mac %pEA vrr-mac %pEA filter %s svi-if %u",
2965 vrf_id_to_name(vrf_id), l3vni, &svi_rmac,
2966 &vrr_rmac,
2967 filter ? "prefix-routes-only" : "none",
2968 svi_ifindex);
fe1dc5a3 2969
a383bfc7
AK		 2970 frrtrace(8, frr_bgp, evpn_local_l3vni_add_zrecv, l3vni, vrf_id,
2971 &svi_rmac, &vrr_rmac, filter, originator_ip,
2972 svi_ifindex, is_anycast_mac);
2973
14e814ea
CS		 2974 bgp_evpn_local_l3vni_add(l3vni, vrf_id, &svi_rmac, &vrr_rmac,
2975 originator_ip, filter, svi_ifindex,
2976 is_anycast_mac);
0483af6e 2977 } else {
2978 if (BGP_DEBUG(zebra, ZEBRA))
2979 zlog_debug("Rx L3-VNI DEL VRF %s VNI %u",
2980 vrf_id_to_name(vrf_id), l3vni);
2981
a383bfc7
AK		 2982 frrtrace(2, frr_bgp, evpn_local_l3vni_del_zrecv, l3vni, vrf_id);
2983
fe1dc5a3 2984 bgp_evpn_local_l3vni_del(l3vni, vrf_id);
0483af6e 2985 }
fe1dc5a3
MK		 2986
2987 return 0;
2988}
2989
121f9dee 2990static int bgp_zebra_process_local_vni(ZAPI_CALLBACK_ARGS)
128ea8ab 2991{
d62a17ae 2992 struct stream *s;
2993 vni_t vni;
2994 struct bgp *bgp;
a4d82a8a 2995 struct in_addr vtep_ip = {INADDR_ANY};
29c53922 2996 vrf_id_t tenant_vrf_id = VRF_DEFAULT;
76d07c7a 2997 struct in_addr mcast_grp = {INADDR_ANY};
9daa5d47 2998 ifindex_t svi_ifindex = 0;
d62a17ae 2999
3000 s = zclient->ibuf;
3001 vni = stream_getl(s);
121f9dee 3002 if (cmd == ZEBRA_VNI_ADD) {
d62a17ae 3003 vtep_ip.s_addr = stream_get_ipv4(s);
29c53922 3004 stream_get(&tenant_vrf_id, s, sizeof(vrf_id_t));
76d07c7a 3005 mcast_grp.s_addr = stream_get_ipv4(s);
9daa5d47 3006 stream_get(&svi_ifindex, s, sizeof(ifindex_t));
29c53922
MK		 3007 }
3008
d62a17ae 3009 bgp = bgp_lookup_by_vrf_id(vrf_id);
3010 if (!bgp)
3011 return 0;
3012
3013 if (BGP_DEBUG(zebra, ZEBRA))
9daa5d47
AD		 3014 zlog_debug(
3015 "Rx VNI %s VRF %s VNI %u tenant-vrf %s SVI ifindex %u",
3016 (cmd == ZEBRA_VNI_ADD) ? "add" : "del",
3017 vrf_id_to_name(vrf_id), vni,
3018 vrf_id_to_name(tenant_vrf_id), svi_ifindex);
d62a17ae 3019
a383bfc7
AK		 3020 if (cmd == ZEBRA_VNI_ADD) {
3021 frrtrace(4, frr_bgp, evpn_local_vni_add_zrecv, vni, vtep_ip,
3022 tenant_vrf_id, mcast_grp);
3023
d62a17ae 3024 return bgp_evpn_local_vni_add(
975a328e
DA		 3025 bgp, vni,
3026 vtep_ip.s_addr != INADDR_ANY ? vtep_ip : bgp->router_id,
9daa5d47 3027 tenant_vrf_id, mcast_grp, svi_ifindex);
a383bfc7
AK		 3028 } else {
3029 frrtrace(1, frr_bgp, evpn_local_vni_del_zrecv, vni);
3030
d62a17ae 3031 return bgp_evpn_local_vni_del(bgp, vni);
a383bfc7 3032 }
128ea8ab 3033}
3034
121f9dee 3035static int bgp_zebra_process_local_macip(ZAPI_CALLBACK_ARGS)
128ea8ab 3036{
d62a17ae 3037 struct stream *s;
3038 vni_t vni;
3039 struct bgp *bgp;
3040 struct ethaddr mac;
3041 struct ipaddr ip;
3042 int ipa_len;
f07e1c99 3043 uint8_t flags = 0;
3044 uint32_t seqnum = 0;
ec0ab544 3045 int state = 0;
c44ab6f1
AK		 3046 char buf2[ESI_STR_LEN];
3047 esi_t esi;
d62a17ae 3048
3049 memset(&ip, 0, sizeof(ip));
3050 s = zclient->ibuf;
3051 vni = stream_getl(s);
28328ea9 3052 stream_get(&mac.octet, s, ETH_ALEN);
d62a17ae 3053 ipa_len = stream_getl(s);
3054 if (ipa_len != 0 && ipa_len != IPV4_MAX_BYTELEN
3055 && ipa_len != IPV6_MAX_BYTELEN) {
e50f7cfd 3056 flog_err(EC_BGP_MACIP_LEN,
1c50c1c0 3057 "%u:Recv MACIP %s with invalid IP addr length %d",
121f9dee 3058 vrf_id, (cmd == ZEBRA_MACIP_ADD) ? "Add" : "Del",
1c50c1c0 3059 ipa_len);
d62a17ae 3060 return -1;
3061 }
3062
3063 if (ipa_len) {
3064 ip.ipa_type =
3065 (ipa_len == IPV4_MAX_BYTELEN) ? IPADDR_V4 : IPADDR_V6;
3066 stream_get(&ip.ip.addr, s, ipa_len);
3067 }
121f9dee 3068 if (cmd == ZEBRA_MACIP_ADD) {
f07e1c99 3069 flags = stream_getc(s);
3070 seqnum = stream_getl(s);
c44ab6f1 3071 stream_get(&esi, s, sizeof(esi_t));
ec0ab544
AK		 3072 } else {
3073 state = stream_getl(s);
35fb444b 3074 memset(&esi, 0, sizeof(esi_t));
f07e1c99 3075 }
d62a17ae 3076
3077 bgp = bgp_lookup_by_vrf_id(vrf_id);
3078 if (!bgp)
3079 return 0;
3080
3081 if (BGP_DEBUG(zebra, ZEBRA))
c0d72166 3082 zlog_debug(
2dd0dde7 3083 "%u:Recv MACIP %s f 0x%x MAC %pEA IP %pIA VNI %u seq %u state %d ESI %s",
c0d72166
DS		 3084 vrf_id, (cmd == ZEBRA_MACIP_ADD) ? "Add" : "Del", flags,
3085 &mac, &ip, vni, seqnum, state,
3086 esi_to_str(&esi, buf2, sizeof(buf2)));
d62a17ae 3087
a383bfc7
AK		 3088 if (cmd == ZEBRA_MACIP_ADD) {
3089 frrtrace(6, frr_bgp, evpn_local_macip_add_zrecv, vni, &mac, &ip,
3090 flags, seqnum, &esi);
3091
f07e1c99 3092 return bgp_evpn_local_macip_add(bgp, vni, &mac, &ip,
c44ab6f1 3093 flags, seqnum, &esi);
a383bfc7
AK		 3094 } else {
3095 frrtrace(4, frr_bgp, evpn_local_macip_del_zrecv, vni, &mac, &ip,
3096 state);
3097
ec0ab544 3098 return bgp_evpn_local_macip_del(bgp, vni, &mac, &ip, state);
a383bfc7 3099 }
128ea8ab 3100}
6aeb9e78 3101
a243d1db 3102static int bgp_zebra_process_local_ip_prefix(ZAPI_CALLBACK_ARGS)
31310b25
MK		 3103{
3104 struct stream *s = NULL;
3105 struct bgp *bgp_vrf = NULL;
3106 struct prefix p;
31310b25 3107
6006b807 3108 memset(&p, 0, sizeof(p));
31310b25
MK		 3109 s = zclient->ibuf;
3110 stream_get(&p, s, sizeof(struct prefix));
3111
3112 bgp_vrf = bgp_lookup_by_vrf_id(vrf_id);
3113 if (!bgp_vrf)
a243d1db 3114 return 0;
31310b25
MK		 3115
3116 if (BGP_DEBUG(zebra, ZEBRA))
2dbe669b 3117 zlog_debug("Recv prefix %pFX %s on vrf %s", &p,
31310b25
MK		 3118 (cmd == ZEBRA_IP_PREFIX_ROUTE_ADD) ? "ADD" : "DEL",
3119 vrf_id_to_name(vrf_id));
3120
3121 if (cmd == ZEBRA_IP_PREFIX_ROUTE_ADD) {
3122
3123 if (p.family == AF_INET)
d90b788e
A		 3124 bgp_evpn_advertise_type5_route(bgp_vrf, &p, NULL,
3125 AFI_IP, SAFI_UNICAST);
31310b25 3126 else
d90b788e
A		 3127 bgp_evpn_advertise_type5_route(bgp_vrf, &p, NULL,
3128 AFI_IP6, SAFI_UNICAST);
31310b25
MK		 3129
3130 } else {
3131 if (p.family == AF_INET)
d90b788e
A		 3132 bgp_evpn_withdraw_type5_route(bgp_vrf, &p, AFI_IP,
3133 SAFI_UNICAST);
31310b25 3134 else
d90b788e
A		 3135 bgp_evpn_withdraw_type5_route(bgp_vrf, &p, AFI_IP6,
3136 SAFI_UNICAST);
31310b25 3137 }
a243d1db 3138 return 0;
31310b25
MK		 3139}
3140
a243d1db 3141static int bgp_zebra_process_label_chunk(ZAPI_CALLBACK_ARGS)
955bfd98
PZ		 3142{
3143 struct stream *s = NULL;
3144 uint8_t response_keep;
3145 uint32_t first;
3146 uint32_t last;
aec865e4
FR		 3147 uint8_t proto;
3148 unsigned short instance;
955bfd98
PZ		 3149
3150 s = zclient->ibuf;
aec865e4
FR		 3151 STREAM_GETC(s, proto);
3152 STREAM_GETW(s, instance);
955bfd98
PZ		 3153 STREAM_GETC(s, response_keep);
3154 STREAM_GETL(s, first);
3155 STREAM_GETL(s, last);
3156
aec865e4 3157 if (zclient->redist_default != proto) {
e50f7cfd 3158 flog_err(EC_BGP_LM_ERROR, "Got LM msg with wrong proto %u",
1c50c1c0 3159 proto);
a243d1db 3160 return 0;
aec865e4
FR		 3161 }
3162 if (zclient->instance != instance) {
e50f7cfd 3163 flog_err(EC_BGP_LM_ERROR, "Got LM msg with wrong instance %u",
1c50c1c0 3164 proto);
a243d1db 3165 return 0;
aec865e4
FR		 3166 }
3167
955bfd98
PZ		 3168 if (first > last ||
3169 first < MPLS_LABEL_UNRESERVED_MIN ||
3170 last > MPLS_LABEL_UNRESERVED_MAX) {
3171
e50f7cfd 3172 flog_err(EC_BGP_LM_ERROR, "%s: Invalid Label chunk: %u - %u",
1c50c1c0 3173 __func__, first, last);
a243d1db 3174 return 0;
955bfd98
PZ		 3175 }
3176 if (BGP_DEBUG(zebra, ZEBRA)) {
3177 zlog_debug("Label Chunk assign: %u - %u (%u) ",
3178 first, last, response_keep);
3179 }
3180
e70e9f8e 3181 bgp_lp_event_chunk(response_keep, first, last);
955bfd98 3182
a243d1db
DL		 3183 return 0;
3184
955bfd98 3185stream_failure: /* for STREAM_GETX */
a243d1db 3186 return -1;
955bfd98
PZ		 3187}
3188
342213ea
DS		 3189extern struct zebra_privs_t bgpd_privs;
3190
138c5a74
DS		 3191static int bgp_ifp_create(struct interface *ifp)
3192{
ef7bd2a3
DS		 3193 struct bgp *bgp;
3194
3195 if (BGP_DEBUG(zebra, ZEBRA))
096f7609
IR		 3196 zlog_debug("Rx Intf add VRF %u IF %s", ifp->vrf->vrf_id,
3197 ifp->name);
ef7bd2a3 3198
096f7609 3199 bgp = ifp->vrf->info;
ef7bd2a3
DS		 3200 if (!bgp)
3201 return 0;
3202
3203 bgp_mac_add_mac_entry(ifp);
3204
3205 bgp_update_interface_nbrs(bgp, ifp, ifp);
0d020cd6 3206 hook_call(bgp_vrf_status_changed, bgp, ifp);
138c5a74
DS		 3207 return 0;
3208}
3209
a243d1db 3210static int bgp_zebra_process_srv6_locator_chunk(ZAPI_CALLBACK_ARGS)
a0281b2e
HS		 3211{
3212 struct stream *s = NULL;
7de4c885
HS		 3213 struct bgp *bgp = bgp_get_default();
3214 struct listnode *node;
1c21a234
NM		 3215 struct srv6_locator_chunk *c;
3216 struct srv6_locator_chunk *chunk = srv6_locator_chunk_alloc();
a0281b2e
HS		 3217
3218 s = zclient->ibuf;
1c21a234 3219 zapi_srv6_locator_chunk_decode(s, chunk);
a0281b2e 3220
1c21a234 3221 if (strcmp(bgp->srv6_locator_name, chunk->locator_name) != 0) {
3a0220e4 3222 zlog_err("%s: Locator name unmatch %s:%s", __func__,
1c21a234 3223 bgp->srv6_locator_name, chunk->locator_name);
69467313 3224 srv6_locator_chunk_free(&chunk);
a243d1db 3225 return 0;
a0281b2e
HS		 3226 }
3227
a0281b2e 3228 for (ALL_LIST_ELEMENTS_RO(bgp->srv6_locator_chunks, node, c)) {
1c21a234 3229 if (!prefix_cmp(&c->prefix, &chunk->prefix)) {
69467313 3230 srv6_locator_chunk_free(&chunk);
a243d1db 3231 return 0;
1c21a234 3232 }
a0281b2e
HS		 3233 }
3234
3235 listnode_add(bgp->srv6_locator_chunks, chunk);
3236 vpn_leak_postchange_all();
a243d1db 3237 return 0;
a0281b2e
HS		 3238}
3239
d79ff732
HS		 3240static int bgp_zebra_process_srv6_locator_add(ZAPI_CALLBACK_ARGS)
3241{
3242 struct srv6_locator loc = {};
3243 struct bgp *bgp = bgp_get_default();
3244 const char *loc_name = bgp->srv6_locator_name;
3245
3246 if (zapi_srv6_locator_decode(zclient->ibuf, &loc) < 0)
3247 return -1;
3248
3249 if (!bgp || !bgp->srv6_enabled)
3250 return 0;
3251
3252 if (bgp_zebra_srv6_manager_get_locator_chunk(loc_name) < 0)
3253 return -1;
3254
3255 return 0;
3256}
3257
3258static int bgp_zebra_process_srv6_locator_delete(ZAPI_CALLBACK_ARGS)
3259{
3260 struct srv6_locator loc = {};
3261 struct bgp *bgp = bgp_get_default();
3262 struct listnode *node, *nnode;
bee2e7d0 3263 struct srv6_locator_chunk *chunk, *tovpn_sid_locator;
d79ff732
HS		 3264 struct bgp_srv6_function *func;
3265 struct bgp *bgp_vrf;
bee2e7d0 3266 struct in6_addr *tovpn_sid;
d79ff732
HS		 3267 struct prefix_ipv6 tmp_prefi;
3268
3269 if (zapi_srv6_locator_decode(zclient->ibuf, &loc) < 0)
3270 return -1;
3271
3272 // refresh chunks
3273 for (ALL_LIST_ELEMENTS(bgp->srv6_locator_chunks, node, nnode, chunk))
3274 if (prefix_match((struct prefix *)&loc.prefix,
03852f67 3275 (struct prefix *)&chunk->prefix)) {
d79ff732 3276 listnode_delete(bgp->srv6_locator_chunks, chunk);
69467313 3277 srv6_locator_chunk_free(&chunk);
03852f67 3278 }
d79ff732
HS		 3279
3280 // refresh functions
3281 for (ALL_LIST_ELEMENTS(bgp->srv6_functions, node, nnode, func)) {
3282 tmp_prefi.family = AF_INET6;
3283 tmp_prefi.prefixlen = 128;
3284 tmp_prefi.prefix = func->sid;
3285 if (prefix_match((struct prefix *)&loc.prefix,
bda15542 3286 (struct prefix *)&tmp_prefi)) {
d79ff732 3287 listnode_delete(bgp->srv6_functions, func);
bda15542
CS		 3288 XFREE(MTYPE_BGP_SRV6_FUNCTION, func);
3289 }
d79ff732
HS		 3290 }
3291
3292 // refresh tovpn_sid
3293 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_vrf)) {
3294 if (bgp_vrf->inst_type != BGP_INSTANCE_TYPE_VRF)
3295 continue;
3296
3297 // refresh vpnv4 tovpn_sid
3298 tovpn_sid = bgp_vrf->vpn_policy[AFI_IP].tovpn_sid;
3299 if (tovpn_sid) {
3300 tmp_prefi.family = AF_INET6;
3301 tmp_prefi.prefixlen = 128;
3302 tmp_prefi.prefix = *tovpn_sid;
3303 if (prefix_match((struct prefix *)&loc.prefix,
3304 (struct prefix *)&tmp_prefi))
3305 XFREE(MTYPE_BGP_SRV6_SID,
3306 bgp_vrf->vpn_policy[AFI_IP].tovpn_sid);
3307 }
3308
3309 // refresh vpnv6 tovpn_sid
3310 tovpn_sid = bgp_vrf->vpn_policy[AFI_IP6].tovpn_sid;
3311 if (tovpn_sid) {
3312 tmp_prefi.family = AF_INET6;
3313 tmp_prefi.prefixlen = 128;
3314 tmp_prefi.prefix = *tovpn_sid;
3315 if (prefix_match((struct prefix *)&loc.prefix,
3316 (struct prefix *)&tmp_prefi))
3317 XFREE(MTYPE_BGP_SRV6_SID,
3318 bgp_vrf->vpn_policy[AFI_IP6].tovpn_sid);
3319 }
527588aa
CS		 3320
3321 /* refresh per-vrf tovpn_sid */
3322 tovpn_sid = bgp_vrf->tovpn_sid;
3323 if (tovpn_sid) {
3324 tmp_prefi.family = AF_INET6;
3325 tmp_prefi.prefixlen = IPV6_MAX_BITLEN;
3326 tmp_prefi.prefix = *tovpn_sid;
3327 if (prefix_match((struct prefix *)&loc.prefix,
3328 (struct prefix *)&tmp_prefi))
3329 XFREE(MTYPE_BGP_SRV6_SID, bgp_vrf->tovpn_sid);
3330 }
d79ff732
HS		 3331 }
3332
3333 vpn_leak_postchange_all();
f8e9c702
CS		 3334
3335 /* refresh tovpn_sid_locator */
3336 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_vrf)) {
3337 if (bgp_vrf->inst_type != BGP_INSTANCE_TYPE_VRF)
3338 continue;
3339
3340 /* refresh vpnv4 tovpn_sid_locator */
3341 tovpn_sid_locator =
3342 bgp_vrf->vpn_policy[AFI_IP].tovpn_sid_locator;
3343 if (tovpn_sid_locator) {
3344 tmp_prefi.family = AF_INET6;
3345 tmp_prefi.prefixlen = IPV6_MAX_BITLEN;
bee2e7d0 3346 tmp_prefi.prefix = tovpn_sid_locator->prefix.prefix;
f8e9c702 3347 if (prefix_match((struct prefix *)&loc.prefix,
a1d5e05f 3348 (struct prefix *)&tmp_prefi))
69467313
CS		 3349 srv6_locator_chunk_free(
3350 &bgp_vrf->vpn_policy[AFI_IP]
3351 .tovpn_sid_locator);
f8e9c702
CS		 3352 }
3353
3354 /* refresh vpnv6 tovpn_sid_locator */
3355 tovpn_sid_locator =
3356 bgp_vrf->vpn_policy[AFI_IP6].tovpn_sid_locator;
3357 if (tovpn_sid_locator) {
3358 tmp_prefi.family = AF_INET6;
3359 tmp_prefi.prefixlen = IPV6_MAX_BITLEN;
bee2e7d0 3360 tmp_prefi.prefix = tovpn_sid_locator->prefix.prefix;
f8e9c702 3361 if (prefix_match((struct prefix *)&loc.prefix,
a1d5e05f 3362 (struct prefix *)&tmp_prefi))
69467313
CS		 3363 srv6_locator_chunk_free(
3364 &bgp_vrf->vpn_policy[AFI_IP6]
3365 .tovpn_sid_locator);
f8e9c702 3366 }
527588aa
CS		 3367
3368 /* refresh per-vrf tovpn_sid_locator */
3369 tovpn_sid_locator = bgp_vrf->tovpn_sid_locator;
3370 if (tovpn_sid_locator) {
3371 tmp_prefi.family = AF_INET6;
3372 tmp_prefi.prefixlen = IPV6_MAX_BITLEN;
3373 tmp_prefi.prefix = tovpn_sid_locator->prefix.prefix;
3374 if (prefix_match((struct prefix *)&loc.prefix,
3375 (struct prefix *)&tmp_prefi))
69467313
CS		 3376 srv6_locator_chunk_free(
3377 &bgp_vrf->tovpn_sid_locator);
527588aa 3378 }
f8e9c702
CS		 3379 }
3380
d79ff732
HS		 3381 return 0;
3382}
3383
a243d1db
DL		 3384static zclient_handler *const bgp_handlers[] = {
3385 [ZEBRA_ROUTER_ID_UPDATE] = bgp_router_id_update,
3386 [ZEBRA_INTERFACE_ADDRESS_ADD] = bgp_interface_address_add,
3387 [ZEBRA_INTERFACE_ADDRESS_DELETE] = bgp_interface_address_delete,
3388 [ZEBRA_INTERFACE_NBR_ADDRESS_ADD] = bgp_interface_nbr_address_add,
3389 [ZEBRA_INTERFACE_NBR_ADDRESS_DELETE] = bgp_interface_nbr_address_delete,
3390 [ZEBRA_INTERFACE_VRF_UPDATE] = bgp_interface_vrf_update,
3391 [ZEBRA_REDISTRIBUTE_ROUTE_ADD] = zebra_read_route,
3392 [ZEBRA_REDISTRIBUTE_ROUTE_DEL] = zebra_read_route,
3393 [ZEBRA_NEXTHOP_UPDATE] = bgp_read_nexthop_update,
3394 [ZEBRA_FEC_UPDATE] = bgp_read_fec_update,
3395 [ZEBRA_LOCAL_ES_ADD] = bgp_zebra_process_local_es_add,
3396 [ZEBRA_LOCAL_ES_DEL] = bgp_zebra_process_local_es_del,
3397 [ZEBRA_VNI_ADD] = bgp_zebra_process_local_vni,
3398 [ZEBRA_LOCAL_ES_EVI_ADD] = bgp_zebra_process_local_es_evi,
3399 [ZEBRA_LOCAL_ES_EVI_DEL] = bgp_zebra_process_local_es_evi,
3400 [ZEBRA_VNI_DEL] = bgp_zebra_process_local_vni,
3401 [ZEBRA_MACIP_ADD] = bgp_zebra_process_local_macip,
3402 [ZEBRA_MACIP_DEL] = bgp_zebra_process_local_macip,
3403 [ZEBRA_L3VNI_ADD] = bgp_zebra_process_local_l3vni,
3404 [ZEBRA_L3VNI_DEL] = bgp_zebra_process_local_l3vni,
3405 [ZEBRA_IP_PREFIX_ROUTE_ADD] = bgp_zebra_process_local_ip_prefix,
3406 [ZEBRA_IP_PREFIX_ROUTE_DEL] = bgp_zebra_process_local_ip_prefix,
3407 [ZEBRA_GET_LABEL_CHUNK] = bgp_zebra_process_label_chunk,
3408 [ZEBRA_RULE_NOTIFY_OWNER] = rule_notify_owner,
3409 [ZEBRA_IPSET_NOTIFY_OWNER] = ipset_notify_owner,
3410 [ZEBRA_IPSET_ENTRY_NOTIFY_OWNER] = ipset_entry_notify_owner,
3411 [ZEBRA_IPTABLE_NOTIFY_OWNER] = iptable_notify_owner,
3412 [ZEBRA_ROUTE_NOTIFY_OWNER] = bgp_zebra_route_notify_owner,
3413 [ZEBRA_SRV6_LOCATOR_ADD] = bgp_zebra_process_srv6_locator_add,
3414 [ZEBRA_SRV6_LOCATOR_DELETE] = bgp_zebra_process_srv6_locator_delete,
3415 [ZEBRA_SRV6_MANAGER_GET_LOCATOR_CHUNK] =
3416 bgp_zebra_process_srv6_locator_chunk,
3417};
3418
4cd690ae
PG		 3419static int bgp_if_new_hook(struct interface *ifp)
3420{
3421 struct bgp_interface *iifp;
3422
3423 if (ifp->info)
3424 return 0;
3425 iifp = XCALLOC(MTYPE_BGP_IF_INFO, sizeof(struct bgp_interface));
3426 ifp->info = iifp;
3427
3428 return 0;
3429}
3430
3431static int bgp_if_delete_hook(struct interface *ifp)
3432{
3433 XFREE(MTYPE_BGP_IF_INFO, ifp->info);
3434 return 0;
3435}
3436
3437void bgp_if_init(void)
3438{
3439 /* Initialize Zebra interface data structure. */
3440 hook_register_prio(if_add, 0, bgp_if_new_hook);
3441 hook_register_prio(if_del, 0, bgp_if_delete_hook);
3442}
3443
f533be73 3444void bgp_zebra_init(struct thread_master *master, unsigned short instance)
718e3744 3445{
d62a17ae 3446 zclient_num_connects = 0;
3447
138c5a74
DS		 3448 if_zapi_callbacks(bgp_ifp_create, bgp_ifp_up,
3449 bgp_ifp_down, bgp_ifp_destroy);
3450
d62a17ae 3451 /* Set default values. */
a243d1db
DL		 3452 zclient = zclient_new(master, &zclient_options_default, bgp_handlers,
3453 array_size(bgp_handlers));
342213ea 3454 zclient_init(zclient, ZEBRA_ROUTE_BGP, 0, &bgpd_privs);
d62a17ae 3455 zclient->zebra_connected = bgp_zebra_connected;
f533be73 3456 zclient->instance = instance;
718e3744 3457}
bb86c601 3458
d62a17ae 3459void bgp_zebra_destroy(void)
bb86c601 3460{
d62a17ae 3461 if (zclient == NULL)
3462 return;
3463 zclient_stop(zclient);
3464 zclient_free(zclient);
3465 zclient = NULL;
bb86c601 3466}
afbb1c59 3467
d62a17ae 3468int bgp_zebra_num_connects(void)
afbb1c59 3469{
d62a17ae 3470 return zclient_num_connects;
afbb1c59 3471}
30d50e6d 3472
6cfe5d15
PG		 3473void bgp_send_pbr_rule_action(struct bgp_pbr_action *pbra,
3474 struct bgp_pbr_rule *pbr,
3475 bool install)
30d50e6d
PG		 3476{
3477 struct stream *s;
3478
6cfe5d15 3479 if (pbra->install_in_progress && !pbr)
30d50e6d 3480 return;
6cfe5d15
PG		 3481 if (pbr && pbr->install_in_progress)
3482 return;
3483 if (BGP_DEBUG(zebra, ZEBRA)) {
3484 if (pbr)
15569c58 3485 zlog_debug("%s: table %d (ip rule) %d", __func__,
6cfe5d15
PG		 3486 pbra->table_id, install);
3487 else
15569c58 3488 zlog_debug("%s: table %d fwmark %d %d", __func__,
6cfe5d15
PG		 3489 pbra->table_id, pbra->fwmark, install);
3490 }
30d50e6d
PG		 3491 s = zclient->obuf;
3492 stream_reset(s);
3493
3494 zclient_create_header(s,
3495 install ? ZEBRA_RULE_ADD : ZEBRA_RULE_DELETE,
3496 VRF_DEFAULT);
3497 stream_putl(s, 1); /* send one pbr action */
3498
6cfe5d15 3499 bgp_encode_pbr_rule_action(s, pbra, pbr);
30d50e6d
PG		 3500
3501 stream_putw_at(s, 0, stream_get_endp(s));
8a3f8f2e
DS		 3502 if ((zclient_send_message(zclient) != ZCLIENT_SEND_FAILURE)
3503 && install) {
6cfe5d15
PG		 3504 if (!pbr)
3505 pbra->install_in_progress = true;
3506 else
3507 pbr->install_in_progress = true;
3508 }
30d50e6d
PG		 3509}
3510
3511void bgp_send_pbr_ipset_match(struct bgp_pbr_match *pbrim, bool install)
3512{
3513 struct stream *s;
3514
3515 if (pbrim->install_in_progress)
3516 return;
f0936054 3517 if (BGP_DEBUG(zebra, ZEBRA))
15569c58
DA		 3518 zlog_debug("%s: name %s type %d %d, ID %u", __func__,
3519 pbrim->ipset_name, pbrim->type, install,
3520 pbrim->unique);
30d50e6d
PG		 3521 s = zclient->obuf;
3522 stream_reset(s);
3523
3524 zclient_create_header(s,
3525 install ? ZEBRA_IPSET_CREATE :
3526 ZEBRA_IPSET_DESTROY,
3527 VRF_DEFAULT);
3528
3529 stream_putl(s, 1); /* send one pbr action */
3530
3531 bgp_encode_pbr_ipset_match(s, pbrim);
3532
3533 stream_putw_at(s, 0, stream_get_endp(s));
8a3f8f2e 3534 if ((zclient_send_message(zclient) != ZCLIENT_SEND_FAILURE) && install)
30d50e6d
PG		 3535 pbrim->install_in_progress = true;
3536}
3537
3538void bgp_send_pbr_ipset_entry_match(struct bgp_pbr_match_entry *pbrime,
3539 bool install)
3540{
3541 struct stream *s;
3542
3543 if (pbrime->install_in_progress)
3544 return;
f0936054 3545 if (BGP_DEBUG(zebra, ZEBRA))
15569c58
DA		 3546 zlog_debug("%s: name %s %d %d, ID %u", __func__,
3547 pbrime->backpointer->ipset_name, pbrime->unique,
3548 install, pbrime->unique);
30d50e6d
PG		 3549 s = zclient->obuf;
3550 stream_reset(s);
3551
3552 zclient_create_header(s,
3553 install ? ZEBRA_IPSET_ENTRY_ADD :
3554 ZEBRA_IPSET_ENTRY_DELETE,
3555 VRF_DEFAULT);
3556
3557 stream_putl(s, 1); /* send one pbr action */
3558
3559 bgp_encode_pbr_ipset_entry_match(s, pbrime);
3560
3561 stream_putw_at(s, 0, stream_get_endp(s));
8a3f8f2e 3562 if ((zclient_send_message(zclient) != ZCLIENT_SEND_FAILURE) && install)
30d50e6d
PG		 3563 pbrime->install_in_progress = true;
3564}
c16a0a62 3565
8f242187
PG		 3566static void bgp_encode_pbr_interface_list(struct bgp *bgp, struct stream *s,
3567 uint8_t family)
4762c213
PG		 3568{
3569 struct bgp_pbr_config *bgp_pbr_cfg = bgp->bgp_pbr_cfg;
3570 struct bgp_pbr_interface_head *head;
3571 struct bgp_pbr_interface *pbr_if;
3572 struct interface *ifp;
3573
3574 if (!bgp_pbr_cfg)
3575 return;
8f242187
PG		 3576 if (family == AF_INET)
3577 head = &(bgp_pbr_cfg->ifaces_by_name_ipv4);
3578 else
3579 head = &(bgp_pbr_cfg->ifaces_by_name_ipv6);
4762c213 3580 RB_FOREACH (pbr_if, bgp_pbr_interface_head, head) {
a36898e7 3581 ifp = if_lookup_by_name(pbr_if->name, bgp->vrf_id);
4762c213
PG		 3582 if (ifp)
3583 stream_putl(s, ifp->ifindex);
3584 }
3585}
3586
8f242187 3587static int bgp_pbr_get_ifnumber(struct bgp *bgp, uint8_t family)
4762c213
PG		 3588{
3589 struct bgp_pbr_config *bgp_pbr_cfg = bgp->bgp_pbr_cfg;
3590 struct bgp_pbr_interface_head *head;
3591 struct bgp_pbr_interface *pbr_if;
3592 int cnt = 0;
3593
3594 if (!bgp_pbr_cfg)
3595 return 0;
8f242187
PG		 3596 if (family == AF_INET)
3597 head = &(bgp_pbr_cfg->ifaces_by_name_ipv4);
3598 else
3599 head = &(bgp_pbr_cfg->ifaces_by_name_ipv6);
4762c213 3600 RB_FOREACH (pbr_if, bgp_pbr_interface_head, head) {
a36898e7 3601 if (if_lookup_by_name(pbr_if->name, bgp->vrf_id))
4762c213
PG		 3602 cnt++;
3603 }
3604 return cnt;
3605}
3606
c16a0a62
PG		 3607void bgp_send_pbr_iptable(struct bgp_pbr_action *pba,
3608 struct bgp_pbr_match *pbm,
3609 bool install)
3610{
3611 struct stream *s;
b5c40105 3612 int ret = 0;
4762c213 3613 int nb_interface;
c16a0a62
PG		 3614
3615 if (pbm->install_iptable_in_progress)
3616 return;
f0936054 3617 if (BGP_DEBUG(zebra, ZEBRA))
15569c58
DA		 3618 zlog_debug("%s: name %s type %d mark %d %d, ID %u", __func__,
3619 pbm->ipset_name, pbm->type, pba->fwmark, install,
88055124 3620 pbm->unique2);
c16a0a62
PG		 3621 s = zclient->obuf;
3622 stream_reset(s);
3623
3624 zclient_create_header(s,
3625 install ? ZEBRA_IPTABLE_ADD :
3626 ZEBRA_IPTABLE_DELETE,
3627 VRF_DEFAULT);
3628
3629 bgp_encode_pbr_iptable_match(s, pba, pbm);
8f242187 3630 nb_interface = bgp_pbr_get_ifnumber(pba->bgp, pbm->family);
4762c213
PG		 3631 stream_putl(s, nb_interface);
3632 if (nb_interface)
8f242187 3633 bgp_encode_pbr_interface_list(pba->bgp, s, pbm->family);
c16a0a62 3634 stream_putw_at(s, 0, stream_get_endp(s));
b5c40105
PG		 3635 ret = zclient_send_message(zclient);
3636 if (install) {
8a3f8f2e 3637 if (ret != ZCLIENT_SEND_FAILURE)
b5c40105
PG		 3638 pba->refcnt++;
3639 else
3640 pbm->install_iptable_in_progress = true;
a6b07429 3641 }
c16a0a62 3642}
f7df1907
PG		 3643
3644/* inject in table <table_id> a default route to:
3645 * - if nexthop IP is present : to this nexthop
3646 * - if vrf is different from local : to the matching VRF
3647 */
3648void bgp_zebra_announce_default(struct bgp *bgp, struct nexthop *nh,
3649 afi_t afi, uint32_t table_id, bool announce)
3650{
3651 struct zapi_nexthop *api_nh;
3652 struct zapi_route api;
3653 struct prefix p;
3654
f01e580f
PG		 3655 if (!nh || (nh->type != NEXTHOP_TYPE_IPV4
3656 && nh->type != NEXTHOP_TYPE_IPV6)
f7df1907
PG		 3657 || nh->vrf_id == VRF_UNKNOWN)
3658 return;
7afeaffa
PG		 3659
3660 /* in vrf-lite, no default route has to be announced
3661 * the table id of vrf is directly used to divert traffic
3662 */
3663 if (!vrf_is_backend_netns() && bgp->vrf_id != nh->vrf_id)
3664 return;
3665
6006b807 3666 memset(&p, 0, sizeof(p));
f01e580f 3667 if (afi != AFI_IP && afi != AFI_IP6)
f7df1907 3668 return;
f01e580f 3669 p.family = afi2family(afi);
f7df1907
PG		 3670 memset(&api, 0, sizeof(api));
3671 api.vrf_id = bgp->vrf_id;
3672 api.type = ZEBRA_ROUTE_BGP;
3673 api.safi = SAFI_UNICAST;
3674 api.prefix = p;
3675 api.tableid = table_id;
3676 api.nexthop_num = 1;
3677 SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
3678 SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
3679 api_nh = &api.nexthops[0];
3680
38a8c751
DS		 3681 api.distance = ZEBRA_EBGP_DISTANCE_DEFAULT;
3682 SET_FLAG(api.message, ZAPI_MESSAGE_DISTANCE);
3683
f7df1907 3684 /* redirect IP */
f01e580f 3685 if (afi == AFI_IP && nh->gate.ipv4.s_addr != INADDR_ANY) {
f7df1907
PG		 3686 api_nh->vrf_id = nh->vrf_id;
3687 api_nh->gate.ipv4 = nh->gate.ipv4;
3688 api_nh->type = NEXTHOP_TYPE_IPV4;
3689
f7df1907 3690 if (BGP_DEBUG(zebra, ZEBRA))
07380148
DA		 3691 zlog_debug(
3692 "BGP: %s default route to %pI4 table %d (redirect IP)",
3693 announce ? "adding" : "withdrawing",
3694 &nh->gate.ipv4, table_id);
3695
f01e580f
PG		 3696 zclient_route_send(announce ? ZEBRA_ROUTE_ADD
3697 : ZEBRA_ROUTE_DELETE,
3698 zclient, &api);
3699 } else if (afi == AFI_IP6 &&
3700 memcmp(&nh->gate.ipv6,
3701 &in6addr_any, sizeof(struct in6_addr))) {
f01e580f
PG		 3702 api_nh->vrf_id = nh->vrf_id;
3703 memcpy(&api_nh->gate.ipv6, &nh->gate.ipv6,
3704 sizeof(struct in6_addr));
3705 api_nh->type = NEXTHOP_TYPE_IPV6;
3706
f01e580f 3707 if (BGP_DEBUG(zebra, ZEBRA))
07380148
DA		 3708 zlog_debug(
3709 "BGP: %s default route to %pI6 table %d (redirect IP)",
3710 announce ? "adding" : "withdrawing",
3711 &nh->gate.ipv6, table_id);
3712
f7df1907
PG		 3713 zclient_route_send(announce ? ZEBRA_ROUTE_ADD
3714 : ZEBRA_ROUTE_DELETE,
3715 zclient, &api);
3716 } else if (nh->vrf_id != bgp->vrf_id) {
3717 struct vrf *vrf;
eb4244f8 3718 struct interface *ifp;
f7df1907 3719
eb4244f8 3720 vrf = vrf_lookup_by_id(nh->vrf_id);
f7df1907
PG		 3721 if (!vrf)
3722 return;
eb4244f8
PG		 3723 /* create default route with interface <VRF>
3724 * with nexthop-vrf <VRF>
f7df1907 3725 */
de4f1a66 3726 ifp = if_lookup_by_name_vrf(vrf->name, vrf);
eb4244f8
PG		 3727 if (!ifp)
3728 return;
3729 api_nh->vrf_id = nh->vrf_id;
3730 api_nh->type = NEXTHOP_TYPE_IFINDEX;
3731 api_nh->ifindex = ifp->ifindex;
3732 if (BGP_DEBUG(zebra, ZEBRA))
d887503c
PG		 3733 zlog_info("BGP: %s default route to %s table %d (redirect VRF)",
3734 announce ? "adding" : "withdrawing",
eb4244f8
PG		 3735 vrf->name, table_id);
3736 zclient_route_send(announce ? ZEBRA_ROUTE_ADD
3737 : ZEBRA_ROUTE_DELETE,
3738 zclient, &api);
f7df1907
PG		 3739 return;
3740 }
3741}
85ef4179 3742
3743/* Send capabilities to RIB */
3744int bgp_zebra_send_capabilities(struct bgp *bgp, bool disable)
3745{
3746 struct zapi_cap api;
3747 int ret = BGP_GR_SUCCESS;
3748
3749 if (zclient == NULL) {
3750 if (BGP_DEBUG(zebra, ZEBRA))
3751 zlog_debug("zclient invalid");
3752 return BGP_GR_FAILURE;
3753 }
3754
3755 /* Check if the client is connected */
3756 if ((zclient->sock < 0) || (zclient->t_connect)) {
3757 if (BGP_DEBUG(zebra, ZEBRA))
3758 zlog_debug("client not connected");
3759 return BGP_GR_FAILURE;
3760 }
3761
3762 /* Check if capability is already sent. If the flag force is set
3763 * send the capability since this can be initial bgp configuration
3764 */
6006b807 3765 memset(&api, 0, sizeof(api));
85ef4179 3766 if (disable) {
3767 api.cap = ZEBRA_CLIENT_GR_DISABLE;
3768 api.vrf_id = bgp->vrf_id;
3769 } else {
3770 api.cap = ZEBRA_CLIENT_GR_CAPABILITIES;
3771 api.stale_removal_time = bgp->rib_stale_time;
3772 api.vrf_id = bgp->vrf_id;
3773 }
3774
36235319 3775 if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES, zclient, &api)
7cfdb485 3776 == ZCLIENT_SEND_FAILURE) {
2ba1fe69 3777 zlog_err("error sending capability");
85ef4179 3778 ret = BGP_GR_FAILURE;
3779 } else {
3780 if (disable)
3781 bgp->present_zebra_gr_state = ZEBRA_GR_DISABLE;
3782 else
3783 bgp->present_zebra_gr_state = ZEBRA_GR_ENABLE;
3784
3785 if (BGP_DEBUG(zebra, ZEBRA))
3786 zlog_debug("send capabilty success");
3787 ret = BGP_GR_SUCCESS;
3788 }
3789 return ret;
3790}
3791
3792/* Send route update pesding or completed status to RIB for the
3793 * specific AFI, SAFI
3794 */
3795int bgp_zebra_update(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type)
3796{
2ba1fe69 3797 struct zapi_cap api = {0};
85ef4179 3798
3799 if (zclient == NULL) {
3800 if (BGP_DEBUG(zebra, ZEBRA))
2ba1fe69 3801 zlog_debug("zclient == NULL, invalid");
85ef4179 3802 return BGP_GR_FAILURE;
3803 }
3804
3805 /* Check if the client is connected */
3806 if ((zclient->sock < 0) || (zclient->t_connect)) {
3807 if (BGP_DEBUG(zebra, ZEBRA))
3808 zlog_debug("client not connected");
3809 return BGP_GR_FAILURE;
3810 }
3811
85ef4179 3812 api.afi = afi;
3813 api.safi = safi;
3814 api.vrf_id = vrf_id;
3815 api.cap = type;
3816
36235319 3817 if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES, zclient, &api)
7cfdb485 3818 == ZCLIENT_SEND_FAILURE) {
85ef4179 3819 if (BGP_DEBUG(zebra, ZEBRA))
3820 zlog_debug("error sending capability");
3821 return BGP_GR_FAILURE;
3822 }
3823 return BGP_GR_SUCCESS;
3824}
3825
3826
85ef4179 3827/* Send RIB stale timer update */
3828int bgp_zebra_stale_timer_update(struct bgp *bgp)
3829{
3830 struct zapi_cap api;
3831
3832 if (zclient == NULL) {
3833 if (BGP_DEBUG(zebra, ZEBRA))
3834 zlog_debug("zclient invalid");
3835 return BGP_GR_FAILURE;
3836 }
3837
3838 /* Check if the client is connected */
3839 if ((zclient->sock < 0) || (zclient->t_connect)) {
3840 if (BGP_DEBUG(zebra, ZEBRA))
3841 zlog_debug("client not connected");
3842 return BGP_GR_FAILURE;
3843 }
3844
6006b807 3845 memset(&api, 0, sizeof(api));
85ef4179 3846 api.cap = ZEBRA_CLIENT_RIB_STALE_TIME;
3847 api.stale_removal_time = bgp->rib_stale_time;
3848 api.vrf_id = bgp->vrf_id;
36235319 3849 if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES, zclient, &api)
7cfdb485 3850 == ZCLIENT_SEND_FAILURE) {
85ef4179 3851 if (BGP_DEBUG(zebra, ZEBRA))
3852 zlog_debug("error sending capability");
3853 return BGP_GR_FAILURE;
3854 }
3855 if (BGP_DEBUG(zebra, ZEBRA))
3856 zlog_debug("send capabilty success");
3857 return BGP_GR_SUCCESS;
3858}
a0281b2e
HS		 3859
3860int bgp_zebra_srv6_manager_get_locator_chunk(const char *name)
3861{
3862 return srv6_manager_get_locator_chunk(zclient, name);
3863}
0249b8b6
HS		 3864
3865int bgp_zebra_srv6_manager_release_locator_chunk(const char *name)
3866{
3867 return srv6_manager_release_locator_chunk(zclient, name);
3868}
FRRouting mirror