]> 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
bgpd: display if FS entry is installed in PBR or not
[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"
039f3a34 36#include "filter.h"
cd1964ff 37#include "mpls.h"
128ea8ab 38#include "vxlan.h"
718e3744 39
40#include "bgpd/bgpd.h"
41#include "bgpd/bgp_route.h"
42#include "bgpd/bgp_attr.h"
43#include "bgpd/bgp_nexthop.h"
44#include "bgpd/bgp_zebra.h"
45#include "bgpd/bgp_fsm.h"
a39275d7 46#include "bgpd/bgp_debug.h"
8196f13d 47#include "bgpd/bgp_mpath.h"
fb018d25 48#include "bgpd/bgp_nexthop.h"
ffd0c037 49#include "bgpd/bgp_nht.h"
8c4f6381 50#include "bgpd/bgp_bfd.h"
cd1964ff 51#include "bgpd/bgp_label.h"
65efcfce 52#if ENABLE_BGP_VNC
d62a17ae 53#include "bgpd/rfapi/rfapi_backend.h"
54#include "bgpd/rfapi/vnc_export_bgp.h"
65efcfce 55#endif
128ea8ab 56#include "bgpd/bgp_evpn.h"
ddb5b488 57#include "bgpd/bgp_mplsvpn.h"
955bfd98 58#include "bgpd/bgp_labelpool.h"
30d50e6d 59#include "bgpd/bgp_pbr.h"
6b0655a2 60
718e3744 61/* All information about zebra. */
228da428 62struct zclient *zclient = NULL;
718e3744 63
ad4cbda1 64/* Can we install into zebra? */
d62a17ae 65static inline int bgp_install_info_to_zebra(struct bgp *bgp)
ad4cbda1 66{
d62a17ae 67 if (zclient->sock <= 0)
68 return 0;
ad4cbda1 69
d62a17ae 70 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp))
71 return 0;
ad4cbda1 72
d62a17ae 73 return 1;
ad4cbda1 74}
75
afbb1c59
LB		 76int zclient_num_connects;
77
18a6dce6 78/* Router-id update message from zebra. */
d62a17ae 79static int bgp_router_id_update(int command, struct zclient *zclient,
80 zebra_size_t length, vrf_id_t vrf_id)
718e3744 81{
d62a17ae 82 struct prefix router_id;
718e3744 83
d62a17ae 84 zebra_router_id_update_read(zclient->ibuf, &router_id);
a39275d7 85
d62a17ae 86 if (BGP_DEBUG(zebra, ZEBRA)) {
87 char buf[PREFIX2STR_BUFFER];
88 prefix2str(&router_id, buf, sizeof(buf));
89 zlog_debug("Rx Router Id update VRF %u Id %s", vrf_id, buf);
90 }
a39275d7 91
d62a17ae 92 bgp_router_id_zebra_bump(vrf_id, &router_id);
93 return 0;
718e3744 94}
95
fb018d25 96/* Nexthop update message from zebra. */
d62a17ae 97static int bgp_read_nexthop_update(int command, struct zclient *zclient,
98 zebra_size_t length, vrf_id_t vrf_id)
fb018d25 99{
d62a17ae 100 bgp_parse_nexthop_update(command, vrf_id);
101 return 0;
078430f6
DS		 102}
103
d62a17ae 104static int bgp_read_import_check_update(int command, struct zclient *zclient,
105 zebra_size_t length, vrf_id_t vrf_id)
078430f6 106{
d62a17ae 107 bgp_parse_nexthop_update(command, vrf_id);
108 return 0;
fb018d25
DS		 109}
110
4a04e5f7 111/* Set or clear interface on which unnumbered neighbor is configured. This
112 * would in turn cause BGP to initiate or turn off IPv6 RAs on this
113 * interface.
114 */
d62a17ae 115static void bgp_update_interface_nbrs(struct bgp *bgp, struct interface *ifp,
116 struct interface *upd_ifp)
4a04e5f7 117{
d62a17ae 118 struct listnode *node, *nnode;
119 struct peer *peer;
120
121 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
122 if (peer->conf_if && (strcmp(peer->conf_if, ifp->name) == 0)) {
123 if (upd_ifp) {
124 peer->ifp = upd_ifp;
125 bgp_zebra_initiate_radv(bgp, peer);
126 } else {
127 bgp_zebra_terminate_radv(bgp, peer);
128 peer->ifp = upd_ifp;
129 }
130 }
131 }
4a04e5f7 132}
133
d62a17ae 134static int bgp_read_fec_update(int command, struct zclient *zclient,
135 zebra_size_t length)
cd1964ff 136{
d62a17ae 137 bgp_parse_fec_update();
138 return 0;
cd1964ff
DS		 139}
140
d62a17ae 141static void bgp_start_interface_nbrs(struct bgp *bgp, struct interface *ifp)
a80beece 142{
d62a17ae 143 struct listnode *node, *nnode;
144 struct peer *peer;
145
146 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
147 if (peer->conf_if && (strcmp(peer->conf_if, ifp->name) == 0)
148 && peer->status != Established) {
149 if (peer_active(peer))
150 BGP_EVENT_ADD(peer, BGP_Stop);
151 BGP_EVENT_ADD(peer, BGP_Start);
152 }
153 }
a80beece
DS		 154}
155
d62a17ae 156static void bgp_nbr_connected_add(struct bgp *bgp, struct nbr_connected *ifc)
a197c47c 157{
d62a17ae 158 struct listnode *node;
159 struct connected *connected;
160 struct interface *ifp;
161 struct prefix *p;
162
163 /* Kick-off the FSM for any relevant peers only if there is a
164 * valid local address on the interface.
165 */
166 ifp = ifc->ifp;
167 for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, connected)) {
168 p = connected->address;
169 if (p->family == AF_INET6
170 && IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
171 break;
172 }
173 if (!connected)
174 return;
175
176 bgp_start_interface_nbrs(bgp, ifp);
a197c47c
DS		 177}
178
d62a17ae 179static void bgp_nbr_connected_delete(struct bgp *bgp, struct nbr_connected *ifc,
180 int del)
a80beece 181{
d62a17ae 182 struct listnode *node, *nnode;
183 struct peer *peer;
184 struct interface *ifp;
185
186 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
187 if (peer->conf_if
188 && (strcmp(peer->conf_if, ifc->ifp->name) == 0)) {
189 peer->last_reset = PEER_DOWN_NBR_ADDR_DEL;
190 BGP_EVENT_ADD(peer, BGP_Stop);
191 }
192 }
193 /* Free neighbor also, if we're asked to. */
194 if (del) {
195 ifp = ifc->ifp;
196 listnode_delete(ifp->nbr_connected, ifc);
197 nbr_connected_free(ifc);
198 }
a80beece
DS		 199}
200
718e3744 201/* Inteface addition message from zebra. */
d62a17ae 202static int bgp_interface_add(int command, struct zclient *zclient,
203 zebra_size_t length, vrf_id_t vrf_id)
718e3744 204{
d62a17ae 205 struct interface *ifp;
206 struct bgp *bgp;
718e3744 207
d62a17ae 208 ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
209 if (!ifp) // unexpected
210 return 0;
718e3744 211
d62a17ae 212 if (BGP_DEBUG(zebra, ZEBRA) && ifp)
213 zlog_debug("Rx Intf add VRF %u IF %s", vrf_id, ifp->name);
a39275d7 214
d62a17ae 215 bgp = bgp_lookup_by_vrf_id(vrf_id);
216 if (!bgp)
217 return 0;
4a04e5f7 218
d62a17ae 219 bgp_update_interface_nbrs(bgp, ifp, ifp);
220 return 0;
718e3744 221}
222
d62a17ae 223static int bgp_interface_delete(int command, struct zclient *zclient,
224 zebra_size_t length, vrf_id_t vrf_id)
718e3744 225{
d62a17ae 226 struct stream *s;
227 struct interface *ifp;
228 struct bgp *bgp;
718e3744 229
2f9123e0
DS		 230 bgp = bgp_lookup_by_vrf_id(vrf_id);
231 if (!bgp)
232 return 0;
233
d62a17ae 234 s = zclient->ibuf;
235 ifp = zebra_interface_state_read(s, vrf_id);
236 if (!ifp) /* This may happen if we've just unregistered for a VRF. */
237 return 0;
a4499b83 238
d62a17ae 239 if (BGP_DEBUG(zebra, ZEBRA))
240 zlog_debug("Rx Intf del VRF %u IF %s", vrf_id, ifp->name);
a39275d7 241
d62a17ae 242 bgp_update_interface_nbrs(bgp, ifp, NULL);
64745052 243
ff880b78 244 if_set_index(ifp, IFINDEX_INTERNAL);
d62a17ae 245 return 0;
718e3744 246}
247
d62a17ae 248static int bgp_interface_up(int command, struct zclient *zclient,
249 zebra_size_t length, vrf_id_t vrf_id)
718e3744 250{
d62a17ae 251 struct stream *s;
252 struct interface *ifp;
253 struct connected *c;
254 struct nbr_connected *nc;
255 struct listnode *node, *nnode;
256 struct bgp *bgp;
6aeb9e78 257
2f9123e0
DS		 258 bgp = bgp_lookup_by_vrf_id(vrf_id);
259 if (!bgp)
260 return 0;
261
d62a17ae 262 s = zclient->ibuf;
263 ifp = zebra_interface_state_read(s, vrf_id);
718e3744 264
d62a17ae 265 if (!ifp)
266 return 0;
718e3744 267
d62a17ae 268 if (BGP_DEBUG(zebra, ZEBRA))
269 zlog_debug("Rx Intf up VRF %u IF %s", vrf_id, ifp->name);
ad4cbda1 270
d62a17ae 271 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, c))
272 bgp_connected_add(bgp, c);
718e3744 273
d62a17ae 274 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, node, nnode, nc))
275 bgp_nbr_connected_add(bgp, nc);
a80beece 276
d62a17ae 277 return 0;
718e3744 278}
279
d62a17ae 280static int bgp_interface_down(int command, struct zclient *zclient,
281 zebra_size_t length, vrf_id_t vrf_id)
718e3744 282{
d62a17ae 283 struct stream *s;
284 struct interface *ifp;
285 struct connected *c;
286 struct nbr_connected *nc;
287 struct listnode *node, *nnode;
288 struct bgp *bgp;
6aeb9e78 289
2f9123e0
DS		 290 bgp = bgp_lookup_by_vrf_id(vrf_id);
291 if (!bgp)
292 return 0;
293
d62a17ae 294 s = zclient->ibuf;
295 ifp = zebra_interface_state_read(s, vrf_id);
296 if (!ifp)
297 return 0;
718e3744 298
d62a17ae 299 if (BGP_DEBUG(zebra, ZEBRA))
300 zlog_debug("Rx Intf down VRF %u IF %s", vrf_id, ifp->name);
ad4cbda1 301
d62a17ae 302 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, c))
303 bgp_connected_delete(bgp, c);
718e3744 304
d62a17ae 305 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, node, nnode, nc))
306 bgp_nbr_connected_delete(bgp, nc, 1);
a80beece 307
d62a17ae 308 /* Fast external-failover */
309 {
310 struct peer *peer;
718e3744 311
d62a17ae 312 if (CHECK_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER))
313 return 0;
718e3744 314
d62a17ae 315 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
8c4f6381 316#if defined(HAVE_CUMULUS)
d62a17ae 317 /* Take down directly connected EBGP peers as well as
318 * 1-hop BFD
319 * tracked (directly connected) IBGP peers.
320 */
321 if ((peer->ttl != 1) && (peer->gtsm_hops != 1)
322 && (!peer->bfd_info
323 || bgp_bfd_is_peer_multihop(peer)))
8c4f6381 324#else
d62a17ae 325 /* Take down directly connected EBGP peers */
326 if ((peer->ttl != 1) && (peer->gtsm_hops != 1))
8c4f6381 327#endif
d62a17ae 328 continue;
718e3744 329
d62a17ae 330 if (ifp == peer->nexthop.ifp) {
331 BGP_EVENT_ADD(peer, BGP_Stop);
332 peer->last_reset = PEER_DOWN_IF_DOWN;
333 }
334 }
335 }
718e3744 336
d62a17ae 337 return 0;
718e3744 338}
339
d62a17ae 340static int bgp_interface_address_add(int command, struct zclient *zclient,
341 zebra_size_t length, vrf_id_t vrf_id)
718e3744 342{
d62a17ae 343 struct connected *ifc;
2f9123e0
DS		 344 struct bgp *bgp;
345
346 bgp = bgp_lookup_by_vrf_id(vrf_id);
347 if (!bgp)
348 return 0;
d62a17ae 349
350 ifc = zebra_interface_address_read(command, zclient->ibuf, vrf_id);
351
352 if (ifc == NULL)
353 return 0;
354
355 if (bgp_debug_zebra(ifc->address)) {
356 char buf[PREFIX2STR_BUFFER];
357 prefix2str(ifc->address, buf, sizeof(buf));
358 zlog_debug("Rx Intf address add VRF %u IF %s addr %s", vrf_id,
359 ifc->ifp->name, buf);
360 }
361
362 if (if_is_operative(ifc->ifp)) {
d62a17ae 363 bgp_connected_add(bgp, ifc);
2f9123e0 364
d62a17ae 365 /* If we have learnt of any neighbors on this interface,
366 * check to kick off any BGP interface-based neighbors,
367 * but only if this is a link-local address.
368 */
369 if (IN6_IS_ADDR_LINKLOCAL(&ifc->address->u.prefix6)
370 && !list_isempty(ifc->ifp->nbr_connected))
371 bgp_start_interface_nbrs(bgp, ifc->ifp);
372 }
373
374 return 0;
718e3744 375}
376
d62a17ae 377static int bgp_interface_address_delete(int command, struct zclient *zclient,
378 zebra_size_t length, vrf_id_t vrf_id)
718e3744 379{
d62a17ae 380 struct connected *ifc;
381 struct bgp *bgp;
6aeb9e78 382
2f9123e0
DS		 383 bgp = bgp_lookup_by_vrf_id(vrf_id);
384 if (!bgp)
385 return 0;
386
d62a17ae 387 ifc = zebra_interface_address_read(command, zclient->ibuf, vrf_id);
718e3744 388
d62a17ae 389 if (ifc == NULL)
390 return 0;
718e3744 391
d62a17ae 392 if (bgp_debug_zebra(ifc->address)) {
393 char buf[PREFIX2STR_BUFFER];
394 prefix2str(ifc->address, buf, sizeof(buf));
395 zlog_debug("Rx Intf address del VRF %u IF %s addr %s", vrf_id,
396 ifc->ifp->name, buf);
397 }
a39275d7 398
d62a17ae 399 if (if_is_operative(ifc->ifp)) {
2f9123e0 400 bgp_connected_delete(bgp, ifc);
d62a17ae 401 }
718e3744 402
d62a17ae 403 connected_free(ifc);
718e3744 404
d62a17ae 405 return 0;
718e3744 406}
407
d62a17ae 408static int bgp_interface_nbr_address_add(int command, struct zclient *zclient,
409 zebra_size_t length, vrf_id_t vrf_id)
a80beece 410{
d62a17ae 411 struct nbr_connected *ifc = NULL;
412 struct bgp *bgp;
413
414 ifc = zebra_interface_nbr_address_read(command, zclient->ibuf, vrf_id);
415
416 if (ifc == NULL)
417 return 0;
418
419 if (bgp_debug_zebra(ifc->address)) {
420 char buf[PREFIX2STR_BUFFER];
421 prefix2str(ifc->address, buf, sizeof(buf));
422 zlog_debug("Rx Intf neighbor add VRF %u IF %s addr %s", vrf_id,
423 ifc->ifp->name, buf);
424 }
425
426 if (if_is_operative(ifc->ifp)) {
427 bgp = bgp_lookup_by_vrf_id(vrf_id);
428 if (bgp)
429 bgp_nbr_connected_add(bgp, ifc);
430 }
431
432 return 0;
a80beece
DS		 433}
434
d62a17ae 435static int bgp_interface_nbr_address_delete(int command,
436 struct zclient *zclient,
437 zebra_size_t length,
438 vrf_id_t vrf_id)
a80beece 439{
d62a17ae 440 struct nbr_connected *ifc = NULL;
441 struct bgp *bgp;
6aeb9e78 442
d62a17ae 443 ifc = zebra_interface_nbr_address_read(command, zclient->ibuf, vrf_id);
a80beece 444
d62a17ae 445 if (ifc == NULL)
446 return 0;
a80beece 447
d62a17ae 448 if (bgp_debug_zebra(ifc->address)) {
449 char buf[PREFIX2STR_BUFFER];
450 prefix2str(ifc->address, buf, sizeof(buf));
451 zlog_debug("Rx Intf neighbor del VRF %u IF %s addr %s", vrf_id,
452 ifc->ifp->name, buf);
453 }
a80beece 454
d62a17ae 455 if (if_is_operative(ifc->ifp)) {
456 bgp = bgp_lookup_by_vrf_id(vrf_id);
457 if (bgp)
458 bgp_nbr_connected_delete(bgp, ifc, 0);
459 }
a80beece 460
d62a17ae 461 nbr_connected_free(ifc);
a80beece 462
d62a17ae 463 return 0;
a80beece
DS		 464}
465
bfcd43b2 466/* VRF update for an interface. */
d62a17ae 467static int bgp_interface_vrf_update(int command, struct zclient *zclient,
468 zebra_size_t length, vrf_id_t vrf_id)
bfcd43b2 469{
d62a17ae 470 struct interface *ifp;
471 vrf_id_t new_vrf_id;
472 struct connected *c;
473 struct nbr_connected *nc;
474 struct listnode *node, *nnode;
475 struct bgp *bgp;
bfcd43b2 476
d62a17ae 477 ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
478 &new_vrf_id);
479 if (!ifp)
480 return 0;
bfcd43b2 481
d62a17ae 482 if (BGP_DEBUG(zebra, ZEBRA) && ifp)
483 zlog_debug("Rx Intf VRF change VRF %u IF %s NewVRF %u", vrf_id,
484 ifp->name, new_vrf_id);
bfcd43b2 485
d62a17ae 486 bgp = bgp_lookup_by_vrf_id(vrf_id);
487 if (!bgp)
488 return 0;
bfcd43b2 489
d62a17ae 490 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, c))
491 bgp_connected_delete(bgp, c);
bfcd43b2 492
d62a17ae 493 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, node, nnode, nc))
494 bgp_nbr_connected_delete(bgp, nc, 1);
bfcd43b2 495
d62a17ae 496 /* Fast external-failover */
497 {
498 struct peer *peer;
bfcd43b2 499
d62a17ae 500 if (CHECK_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER))
501 return 0;
bfcd43b2 502
d62a17ae 503 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
504 if ((peer->ttl != 1) && (peer->gtsm_hops != 1))
505 continue;
bfcd43b2 506
d62a17ae 507 if (ifp == peer->nexthop.ifp)
508 BGP_EVENT_ADD(peer, BGP_Stop);
509 }
510 }
bfcd43b2 511
d62a17ae 512 if_update_to_new_vrf(ifp, new_vrf_id);
bfcd43b2 513
d62a17ae 514 bgp = bgp_lookup_by_vrf_id(new_vrf_id);
515 if (!bgp)
516 return 0;
bfcd43b2 517
d62a17ae 518 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, c))
519 bgp_connected_add(bgp, c);
bfcd43b2 520
d62a17ae 521 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, node, nnode, nc))
522 bgp_nbr_connected_add(bgp, nc);
523 return 0;
bfcd43b2 524}
525
718e3744 526/* Zebra route add and delete treatment. */
74489921
RW		 527static int zebra_read_route(int command, struct zclient *zclient,
528 zebra_size_t length, vrf_id_t vrf_id)
718e3744 529{
9de1f7ff 530 enum nexthop_types_t nhtype;
74489921
RW		 531 struct zapi_route api;
532 union g_addr nexthop;
9de1f7ff 533 ifindex_t ifindex;
74489921 534 int add, i;
d62a17ae 535 struct bgp *bgp;
536
537 bgp = bgp_lookup_by_vrf_id(vrf_id);
538 if (!bgp)
539 return 0;
540
74489921
RW		 541 if (zapi_route_decode(zclient->ibuf, &api) < 0)
542 return -1;
d62a17ae 543
74489921
RW		 544 /* we completely ignore srcdest routes for now. */
545 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX))
546 return 0;
d62a17ae 547
74489921
RW		 548 /* ignore link-local address. */
549 if (api.prefix.family == AF_INET6
550 && IN6_IS_ADDR_LINKLOCAL(&api.prefix.u.prefix6))
551 return 0;
d62a17ae 552
74489921
RW		 553 nexthop = api.nexthops[0].gate;
554 ifindex = api.nexthops[0].ifindex;
9de1f7ff 555 nhtype = api.nexthops[0].type;
d62a17ae 556
74489921
RW		 557 add = (command == ZEBRA_REDISTRIBUTE_ROUTE_ADD);
558 if (add) {
d62a17ae 559 /*
560 * The ADD message is actually an UPDATE and there is no
561 * explicit DEL
562 * for a prior redistributed route, if any. So, perform an
563 * implicit
564 * DEL processing for the same redistributed route from any
565 * other
566 * source type.
567 */
568 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
569 if (i != api.type)
74489921 570 bgp_redistribute_delete(bgp, &api.prefix, i,
d62a17ae 571 api.instance);
572 }
573
574 /* Now perform the add/update. */
74489921 575 bgp_redistribute_add(bgp, &api.prefix, &nexthop, ifindex,
a4d82a8a
PZ		 576 nhtype, api.metric, api.type, api.instance,
577 api.tag);
d62a17ae 578 } else {
74489921
RW		 579 bgp_redistribute_delete(bgp, &api.prefix, api.type,
580 api.instance);
a39275d7 581 }
d62a17ae 582
74489921
RW		 583 if (bgp_debug_zebra(&api.prefix)) {
584 char buf[2][PREFIX_STRLEN];
585
586 prefix2str(&api.prefix, buf[0], sizeof(buf[0]));
77e62f2b 587 if (add) {
588 inet_ntop(api.prefix.family, &nexthop, buf[1],
589 sizeof(buf[1]));
590 zlog_debug(
591 "Rx route ADD VRF %u %s[%d] %s nexthop %s (type %d if %u) metric %u tag %" ROUTE_TAG_PRI,
592 vrf_id, zebra_route_string(api.type),
593 api.instance, buf[0], buf[1], nhtype,
594 ifindex, api.metric, api.tag);
595 } else {
596 zlog_debug(
597 "Rx route DEL VRF %u %s[%d] %s",
598 vrf_id, zebra_route_string(api.type),
599 api.instance, buf[0]);
600 }
d62a17ae 601 }
602
603 return 0;
718e3744 604}
6b0655a2 605
d62a17ae 606struct interface *if_lookup_by_ipv4(struct in_addr *addr, vrf_id_t vrf_id)
718e3744 607{
f4e14fdb 608 struct vrf *vrf;
d62a17ae 609 struct listnode *cnode;
610 struct interface *ifp;
611 struct connected *connected;
612 struct prefix_ipv4 p;
613 struct prefix *cp;
614
f4e14fdb
RW		 615 vrf = vrf_lookup_by_id(vrf_id);
616 if (!vrf)
617 return NULL;
618
d62a17ae 619 p.family = AF_INET;
620 p.prefix = *addr;
621 p.prefixlen = IPV4_MAX_BITLEN;
622
451fda4f 623 FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae 624 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
625 cp = connected->address;
626
627 if (cp->family == AF_INET)
628 if (prefix_match(cp, (struct prefix *)&p))
629 return ifp;
630 }
718e3744 631 }
d62a17ae 632 return NULL;
718e3744 633}
634
d62a17ae 635struct interface *if_lookup_by_ipv4_exact(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 *cp;
642
f4e14fdb
RW		 643 vrf = vrf_lookup_by_id(vrf_id);
644 if (!vrf)
645 return NULL;
646
451fda4f 647 FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae 648 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
649 cp = connected->address;
650
651 if (cp->family == AF_INET)
652 if (IPV4_ADDR_SAME(&cp->u.prefix4, addr))
653 return ifp;
654 }
718e3744 655 }
d62a17ae 656 return NULL;
718e3744 657}
658
d62a17ae 659struct interface *if_lookup_by_ipv6(struct in6_addr *addr, ifindex_t ifindex,
660 vrf_id_t vrf_id)
718e3744 661{
f4e14fdb 662 struct vrf *vrf;
d62a17ae 663 struct listnode *cnode;
664 struct interface *ifp;
665 struct connected *connected;
666 struct prefix_ipv6 p;
667 struct prefix *cp;
668
f4e14fdb
RW		 669 vrf = vrf_lookup_by_id(vrf_id);
670 if (!vrf)
671 return NULL;
672
d62a17ae 673 p.family = AF_INET6;
674 p.prefix = *addr;
675 p.prefixlen = IPV6_MAX_BITLEN;
676
451fda4f 677 FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae 678 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
679 cp = connected->address;
680
681 if (cp->family == AF_INET6)
682 if (prefix_match(cp, (struct prefix *)&p)) {
683 if (IN6_IS_ADDR_LINKLOCAL(
684 &cp->u.prefix6)) {
685 if (ifindex == ifp->ifindex)
686 return ifp;
687 } else
688 return ifp;
689 }
690 }
718e3744 691 }
d62a17ae 692 return NULL;
718e3744 693}
694
d62a17ae 695struct interface *if_lookup_by_ipv6_exact(struct in6_addr *addr,
696 ifindex_t ifindex, vrf_id_t vrf_id)
718e3744 697{
f4e14fdb 698 struct vrf *vrf;
d62a17ae 699 struct listnode *cnode;
700 struct interface *ifp;
701 struct connected *connected;
702 struct prefix *cp;
703
f4e14fdb
RW		 704 vrf = vrf_lookup_by_id(vrf_id);
705 if (!vrf)
706 return NULL;
707
451fda4f 708 FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae 709 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
710 cp = connected->address;
711
712 if (cp->family == AF_INET6)
713 if (IPV6_ADDR_SAME(&cp->u.prefix6, addr)) {
714 if (IN6_IS_ADDR_LINKLOCAL(
715 &cp->u.prefix6)) {
716 if (ifindex == ifp->ifindex)
717 return ifp;
718 } else
719 return ifp;
720 }
721 }
718e3744 722 }
d62a17ae 723 return NULL;
718e3744 724}
725
d62a17ae 726static int if_get_ipv6_global(struct interface *ifp, struct in6_addr *addr)
718e3744 727{
d62a17ae 728 struct listnode *cnode;
729 struct connected *connected;
730 struct prefix *cp;
731
732 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
733 cp = connected->address;
734
735 if (cp->family == AF_INET6)
736 if (!IN6_IS_ADDR_LINKLOCAL(&cp->u.prefix6)) {
737 memcpy(addr, &cp->u.prefix6, IPV6_MAX_BYTELEN);
738 return 1;
739 }
740 }
741 return 0;
718e3744 742}
743
d62a17ae 744static int if_get_ipv6_local(struct interface *ifp, struct in6_addr *addr)
718e3744 745{
d62a17ae 746 struct listnode *cnode;
747 struct connected *connected;
748 struct prefix *cp;
749
750 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
751 cp = connected->address;
752
753 if (cp->family == AF_INET6)
754 if (IN6_IS_ADDR_LINKLOCAL(&cp->u.prefix6)) {
755 memcpy(addr, &cp->u.prefix6, IPV6_MAX_BYTELEN);
756 return 1;
757 }
758 }
759 return 0;
718e3744 760}
718e3744 761
d62a17ae 762static int if_get_ipv4_address(struct interface *ifp, struct in_addr *addr)
6ee06fa9 763{
d62a17ae 764 struct listnode *cnode;
765 struct connected *connected;
766 struct prefix *cp;
767
768 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
769 cp = connected->address;
770 if ((cp->family == AF_INET)
771 && !ipv4_martian(&(cp->u.prefix4))) {
772 *addr = cp->u.prefix4;
773 return 1;
774 }
775 }
776 return 0;
6ee06fa9
PM		 777}
778
d62a17ae 779int bgp_nexthop_set(union sockunion *local, union sockunion *remote,
780 struct bgp_nexthop *nexthop, struct peer *peer)
718e3744 781{
d62a17ae 782 int ret = 0;
783 struct interface *ifp = NULL;
784
785 memset(nexthop, 0, sizeof(struct bgp_nexthop));
786
787 if (!local)
788 return -1;
789 if (!remote)
790 return -1;
791
792 if (local->sa.sa_family == AF_INET) {
793 nexthop->v4 = local->sin.sin_addr;
794 if (peer->update_if)
795 ifp = if_lookup_by_name(peer->update_if,
796 peer->bgp->vrf_id);
797 else
798 ifp = if_lookup_by_ipv4_exact(&local->sin.sin_addr,
799 peer->bgp->vrf_id);
718e3744 800 }
d62a17ae 801 if (local->sa.sa_family == AF_INET6) {
802 if (IN6_IS_ADDR_LINKLOCAL(&local->sin6.sin6_addr)) {
803 if (peer->conf_if || peer->ifname)
804 ifp = if_lookup_by_name(peer->conf_if
805 ? peer->conf_if
806 : peer->ifname,
807 peer->bgp->vrf_id);
808 } else if (peer->update_if)
809 ifp = if_lookup_by_name(peer->update_if,
810 peer->bgp->vrf_id);
811 else
812 ifp = if_lookup_by_ipv6_exact(&local->sin6.sin6_addr,
813 local->sin6.sin6_scope_id,
814 peer->bgp->vrf_id);
718e3744 815 }
d62a17ae 816
817 if (!ifp)
818 return -1;
819
820 nexthop->ifp = ifp;
821
822 /* IPv4 connection, fetch and store IPv6 local address(es) if any. */
823 if (local->sa.sa_family == AF_INET) {
824 /* IPv6 nexthop*/
825 ret = if_get_ipv6_global(ifp, &nexthop->v6_global);
826
827 if (!ret) {
828 /* There is no global nexthop. Use link-local address as
829 * both the
830 * global and link-local nexthop. In this scenario, the
831 * expectation
832 * for interop is that the network admin would use a
833 * route-map to
834 * specify the global IPv6 nexthop.
835 */
836 if_get_ipv6_local(ifp, &nexthop->v6_global);
837 memcpy(&nexthop->v6_local, &nexthop->v6_global,
838 IPV6_MAX_BYTELEN);
839 } else
840 if_get_ipv6_local(ifp, &nexthop->v6_local);
841
842 if (if_lookup_by_ipv4(&remote->sin.sin_addr, peer->bgp->vrf_id))
843 peer->shared_network = 1;
844 else
845 peer->shared_network = 0;
718e3744 846 }
718e3744 847
d62a17ae 848 /* IPv6 connection, fetch and store IPv4 local address if any. */
849 if (local->sa.sa_family == AF_INET6) {
850 struct interface *direct = NULL;
851
852 /* IPv4 nexthop. */
853 ret = if_get_ipv4_address(ifp, &nexthop->v4);
854 if (!ret && peer->local_id.s_addr)
855 nexthop->v4 = peer->local_id;
856
857 /* Global address*/
858 if (!IN6_IS_ADDR_LINKLOCAL(&local->sin6.sin6_addr)) {
859 memcpy(&nexthop->v6_global, &local->sin6.sin6_addr,
860 IPV6_MAX_BYTELEN);
861
862 /* If directory connected set link-local address. */
863 direct = if_lookup_by_ipv6(&remote->sin6.sin6_addr,
864 remote->sin6.sin6_scope_id,
865 peer->bgp->vrf_id);
866 if (direct)
867 if_get_ipv6_local(ifp, &nexthop->v6_local);
868 } else
869 /* Link-local address. */
870 {
871 ret = if_get_ipv6_global(ifp, &nexthop->v6_global);
872
873 /* If there is no global address. Set link-local
874 address as
875 global. I know this break RFC specification... */
876 /* In this scenario, the expectation for interop is that
877 * the
878 * network admin would use a route-map to specify the
879 * global
880 * IPv6 nexthop.
881 */
882 if (!ret)
883 memcpy(&nexthop->v6_global,
884 &local->sin6.sin6_addr,
885 IPV6_MAX_BYTELEN);
886 /* Always set the link-local address */
887 memcpy(&nexthop->v6_local, &local->sin6.sin6_addr,
888 IPV6_MAX_BYTELEN);
889 }
890
891 if (IN6_IS_ADDR_LINKLOCAL(&local->sin6.sin6_addr)
892 || if_lookup_by_ipv6(&remote->sin6.sin6_addr,
893 remote->sin6.sin6_scope_id,
894 peer->bgp->vrf_id))
895 peer->shared_network = 1;
896 else
897 peer->shared_network = 0;
898 }
718e3744 899
d62a17ae 900/* KAME stack specific treatment. */
718e3744 901#ifdef KAME
d62a17ae 902 if (IN6_IS_ADDR_LINKLOCAL(&nexthop->v6_global)
903 && IN6_LINKLOCAL_IFINDEX(nexthop->v6_global)) {
904 SET_IN6_LINKLOCAL_IFINDEX(nexthop->v6_global, 0);
905 }
906 if (IN6_IS_ADDR_LINKLOCAL(&nexthop->v6_local)
907 && IN6_LINKLOCAL_IFINDEX(nexthop->v6_local)) {
908 SET_IN6_LINKLOCAL_IFINDEX(nexthop->v6_local, 0);
909 }
718e3744 910#endif /* KAME */
e33a4880 911
d62a17ae 912 /* If we have identified the local interface, there is no error for now.
913 */
914 return 0;
718e3744 915}
916
77e62f2b 917static struct in6_addr *bgp_info_to_ipv6_nexthop(struct bgp_info *info,
918 ifindex_t *ifindex)
73ac8160 919{
d62a17ae 920 struct in6_addr *nexthop = NULL;
921
922 /* Only global address nexthop exists. */
77e62f2b 923 if (info->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) {
d62a17ae 924 nexthop = &info->attr->mp_nexthop_global;
77e62f2b 925 if (IN6_IS_ADDR_LINKLOCAL(nexthop))
926 *ifindex = info->attr->nh_ifindex;
927
928 }
d62a17ae 929
930 /* If both global and link-local address present. */
931 if (info->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) {
932 /* Check if route-map is set to prefer global over link-local */
77e62f2b 933 if (info->attr->mp_nexthop_prefer_global) {
d62a17ae 934 nexthop = &info->attr->mp_nexthop_global;
77e62f2b 935 if (IN6_IS_ADDR_LINKLOCAL(nexthop))
936 *ifindex = info->attr->nh_ifindex;
937 } else {
d62a17ae 938 /* Workaround for Cisco's nexthop bug. */
939 if (IN6_IS_ADDR_UNSPECIFIED(
940 &info->attr->mp_nexthop_global)
59a0f1cb
DS		 941 && info->peer->su_remote->sa.sa_family
942 == AF_INET6) {
d62a17ae 943 nexthop =
944 &info->peer->su_remote->sin6.sin6_addr;
77e62f2b 945 if (IN6_IS_ADDR_LINKLOCAL(nexthop))
59a0f1cb
DS		 946 *ifindex = info->peer->nexthop.ifp
947 ->ifindex;
77e62f2b 948 } else {
d62a17ae 949 nexthop = &info->attr->mp_nexthop_local;
77e62f2b 950 if (IN6_IS_ADDR_LINKLOCAL(nexthop))
951 *ifindex = info->attr->nh_lla_ifindex;
952 }
d62a17ae 953 }
954 }
955
956 return nexthop;
73ac8160
DS		 957}
958
d62a17ae 959static int bgp_table_map_apply(struct route_map *map, struct prefix *p,
960 struct bgp_info *info)
73ac8160 961{
b4cb15c6
DL		 962 route_map_result_t ret;
963
964 ret = route_map_apply(map, p, RMAP_BGP, info);
965 bgp_attr_flush(info->attr);
966
967 if (ret != RMAP_DENYMATCH)
d62a17ae 968 return 1;
969
970 if (bgp_debug_zebra(p)) {
971 if (p->family == AF_INET) {
972 char buf[2][INET_ADDRSTRLEN];
973 zlog_debug(
974 "Zebra rmap deny: IPv4 route %s/%d nexthop %s",
975 inet_ntop(AF_INET, &p->u.prefix4, buf[0],
976 sizeof(buf[0])),
977 p->prefixlen,
978 inet_ntop(AF_INET, &info->attr->nexthop, buf[1],
979 sizeof(buf[1])));
980 }
981 if (p->family == AF_INET6) {
982 char buf[2][INET6_ADDRSTRLEN];
77e62f2b 983 ifindex_t ifindex;
984 struct in6_addr *nexthop;
985
986 nexthop = bgp_info_to_ipv6_nexthop(info, &ifindex);
d62a17ae 987 zlog_debug(
988 "Zebra rmap deny: IPv6 route %s/%d nexthop %s",
989 inet_ntop(AF_INET6, &p->u.prefix6, buf[0],
990 sizeof(buf[0])),
991 p->prefixlen,
77e62f2b 992 inet_ntop(AF_INET6, nexthop,
d62a17ae 993 buf[1], sizeof(buf[1])));
994 }
995 }
996 return 0;
73ac8160
DS		 997}
998
b98f7728
PG		 999static struct thread *bgp_tm_thread_connect;
1000static bool bgp_tm_status_connected;
31c28cd7
PG		 1001static bool bgp_tm_chunk_obtained;
1002#define BGP_FLOWSPEC_TABLE_CHUNK 100000
1003static uint32_t bgp_tm_min, bgp_tm_max, bgp_tm_chunk_size;
b98f7728
PG		 1004
1005static int bgp_zebra_tm_connect(struct thread *t)
1006{
1007 struct zclient *zclient;
1008 int delay = 10, ret = 0;
1009
1010 zclient = THREAD_ARG(t);
1011 if (bgp_tm_status_connected && zclient->sock > 0)
1012 delay = 60;
1013 else {
1014 bgp_tm_status_connected = false;
1015 ret = tm_table_manager_connect(zclient);
1016 }
1017 if (ret < 0) {
1018 zlog_warn("Error connecting to table manager!");
1019 bgp_tm_status_connected = false;
1020 } else {
1021 if (!bgp_tm_status_connected)
1022 zlog_debug("Connecting to table manager. Success");
1023 bgp_tm_status_connected = true;
31c28cd7
PG		 1024 if (!bgp_tm_chunk_obtained) {
1025 if (bgp_zebra_get_table_range(bgp_tm_chunk_size,
1026 &bgp_tm_min,
1027 &bgp_tm_max) >= 0)
1028 bgp_tm_chunk_obtained = true;
1029 }
b98f7728
PG		 1030 }
1031 thread_add_timer(bm->master, bgp_zebra_tm_connect, zclient, delay,
1032 &bgp_tm_thread_connect);
1033 return 0;
1034}
1035
31c28cd7
PG		 1036uint32_t bgp_zebra_tm_get_id(void)
1037{
1038 static int table_id;
1039
1040 if (!bgp_tm_chunk_obtained)
1041 return ++table_id;
1042 return bgp_tm_min++;
1043}
1044
b98f7728
PG		 1045void bgp_zebra_init_tm_connect(void)
1046{
1047 int delay = 1;
1048
1049 /* if already set, do nothing
1050 */
1051 if (bgp_tm_thread_connect != NULL)
1052 return;
1053 bgp_tm_status_connected = false;
31c28cd7
PG		 1054 bgp_tm_chunk_obtained = false;
1055 bgp_tm_min = bgp_tm_max = 0;
1056 bgp_tm_chunk_size = BGP_FLOWSPEC_TABLE_CHUNK;
b98f7728
PG		 1057 thread_add_timer(bm->master, bgp_zebra_tm_connect, zclient, delay,
1058 &bgp_tm_thread_connect);
1059}
1060
1061int bgp_zebra_get_table_range(uint32_t chunk_size,
1062 uint32_t *start, uint32_t *end)
1063{
1064 int ret;
1065
1066 if (!bgp_tm_status_connected)
1067 return -1;
1068 ret = tm_get_table_chunk(zclient, chunk_size, start, end);
1069 if (ret < 0) {
1070 zlog_err("BGP: Error getting table chunk %u", chunk_size);
1071 return -1;
1072 }
1073 zlog_info("BGP: Table Manager returns range from chunk %u is [%u %u]",
1074 chunk_size, *start, *end);
1075 return 0;
1076}
1077
77e62f2b 1078static int update_ipv4nh_for_route_install(int nh_othervrf,
1079 struct in_addr *nexthop,
1080 struct attr *attr,
1081 bool is_evpn,
1082 struct zapi_nexthop *api_nh)
1083{
1084 api_nh->gate.ipv4 = *nexthop;
1085
1086 /* Need to set fields appropriately for EVPN routes imported into
1087 * a VRF (which are programmed as onlink on l3-vni SVI) as well as
1088 * connected routes leaked into a VRF.
1089 */
1090 if (is_evpn)
1091 api_nh->type = NEXTHOP_TYPE_IPV4_IFINDEX;
1092 else if (nh_othervrf &&
1093 api_nh->gate.ipv4.s_addr == INADDR_ANY) {
1094 api_nh->type = NEXTHOP_TYPE_IFINDEX;
1095 api_nh->ifindex = attr->nh_ifindex;
1096 } else
1097 api_nh->type = NEXTHOP_TYPE_IPV4;
1098
1099 return 1;
1100}
1101
1102static int update_ipv6nh_for_route_install(int nh_othervrf,
1103 struct in6_addr *nexthop,
1104 ifindex_t ifindex,
1105 struct bgp_info *ri,
1106 struct bgp_info *best_ri,
1107 bool is_evpn,
1108 struct zapi_nexthop *api_nh)
1109{
1110 struct attr *attr;
1111
1112 attr = ri->attr;
1113
1114 if (is_evpn)
1115 api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
1116 else if (nh_othervrf) {
1117 if (IN6_IS_ADDR_UNSPECIFIED(nexthop)) {
1118 api_nh->type = NEXTHOP_TYPE_IFINDEX;
1119 api_nh->ifindex = attr->nh_ifindex;
1120 } else if (IN6_IS_ADDR_LINKLOCAL(nexthop)) {
1121 if (ifindex == 0)
1122 return 0;
1123 api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
1124 api_nh->ifindex = ifindex;
1125 } else {
1126 api_nh->type = NEXTHOP_TYPE_IPV6;
1127 api_nh->ifindex = 0;
1128 }
1129 } else {
1130 if (IN6_IS_ADDR_LINKLOCAL(nexthop)) {
1131 if (ri == best_ri &&
1132 attr->mp_nexthop_len
1133 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL)
1134 if (ri->peer->nexthop.ifp)
1135 ifindex = ri->peer->nexthop.ifp
1136 ->ifindex;
1137 if (!ifindex) {
1138 if (ri->peer->conf_if)
1139 ifindex = ri->peer->ifp->ifindex;
1140 else if (ri->peer->ifname)
1141 ifindex = ifname2ifindex(
1142 ri->peer->ifname,
1143 ri->peer->bgp->vrf_id);
1144 else if (ri->peer->nexthop.ifp)
1145 ifindex = ri->peer->nexthop.ifp
1146 ->ifindex;
1147 }
1148
1149 if (ifindex == 0)
1150 return 0;
1151 api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
1152 api_nh->ifindex = ifindex;
1153 } else {
1154 api_nh->type = NEXTHOP_TYPE_IPV6;
1155 api_nh->ifindex = 0;
1156 }
1157 }
1158 api_nh->gate.ipv6 = *nexthop;
1159
1160 return 1;
1161}
1162
d62a17ae 1163void bgp_zebra_announce(struct bgp_node *rn, struct prefix *p,
1164 struct bgp_info *info, struct bgp *bgp, afi_t afi,
1165 safi_t safi)
718e3744 1166{
9913029c
RW		 1167 struct zapi_route api;
1168 struct zapi_nexthop *api_nh;
2ad4f093 1169 int nh_family;
a74e593b 1170 unsigned int valid_nh_count = 0;
2ad4f093 1171 int has_valid_label = 0;
d7c0a89a 1172 uint8_t distance;
d62a17ae 1173 struct peer *peer;
1174 struct bgp_info *mpinfo;
d7c0a89a 1175 uint32_t metric;
b4cb15c6 1176 struct attr local_attr;
d62a17ae 1177 struct bgp_info local_info;
b4cb15c6 1178 struct bgp_info *mpinfo_cp = &local_info;
d62a17ae 1179 route_tag_t tag;
1180 mpls_label_t label;
ddb5b488 1181 int nh_othervrf = 0;
960035b2 1182 char buf_prefix[PREFIX_STRLEN]; /* filled in if we are debugging */
77e62f2b 1183 bool is_evpn = false;
1184 int nh_updated;
d62a17ae 1185
1186 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1187 * know of this instance.
1188 */
1189 if (!bgp_install_info_to_zebra(bgp))
1190 return;
1191
d62a17ae 1192 if (bgp->main_zebra_update_hold)
1193 return;
1194
960035b2 1195 if (bgp_debug_zebra(p))
ba1976db 1196 prefix2str(p, buf_prefix, sizeof(buf_prefix));
960035b2 1197
529efa23
PG		 1198 if (safi == SAFI_FLOWSPEC)
1199 return bgp_pbr_update_entry(bgp, &rn->p,
1200 info, afi, safi, true);
1201
ddb5b488
PZ		 1202 /*
1203 * vrf leaking support (will have only one nexthop)
1204 */
1205 if (info->extra && info->extra->bgp_orig)
1206 nh_othervrf = 1;
1207
9913029c
RW		 1208 /* Make Zebra API structure. */
1209 memset(&api, 0, sizeof(api));
1210 api.vrf_id = bgp->vrf_id;
1211 api.type = ZEBRA_ROUTE_BGP;
1212 api.safi = safi;
1213 api.prefix = *p;
1214 SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
1215
d62a17ae 1216 peer = info->peer;
1217
ddb5b488
PZ		 1218 if (info->type == ZEBRA_ROUTE_BGP
1219 && info->sub_type == BGP_ROUTE_IMPORTED) {
1220
1ec90b5e 1221 /* Obtain peer from parent */
1222 if (info->extra && info->extra->parent)
1223 peer = ((struct bgp_info *)(info->extra->parent))->peer;
ddb5b488
PZ		 1224 }
1225
d62a17ae 1226 tag = info->attr->tag;
1227
020a3f60
DS		 1228 /*
1229 * When we create an aggregate route we must also install a
1230 * Null0 route in the RIB
1231 */
d62a17ae 1232 if (info->sub_type == BGP_ROUTE_AGGREGATE)
09a484dd 1233 zapi_route_set_blackhole(&api, BLACKHOLE_NULL);
d62a17ae 1234
88493076 1235 /* If the route's source is EVPN, flag as such. */
77e62f2b 1236 is_evpn = is_route_parent_evpn(info);
1237 if (is_evpn)
90264d64 1238 SET_FLAG(api.flags, ZEBRA_FLAG_EVPN_ROUTE);
d3135ba3 1239
d62a17ae 1240 if (peer->sort == BGP_PEER_IBGP || peer->sort == BGP_PEER_CONFED
1241 || info->sub_type == BGP_ROUTE_AGGREGATE) {
9913029c 1242 SET_FLAG(api.flags, ZEBRA_FLAG_IBGP);
4e8b02f4 1243 SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
718e3744 1244 }
a39275d7 1245
d62a17ae 1246 if ((peer->sort == BGP_PEER_EBGP && peer->ttl != 1)
1247 || CHECK_FLAG(peer->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK)
1248 || bgp_flag_check(bgp, BGP_FLAG_DISABLE_NH_CONNECTED_CHK))
1249
4e8b02f4 1250 SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
d62a17ae 1251
2ad4f093
RW		 1252 /* Metric is currently based on the best-path only */
1253 metric = info->attr->med;
1254 for (mpinfo = info; mpinfo; mpinfo = bgp_info_mpath_next(mpinfo)) {
a74e593b
RW		 1255 if (valid_nh_count >= multipath_num)
1256 break;
1257
b4cb15c6
DL		 1258 *mpinfo_cp = *mpinfo;
1259
d0d695f4
RW		 1260 /* Get nexthop address-family */
1261 if (p->family == AF_INET
1262 && !BGP_ATTR_NEXTHOP_AFI_IP6(mpinfo_cp->attr))
1263 nh_family = AF_INET;
1264 else if (p->family == AF_INET6
1265 || (p->family == AF_INET
1266 && BGP_ATTR_NEXTHOP_AFI_IP6(mpinfo_cp->attr)))
1267 nh_family = AF_INET6;
1268 else
1269 continue;
1270
1374aec9 1271 api_nh = &api.nexthops[valid_nh_count];
a12495e7
DS		 1272 api_nh->vrf_id = nh_othervrf ? info->extra->bgp_orig->vrf_id
1273 : bgp->vrf_id;
2ad4f093 1274 if (nh_family == AF_INET) {
ddb5b488 1275 if (bgp_debug_zebra(&api.prefix)) {
ddb5b488
PZ		 1276 if (mpinfo->extra) {
1277 zlog_debug(
1278 "%s: p=%s, bgp_is_valid_label: %d",
1279 __func__, buf_prefix,
1280 bgp_is_valid_label(
1281 &mpinfo->extra
1282 ->label[0]));
1283 } else {
1284 zlog_debug(
1285 "%s: p=%s, extra is NULL, no label",
1286 __func__, buf_prefix);
1287 }
1288 }
1289
6c0a6053 1290 if (bgp->table_map[afi][safi].name) {
d62a17ae 1291 /* Copy info and attributes, so the route-map
b4cb15c6
DL		 1292 apply doesn't modify the BGP route info. */
1293 local_attr = *mpinfo->attr;
1294 mpinfo_cp->attr = &local_attr;
ddb5b488 1295 }
b4cb15c6 1296
ddb5b488 1297 if (bgp->table_map[afi][safi].name) {
b4cb15c6 1298 if (!bgp_table_map_apply(
d62a17ae 1299 bgp->table_map[afi][safi].map, p,
b4cb15c6
DL		 1300 mpinfo_cp))
1301 continue;
1302
1303 /* metric/tag is only allowed to be
1304 * overridden on 1st nexthop */
1305 if (mpinfo == info) {
1306 metric = mpinfo_cp->attr->med;
1307 tag = mpinfo_cp->attr->tag;
d62a17ae 1308 }
b4cb15c6 1309 }
d62a17ae 1310
77e62f2b 1311 nh_updated = update_ipv4nh_for_route_install(
1312 nh_othervrf,
1313 &mpinfo_cp->attr->nexthop,
1314 mpinfo_cp->attr, is_evpn, api_nh);
2ad4f093
RW		 1315 } else {
1316 ifindex_t ifindex;
1317 struct in6_addr *nexthop;
9913029c 1318
6c0a6053 1319 if (bgp->table_map[afi][safi].name) {
ddb5b488
PZ		 1320 /* Copy info and attributes, so the route-map
1321 apply doesn't modify the BGP route info. */
1322 local_attr = *mpinfo->attr;
1323 mpinfo_cp->attr = &local_attr;
ddb5b488
PZ		 1324 }
1325
d62a17ae 1326 if (bgp->table_map[afi][safi].name) {
1327 /* Copy info and attributes, so the route-map
b4cb15c6
DL		 1328 apply doesn't modify the BGP route info. */
1329 local_attr = *mpinfo->attr;
1330 mpinfo_cp->attr = &local_attr;
1331
1332 if (!bgp_table_map_apply(
d62a17ae 1333 bgp->table_map[afi][safi].map, p,
b4cb15c6
DL		 1334 mpinfo_cp))
1335 continue;
1336
1337 /* metric/tag is only allowed to be
1338 * overridden on 1st nexthop */
1339 if (mpinfo == info) {
1340 metric = mpinfo_cp->attr->med;
1341 tag = mpinfo_cp->attr->tag;
d62a17ae 1342 }
b4cb15c6 1343 }
77e62f2b 1344 nexthop = bgp_info_to_ipv6_nexthop(mpinfo_cp,
1345 &ifindex);
1346 nh_updated = update_ipv6nh_for_route_install(
1347 nh_othervrf, nexthop, ifindex,
1348 mpinfo, info, is_evpn, api_nh);
2ad4f093 1349 }
d62a17ae 1350
77e62f2b 1351 /* Did we get proper nexthop info to update zebra? */
1352 if (!nh_updated)
1353 continue;
1354
a4d82a8a
PZ		 1355 if (mpinfo->extra
1356 && bgp_is_valid_label(&mpinfo->extra->label[0])
90264d64 1357 && !CHECK_FLAG(api.flags, ZEBRA_FLAG_EVPN_ROUTE)) {
2ad4f093 1358 has_valid_label = 1;
b57ba6d2 1359 label = label_pton(&mpinfo->extra->label[0]);
9913029c 1360
2ad4f093
RW		 1361 api_nh->label_num = 1;
1362 api_nh->labels[0] = label;
d62a17ae 1363 }
22e63104 1364 memcpy(&api_nh->rmac, &(mpinfo->attr->rmac),
1365 sizeof(struct ethaddr));
2ad4f093
RW		 1366 valid_nh_count++;
1367 }
d62a17ae 1368
77e62f2b 1369
a89b49cc 1370 /* if this is a evpn route we don't have to include the label */
a4d82a8a 1371 if (has_valid_label && !(CHECK_FLAG(api.flags, ZEBRA_FLAG_EVPN_ROUTE)))
2ad4f093 1372 SET_FLAG(api.message, ZAPI_MESSAGE_LABEL);
d62a17ae 1373
09a484dd 1374 if (info->sub_type != BGP_ROUTE_AGGREGATE)
2ad4f093 1375 api.nexthop_num = valid_nh_count;
d62a17ae 1376
2ad4f093
RW		 1377 SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
1378 api.metric = metric;
d62a17ae 1379
2ad4f093
RW		 1380 if (tag) {
1381 SET_FLAG(api.message, ZAPI_MESSAGE_TAG);
1382 api.tag = tag;
1383 }
d62a17ae 1384
2ad4f093
RW		 1385 distance = bgp_distance_apply(p, info, afi, safi, bgp);
1386 if (distance) {
1387 SET_FLAG(api.message, ZAPI_MESSAGE_DISTANCE);
1388 api.distance = distance;
1389 }
d62a17ae 1390
2ad4f093
RW		 1391 if (bgp_debug_zebra(p)) {
1392 char prefix_buf[PREFIX_STRLEN];
1393 char nh_buf[INET6_ADDRSTRLEN];
1394 char label_buf[20];
1395 int i;
1396
1397 prefix2str(&api.prefix, prefix_buf, sizeof(prefix_buf));
1398 zlog_debug("Tx route %s VRF %u %s metric %u tag %" ROUTE_TAG_PRI
1399 " count %d",
1400 valid_nh_count ? "add" : "delete", bgp->vrf_id,
1401 prefix_buf, api.metric, api.tag, api.nexthop_num);
1402 for (i = 0; i < api.nexthop_num; i++) {
1403 api_nh = &api.nexthops[i];
1404
77e62f2b 1405 if (api_nh->type == NEXTHOP_TYPE_IFINDEX)
1406 nh_buf[0] = '\0';
1407 else {
1408 if (api_nh->type == NEXTHOP_TYPE_IPV4)
1409 nh_family = AF_INET;
1410 else
1411 nh_family = AF_INET6;
1412 inet_ntop(nh_family, &api_nh->gate, nh_buf,
1413 sizeof(nh_buf));
1414 }
2ad4f093
RW		 1415
1416 label_buf[0] = '\0';
a4d82a8a
PZ		 1417 if (has_valid_label
1418 && !CHECK_FLAG(api.flags, ZEBRA_FLAG_EVPN_ROUTE))
2ad4f093
RW		 1419 sprintf(label_buf, "label %u",
1420 api_nh->labels[0]);
77e62f2b 1421 zlog_debug(" nhop [%d]: %s if %u VRF %u %s",
1422 i + 1, nh_buf, api_nh->ifindex,
1423 api_nh->vrf_id, label_buf);
d62a17ae 1424 }
1425 }
2ad4f093 1426
960035b2
PZ		 1427 if (bgp_debug_zebra(p)) {
1428 int recursion_flag = 0;
1429
1430 if (CHECK_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION))
1431 recursion_flag = 1;
1432
1433 zlog_debug("%s: %s: announcing to zebra (recursion %sset)",
1434 __func__, buf_prefix,
1435 (recursion_flag ? "" : "NOT "));
1436 }
2ad4f093
RW		 1437 zclient_route_send(valid_nh_count ? ZEBRA_ROUTE_ADD
1438 : ZEBRA_ROUTE_DELETE,
1439 zclient, &api);
718e3744 1440}
1441
73ac8160 1442/* Announce all routes of a table to zebra */
d62a17ae 1443void bgp_zebra_announce_table(struct bgp *bgp, afi_t afi, safi_t safi)
73ac8160 1444{
d62a17ae 1445 struct bgp_node *rn;
1446 struct bgp_table *table;
1447 struct bgp_info *ri;
1448
1449 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1450 * know of this instance.
1451 */
1452 if (!bgp_install_info_to_zebra(bgp))
1453 return;
1454
1455 table = bgp->rib[afi][safi];
1456 if (!table)
1457 return;
1458
1459 for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn))
1460 for (ri = rn->info; ri; ri = ri->next)
ddb5b488
PZ		 1461 if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED) &&
1462
1463 (ri->type == ZEBRA_ROUTE_BGP
1464 && (ri->sub_type == BGP_ROUTE_NORMAL
1465 || ri->sub_type == BGP_ROUTE_IMPORTED)))
1466
d62a17ae 1467 bgp_zebra_announce(rn, &rn->p, ri, bgp, afi,
1468 safi);
73ac8160
DS		 1469}
1470
568e10ca 1471void bgp_zebra_withdraw(struct prefix *p, struct bgp_info *info,
1472 struct bgp *bgp, safi_t safi)
718e3744 1473{
2ad4f093 1474 struct zapi_route api;
f7df1907 1475 struct peer *peer;
ddb5b488 1476
d62a17ae 1477 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1478 * know of this instance.
1479 */
568e10ca 1480 if (!bgp_install_info_to_zebra(bgp))
d62a17ae 1481 return;
1482
f7df1907
PG		 1483 if (safi == SAFI_FLOWSPEC) {
1484 peer = info->peer;
529efa23
PG		 1485 return bgp_pbr_update_entry(peer->bgp, p,
1486 info, AFI_IP, safi, false);
f7df1907 1487 }
529efa23 1488
2ad4f093 1489 memset(&api, 0, sizeof(api));
568e10ca 1490 api.vrf_id = bgp->vrf_id;
2ad4f093
RW		 1491 api.type = ZEBRA_ROUTE_BGP;
1492 api.safi = safi;
1493 api.prefix = *p;
d62a17ae 1494
88493076 1495 /* If the route's source is EVPN, flag as such. */
1496 if (is_route_parent_evpn(info))
90264d64 1497 SET_FLAG(api.flags, ZEBRA_FLAG_EVPN_ROUTE);
01740ff4 1498
2ad4f093
RW		 1499 if (bgp_debug_zebra(p)) {
1500 char buf[PREFIX_STRLEN];
d62a17ae 1501
2ad4f093 1502 prefix2str(&api.prefix, buf, sizeof(buf));
568e10ca 1503 zlog_debug("Tx route delete VRF %u %s", bgp->vrf_id, buf);
d62a17ae 1504 }
d62a17ae 1505
2ad4f093 1506 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
718e3744 1507}
56c1f7d8 1508
d7c0a89a
QY		 1509struct bgp_redist *bgp_redist_lookup(struct bgp *bgp, afi_t afi, uint8_t type,
1510 unsigned short instance)
7c8ff89e 1511{
d62a17ae 1512 struct list *red_list;
1513 struct listnode *node;
1514 struct bgp_redist *red;
7c8ff89e 1515
d62a17ae 1516 red_list = bgp->redist[afi][type];
1517 if (!red_list)
1518 return (NULL);
7c8ff89e 1519
d62a17ae 1520 for (ALL_LIST_ELEMENTS_RO(red_list, node, red))
1521 if (red->instance == instance)
1522 return red;
7c8ff89e 1523
d62a17ae 1524 return NULL;
7c8ff89e
DS		 1525}
1526
d7c0a89a
QY		 1527struct bgp_redist *bgp_redist_add(struct bgp *bgp, afi_t afi, uint8_t type,
1528 unsigned short instance)
7c8ff89e 1529{
d62a17ae 1530 struct list *red_list;
1531 struct bgp_redist *red;
7c8ff89e 1532
d62a17ae 1533 red = bgp_redist_lookup(bgp, afi, type, instance);
1534 if (red)
1535 return red;
7c8ff89e 1536
d62a17ae 1537 if (!bgp->redist[afi][type])
1538 bgp->redist[afi][type] = list_new();
7c8ff89e 1539
d62a17ae 1540 red_list = bgp->redist[afi][type];
1541 red = (struct bgp_redist *)XCALLOC(MTYPE_BGP_REDIST,
1542 sizeof(struct bgp_redist));
1543 red->instance = instance;
7c8ff89e 1544
d62a17ae 1545 listnode_add(red_list, red);
7c8ff89e 1546
d62a17ae 1547 return red;
7c8ff89e
DS		 1548}
1549
d7c0a89a
QY		 1550static void bgp_redist_del(struct bgp *bgp, afi_t afi, uint8_t type,
1551 unsigned short instance)
7c8ff89e 1552{
d62a17ae 1553 struct bgp_redist *red;
1554
1555 red = bgp_redist_lookup(bgp, afi, type, instance);
1556
1557 if (red) {
1558 listnode_delete(bgp->redist[afi][type], red);
1559 XFREE(MTYPE_BGP_REDIST, red);
acdf5e25
DS		 1560 if (!bgp->redist[afi][type]->count)
1561 list_delete_and_null(&bgp->redist[afi][type]);
d62a17ae 1562 }
7c8ff89e 1563}
6b0655a2 1564
718e3744 1565/* Other routes redistribution into BGP. */
d7c0a89a
QY		 1566int bgp_redistribute_set(struct bgp *bgp, afi_t afi, int type,
1567 unsigned short instance)
718e3744 1568{
718e3744 1569
d62a17ae 1570 /* Return if already redistribute flag is set. */
1571 if (instance) {
1572 if (redist_check_instance(&zclient->mi_redist[afi][type],
1573 instance))
1574 return CMD_WARNING;
718e3744 1575
d62a17ae 1576 redist_add_instance(&zclient->mi_redist[afi][type], instance);
1577 } else {
1578 if (vrf_bitmap_check(zclient->redist[afi][type], bgp->vrf_id))
1579 return CMD_WARNING;
7076bb2f 1580
65efcfce 1581#if ENABLE_BGP_VNC
d62a17ae 1582 if (bgp->vrf_id == VRF_DEFAULT
1583 && type == ZEBRA_ROUTE_VNC_DIRECT) {
1584 vnc_export_bgp_enable(
1585 bgp, afi); /* only enables if mode bits cfg'd */
1586 }
65efcfce
LB		 1587#endif
1588
d62a17ae 1589 vrf_bitmap_set(zclient->redist[afi][type], bgp->vrf_id);
1590 }
718e3744 1591
ea12cf11
DS		 1592 /*
1593 * Don't try to register if we're not connected to Zebra or Zebra
1594 * doesn't know of this instance.
1595 *
1596 * When we come up later well resend if needed.
d62a17ae 1597 */
1598 if (!bgp_install_info_to_zebra(bgp))
ea12cf11 1599 return CMD_SUCCESS;
a39275d7 1600
d62a17ae 1601 if (BGP_DEBUG(zebra, ZEBRA))
1602 zlog_debug("Tx redistribute add VRF %u afi %d %s %d",
1603 bgp->vrf_id, afi, zebra_route_string(type),
1604 instance);
518f0eb1 1605
d62a17ae 1606 /* Send distribute add message to zebra. */
1607 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, afi, type,
1608 instance, bgp->vrf_id);
718e3744 1609
d62a17ae 1610 return CMD_SUCCESS;
718e3744 1611}
1612
d62a17ae 1613int bgp_redistribute_resend(struct bgp *bgp, afi_t afi, int type,
d7c0a89a 1614 unsigned short instance)
518f0eb1 1615{
d62a17ae 1616 /* Don't try to send if we're not connected to Zebra or Zebra doesn't
1617 * know of this instance.
1618 */
1619 if (!bgp_install_info_to_zebra(bgp))
1620 return -1;
1621
1622 if (BGP_DEBUG(zebra, ZEBRA))
1623 zlog_debug("Tx redistribute del/add VRF %u afi %d %s %d",
1624 bgp->vrf_id, afi, zebra_route_string(type),
1625 instance);
1626
1627 /* Send distribute add message to zebra. */
1628 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, zclient, afi, type,
1629 instance, bgp->vrf_id);
1630 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, afi, type,
1631 instance, bgp->vrf_id);
1632
1633 return 0;
518f0eb1
DS		 1634}
1635
718e3744 1636/* Redistribute with route-map specification. */
d62a17ae 1637int bgp_redistribute_rmap_set(struct bgp_redist *red, const char *name)
718e3744 1638{
d62a17ae 1639 if (red->rmap.name && (strcmp(red->rmap.name, name) == 0))
1640 return 0;
718e3744 1641
d62a17ae 1642 if (red->rmap.name)
1643 XFREE(MTYPE_ROUTE_MAP_NAME, red->rmap.name);
1644 red->rmap.name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, name);
1645 red->rmap.map = route_map_lookup_by_name(name);
718e3744 1646
d62a17ae 1647 return 1;
718e3744 1648}
1649
1650/* Redistribute with metric specification. */
d62a17ae 1651int bgp_redistribute_metric_set(struct bgp *bgp, struct bgp_redist *red,
d7c0a89a 1652 afi_t afi, int type, uint32_t metric)
718e3744 1653{
d62a17ae 1654 struct bgp_node *rn;
1655 struct bgp_info *ri;
1656
1657 if (red->redist_metric_flag && red->redist_metric == metric)
1658 return 0;
1659
1660 red->redist_metric_flag = 1;
1661 red->redist_metric = metric;
1662
1663 for (rn = bgp_table_top(bgp->rib[afi][SAFI_UNICAST]); rn;
1664 rn = bgp_route_next(rn)) {
1665 for (ri = rn->info; ri; ri = ri->next) {
1666 if (ri->sub_type == BGP_ROUTE_REDISTRIBUTE
1667 && ri->type == type
1668 && ri->instance == red->instance) {
1669 struct attr *old_attr;
1670 struct attr new_attr;
1671
1672 bgp_attr_dup(&new_attr, ri->attr);
1673 new_attr.med = red->redist_metric;
1674 old_attr = ri->attr;
1675 ri->attr = bgp_attr_intern(&new_attr);
1676 bgp_attr_unintern(&old_attr);
1677
1678 bgp_info_set_flag(rn, ri,
1679 BGP_INFO_ATTR_CHANGED);
1680 bgp_process(bgp, rn, afi, SAFI_UNICAST);
1681 }
1682 }
1683 }
1684
1685 return 1;
718e3744 1686}
1687
1688/* Unset redistribution. */
d62a17ae 1689int bgp_redistribute_unreg(struct bgp *bgp, afi_t afi, int type,
d7c0a89a 1690 unsigned short instance)
718e3744 1691{
d62a17ae 1692 struct bgp_redist *red;
1693
1694 red = bgp_redist_lookup(bgp, afi, type, instance);
1695 if (!red)
1696 return CMD_SUCCESS;
1697
1698 /* Return if zebra connection is disabled. */
1699 if (instance) {
1700 if (!redist_check_instance(&zclient->mi_redist[afi][type],
1701 instance))
1702 return CMD_WARNING;
1703 redist_del_instance(&zclient->mi_redist[afi][type], instance);
1704 } else {
1705 if (!vrf_bitmap_check(zclient->redist[afi][type], bgp->vrf_id))
1706 return CMD_WARNING;
1707 vrf_bitmap_unset(zclient->redist[afi][type], bgp->vrf_id);
1708 }
718e3744 1709
65efcfce 1710
d62a17ae 1711 if (bgp_install_info_to_zebra(bgp)) {
1712 /* Send distribute delete message to zebra. */
1713 if (BGP_DEBUG(zebra, ZEBRA))
1714 zlog_debug("Tx redistribute del VRF %u afi %d %s %d",
1715 bgp->vrf_id, afi, zebra_route_string(type),
1716 instance);
1717 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, zclient, afi,
1718 type, instance, bgp->vrf_id);
1719 }
1720
1721 /* Withdraw redistributed routes from current BGP's routing table. */
1722 bgp_redistribute_withdraw(bgp, afi, type, instance);
1723
1724 return CMD_SUCCESS;
718e3744 1725}
1726
6aeb9e78 1727/* Unset redistribution. */
d62a17ae 1728int bgp_redistribute_unset(struct bgp *bgp, afi_t afi, int type,
d7c0a89a 1729 unsigned short instance)
6aeb9e78 1730{
d62a17ae 1731 struct bgp_redist *red;
6aeb9e78 1732
ddb5b488
PZ		 1733/*
1734 * vnc and vpn->vrf checks must be before red check because
1735 * they operate within bgpd irrespective of zebra connection
1736 * status. red lookup fails if there is no zebra connection.
1737 */
1738#if ENABLE_BGP_VNC
1739 if (bgp->vrf_id == VRF_DEFAULT && type == ZEBRA_ROUTE_VNC_DIRECT) {
1740 vnc_export_bgp_disable(bgp, afi);
1741 }
1742#endif
ddb5b488 1743
d62a17ae 1744 red = bgp_redist_lookup(bgp, afi, type, instance);
1745 if (!red)
1746 return CMD_SUCCESS;
6aeb9e78 1747
d62a17ae 1748 bgp_redistribute_unreg(bgp, afi, type, instance);
6aeb9e78 1749
d62a17ae 1750 /* Unset route-map. */
1751 if (red->rmap.name)
1752 XFREE(MTYPE_ROUTE_MAP_NAME, red->rmap.name);
1753 red->rmap.name = NULL;
1754 red->rmap.map = NULL;
6aeb9e78 1755
d62a17ae 1756 /* Unset metric. */
1757 red->redist_metric_flag = 0;
1758 red->redist_metric = 0;
6aeb9e78 1759
d62a17ae 1760 bgp_redist_del(bgp, afi, type, instance);
6aeb9e78 1761
d62a17ae 1762 return CMD_SUCCESS;
6aeb9e78
DS		 1763}
1764
eb117f29
SK		 1765/* Update redistribute vrf bitmap during triggers like
1766 restart networking or delete/add VRFs */
d62a17ae 1767void bgp_update_redist_vrf_bitmaps(struct bgp *bgp, vrf_id_t old_vrf_id)
eb117f29 1768{
d62a17ae 1769 int i;
1770 afi_t afi;
1771
1772 for (afi = AFI_IP; afi < AFI_MAX; afi++)
1773 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
48c74f88
DS		 1774 if ((old_vrf_id == VRF_UNKNOWN)
1775 || vrf_bitmap_check(zclient->redist[afi][i],
1776 old_vrf_id)) {
d62a17ae 1777 vrf_bitmap_unset(zclient->redist[afi][i],
1778 old_vrf_id);
1779 vrf_bitmap_set(zclient->redist[afi][i],
1780 bgp->vrf_id);
1781 }
1782 return;
eb117f29
SK		 1783}
1784
d62a17ae 1785void bgp_zclient_reset(void)
718e3744 1786{
d62a17ae 1787 zclient_reset(zclient);
718e3744 1788}
1789
ad4cbda1 1790/* Register this instance with Zebra. Invoked upon connect (for
1791 * default instance) and when other VRFs are learnt (or created and
1792 * already learnt).
1793 */
d62a17ae 1794void bgp_zebra_instance_register(struct bgp *bgp)
ad4cbda1 1795{
d62a17ae 1796 /* Don't try to register if we're not connected to Zebra */
1797 if (!zclient || zclient->sock < 0)
1798 return;
ad4cbda1 1799
d62a17ae 1800 if (BGP_DEBUG(zebra, ZEBRA))
1801 zlog_debug("Registering VRF %u", bgp->vrf_id);
ad4cbda1 1802
d62a17ae 1803 /* Register for router-id, interfaces, redistributed routes. */
1804 zclient_send_reg_requests(zclient, bgp->vrf_id);
7724c0a1 1805
d62a17ae 1806 /* For default instance, register to learn about VNIs, if appropriate.
1807 */
a4d82a8a 1808 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT && is_evpn_enabled())
d62a17ae 1809 bgp_zebra_advertise_all_vni(bgp, 1);
ad4cbda1 1810}
1811
1812/* Deregister this instance with Zebra. Invoked upon the instance
1813 * being deleted (default or VRF) and it is already registered.
1814 */
d62a17ae 1815void bgp_zebra_instance_deregister(struct bgp *bgp)
ad4cbda1 1816{
d62a17ae 1817 /* Don't try to deregister if we're not connected to Zebra */
1818 if (zclient->sock < 0)
1819 return;
ad4cbda1 1820
d62a17ae 1821 if (BGP_DEBUG(zebra, ZEBRA))
1822 zlog_debug("Deregistering VRF %u", bgp->vrf_id);
ad4cbda1 1823
d62a17ae 1824 /* For default instance, unregister learning about VNIs, if appropriate.
1825 */
a4d82a8a 1826 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT && is_evpn_enabled())
d62a17ae 1827 bgp_zebra_advertise_all_vni(bgp, 0);
7724c0a1 1828
d62a17ae 1829 /* Deregister for router-id, interfaces, redistributed routes. */
1830 zclient_send_dereg_requests(zclient, bgp->vrf_id);
ad4cbda1 1831}
1832
d62a17ae 1833void bgp_zebra_initiate_radv(struct bgp *bgp, struct peer *peer)
4a04e5f7 1834{
d62a17ae 1835 int ra_interval = BGP_UNNUM_DEFAULT_RA_INTERVAL;
5c81b96a 1836
d62a17ae 1837 /* Don't try to initiate if we're not connected to Zebra */
1838 if (zclient->sock < 0)
1839 return;
4a04e5f7 1840
d62a17ae 1841 if (BGP_DEBUG(zebra, ZEBRA))
1842 zlog_debug("%u: Initiating RA for peer %s", bgp->vrf_id,
1843 peer->host);
4a04e5f7 1844
d62a17ae 1845 zclient_send_interface_radv_req(zclient, bgp->vrf_id, peer->ifp, 1,
1846 ra_interval);
4a04e5f7 1847}
1848
d62a17ae 1849void bgp_zebra_terminate_radv(struct bgp *bgp, struct peer *peer)
4a04e5f7 1850{
d62a17ae 1851 /* Don't try to terminate if we're not connected to Zebra */
1852 if (zclient->sock < 0)
1853 return;
4a04e5f7 1854
d62a17ae 1855 if (BGP_DEBUG(zebra, ZEBRA))
1856 zlog_debug("%u: Terminating RA for peer %s", bgp->vrf_id,
1857 peer->host);
4a04e5f7 1858
d62a17ae 1859 zclient_send_interface_radv_req(zclient, bgp->vrf_id, peer->ifp, 0, 0);
4a04e5f7 1860}
1861
31310b25
MK		 1862int bgp_zebra_advertise_subnet(struct bgp *bgp, int advertise, vni_t vni)
1863{
1864 struct stream *s = NULL;
1865
1866 /* Check socket. */
1867 if (!zclient || zclient->sock < 0)
1868 return 0;
1869
1870 /* Don't try to register if Zebra doesn't know of this instance. */
1871 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp))
1872 return 0;
1873
1874 s = zclient->obuf;
1875 stream_reset(s);
1876
1877 zclient_create_header(s, ZEBRA_ADVERTISE_SUBNET, bgp->vrf_id);
1878 stream_putc(s, advertise);
1879 stream_put3(s, vni);
1880 stream_putw_at(s, 0, stream_get_endp(s));
1881
1882 return zclient_send_message(zclient);
1883}
1884
1a98c087
MK		 1885int bgp_zebra_advertise_gw_macip(struct bgp *bgp, int advertise, vni_t vni)
1886{
1887 struct stream *s = NULL;
1888
1889 /* Check socket. */
1890 if (!zclient || zclient->sock < 0)
1891 return 0;
1892
1893 /* Don't try to register if Zebra doesn't know of this instance. */
1894 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp))
1895 return 0;
1896
1897 s = zclient->obuf;
1898 stream_reset(s);
1899
1900 zclient_create_header(s, ZEBRA_ADVERTISE_DEFAULT_GW, bgp->vrf_id);
1901 stream_putc(s, advertise);
cc6d5476 1902 stream_putl(s, vni);
1a98c087
MK		 1903 stream_putw_at(s, 0, stream_get_endp(s));
1904
1905 return zclient_send_message(zclient);
1906}
1907
d62a17ae 1908int bgp_zebra_advertise_all_vni(struct bgp *bgp, int advertise)
7724c0a1 1909{
d62a17ae 1910 struct stream *s;
7724c0a1 1911
d62a17ae 1912 /* Check socket. */
1913 if (!zclient || zclient->sock < 0)
1914 return 0;
7724c0a1 1915
d62a17ae 1916 /* Don't try to register if Zebra doesn't know of this instance. */
1917 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp))
1918 return 0;
7724c0a1 1919
d62a17ae 1920 s = zclient->obuf;
1921 stream_reset(s);
7724c0a1 1922
d62a17ae 1923 zclient_create_header(s, ZEBRA_ADVERTISE_ALL_VNI, bgp->vrf_id);
1924 stream_putc(s, advertise);
1925 stream_putw_at(s, 0, stream_get_endp(s));
7724c0a1 1926
d62a17ae 1927 return zclient_send_message(zclient);
7724c0a1 1928}
1929
30d50e6d
PG		 1930static int rule_notify_owner(int command, struct zclient *zclient,
1931 zebra_size_t length, vrf_id_t vrf_id)
1932{
1933 uint32_t seqno, priority, unique;
1934 enum zapi_rule_notify_owner note;
1935 struct bgp_pbr_action *bgp_pbra;
1936 ifindex_t ifi;
1937
1938 if (!zapi_rule_notify_decode(zclient->ibuf, &seqno, &priority, &unique,
1939 &ifi, &note))
1940 return -1;
1941
70eabd12 1942 bgp_pbra = bgp_pbr_action_rule_lookup(vrf_id, unique);
30d50e6d
PG		 1943 if (!bgp_pbra) {
1944 if (BGP_DEBUG(zebra, ZEBRA))
1945 zlog_debug("%s: Fail to look BGP rule (%u)",
1946 __PRETTY_FUNCTION__, unique);
1947 return 0;
1948 }
1949
1950 switch (note) {
1951 case ZAPI_RULE_FAIL_INSTALL:
1952 if (BGP_DEBUG(zebra, ZEBRA))
1953 zlog_debug("%s: Received RULE_FAIL_INSTALL",
1954 __PRETTY_FUNCTION__);
1955 bgp_pbra->installed = false;
1956 bgp_pbra->install_in_progress = false;
1957 break;
1958 case ZAPI_RULE_INSTALLED:
1959 bgp_pbra->installed = true;
1960 bgp_pbra->install_in_progress = false;
1961 if (BGP_DEBUG(zebra, ZEBRA))
1962 zlog_debug("%s: Received RULE_INSTALLED",
1963 __PRETTY_FUNCTION__);
1964 break;
1965 case ZAPI_RULE_REMOVED:
1966 if (BGP_DEBUG(zebra, ZEBRA))
1967 zlog_debug("%s: Received RULE REMOVED",
1968 __PRETTY_FUNCTION__);
1969 break;
1970 }
1971
1972 return 0;
1973}
1974
1975static int ipset_notify_owner(int command, struct zclient *zclient,
1976 zebra_size_t length, vrf_id_t vrf_id)
1977{
1978 uint32_t unique;
1979 enum zapi_ipset_notify_owner note;
1980 struct bgp_pbr_match *bgp_pbim;
1981
1982 if (!zapi_ipset_notify_decode(zclient->ibuf,
1983 &unique,
1984 &note))
1985 return -1;
1986
1987 bgp_pbim = bgp_pbr_match_ipset_lookup(vrf_id, unique);
1988 if (!bgp_pbim) {
1989 if (BGP_DEBUG(zebra, ZEBRA))
82e194ed
PG		 1990 zlog_debug("%s: Fail to look BGP match ( %u %u)",
1991 __PRETTY_FUNCTION__, note, unique);
30d50e6d
PG		 1992 return 0;
1993 }
1994
1995 switch (note) {
1996 case ZAPI_IPSET_FAIL_INSTALL:
1997 if (BGP_DEBUG(zebra, ZEBRA))
1998 zlog_debug("%s: Received IPSET_FAIL_INSTALL",
1999 __PRETTY_FUNCTION__);
2000 bgp_pbim->installed = false;
2001 bgp_pbim->install_in_progress = false;
2002 break;
2003 case ZAPI_IPSET_INSTALLED:
2004 bgp_pbim->installed = true;
2005 bgp_pbim->install_in_progress = false;
2006 if (BGP_DEBUG(zebra, ZEBRA))
2007 zlog_debug("%s: Received IPSET_INSTALLED",
2008 __PRETTY_FUNCTION__);
2009 break;
2010 case ZAPI_IPSET_REMOVED:
2011 if (BGP_DEBUG(zebra, ZEBRA))
2012 zlog_debug("%s: Received IPSET REMOVED",
2013 __PRETTY_FUNCTION__);
2014 break;
2015 }
2016
2017 return 0;
2018}
2019
2020static int ipset_entry_notify_owner(int command, struct zclient *zclient,
2021 zebra_size_t length, vrf_id_t vrf_id)
2022{
2023 uint32_t unique;
2024 char ipset_name[ZEBRA_IPSET_NAME_SIZE];
2025 enum zapi_ipset_entry_notify_owner note;
2026 struct bgp_pbr_match_entry *bgp_pbime;
2027
2028 if (!zapi_ipset_entry_notify_decode(
2029 zclient->ibuf,
2030 &unique,
2031 ipset_name,
2032 &note))
2033 return -1;
2034 bgp_pbime = bgp_pbr_match_ipset_entry_lookup(vrf_id,
2035 ipset_name,
2036 unique);
2037 if (!bgp_pbime) {
2038 if (BGP_DEBUG(zebra, ZEBRA))
82e194ed
PG		 2039 zlog_debug("%s: Fail to look BGP match entry (%u %u)",
2040 __PRETTY_FUNCTION__, note, unique);
30d50e6d
PG		 2041 return 0;
2042 }
2043
2044 switch (note) {
2045 case ZAPI_IPSET_ENTRY_FAIL_INSTALL:
2046 if (BGP_DEBUG(zebra, ZEBRA))
2047 zlog_debug("%s: Received IPSET_ENTRY_FAIL_INSTALL",
2048 __PRETTY_FUNCTION__);
2049 bgp_pbime->installed = false;
2050 bgp_pbime->install_in_progress = false;
2051 break;
2052 case ZAPI_IPSET_ENTRY_INSTALLED:
b588b642
PG		 2053 {
2054 struct bgp_info *bgp_info;
2055 struct bgp_info_extra *extra;
2056
2057 bgp_pbime->installed = true;
2058 bgp_pbime->install_in_progress = false;
2059 if (BGP_DEBUG(zebra, ZEBRA))
2060 zlog_debug("%s: Received IPSET_ENTRY_INSTALLED",
2061 __PRETTY_FUNCTION__);
2062 /* link bgp_info to bpme */
2063 bgp_info = (struct bgp_info *)bgp_pbime->bgp_info;
2064 extra = bgp_info_extra_get(bgp_info);
2065 extra->bgp_fs_pbr = (void *)bgp_pbime;
2066 }
30d50e6d
PG		 2067 break;
2068 case ZAPI_IPSET_ENTRY_REMOVED:
2069 if (BGP_DEBUG(zebra, ZEBRA))
2070 zlog_debug("%s: Received IPSET_ENTRY_REMOVED",
2071 __PRETTY_FUNCTION__);
2072 break;
2073 }
2074 return 0;
2075}
2076
c16a0a62
PG		 2077static int iptable_notify_owner(int command, struct zclient *zclient,
2078 zebra_size_t length, vrf_id_t vrf_id)
2079{
2080 uint32_t unique;
2081 enum zapi_iptable_notify_owner note;
2082 struct bgp_pbr_match *bgpm;
2083
2084 if (!zapi_iptable_notify_decode(
2085 zclient->ibuf,
2086 &unique,
2087 &note))
2088 return -1;
2089 bgpm = bgp_pbr_match_iptable_lookup(vrf_id, unique);
2090 if (!bgpm) {
2091 if (BGP_DEBUG(zebra, ZEBRA))
82e194ed
PG		 2092 zlog_debug("%s: Fail to look BGP iptable (%u %u)",
2093 __PRETTY_FUNCTION__, note, unique);
c16a0a62
PG		 2094 return 0;
2095 }
2096 switch (note) {
2097 case ZAPI_IPTABLE_FAIL_INSTALL:
2098 if (BGP_DEBUG(zebra, ZEBRA))
2099 zlog_debug("%s: Received IPTABLE_FAIL_INSTALL",
2100 __PRETTY_FUNCTION__);
2101 bgpm->installed_in_iptable = false;
2102 bgpm->install_iptable_in_progress = false;
2103 break;
2104 case ZAPI_IPTABLE_INSTALLED:
2105 bgpm->installed_in_iptable = true;
2106 bgpm->install_iptable_in_progress = false;
2107 if (BGP_DEBUG(zebra, ZEBRA))
2108 zlog_debug("%s: Received IPTABLE_INSTALLED",
2109 __PRETTY_FUNCTION__);
a6b07429 2110 bgpm->action->refcnt++;
c16a0a62
PG		 2111 break;
2112 case ZAPI_IPTABLE_REMOVED:
2113 if (BGP_DEBUG(zebra, ZEBRA))
2114 zlog_debug("%s: Received IPTABLE REMOVED",
2115 __PRETTY_FUNCTION__);
2116 break;
2117 }
2118 return 0;
2119}
2120
30d50e6d
PG		 2121static void bgp_encode_pbr_rule_action(struct stream *s,
2122 struct bgp_pbr_action *pbra)
2123{
2124 struct prefix any;
2125
2126 stream_putl(s, 0); /* seqno unused */
2127 stream_putl(s, 0); /* ruleno unused */
2128
2129 stream_putl(s, pbra->unique);
2130
2131 memset(&any, 0, sizeof(any));
2132 any.family = AF_INET;
2133 stream_putc(s, any.family);
2134 stream_putc(s, any.prefixlen);
2135 stream_put(s, &any.u.prefix, prefix_blen(&any));
2136
2137 stream_putw(s, 0); /* src port */
2138
2139 stream_putc(s, any.family);
2140 stream_putc(s, any.prefixlen);
2141 stream_put(s, &any.u.prefix, prefix_blen(&any));
2142
2143 stream_putw(s, 0); /* dst port */
2144
2145 stream_putl(s, pbra->fwmark); /* fwmark */
2146
2147 stream_putl(s, pbra->table_id);
2148
2149 stream_putl(s, 0); /* ifindex unused */
2150}
2151
2152static void bgp_encode_pbr_ipset_match(struct stream *s,
2153 struct bgp_pbr_match *pbim)
2154{
2155 stream_putl(s, pbim->unique);
2156 stream_putl(s, pbim->type);
2157
2158 stream_put(s, pbim->ipset_name,
2159 ZEBRA_IPSET_NAME_SIZE);
2160
2161
2162}
2163
2164static void bgp_encode_pbr_ipset_entry_match(struct stream *s,
2165 struct bgp_pbr_match_entry *pbime)
2166{
2167 stream_putl(s, pbime->unique);
2168 /* check that back pointer is not null */
2169 stream_put(s, pbime->backpointer->ipset_name,
2170 ZEBRA_IPSET_NAME_SIZE);
2171
2172 stream_putc(s, pbime->src.family);
2173 stream_putc(s, pbime->src.prefixlen);
2174 stream_put(s, &pbime->src.u.prefix, prefix_blen(&pbime->src));
2175
2176 stream_putc(s, pbime->dst.family);
2177 stream_putc(s, pbime->dst.prefixlen);
2178 stream_put(s, &pbime->dst.u.prefix, prefix_blen(&pbime->dst));
f730e566
PG		 2179
2180 stream_putw(s, pbime->src_port_min);
2181 stream_putw(s, pbime->src_port_max);
2182 stream_putw(s, pbime->dst_port_min);
2183 stream_putw(s, pbime->dst_port_max);
2184 stream_putc(s, pbime->proto);
30d50e6d
PG		 2185}
2186
c16a0a62
PG		 2187static void bgp_encode_pbr_iptable_match(struct stream *s,
2188 struct bgp_pbr_action *bpa,
2189 struct bgp_pbr_match *pbm)
2190{
2191 stream_putl(s, pbm->unique2);
2192
2193 stream_putl(s, pbm->type);
2194
2195 stream_putl(s, pbm->flags);
2196
2197 /* TODO: correlate with what is contained
2198 * into bgp_pbr_action.
2199 * currently only forward supported
2200 */
2201 if (bpa->nh.type == NEXTHOP_TYPE_BLACKHOLE)
2202 stream_putl(s, ZEBRA_IPTABLES_DROP);
2203 else
2204 stream_putl(s, ZEBRA_IPTABLES_FORWARD);
2205 stream_putl(s, bpa->fwmark);
2206 stream_put(s, pbm->ipset_name,
2207 ZEBRA_IPSET_NAME_SIZE);
2208}
2209
ad4cbda1 2210/* BGP has established connection with Zebra. */
d62a17ae 2211static void bgp_zebra_connected(struct zclient *zclient)
7076bb2f 2212{
d62a17ae 2213 struct bgp *bgp;
7076bb2f 2214
d62a17ae 2215 zclient_num_connects++; /* increment even if not responding */
afbb1c59 2216
d62a17ae 2217 /* At this point, we may or may not have BGP instances configured, but
2218 * we're only interested in the default VRF (others wouldn't have learnt
2219 * the VRF from Zebra yet.)
2220 */
2221 bgp = bgp_get_default();
2222 if (!bgp)
2223 return;
ad4cbda1 2224
d62a17ae 2225 bgp_zebra_instance_register(bgp);
ad4cbda1 2226
d62a17ae 2227 /* Send the client registration */
2228 bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER);
2376c3f2 2229
955bfd98 2230 /* tell label pool that zebra is connected */
e70e9f8e 2231 bgp_lp_event_zebra_up();
955bfd98 2232
d62a17ae 2233 /* TODO - What if we have peers and networks configured, do we have to
2234 * kick-start them?
2235 */
7076bb2f
FL		 2236}
2237
fe1dc5a3
MK		 2238static int bgp_zebra_process_local_l3vni(int cmd, struct zclient *zclient,
2239 zebra_size_t length, vrf_id_t vrf_id)
2240{
c48d9f5f 2241 int filter = 0;
fe1dc5a3 2242 char buf[ETHER_ADDR_STRLEN];
b67a60d2 2243 vni_t l3vni = 0;
fe1dc5a3 2244 struct ethaddr rmac;
b67a60d2 2245 struct in_addr originator_ip;
fe1dc5a3
MK		 2246 struct stream *s;
2247
2248 memset(&rmac, 0, sizeof(struct ethaddr));
b67a60d2 2249 memset(&originator_ip, 0, sizeof(struct in_addr));
fe1dc5a3
MK		 2250 s = zclient->ibuf;
2251 l3vni = stream_getl(s);
b67a60d2 2252 if (cmd == ZEBRA_L3VNI_ADD) {
fe1dc5a3 2253 stream_get(&rmac, s, sizeof(struct ethaddr));
b67a60d2 2254 originator_ip.s_addr = stream_get_ipv4(s);
c48d9f5f 2255 stream_get(&filter, s, sizeof(int));
b67a60d2 2256 }
fe1dc5a3
MK		 2257
2258 if (BGP_DEBUG(zebra, ZEBRA))
c48d9f5f 2259 zlog_debug("Rx L3-VNI %s VRF %s VNI %u RMAC %s filter %s",
fe1dc5a3 2260 (cmd == ZEBRA_L3VNI_ADD) ? "add" : "del",
996c9314 2261 vrf_id_to_name(vrf_id), l3vni,
c48d9f5f
MK		 2262 prefix_mac2str(&rmac, buf, sizeof(buf)),
2263 filter ? "prefix-routes-only" : "none");
fe1dc5a3
MK		 2264
2265 if (cmd == ZEBRA_L3VNI_ADD)
c48d9f5f
MK		 2266 bgp_evpn_local_l3vni_add(l3vni, vrf_id, &rmac, originator_ip,
2267 filter);
fe1dc5a3
MK		 2268 else
2269 bgp_evpn_local_l3vni_del(l3vni, vrf_id);
2270
2271 return 0;
2272}
2273
d62a17ae 2274static int bgp_zebra_process_local_vni(int command, struct zclient *zclient,
2275 zebra_size_t length, vrf_id_t vrf_id)
128ea8ab 2276{
d62a17ae 2277 struct stream *s;
2278 vni_t vni;
2279 struct bgp *bgp;
a4d82a8a 2280 struct in_addr vtep_ip = {INADDR_ANY};
29c53922 2281 vrf_id_t tenant_vrf_id = VRF_DEFAULT;
d62a17ae 2282
2283 s = zclient->ibuf;
2284 vni = stream_getl(s);
29c53922 2285 if (command == ZEBRA_VNI_ADD) {
d62a17ae 2286 vtep_ip.s_addr = stream_get_ipv4(s);
29c53922
MK		 2287 stream_get(&tenant_vrf_id, s, sizeof(vrf_id_t));
2288 }
2289
d62a17ae 2290 bgp = bgp_lookup_by_vrf_id(vrf_id);
2291 if (!bgp)
2292 return 0;
2293
2294 if (BGP_DEBUG(zebra, ZEBRA))
29c53922
MK		 2295 zlog_debug("Rx VNI %s VRF %s VNI %u tenant-vrf %s",
2296 (command == ZEBRA_VNI_ADD) ? "add" : "del",
a4d82a8a
PZ		 2297 vrf_id_to_name(vrf_id), vni,
2298 vrf_id_to_name(tenant_vrf_id));
d62a17ae 2299
2300 if (command == ZEBRA_VNI_ADD)
2301 return bgp_evpn_local_vni_add(
29c53922
MK		 2302 bgp, vni, vtep_ip.s_addr ? vtep_ip : bgp->router_id,
2303 tenant_vrf_id);
d62a17ae 2304 else
2305 return bgp_evpn_local_vni_del(bgp, vni);
128ea8ab 2306}
2307
d62a17ae 2308static int bgp_zebra_process_local_macip(int command, struct zclient *zclient,
2309 zebra_size_t length, vrf_id_t vrf_id)
128ea8ab 2310{
d62a17ae 2311 struct stream *s;
2312 vni_t vni;
2313 struct bgp *bgp;
2314 struct ethaddr mac;
2315 struct ipaddr ip;
2316 int ipa_len;
2317 char buf[ETHER_ADDR_STRLEN];
2318 char buf1[INET6_ADDRSTRLEN];
d7c0a89a 2319 uint8_t flags;
d62a17ae 2320
2321 memset(&ip, 0, sizeof(ip));
2322 s = zclient->ibuf;
2323 vni = stream_getl(s);
28328ea9 2324 stream_get(&mac.octet, s, ETH_ALEN);
d62a17ae 2325 ipa_len = stream_getl(s);
2326 if (ipa_len != 0 && ipa_len != IPV4_MAX_BYTELEN
2327 && ipa_len != IPV6_MAX_BYTELEN) {
2328 zlog_err("%u:Recv MACIP %s with invalid IP addr length %d",
2329 vrf_id, (command == ZEBRA_MACIP_ADD) ? "Add" : "Del",
2330 ipa_len);
2331 return -1;
2332 }
2333
2334 if (ipa_len) {
2335 ip.ipa_type =
2336 (ipa_len == IPV4_MAX_BYTELEN) ? IPADDR_V4 : IPADDR_V6;
2337 stream_get(&ip.ip.addr, s, ipa_len);
2338 }
1a98c087 2339 flags = stream_getc(s);
d62a17ae 2340
2341 bgp = bgp_lookup_by_vrf_id(vrf_id);
2342 if (!bgp)
2343 return 0;
2344
2345 if (BGP_DEBUG(zebra, ZEBRA))
1a98c087
MK		 2346 zlog_debug("%u:Recv MACIP %s flags 0x%x MAC %s IP %s VNI %u",
2347 vrf_id, (command == ZEBRA_MACIP_ADD) ? "Add" : "Del",
2348 flags, prefix_mac2str(&mac, buf, sizeof(buf)),
d62a17ae 2349 ipaddr2str(&ip, buf1, sizeof(buf1)), vni);
2350
2351 if (command == ZEBRA_MACIP_ADD)
1a98c087 2352 return bgp_evpn_local_macip_add(bgp, vni, &mac, &ip, flags);
d62a17ae 2353 else
2354 return bgp_evpn_local_macip_del(bgp, vni, &mac, &ip);
128ea8ab 2355}
6aeb9e78 2356
a4d82a8a 2357static void bgp_zebra_process_local_ip_prefix(int cmd, struct zclient *zclient,
31310b25
MK		 2358 zebra_size_t length,
2359 vrf_id_t vrf_id)
2360{
2361 struct stream *s = NULL;
2362 struct bgp *bgp_vrf = NULL;
2363 struct prefix p;
2364 char buf[PREFIX_STRLEN];
2365
2366 memset(&p, 0, sizeof(struct prefix));
2367 s = zclient->ibuf;
2368 stream_get(&p, s, sizeof(struct prefix));
2369
2370 bgp_vrf = bgp_lookup_by_vrf_id(vrf_id);
2371 if (!bgp_vrf)
2372 return;
2373
2374 if (BGP_DEBUG(zebra, ZEBRA))
2375 zlog_debug("Recv prefix %s %s on vrf %s",
2376 prefix2str(&p, buf, sizeof(buf)),
2377 (cmd == ZEBRA_IP_PREFIX_ROUTE_ADD) ? "ADD" : "DEL",
2378 vrf_id_to_name(vrf_id));
2379
2380 if (cmd == ZEBRA_IP_PREFIX_ROUTE_ADD) {
2381
2382 if (p.family == AF_INET)
a4d82a8a
PZ		 2383 return bgp_evpn_advertise_type5_route(
2384 bgp_vrf, &p, NULL, AFI_IP, SAFI_UNICAST);
31310b25 2385 else
a4d82a8a
PZ		 2386 return bgp_evpn_advertise_type5_route(
2387 bgp_vrf, &p, NULL, AFI_IP6, SAFI_UNICAST);
31310b25
MK		 2388
2389 } else {
2390 if (p.family == AF_INET)
a4d82a8a
PZ		 2391 return bgp_evpn_withdraw_type5_route(
2392 bgp_vrf, &p, AFI_IP, SAFI_UNICAST);
31310b25 2393 else
a4d82a8a
PZ		 2394 return bgp_evpn_withdraw_type5_route(
2395 bgp_vrf, &p, AFI_IP6, SAFI_UNICAST);
31310b25
MK		 2396 }
2397}
2398
955bfd98
PZ		 2399static void bgp_zebra_process_label_chunk(
2400 int cmd,
2401 struct zclient *zclient,
2402 zebra_size_t length,
2403 vrf_id_t vrf_id)
2404{
2405 struct stream *s = NULL;
2406 uint8_t response_keep;
2407 uint32_t first;
2408 uint32_t last;
aec865e4
FR		 2409 uint8_t proto;
2410 unsigned short instance;
955bfd98
PZ		 2411
2412 s = zclient->ibuf;
aec865e4
FR		 2413 STREAM_GETC(s, proto);
2414 STREAM_GETW(s, instance);
955bfd98
PZ		 2415 STREAM_GETC(s, response_keep);
2416 STREAM_GETL(s, first);
2417 STREAM_GETL(s, last);
2418
aec865e4
FR		 2419 if (zclient->redist_default != proto) {
2420 zlog_err("Got LM msg with wrong proto %u", proto);
2421 return;
2422 }
2423 if (zclient->instance != instance) {
2424 zlog_err("Got LM msg with wrong instance %u", proto);
2425 return;
2426 }
2427
955bfd98
PZ		 2428 if (first > last ||
2429 first < MPLS_LABEL_UNRESERVED_MIN ||
2430 last > MPLS_LABEL_UNRESERVED_MAX) {
2431
2432 zlog_err("%s: Invalid Label chunk: %u - %u",
2433 __func__, first, last);
2434 return;
2435 }
2436 if (BGP_DEBUG(zebra, ZEBRA)) {
2437 zlog_debug("Label Chunk assign: %u - %u (%u) ",
2438 first, last, response_keep);
2439 }
2440
e70e9f8e 2441 bgp_lp_event_chunk(response_keep, first, last);
955bfd98
PZ		 2442
2443stream_failure: /* for STREAM_GETX */
2444 return;
2445}
2446
342213ea
DS		 2447extern struct zebra_privs_t bgpd_privs;
2448
d62a17ae 2449void bgp_zebra_init(struct thread_master *master)
718e3744 2450{
d62a17ae 2451 zclient_num_connects = 0;
2452
2453 /* Set default values. */
e1a1880d 2454 zclient = zclient_new_notify(master, &zclient_options_default);
342213ea 2455 zclient_init(zclient, ZEBRA_ROUTE_BGP, 0, &bgpd_privs);
d62a17ae 2456 zclient->zebra_connected = bgp_zebra_connected;
2457 zclient->router_id_update = bgp_router_id_update;
2458 zclient->interface_add = bgp_interface_add;
2459 zclient->interface_delete = bgp_interface_delete;
2460 zclient->interface_address_add = bgp_interface_address_add;
2461 zclient->interface_address_delete = bgp_interface_address_delete;
2462 zclient->interface_nbr_address_add = bgp_interface_nbr_address_add;
2463 zclient->interface_nbr_address_delete =
2464 bgp_interface_nbr_address_delete;
2465 zclient->interface_vrf_update = bgp_interface_vrf_update;
74489921
RW		 2466 zclient->redistribute_route_add = zebra_read_route;
2467 zclient->redistribute_route_del = zebra_read_route;
d62a17ae 2468 zclient->interface_up = bgp_interface_up;
2469 zclient->interface_down = bgp_interface_down;
d62a17ae 2470 zclient->nexthop_update = bgp_read_nexthop_update;
2471 zclient->import_check_update = bgp_read_import_check_update;
2472 zclient->fec_update = bgp_read_fec_update;
2473 zclient->local_vni_add = bgp_zebra_process_local_vni;
2474 zclient->local_vni_del = bgp_zebra_process_local_vni;
2475 zclient->local_macip_add = bgp_zebra_process_local_macip;
2476 zclient->local_macip_del = bgp_zebra_process_local_macip;
fe1dc5a3
MK		 2477 zclient->local_l3vni_add = bgp_zebra_process_local_l3vni;
2478 zclient->local_l3vni_del = bgp_zebra_process_local_l3vni;
31310b25
MK		 2479 zclient->local_ip_prefix_add = bgp_zebra_process_local_ip_prefix;
2480 zclient->local_ip_prefix_del = bgp_zebra_process_local_ip_prefix;
955bfd98 2481 zclient->label_chunk = bgp_zebra_process_label_chunk;
30d50e6d
PG		 2482 zclient->rule_notify_owner = rule_notify_owner;
2483 zclient->ipset_notify_owner = ipset_notify_owner;
2484 zclient->ipset_entry_notify_owner = ipset_entry_notify_owner;
c16a0a62 2485 zclient->iptable_notify_owner = iptable_notify_owner;
718e3744 2486}
bb86c601 2487
d62a17ae 2488void bgp_zebra_destroy(void)
bb86c601 2489{
d62a17ae 2490 if (zclient == NULL)
2491 return;
2492 zclient_stop(zclient);
2493 zclient_free(zclient);
2494 zclient = NULL;
bb86c601 2495}
afbb1c59 2496
d62a17ae 2497int bgp_zebra_num_connects(void)
afbb1c59 2498{
d62a17ae 2499 return zclient_num_connects;
afbb1c59 2500}
30d50e6d
PG		 2501
2502void bgp_send_pbr_rule_action(struct bgp_pbr_action *pbra, bool install)
2503{
2504 struct stream *s;
2505
2506 if (pbra->install_in_progress)
2507 return;
2508 zlog_debug("%s: table %d fwmark %d %d", __PRETTY_FUNCTION__,
2509 pbra->table_id, pbra->fwmark, install);
2510 s = zclient->obuf;
2511 stream_reset(s);
2512
2513 zclient_create_header(s,
2514 install ? ZEBRA_RULE_ADD : ZEBRA_RULE_DELETE,
2515 VRF_DEFAULT);
2516 stream_putl(s, 1); /* send one pbr action */
2517
2518 bgp_encode_pbr_rule_action(s, pbra);
2519
2520 stream_putw_at(s, 0, stream_get_endp(s));
2521 if (!zclient_send_message(zclient) && install)
2522 pbra->install_in_progress = true;
2523}
2524
2525void bgp_send_pbr_ipset_match(struct bgp_pbr_match *pbrim, bool install)
2526{
2527 struct stream *s;
2528
2529 if (pbrim->install_in_progress)
2530 return;
2531 zlog_debug("%s: name %s type %d %d", __PRETTY_FUNCTION__,
2532 pbrim->ipset_name, pbrim->type, install);
2533 s = zclient->obuf;
2534 stream_reset(s);
2535
2536 zclient_create_header(s,
2537 install ? ZEBRA_IPSET_CREATE :
2538 ZEBRA_IPSET_DESTROY,
2539 VRF_DEFAULT);
2540
2541 stream_putl(s, 1); /* send one pbr action */
2542
2543 bgp_encode_pbr_ipset_match(s, pbrim);
2544
2545 stream_putw_at(s, 0, stream_get_endp(s));
2546 if (!zclient_send_message(zclient) && install)
2547 pbrim->install_in_progress = true;
2548}
2549
2550void bgp_send_pbr_ipset_entry_match(struct bgp_pbr_match_entry *pbrime,
2551 bool install)
2552{
2553 struct stream *s;
2554
2555 if (pbrime->install_in_progress)
2556 return;
2557 zlog_debug("%s: name %s %d %d", __PRETTY_FUNCTION__,
2558 pbrime->backpointer->ipset_name,
2559 pbrime->unique, install);
2560 s = zclient->obuf;
2561 stream_reset(s);
2562
2563 zclient_create_header(s,
2564 install ? ZEBRA_IPSET_ENTRY_ADD :
2565 ZEBRA_IPSET_ENTRY_DELETE,
2566 VRF_DEFAULT);
2567
2568 stream_putl(s, 1); /* send one pbr action */
2569
2570 bgp_encode_pbr_ipset_entry_match(s, pbrime);
2571
2572 stream_putw_at(s, 0, stream_get_endp(s));
2573 if (!zclient_send_message(zclient) && install)
2574 pbrime->install_in_progress = true;
2575}
c16a0a62
PG		 2576
2577void bgp_send_pbr_iptable(struct bgp_pbr_action *pba,
2578 struct bgp_pbr_match *pbm,
2579 bool install)
2580{
2581 struct stream *s;
b5c40105 2582 int ret = 0;
c16a0a62
PG		 2583
2584 if (pbm->install_iptable_in_progress)
2585 return;
2586 zlog_debug("%s: name %s type %d mark %d %d", __PRETTY_FUNCTION__,
2587 pbm->ipset_name, pbm->type, pba->fwmark, install);
2588 s = zclient->obuf;
2589 stream_reset(s);
2590
2591 zclient_create_header(s,
2592 install ? ZEBRA_IPTABLE_ADD :
2593 ZEBRA_IPTABLE_DELETE,
2594 VRF_DEFAULT);
2595
2596 bgp_encode_pbr_iptable_match(s, pba, pbm);
2597
2598 stream_putw_at(s, 0, stream_get_endp(s));
b5c40105
PG		 2599 ret = zclient_send_message(zclient);
2600 if (install) {
2601 if (ret)
2602 pba->refcnt++;
2603 else
2604 pbm->install_iptable_in_progress = true;
a6b07429 2605 }
c16a0a62 2606}
f7df1907
PG		 2607
2608/* inject in table <table_id> a default route to:
2609 * - if nexthop IP is present : to this nexthop
2610 * - if vrf is different from local : to the matching VRF
2611 */
2612void bgp_zebra_announce_default(struct bgp *bgp, struct nexthop *nh,
2613 afi_t afi, uint32_t table_id, bool announce)
2614{
2615 struct zapi_nexthop *api_nh;
2616 struct zapi_route api;
2617 struct prefix p;
2618
2619 if (!nh || nh->type != NEXTHOP_TYPE_IPV4
2620 || nh->vrf_id == VRF_UNKNOWN)
2621 return;
2622 memset(&p, 0, sizeof(struct prefix));
2623 /* default route */
2624 if (afi != AFI_IP)
2625 return;
2626 p.family = AF_INET;
2627 memset(&api, 0, sizeof(api));
2628 api.vrf_id = bgp->vrf_id;
2629 api.type = ZEBRA_ROUTE_BGP;
2630 api.safi = SAFI_UNICAST;
2631 api.prefix = p;
2632 api.tableid = table_id;
2633 api.nexthop_num = 1;
2634 SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
2635 SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
2636 api_nh = &api.nexthops[0];
2637
2638 /* redirect IP */
2639 if (nh->gate.ipv4.s_addr) {
2640 char buff[PREFIX_STRLEN];
2641
2642 api_nh->vrf_id = nh->vrf_id;
2643 api_nh->gate.ipv4 = nh->gate.ipv4;
2644 api_nh->type = NEXTHOP_TYPE_IPV4;
2645
2646 inet_ntop(AF_INET, &(nh->gate.ipv4), buff, INET_ADDRSTRLEN);
2647 if (BGP_DEBUG(zebra, ZEBRA))
d887503c
PG		 2648 zlog_info("BGP: %s default route to %s table %d (redirect IP)",
2649 announce ? "adding" : "withdrawing",
f7df1907
PG		 2650 buff, table_id);
2651 zclient_route_send(announce ? ZEBRA_ROUTE_ADD
2652 : ZEBRA_ROUTE_DELETE,
2653 zclient, &api);
2654 } else if (nh->vrf_id != bgp->vrf_id) {
2655 struct vrf *vrf;
eb4244f8 2656 struct interface *ifp;
f7df1907 2657
eb4244f8 2658 vrf = vrf_lookup_by_id(nh->vrf_id);
f7df1907
PG		 2659 if (!vrf)
2660 return;
eb4244f8
PG		 2661 /* create default route with interface <VRF>
2662 * with nexthop-vrf <VRF>
f7df1907 2663 */
eb4244f8
PG		 2664 ifp = if_lookup_by_name_all_vrf(vrf->name);
2665 if (!ifp)
2666 return;
2667 api_nh->vrf_id = nh->vrf_id;
2668 api_nh->type = NEXTHOP_TYPE_IFINDEX;
2669 api_nh->ifindex = ifp->ifindex;
2670 if (BGP_DEBUG(zebra, ZEBRA))
d887503c
PG		 2671 zlog_info("BGP: %s default route to %s table %d (redirect VRF)",
2672 announce ? "adding" : "withdrawing",
eb4244f8
PG		 2673 vrf->name, table_id);
2674 zclient_route_send(announce ? ZEBRA_ROUTE_ADD
2675 : ZEBRA_ROUTE_DELETE,
2676 zclient, &api);
f7df1907
PG		 2677 return;
2678 }
2679}
FRRouting mirror