2 Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
4 This file is part of GNU Zebra.
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
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.
16 You should have received a copy of the GNU General Public License
17 along with GNU Zebra; see the file COPYING. If not, write to the
18 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
28 #include "sockunion.h"
38 #include "bgpd/bgpd.h"
39 #include "bgpd/bgp_route.h"
40 #include "bgpd/bgp_attr.h"
41 #include "bgpd/bgp_nexthop.h"
42 #include "bgpd/bgp_zebra.h"
43 #include "bgpd/bgp_fsm.h"
44 #include "bgpd/bgp_debug.h"
45 #include "bgpd/bgp_mpath.h"
46 #include "bgpd/bgp_nexthop.h"
47 #include "bgpd/bgp_nht.h"
48 #include "bgpd/bgp_bfd.h"
50 # include "bgpd/rfapi/rfapi_backend.h"
51 # include "bgpd/rfapi/vnc_export_bgp.h"
54 /* All information about zebra. */
55 struct zclient
*zclient
= NULL
;
57 /* Growable buffer for nexthops sent to zebra */
58 struct stream
*bgp_nexthop_buf
= NULL
;
59 struct stream
*bgp_ifindices_buf
= NULL
;
61 /* These array buffers are used in making a copy of the attributes for
62 route-map apply. Arrays are being used here to minimize mallocs and
63 frees for the temporary copy of the attributes.
64 Given the zapi api expects the nexthop buffer to contain pointer to
65 pointers for nexthops, we couldnt have used a single nexthop variable
66 on the stack, hence we had two options:
67 1. maintain a linked-list and free it after zapi_*_route call
68 2. use an array to avoid number of mallocs.
69 Number of supported next-hops are finite, use of arrays should be ok. */
70 struct attr attr_cp
[MULTIPATH_NUM
];
71 struct attr_extra attr_extra_cp
[MULTIPATH_NUM
];
72 unsigned int attr_index
= 0;
74 /* Once per address-family initialization of the attribute array */
75 #define BGP_INFO_ATTR_BUF_INIT()\
77 memset(attr_cp, 0, MULTIPATH_NUM * sizeof(struct attr));\
78 memset(attr_extra_cp, 0, MULTIPATH_NUM * sizeof(struct attr_extra));\
82 #define BGP_INFO_ATTR_BUF_COPY(info_src, info_dst)\
84 *info_dst = *info_src; \
85 assert(attr_index != multipath_num);\
86 attr_cp[attr_index].extra = &attr_extra_cp[attr_index]; \
87 bgp_attr_dup (&attr_cp[attr_index], info_src->attr); \
88 bgp_attr_deep_dup (&attr_cp[attr_index], info_src->attr); \
89 info_dst->attr = &attr_cp[attr_index]; \
93 #define BGP_INFO_ATTR_BUF_FREE(info) \
95 bgp_attr_deep_free(info->attr); \
99 /* Can we install into zebra? */
101 bgp_install_info_to_zebra (struct bgp
*bgp
)
103 if (zclient
->sock
<= 0)
106 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
112 int zclient_num_connects
;
114 /* Router-id update message from zebra. */
116 bgp_router_id_update (int command
, struct zclient
*zclient
, zebra_size_t length
,
119 struct prefix router_id
;
121 zebra_router_id_update_read(zclient
->ibuf
,&router_id
);
123 if (BGP_DEBUG (zebra
, ZEBRA
))
125 char buf
[PREFIX2STR_BUFFER
];
126 prefix2str(&router_id
, buf
, sizeof(buf
));
127 zlog_debug("Rx Router Id update VRF %u Id %s", vrf_id
, buf
);
130 bgp_router_id_zebra_bump (vrf_id
, &router_id
);
134 /* Nexthop update message from zebra. */
136 bgp_read_nexthop_update (int command
, struct zclient
*zclient
,
137 zebra_size_t length
, vrf_id_t vrf_id
)
139 bgp_parse_nexthop_update(command
, vrf_id
);
144 bgp_read_import_check_update(int command
, struct zclient
*zclient
,
145 zebra_size_t length
, vrf_id_t vrf_id
)
147 bgp_parse_nexthop_update(command
, vrf_id
);
151 /* Set or clear interface on which unnumbered neighbor is configured. This
152 * would in turn cause BGP to initiate or turn off IPv6 RAs on this
156 bgp_update_interface_nbrs (struct bgp
*bgp
, struct interface
*ifp
,
157 struct interface
*upd_ifp
)
159 struct listnode
*node
, *nnode
;
162 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
165 (strcmp (peer
->conf_if
, ifp
->name
) == 0))
170 bgp_zebra_initiate_radv (bgp
, peer
);
174 bgp_zebra_terminate_radv (bgp
, peer
);
182 bgp_start_interface_nbrs (struct bgp
*bgp
, struct interface
*ifp
)
184 struct listnode
*node
, *nnode
;
187 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
190 (strcmp (peer
->conf_if
, ifp
->name
) == 0) &&
191 peer
->status
!= Established
)
193 if (peer_active(peer
))
194 BGP_EVENT_ADD (peer
, BGP_Stop
);
195 BGP_EVENT_ADD (peer
, BGP_Start
);
201 bgp_nbr_connected_add (struct bgp
*bgp
, struct nbr_connected
*ifc
)
203 struct listnode
*node
;
204 struct connected
*connected
;
205 struct interface
*ifp
;
208 /* Kick-off the FSM for any relevant peers only if there is a
209 * valid local address on the interface.
212 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, node
, connected
))
214 p
= connected
->address
;
215 if (p
->family
== AF_INET6
&&
216 IN6_IS_ADDR_LINKLOCAL (&p
->u
.prefix6
))
222 bgp_start_interface_nbrs (bgp
, ifp
);
226 bgp_nbr_connected_delete (struct bgp
*bgp
, struct nbr_connected
*ifc
, int del
)
228 struct listnode
*node
, *nnode
;
230 struct interface
*ifp
;
232 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
234 if (peer
->conf_if
&& (strcmp (peer
->conf_if
, ifc
->ifp
->name
) == 0))
236 peer
->last_reset
= PEER_DOWN_NBR_ADDR_DEL
;
237 BGP_EVENT_ADD (peer
, BGP_Stop
);
240 /* Free neighbor also, if we're asked to. */
244 listnode_delete (ifp
->nbr_connected
, ifc
);
245 nbr_connected_free (ifc
);
249 /* Inteface addition message from zebra. */
251 bgp_interface_add (int command
, struct zclient
*zclient
, zebra_size_t length
,
254 struct interface
*ifp
;
257 ifp
= zebra_interface_add_read (zclient
->ibuf
, vrf_id
);
258 if (!ifp
) // unexpected
261 if (BGP_DEBUG (zebra
, ZEBRA
) && ifp
)
262 zlog_debug("Rx Intf add VRF %u IF %s", vrf_id
, ifp
->name
);
264 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
268 bgp_update_interface_nbrs (bgp
, ifp
, ifp
);
273 bgp_interface_delete (int command
, struct zclient
*zclient
,
274 zebra_size_t length
, vrf_id_t vrf_id
)
277 struct interface
*ifp
;
281 ifp
= zebra_interface_state_read (s
, vrf_id
);
282 if (!ifp
) /* This may happen if we've just unregistered for a VRF. */
285 ifp
->ifindex
= IFINDEX_DELETED
;
287 if (BGP_DEBUG (zebra
, ZEBRA
))
288 zlog_debug("Rx Intf del VRF %u IF %s", vrf_id
, ifp
->name
);
290 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
294 bgp_update_interface_nbrs (bgp
, ifp
, NULL
);
299 bgp_interface_up (int command
, struct zclient
*zclient
, zebra_size_t length
,
303 struct interface
*ifp
;
305 struct nbr_connected
*nc
;
306 struct listnode
*node
, *nnode
;
310 ifp
= zebra_interface_state_read (s
, vrf_id
);
315 if (BGP_DEBUG (zebra
, ZEBRA
))
316 zlog_debug("Rx Intf up VRF %u IF %s", vrf_id
, ifp
->name
);
318 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
322 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, c
))
323 bgp_connected_add (bgp
, c
);
325 for (ALL_LIST_ELEMENTS (ifp
->nbr_connected
, node
, nnode
, nc
))
326 bgp_nbr_connected_add (bgp
, nc
);
332 bgp_interface_down (int command
, struct zclient
*zclient
, zebra_size_t length
,
336 struct interface
*ifp
;
338 struct nbr_connected
*nc
;
339 struct listnode
*node
, *nnode
;
343 ifp
= zebra_interface_state_read (s
, vrf_id
);
347 if (BGP_DEBUG (zebra
, ZEBRA
))
348 zlog_debug("Rx Intf down VRF %u IF %s", vrf_id
, ifp
->name
);
350 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
354 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, c
))
355 bgp_connected_delete (bgp
, c
);
357 for (ALL_LIST_ELEMENTS (ifp
->nbr_connected
, node
, nnode
, nc
))
358 bgp_nbr_connected_delete (bgp
, nc
, 1);
360 /* Fast external-failover */
364 if (CHECK_FLAG (bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
367 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
369 #if defined(HAVE_CUMULUS)
370 /* Take down directly connected EBGP peers as well as 1-hop BFD
371 * tracked (directly connected) IBGP peers.
373 if ((peer
->ttl
!= 1) && (peer
->gtsm_hops
!= 1) &&
374 (!peer
->bfd_info
|| bgp_bfd_is_peer_multihop(peer
)))
376 /* Take down directly connected EBGP peers */
377 if ((peer
->ttl
!= 1) && (peer
->gtsm_hops
!= 1))
381 if (ifp
== peer
->nexthop
.ifp
)
383 BGP_EVENT_ADD (peer
, BGP_Stop
);
384 peer
->last_reset
= PEER_DOWN_IF_DOWN
;
393 bgp_interface_address_add (int command
, struct zclient
*zclient
,
394 zebra_size_t length
, vrf_id_t vrf_id
)
396 struct connected
*ifc
;
398 ifc
= zebra_interface_address_read (command
, zclient
->ibuf
, vrf_id
);
403 if (bgp_debug_zebra(ifc
->address
))
405 char buf
[PREFIX2STR_BUFFER
];
406 prefix2str(ifc
->address
, buf
, sizeof(buf
));
407 zlog_debug("Rx Intf address add VRF %u IF %s addr %s",
408 vrf_id
, ifc
->ifp
->name
, buf
);
411 if (if_is_operative (ifc
->ifp
))
415 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
419 bgp_connected_add (bgp
, ifc
);
420 /* If we have learnt of any neighbors on this interface,
421 * check to kick off any BGP interface-based neighbors,
422 * but only if this is a link-local address.
424 if (IN6_IS_ADDR_LINKLOCAL(&ifc
->address
->u
.prefix6
) &&
425 !list_isempty(ifc
->ifp
->nbr_connected
))
426 bgp_start_interface_nbrs (bgp
, ifc
->ifp
);
433 bgp_interface_address_delete (int command
, struct zclient
*zclient
,
434 zebra_size_t length
, vrf_id_t vrf_id
)
436 struct connected
*ifc
;
439 ifc
= zebra_interface_address_read (command
, zclient
->ibuf
, vrf_id
);
444 if (bgp_debug_zebra(ifc
->address
))
446 char buf
[PREFIX2STR_BUFFER
];
447 prefix2str(ifc
->address
, buf
, sizeof(buf
));
448 zlog_debug("Rx Intf address del VRF %u IF %s addr %s",
449 vrf_id
, ifc
->ifp
->name
, buf
);
452 if (if_is_operative (ifc
->ifp
))
454 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
456 bgp_connected_delete (bgp
, ifc
);
459 connected_free (ifc
);
465 bgp_interface_nbr_address_add (int command
, struct zclient
*zclient
,
466 zebra_size_t length
, vrf_id_t vrf_id
)
468 struct nbr_connected
*ifc
= NULL
;
471 ifc
= zebra_interface_nbr_address_read (command
, zclient
->ibuf
, vrf_id
);
476 if (bgp_debug_zebra(ifc
->address
))
478 char buf
[PREFIX2STR_BUFFER
];
479 prefix2str(ifc
->address
, buf
, sizeof(buf
));
480 zlog_debug("Rx Intf neighbor add VRF %u IF %s addr %s",
481 vrf_id
, ifc
->ifp
->name
, buf
);
484 if (if_is_operative (ifc
->ifp
))
486 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
488 bgp_nbr_connected_add (bgp
, ifc
);
495 bgp_interface_nbr_address_delete (int command
, struct zclient
*zclient
,
496 zebra_size_t length
, vrf_id_t vrf_id
)
498 struct nbr_connected
*ifc
= NULL
;
501 ifc
= zebra_interface_nbr_address_read (command
, zclient
->ibuf
, vrf_id
);
506 if (bgp_debug_zebra(ifc
->address
))
508 char buf
[PREFIX2STR_BUFFER
];
509 prefix2str(ifc
->address
, buf
, sizeof(buf
));
510 zlog_debug("Rx Intf neighbor del VRF %u IF %s addr %s",
511 vrf_id
, ifc
->ifp
->name
, buf
);
514 if (if_is_operative (ifc
->ifp
))
516 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
518 bgp_nbr_connected_delete (bgp
, ifc
, 0);
521 nbr_connected_free (ifc
);
526 /* VRF update for an interface. */
528 bgp_interface_vrf_update (int command
, struct zclient
*zclient
, zebra_size_t length
,
531 struct interface
*ifp
;
534 struct nbr_connected
*nc
;
535 struct listnode
*node
, *nnode
;
538 ifp
= zebra_interface_vrf_update_read (zclient
->ibuf
, vrf_id
, &new_vrf_id
);
542 if (BGP_DEBUG (zebra
, ZEBRA
) && ifp
)
543 zlog_debug("Rx Intf VRF change VRF %u IF %s NewVRF %u",
544 vrf_id
, ifp
->name
, new_vrf_id
);
546 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
550 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, c
))
551 bgp_connected_delete (bgp
, c
);
553 for (ALL_LIST_ELEMENTS (ifp
->nbr_connected
, node
, nnode
, nc
))
554 bgp_nbr_connected_delete (bgp
, nc
, 1);
556 /* Fast external-failover */
560 if (CHECK_FLAG (bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
563 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
565 if ((peer
->ttl
!= 1) && (peer
->gtsm_hops
!= 1))
568 if (ifp
== peer
->nexthop
.ifp
)
569 BGP_EVENT_ADD (peer
, BGP_Stop
);
573 if_update_vrf (ifp
, ifp
->name
, strlen (ifp
->name
), new_vrf_id
);
575 bgp
= bgp_lookup_by_vrf_id (new_vrf_id
);
579 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, c
))
580 bgp_connected_add (bgp
, c
);
582 for (ALL_LIST_ELEMENTS (ifp
->nbr_connected
, node
, nnode
, nc
))
583 bgp_nbr_connected_add (bgp
, nc
);
587 /* Zebra route add and delete treatment. */
589 zebra_read_ipv4 (int command
, struct zclient
*zclient
, zebra_size_t length
,
593 struct zapi_ipv4 api
;
594 struct in_addr nexthop
;
595 struct prefix_ipv4 p
;
596 unsigned int ifindex
;
600 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
607 /* Type, flags, message. */
608 api
.type
= stream_getc (s
);
609 api
.instance
= stream_getw (s
);
610 api
.flags
= stream_getl (s
);
611 api
.message
= stream_getc (s
);
614 memset (&p
, 0, sizeof (struct prefix_ipv4
));
616 p
.prefixlen
= MIN(IPV4_MAX_PREFIXLEN
, stream_getc (s
));
617 stream_get (&p
.prefix
, s
, PSIZE (p
.prefixlen
));
619 /* Nexthop, ifindex, distance, metric. */
620 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
))
622 api
.nexthop_num
= stream_getc (s
);
623 nexthop
.s_addr
= stream_get_ipv4 (s
);
626 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_IFINDEX
))
628 api
.ifindex_num
= stream_getc (s
);
629 ifindex
= stream_getl (s
); /* ifindex, unused */
636 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_DISTANCE
))
637 api
.distance
= stream_getc (s
);
639 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
))
640 api
.metric
= stream_getl (s
);
644 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_TAG
))
645 api
.tag
= stream_getl (s
);
649 if (command
== ZEBRA_REDISTRIBUTE_IPV4_ADD
)
651 if (bgp_debug_zebra((struct prefix
*)&p
))
653 char buf
[2][INET_ADDRSTRLEN
];
654 zlog_debug("Rx IPv4 route add VRF %u %s[%d] %s/%d nexthop %s metric %u tag %"ROUTE_TAG_PRI
,
656 zebra_route_string(api
.type
), api
.instance
,
657 inet_ntop(AF_INET
, &p
.prefix
, buf
[0], sizeof(buf
[0])),
659 inet_ntop(AF_INET
, &nexthop
, buf
[1], sizeof(buf
[1])),
665 * The ADD message is actually an UPDATE and there is no explicit DEL
666 * for a prior redistributed route, if any. So, perform an implicit
667 * DEL processing for the same redistributed route from any other
670 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
673 bgp_redistribute_delete(bgp
, (struct prefix
*)&p
, i
, api
.instance
);
676 /* Now perform the add/update. */
677 bgp_redistribute_add(bgp
, (struct prefix
*)&p
, &nexthop
, NULL
, ifindex
,
678 api
.metric
, api
.type
, api
.instance
, api
.tag
);
680 else if (command
== ZEBRA_REDISTRIBUTE_IPV4_DEL
)
682 if (bgp_debug_zebra((struct prefix
*)&p
))
684 char buf
[2][INET_ADDRSTRLEN
];
685 zlog_debug("Rx IPv4 route delete VRF %u %s[%d] %s/%d "
686 "nexthop %s metric %u tag %"ROUTE_TAG_PRI
,
688 zebra_route_string(api
.type
), api
.instance
,
689 inet_ntop(AF_INET
, &p
.prefix
, buf
[0], sizeof(buf
[0])),
691 inet_ntop(AF_INET
, &nexthop
, buf
[1], sizeof(buf
[1])),
695 bgp_redistribute_delete(bgp
, (struct prefix
*)&p
, api
.type
, api
.instance
);
701 /* Zebra route add and delete treatment. */
703 zebra_read_ipv6 (int command
, struct zclient
*zclient
, zebra_size_t length
,
707 struct zapi_ipv6 api
;
708 struct in6_addr nexthop
;
709 struct prefix_ipv6 p
, src_p
;
710 unsigned int ifindex
;
714 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
719 memset (&nexthop
, 0, sizeof (struct in6_addr
));
721 /* Type, flags, message. */
722 api
.type
= stream_getc (s
);
723 api
.instance
= stream_getw (s
);
724 api
.flags
= stream_getl (s
);
725 api
.message
= stream_getc (s
);
728 memset (&p
, 0, sizeof (struct prefix_ipv6
));
730 p
.prefixlen
= MIN(IPV6_MAX_PREFIXLEN
, stream_getc (s
));
731 stream_get (&p
.prefix
, s
, PSIZE (p
.prefixlen
));
733 memset (&src_p
, 0, sizeof (struct prefix_ipv6
));
734 src_p
.family
= AF_INET6
;
735 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_SRCPFX
))
737 src_p
.prefixlen
= stream_getc (s
);
738 stream_get (&src_p
.prefix
, s
, PSIZE (src_p
.prefixlen
));
742 /* we completely ignore srcdest routes for now. */
745 /* Nexthop, ifindex, distance, metric. */
746 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
))
748 api
.nexthop_num
= stream_getc (s
);
749 stream_get (&nexthop
, s
, 16);
752 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_IFINDEX
))
754 api
.ifindex_num
= stream_getc (s
);
755 ifindex
= stream_getl (s
); /* ifindex, unused */
762 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_DISTANCE
))
763 api
.distance
= stream_getc (s
);
767 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
))
768 api
.metric
= stream_getl (s
);
772 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_TAG
))
773 api
.tag
= stream_getl (s
);
777 /* Simply ignore link-local address. */
778 if (IN6_IS_ADDR_LINKLOCAL (&p
.prefix
))
781 if (command
== ZEBRA_REDISTRIBUTE_IPV6_ADD
)
783 if (bgp_debug_zebra((struct prefix
*)&p
))
785 char buf
[2][INET6_ADDRSTRLEN
];
786 zlog_debug("Rx IPv6 route add VRF %u %s[%d] %s/%d nexthop %s metric %u tag %"ROUTE_TAG_PRI
,
788 zebra_route_string(api
.type
), api
.instance
,
789 inet_ntop(AF_INET6
, &p
.prefix
, buf
[0], sizeof(buf
[0])),
791 inet_ntop(AF_INET
, &nexthop
, buf
[1], sizeof(buf
[1])),
797 * The ADD message is actually an UPDATE and there is no explicit DEL
798 * for a prior redistributed route, if any. So, perform an implicit
799 * DEL processing for the same redistributed route from any other
802 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
805 bgp_redistribute_delete(bgp
, (struct prefix
*)&p
, i
, api
.instance
);
808 bgp_redistribute_add (bgp
, (struct prefix
*)&p
, NULL
, &nexthop
, ifindex
,
809 api
.metric
, api
.type
, api
.instance
, api
.tag
);
811 else if (command
== ZEBRA_REDISTRIBUTE_IPV6_DEL
)
813 if (bgp_debug_zebra((struct prefix
*)&p
))
815 char buf
[2][INET6_ADDRSTRLEN
];
816 zlog_debug("Rx IPv6 route delete VRF %u %s[%d] %s/%d "
817 "nexthop %s metric %u tag %"ROUTE_TAG_PRI
,
819 zebra_route_string(api
.type
), api
.instance
,
820 inet_ntop(AF_INET6
, &p
.prefix
, buf
[0], sizeof(buf
[0])),
822 inet_ntop(AF_INET6
, &nexthop
, buf
[1], sizeof(buf
[1])),
826 bgp_redistribute_delete (bgp
, (struct prefix
*) &p
, api
.type
, api
.instance
);
833 if_lookup_by_ipv4 (struct in_addr
*addr
, vrf_id_t vrf_id
)
835 struct listnode
*ifnode
;
836 struct listnode
*cnode
;
837 struct interface
*ifp
;
838 struct connected
*connected
;
839 struct prefix_ipv4 p
;
844 p
.prefixlen
= IPV4_MAX_BITLEN
;
846 for (ALL_LIST_ELEMENTS_RO (vrf_iflist(vrf_id
), ifnode
, ifp
))
848 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
850 cp
= connected
->address
;
852 if (cp
->family
== AF_INET
)
853 if (prefix_match (cp
, (struct prefix
*)&p
))
861 if_lookup_by_ipv4_exact (struct in_addr
*addr
, vrf_id_t vrf_id
)
863 struct listnode
*ifnode
;
864 struct listnode
*cnode
;
865 struct interface
*ifp
;
866 struct connected
*connected
;
869 for (ALL_LIST_ELEMENTS_RO (vrf_iflist(vrf_id
), ifnode
, ifp
))
871 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
873 cp
= connected
->address
;
875 if (cp
->family
== AF_INET
)
876 if (IPV4_ADDR_SAME (&cp
->u
.prefix4
, addr
))
884 if_lookup_by_ipv6 (struct in6_addr
*addr
, ifindex_t ifindex
, vrf_id_t vrf_id
)
886 struct listnode
*ifnode
;
887 struct listnode
*cnode
;
888 struct interface
*ifp
;
889 struct connected
*connected
;
890 struct prefix_ipv6 p
;
895 p
.prefixlen
= IPV6_MAX_BITLEN
;
897 for (ALL_LIST_ELEMENTS_RO (vrf_iflist(vrf_id
), ifnode
, ifp
))
899 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
901 cp
= connected
->address
;
903 if (cp
->family
== AF_INET6
)
904 if (prefix_match (cp
, (struct prefix
*)&p
))
906 if (IN6_IS_ADDR_LINKLOCAL(&cp
->u
.prefix6
))
908 if (ifindex
== ifp
->ifindex
)
920 if_lookup_by_ipv6_exact (struct in6_addr
*addr
, ifindex_t ifindex
, vrf_id_t vrf_id
)
922 struct listnode
*ifnode
;
923 struct listnode
*cnode
;
924 struct interface
*ifp
;
925 struct connected
*connected
;
928 for (ALL_LIST_ELEMENTS_RO (vrf_iflist(vrf_id
), ifnode
, ifp
))
930 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
932 cp
= connected
->address
;
934 if (cp
->family
== AF_INET6
)
935 if (IPV6_ADDR_SAME (&cp
->u
.prefix6
, addr
))
937 if (IN6_IS_ADDR_LINKLOCAL(&cp
->u
.prefix6
))
939 if (ifindex
== ifp
->ifindex
)
951 if_get_ipv6_global (struct interface
*ifp
, struct in6_addr
*addr
)
953 struct listnode
*cnode
;
954 struct connected
*connected
;
957 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
959 cp
= connected
->address
;
961 if (cp
->family
== AF_INET6
)
962 if (! IN6_IS_ADDR_LINKLOCAL (&cp
->u
.prefix6
))
964 memcpy (addr
, &cp
->u
.prefix6
, IPV6_MAX_BYTELEN
);
972 if_get_ipv6_local (struct interface
*ifp
, struct in6_addr
*addr
)
974 struct listnode
*cnode
;
975 struct connected
*connected
;
978 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
980 cp
= connected
->address
;
982 if (cp
->family
== AF_INET6
)
983 if (IN6_IS_ADDR_LINKLOCAL (&cp
->u
.prefix6
))
985 memcpy (addr
, &cp
->u
.prefix6
, IPV6_MAX_BYTELEN
);
993 if_get_ipv4_address (struct interface
*ifp
, struct in_addr
*addr
)
995 struct listnode
*cnode
;
996 struct connected
*connected
;
999 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
1001 cp
= connected
->address
;
1002 if ((cp
->family
== AF_INET
) && !ipv4_martian(&(cp
->u
.prefix4
)))
1004 *addr
= cp
->u
.prefix4
;
1012 bgp_nexthop_set (union sockunion
*local
, union sockunion
*remote
,
1013 struct bgp_nexthop
*nexthop
, struct peer
*peer
)
1016 struct interface
*ifp
= NULL
;
1018 memset (nexthop
, 0, sizeof (struct bgp_nexthop
));
1025 if (local
->sa
.sa_family
== AF_INET
)
1027 nexthop
->v4
= local
->sin
.sin_addr
;
1028 if (peer
->update_if
)
1029 ifp
= if_lookup_by_name (peer
->update_if
, peer
->bgp
->vrf_id
);
1031 ifp
= if_lookup_by_ipv4_exact (&local
->sin
.sin_addr
, peer
->bgp
->vrf_id
);
1033 if (local
->sa
.sa_family
== AF_INET6
)
1035 if (IN6_IS_ADDR_LINKLOCAL (&local
->sin6
.sin6_addr
))
1037 if (peer
->conf_if
|| peer
->ifname
)
1038 ifp
= if_lookup_by_name (peer
->conf_if
? peer
->conf_if
: peer
->ifname
, peer
->bgp
->vrf_id
);
1040 else if (peer
->update_if
)
1041 ifp
= if_lookup_by_name (peer
->update_if
, peer
->bgp
->vrf_id
);
1043 ifp
= if_lookup_by_ipv6_exact (&local
->sin6
.sin6_addr
,
1044 local
->sin6
.sin6_scope_id
,
1053 /* IPv4 connection, fetch and store IPv6 local address(es) if any. */
1054 if (local
->sa
.sa_family
== AF_INET
)
1057 ret
= if_get_ipv6_global (ifp
, &nexthop
->v6_global
);
1061 /* There is no global nexthop. Use link-local address as both the
1062 * global and link-local nexthop. In this scenario, the expectation
1063 * for interop is that the network admin would use a route-map to
1064 * specify the global IPv6 nexthop.
1066 if_get_ipv6_local (ifp
, &nexthop
->v6_global
);
1067 memcpy (&nexthop
->v6_local
, &nexthop
->v6_global
,
1071 if_get_ipv6_local (ifp
, &nexthop
->v6_local
);
1073 if (if_lookup_by_ipv4 (&remote
->sin
.sin_addr
, peer
->bgp
->vrf_id
))
1074 peer
->shared_network
= 1;
1076 peer
->shared_network
= 0;
1079 /* IPv6 connection, fetch and store IPv4 local address if any. */
1080 if (local
->sa
.sa_family
== AF_INET6
)
1082 struct interface
*direct
= NULL
;
1085 ret
= if_get_ipv4_address(ifp
, &nexthop
->v4
);
1086 if (!ret
&& peer
->local_id
.s_addr
)
1087 nexthop
->v4
= peer
->local_id
;
1090 if (! IN6_IS_ADDR_LINKLOCAL (&local
->sin6
.sin6_addr
))
1092 memcpy (&nexthop
->v6_global
, &local
->sin6
.sin6_addr
,
1095 /* If directory connected set link-local address. */
1096 direct
= if_lookup_by_ipv6 (&remote
->sin6
.sin6_addr
,
1097 remote
->sin6
.sin6_scope_id
, peer
->bgp
->vrf_id
);
1099 if_get_ipv6_local (ifp
, &nexthop
->v6_local
);
1102 /* Link-local address. */
1104 ret
= if_get_ipv6_global (ifp
, &nexthop
->v6_global
);
1106 /* If there is no global address. Set link-local address as
1107 global. I know this break RFC specification... */
1108 /* In this scenario, the expectation for interop is that the
1109 * network admin would use a route-map to specify the global
1113 memcpy (&nexthop
->v6_global
, &local
->sin6
.sin6_addr
,
1115 /* Always set the link-local address */
1116 memcpy (&nexthop
->v6_local
, &local
->sin6
.sin6_addr
,
1120 if (IN6_IS_ADDR_LINKLOCAL (&local
->sin6
.sin6_addr
) ||
1121 if_lookup_by_ipv6 (&remote
->sin6
.sin6_addr
, remote
->sin6
.sin6_scope_id
,
1123 peer
->shared_network
= 1;
1125 peer
->shared_network
= 0;
1128 /* KAME stack specific treatment. */
1130 if (IN6_IS_ADDR_LINKLOCAL (&nexthop
->v6_global
)
1131 && IN6_LINKLOCAL_IFINDEX (nexthop
->v6_global
))
1133 SET_IN6_LINKLOCAL_IFINDEX (nexthop
->v6_global
, 0);
1135 if (IN6_IS_ADDR_LINKLOCAL (&nexthop
->v6_local
)
1136 && IN6_LINKLOCAL_IFINDEX (nexthop
->v6_local
))
1138 SET_IN6_LINKLOCAL_IFINDEX (nexthop
->v6_local
, 0);
1142 /* If we have identified the local interface, there is no error for now. */
1146 static struct in6_addr
*
1147 bgp_info_to_ipv6_nexthop (struct bgp_info
*info
)
1149 struct in6_addr
*nexthop
= NULL
;
1151 /* Only global address nexthop exists. */
1152 if (info
->attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL
)
1153 nexthop
= &info
->attr
->extra
->mp_nexthop_global
;
1155 /* If both global and link-local address present. */
1156 if (info
->attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
1158 /* Check if route-map is set to prefer global over link-local */
1159 if (info
->attr
->extra
->mp_nexthop_prefer_global
)
1160 nexthop
= &info
->attr
->extra
->mp_nexthop_global
;
1163 /* Workaround for Cisco's nexthop bug. */
1164 if (IN6_IS_ADDR_UNSPECIFIED (&info
->attr
->extra
->mp_nexthop_global
)
1165 && info
->peer
->su_remote
->sa
.sa_family
== AF_INET6
)
1166 nexthop
= &info
->peer
->su_remote
->sin6
.sin6_addr
;
1168 nexthop
= &info
->attr
->extra
->mp_nexthop_local
;
1176 bgp_table_map_apply (struct route_map
*map
, struct prefix
*p
,
1177 struct bgp_info
*info
)
1179 if (route_map_apply(map
, p
, RMAP_BGP
, info
) != RMAP_DENYMATCH
)
1182 if (bgp_debug_zebra(p
))
1184 if (p
->family
== AF_INET
)
1186 char buf
[2][INET_ADDRSTRLEN
];
1187 zlog_debug("Zebra rmap deny: IPv4 route %s/%d nexthop %s",
1188 inet_ntop(AF_INET
, &p
->u
.prefix4
, buf
[0], sizeof(buf
[0])),
1190 inet_ntop(AF_INET
, &info
->attr
->nexthop
, buf
[1],
1193 if (p
->family
== AF_INET6
)
1195 char buf
[2][INET6_ADDRSTRLEN
];
1196 zlog_debug("Zebra rmap deny: IPv6 route %s/%d nexthop %s",
1197 inet_ntop(AF_INET6
, &p
->u
.prefix6
, buf
[0], sizeof(buf
[0])),
1199 inet_ntop(AF_INET6
, bgp_info_to_ipv6_nexthop(info
), buf
[1],
1207 bgp_zebra_announce (struct prefix
*p
, struct bgp_info
*info
, struct bgp
*bgp
,
1208 afi_t afi
, safi_t safi
)
1213 struct bgp_info
*mpinfo
;
1214 size_t oldsize
, newsize
;
1215 u_int32_t nhcount
, metric
;
1216 struct bgp_info local_info
;
1217 struct bgp_info
*info_cp
= &local_info
;
1220 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1221 * know of this instance.
1223 if (!bgp_install_info_to_zebra (bgp
))
1226 if ((p
->family
== AF_INET
&&
1227 !vrf_bitmap_check (zclient
->redist
[AFI_IP
][ZEBRA_ROUTE_BGP
], bgp
->vrf_id
))
1228 || (p
->family
== AF_INET6
&&
1229 !vrf_bitmap_check (zclient
->redist
[AFI_IP6
][ZEBRA_ROUTE_BGP
], bgp
->vrf_id
)))
1232 if (bgp
->main_zebra_update_hold
)
1238 if ((info
->attr
->extra
) && (info
->attr
->extra
->tag
!= 0))
1239 tag
= info
->attr
->extra
->tag
;
1243 /* When we create an aggregate route we must also install a Null0 route in
1245 if (info
->sub_type
== BGP_ROUTE_AGGREGATE
)
1246 SET_FLAG (flags
, ZEBRA_FLAG_BLACKHOLE
);
1248 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->sort
== BGP_PEER_CONFED
||
1249 info
->sub_type
== BGP_ROUTE_AGGREGATE
)
1251 SET_FLAG (flags
, ZEBRA_FLAG_IBGP
);
1252 SET_FLAG (flags
, ZEBRA_FLAG_INTERNAL
);
1255 if ((peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
!= 1)
1256 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)
1257 || bgp_flag_check(bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
1259 SET_FLAG (flags
, ZEBRA_FLAG_INTERNAL
);
1261 nhcount
= 1 + bgp_info_mpath_count (info
);
1263 if (p
->family
== AF_INET
&& !BGP_ATTR_NEXTHOP_AFI_IP6(info
->attr
))
1265 struct zapi_ipv4 api
;
1266 struct in_addr
*nexthop
;
1267 char buf
[2][INET_ADDRSTRLEN
];
1268 int valid_nh_count
= 0;
1270 /* resize nexthop buffer size if necessary */
1271 if ((oldsize
= stream_get_size (bgp_nexthop_buf
)) <
1272 (sizeof (struct in_addr
*) * nhcount
))
1274 newsize
= (sizeof (struct in_addr
*) * nhcount
);
1275 newsize
= stream_resize (bgp_nexthop_buf
, newsize
);
1276 if (newsize
== oldsize
)
1278 zlog_err ("can't resize nexthop buffer");
1282 stream_reset (bgp_nexthop_buf
);
1285 /* Metric is currently based on the best-path only. */
1286 metric
= info
->attr
->med
;
1288 if (bgp
->table_map
[afi
][safi
].name
)
1290 BGP_INFO_ATTR_BUF_INIT();
1292 /* Copy info and attributes, so the route-map apply doesn't modify the
1294 BGP_INFO_ATTR_BUF_COPY(info
, info_cp
);
1295 if (bgp_table_map_apply(bgp
->table_map
[afi
][safi
].map
, p
, info_cp
))
1297 metric
= info_cp
->attr
->med
;
1298 nexthop
= &info_cp
->attr
->nexthop
;
1300 if (info_cp
->attr
->extra
)
1301 tag
= info_cp
->attr
->extra
->tag
;
1303 BGP_INFO_ATTR_BUF_FREE(info_cp
);
1307 nexthop
= &info
->attr
->nexthop
;
1312 stream_put (bgp_nexthop_buf
, &nexthop
, sizeof (struct in_addr
*));
1316 for (mpinfo
= bgp_info_mpath_first (info
); mpinfo
;
1317 mpinfo
= bgp_info_mpath_next (mpinfo
))
1321 if (bgp
->table_map
[afi
][safi
].name
)
1323 /* Copy info and attributes, so the route-map apply doesn't modify the
1325 BGP_INFO_ATTR_BUF_COPY(mpinfo
, info_cp
);
1326 if (bgp_table_map_apply(bgp
->table_map
[afi
][safi
].map
, p
, info_cp
))
1327 nexthop
= &info_cp
->attr
->nexthop
;
1328 BGP_INFO_ATTR_BUF_FREE(info_cp
);
1332 nexthop
= &mpinfo
->attr
->nexthop
;
1335 if (nexthop
== NULL
)
1338 stream_put (bgp_nexthop_buf
, &nexthop
, sizeof (struct in_addr
*));
1342 api
.vrf_id
= bgp
->vrf_id
;
1344 api
.type
= ZEBRA_ROUTE_BGP
;
1348 SET_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
);
1350 /* Note that this currently only applies to Null0 routes for aggregates.
1351 * ZEBRA_FLAG_BLACKHOLE signals zapi_ipv4_route to encode a special
1352 * BLACKHOLE nexthop. We want to set api.nexthop_num to zero since we
1353 * do not want to also encode the 0.0.0.0 nexthop for the aggregate route.
1355 if (CHECK_FLAG(flags
, ZEBRA_FLAG_BLACKHOLE
))
1356 api
.nexthop_num
= 0;
1358 api
.nexthop_num
= valid_nh_count
;
1360 api
.nexthop
= (struct in_addr
**)STREAM_DATA (bgp_nexthop_buf
);
1361 api
.ifindex_num
= 0;
1362 SET_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
);
1363 api
.metric
= metric
;
1368 SET_FLAG (api
.message
, ZAPI_MESSAGE_TAG
);
1372 distance
= bgp_distance_apply (p
, info
, afi
, safi
, bgp
);
1375 SET_FLAG (api
.message
, ZAPI_MESSAGE_DISTANCE
);
1376 api
.distance
= distance
;
1379 if (bgp_debug_zebra(p
))
1382 zlog_debug("Tx IPv4 route %s VRF %u %s/%d metric %u tag %"ROUTE_TAG_PRI
1383 " count %d", (valid_nh_count
? "add":"delete"),
1385 inet_ntop(AF_INET
, &p
->u
.prefix4
, buf
[0], sizeof(buf
[0])),
1386 p
->prefixlen
, api
.metric
, api
.tag
, api
.nexthop_num
);
1387 for (i
= 0; i
< api
.nexthop_num
; i
++)
1388 zlog_debug(" IPv4 [nexthop %d] %s", i
+1,
1389 inet_ntop(AF_INET
, api
.nexthop
[i
], buf
[1], sizeof(buf
[1])));
1392 zapi_ipv4_route (valid_nh_count
? ZEBRA_IPV4_ROUTE_ADD
: ZEBRA_IPV4_ROUTE_DELETE
,
1393 zclient
, (struct prefix_ipv4
*) p
, &api
);
1396 /* We have to think about a IPv6 link-local address curse. */
1397 if (p
->family
== AF_INET6
||
1398 (p
->family
== AF_INET
&& BGP_ATTR_NEXTHOP_AFI_IP6(info
->attr
)))
1401 struct in6_addr
*nexthop
;
1402 struct zapi_ipv6 api
;
1403 int valid_nh_count
= 0;
1404 char buf
[2][INET6_ADDRSTRLEN
];
1406 /* resize nexthop buffer size if necessary */
1407 if ((oldsize
= stream_get_size (bgp_nexthop_buf
)) <
1408 (sizeof (struct in6_addr
*) * nhcount
))
1410 newsize
= (sizeof (struct in6_addr
*) * nhcount
);
1411 newsize
= stream_resize (bgp_nexthop_buf
, newsize
);
1412 if (newsize
== oldsize
)
1414 zlog_err ("can't resize nexthop buffer");
1418 stream_reset (bgp_nexthop_buf
);
1420 /* resize ifindices buffer size if necessary */
1421 if ((oldsize
= stream_get_size (bgp_ifindices_buf
)) <
1422 (sizeof (unsigned int) * nhcount
))
1424 newsize
= (sizeof (unsigned int) * nhcount
);
1425 newsize
= stream_resize (bgp_ifindices_buf
, newsize
);
1426 if (newsize
== oldsize
)
1428 zlog_err ("can't resize nexthop buffer");
1432 stream_reset (bgp_ifindices_buf
);
1437 assert (info
->attr
->extra
);
1439 /* Metric is currently based on the best-path only. */
1440 metric
= info
->attr
->med
;
1442 if (bgp
->table_map
[afi
][safi
].name
)
1444 BGP_INFO_ATTR_BUF_INIT();
1446 /* Copy info and attributes, so the route-map apply doesn't modify the
1448 BGP_INFO_ATTR_BUF_COPY(info
, info_cp
);
1449 if (bgp_table_map_apply(bgp
->table_map
[afi
][safi
].map
, p
, info_cp
))
1451 metric
= info_cp
->attr
->med
;
1452 nexthop
= bgp_info_to_ipv6_nexthop(info_cp
);
1454 if (info_cp
->attr
->extra
)
1455 tag
= info_cp
->attr
->extra
->tag
;
1457 BGP_INFO_ATTR_BUF_FREE(info_cp
);
1461 nexthop
= bgp_info_to_ipv6_nexthop(info
);
1466 if (info
->attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
1467 if (info
->peer
->nexthop
.ifp
)
1468 ifindex
= info
->peer
->nexthop
.ifp
->ifindex
;
1472 if (info
->peer
->conf_if
|| info
->peer
->ifname
)
1473 ifindex
= if_nametoindex (info
->peer
->conf_if
? info
->peer
->conf_if
: info
->peer
->ifname
);
1474 else if (info
->peer
->nexthop
.ifp
)
1475 ifindex
= info
->peer
->nexthop
.ifp
->ifindex
;
1477 stream_put (bgp_nexthop_buf
, &nexthop
, sizeof (struct in6_addr
*));
1478 stream_put (bgp_ifindices_buf
, &ifindex
, sizeof (unsigned int));
1482 for (mpinfo
= bgp_info_mpath_first (info
); mpinfo
;
1483 mpinfo
= bgp_info_mpath_next (mpinfo
))
1488 if (bgp
->table_map
[afi
][safi
].name
)
1490 /* Copy info and attributes, so the route-map apply doesn't modify the
1492 BGP_INFO_ATTR_BUF_COPY(mpinfo
, info_cp
);
1493 if (bgp_table_map_apply(bgp
->table_map
[afi
][safi
].map
, p
, info_cp
))
1494 nexthop
= bgp_info_to_ipv6_nexthop(info_cp
);
1495 BGP_INFO_ATTR_BUF_FREE(info_cp
);
1499 nexthop
= bgp_info_to_ipv6_nexthop(mpinfo
);
1502 if (nexthop
== NULL
)
1505 if (mpinfo
->attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
1506 if (mpinfo
->peer
->nexthop
.ifp
)
1507 ifindex
= mpinfo
->peer
->nexthop
.ifp
->ifindex
;
1511 if (mpinfo
->peer
->conf_if
|| mpinfo
->peer
->ifname
)
1512 ifindex
= ifname2ifindex (mpinfo
->peer
->conf_if
? mpinfo
->peer
->conf_if
: mpinfo
->peer
->ifname
, bgp
->vrf_id
);
1513 else if (mpinfo
->peer
->nexthop
.ifp
)
1514 ifindex
= mpinfo
->peer
->nexthop
.ifp
->ifindex
;
1519 stream_put (bgp_nexthop_buf
, &nexthop
, sizeof (struct in6_addr
*));
1520 stream_put (bgp_ifindices_buf
, &ifindex
, sizeof (unsigned int));
1524 /* Make Zebra API structure. */
1525 api
.vrf_id
= bgp
->vrf_id
;
1527 api
.type
= ZEBRA_ROUTE_BGP
;
1531 SET_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
);
1533 /* Note that this currently only applies to Null0 routes for aggregates.
1534 * ZEBRA_FLAG_BLACKHOLE signals zapi_ipv6_route to encode a special
1535 * BLACKHOLE nexthop. We want to set api.nexthop_num to zero since we
1536 * do not want to also encode the :: nexthop for the aggregate route.
1538 if (CHECK_FLAG(flags
, ZEBRA_FLAG_BLACKHOLE
))
1539 api
.nexthop_num
= 0;
1541 api
.nexthop_num
= valid_nh_count
;
1543 api
.nexthop
= (struct in6_addr
**)STREAM_DATA (bgp_nexthop_buf
);
1544 SET_FLAG (api
.message
, ZAPI_MESSAGE_IFINDEX
);
1545 api
.ifindex_num
= valid_nh_count
;
1546 api
.ifindex
= (ifindex_t
*)STREAM_DATA (bgp_ifindices_buf
);
1547 SET_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
);
1548 api
.metric
= metric
;
1553 SET_FLAG (api
.message
, ZAPI_MESSAGE_TAG
);
1557 distance
= bgp_distance_apply (p
, info
, afi
, safi
, bgp
);
1560 SET_FLAG (api
.message
, ZAPI_MESSAGE_DISTANCE
);
1561 api
.distance
= distance
;
1564 if (p
->family
== AF_INET
)
1566 if (bgp_debug_zebra(p
))
1569 zlog_debug("Tx IPv4 route %s VRF %u %s/%d metric %u tag %"ROUTE_TAG_PRI
,
1570 valid_nh_count
? "add" : "delete", bgp
->vrf_id
,
1571 inet_ntop(AF_INET
, &p
->u
.prefix4
, buf
[0], sizeof(buf
[0])),
1572 p
->prefixlen
, api
.metric
, api
.tag
);
1573 for (i
= 0; i
< api
.nexthop_num
; i
++)
1574 zlog_debug(" IPv6 [nexthop %d] %s", i
+1,
1575 inet_ntop(AF_INET6
, api
.nexthop
[i
], buf
[1], sizeof(buf
[1])));
1579 zapi_ipv4_route_ipv6_nexthop (ZEBRA_IPV4_ROUTE_IPV6_NEXTHOP_ADD
,
1580 zclient
, (struct prefix_ipv4
*) p
,
1581 (struct zapi_ipv6
*)&api
);
1583 zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE
,
1584 zclient
, (struct prefix_ipv4
*) p
, (struct zapi_ipv4
*)&api
);
1588 if (bgp_debug_zebra(p
))
1591 zlog_debug("Tx IPv6 route %s VRF %u %s/%d metric %u tag %"ROUTE_TAG_PRI
,
1592 valid_nh_count
? "add" : "delete", bgp
->vrf_id
,
1593 inet_ntop(AF_INET6
, &p
->u
.prefix6
, buf
[0], sizeof(buf
[0])),
1594 p
->prefixlen
, api
.metric
, api
.tag
);
1595 for (i
= 0; i
< api
.nexthop_num
; i
++)
1596 zlog_debug(" IPv6 [nexthop %d] %s", i
+1,
1597 inet_ntop(AF_INET6
, api
.nexthop
[i
], buf
[1], sizeof(buf
[1])));
1600 zapi_ipv6_route (valid_nh_count
?
1601 ZEBRA_IPV6_ROUTE_ADD
: ZEBRA_IPV6_ROUTE_DELETE
,
1602 zclient
, (struct prefix_ipv6
*) p
, NULL
, &api
);
1607 /* Announce all routes of a table to zebra */
1609 bgp_zebra_announce_table (struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1611 struct bgp_node
*rn
;
1612 struct bgp_table
*table
;
1613 struct bgp_info
*ri
;
1615 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1616 * know of this instance.
1618 if (!bgp_install_info_to_zebra (bgp
))
1621 table
= bgp
->rib
[afi
][safi
];
1624 for (rn
= bgp_table_top (table
); rn
; rn
= bgp_route_next (rn
))
1625 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1626 if (CHECK_FLAG (ri
->flags
, BGP_INFO_SELECTED
)
1627 && ri
->type
== ZEBRA_ROUTE_BGP
1628 && ri
->sub_type
== BGP_ROUTE_NORMAL
)
1629 bgp_zebra_announce (&rn
->p
, ri
, bgp
, afi
, safi
);
1633 bgp_zebra_withdraw (struct prefix
*p
, struct bgp_info
*info
, safi_t safi
)
1641 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1642 * know of this instance.
1644 if (!bgp_install_info_to_zebra (peer
->bgp
))
1647 if ((p
->family
== AF_INET
&&
1648 !vrf_bitmap_check (zclient
->redist
[AFI_IP
][ZEBRA_ROUTE_BGP
], peer
->bgp
->vrf_id
))
1649 || (p
->family
== AF_INET6
&&
1650 !vrf_bitmap_check (zclient
->redist
[AFI_IP6
][ZEBRA_ROUTE_BGP
], peer
->bgp
->vrf_id
)))
1655 if (peer
->sort
== BGP_PEER_IBGP
)
1657 SET_FLAG (flags
, ZEBRA_FLAG_INTERNAL
);
1658 SET_FLAG (flags
, ZEBRA_FLAG_IBGP
);
1661 if ((peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
!= 1)
1662 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)
1663 || bgp_flag_check(peer
->bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
1664 SET_FLAG (flags
, ZEBRA_FLAG_INTERNAL
);
1666 if (p
->family
== AF_INET
)
1668 struct zapi_ipv4 api
;
1670 api
.vrf_id
= peer
->bgp
->vrf_id
;
1673 api
.type
= ZEBRA_ROUTE_BGP
;
1677 SET_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
);
1678 api
.nexthop_num
= 0;
1680 api
.ifindex_num
= 0;
1681 SET_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
);
1682 api
.metric
= info
->attr
->med
;
1685 if ((info
->attr
->extra
) && (info
->attr
->extra
->tag
!= 0))
1687 SET_FLAG(api
.message
, ZAPI_MESSAGE_TAG
);
1688 api
.tag
= info
->attr
->extra
->tag
;
1691 if (bgp_debug_zebra(p
))
1693 char buf
[2][INET_ADDRSTRLEN
];
1694 zlog_debug("Tx IPv4 route delete VRF %u %s/%d metric %u tag %"ROUTE_TAG_PRI
,
1696 inet_ntop(AF_INET
, &p
->u
.prefix4
, buf
[0], sizeof(buf
[0])),
1697 p
->prefixlen
, api
.metric
, api
.tag
);
1700 zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE
, zclient
,
1701 (struct prefix_ipv4
*) p
, &api
);
1703 /* We have to think about a IPv6 link-local address curse. */
1704 if (p
->family
== AF_INET6
)
1706 struct zapi_ipv6 api
;
1708 assert (info
->attr
->extra
);
1710 api
.vrf_id
= peer
->bgp
->vrf_id
;
1712 api
.type
= ZEBRA_ROUTE_BGP
;
1716 SET_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
);
1717 api
.nexthop_num
= 0;
1719 api
.ifindex_num
= 0;
1720 SET_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
);
1721 api
.metric
= info
->attr
->med
;
1724 if ((info
->attr
->extra
) && (info
->attr
->extra
->tag
!= 0))
1726 SET_FLAG(api
.message
, ZAPI_MESSAGE_TAG
);
1727 api
.tag
= info
->attr
->extra
->tag
;
1730 if (bgp_debug_zebra(p
))
1732 char buf
[2][INET6_ADDRSTRLEN
];
1733 zlog_debug("Tx IPv6 route delete VRF %u %s/%d metric %u tag %"ROUTE_TAG_PRI
,
1735 inet_ntop(AF_INET6
, &p
->u
.prefix6
, buf
[0], sizeof(buf
[0])),
1736 p
->prefixlen
, api
.metric
, api
.tag
);
1739 zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE
, zclient
,
1740 (struct prefix_ipv6
*) p
, NULL
, &api
);
1745 bgp_redist_lookup (struct bgp
*bgp
, afi_t afi
, u_char type
, u_short instance
)
1747 struct list
*red_list
;
1748 struct listnode
*node
;
1749 struct bgp_redist
*red
;
1751 red_list
= bgp
->redist
[afi
][type
];
1755 for (ALL_LIST_ELEMENTS_RO(red_list
, node
, red
))
1756 if (red
->instance
== instance
)
1763 bgp_redist_add (struct bgp
*bgp
, afi_t afi
, u_char type
, u_short instance
)
1765 struct list
*red_list
;
1766 struct bgp_redist
*red
;
1768 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
1772 if (!bgp
->redist
[afi
][type
])
1773 bgp
->redist
[afi
][type
] = list_new();
1775 red_list
= bgp
->redist
[afi
][type
];
1776 red
= (struct bgp_redist
*)XCALLOC(MTYPE_BGP_REDIST
, sizeof(struct bgp_redist
));
1777 red
->instance
= instance
;
1779 listnode_add(red_list
, red
);
1785 bgp_redist_del (struct bgp
*bgp
, afi_t afi
, u_char type
, u_short instance
)
1787 struct bgp_redist
*red
;
1789 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
1793 listnode_delete(bgp
->redist
[afi
][type
], red
);
1794 XFREE (MTYPE_BGP_REDIST
, red
);
1795 if (!bgp
->redist
[afi
][type
]->count
)
1797 list_free(bgp
->redist
[afi
][type
]);
1798 bgp
->redist
[afi
][type
] = NULL
;
1803 /* Other routes redistribution into BGP. */
1805 bgp_redistribute_set (struct bgp
*bgp
, afi_t afi
, int type
, u_short instance
)
1808 /* Return if already redistribute flag is set. */
1811 if (redist_check_instance(&zclient
->mi_redist
[afi
][type
], instance
))
1814 redist_add_instance(&zclient
->mi_redist
[afi
][type
], instance
);
1818 if (vrf_bitmap_check (zclient
->redist
[afi
][type
], bgp
->vrf_id
))
1822 if (bgp
->vrf_id
== VRF_DEFAULT
&&
1823 type
== ZEBRA_ROUTE_VNC_DIRECT
) {
1824 vnc_export_bgp_enable(bgp
, afi
); /* only enables if mode bits cfg'd */
1828 vrf_bitmap_set (zclient
->redist
[afi
][type
], bgp
->vrf_id
);
1831 /* Don't try to register if we're not connected to Zebra or Zebra doesn't
1832 * know of this instance.
1834 if (!bgp_install_info_to_zebra (bgp
))
1837 if (BGP_DEBUG (zebra
, ZEBRA
))
1838 zlog_debug("Tx redistribute add VRF %u afi %d %s %d",
1840 zebra_route_string(type
), instance
);
1842 /* Send distribute add message to zebra. */
1843 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD
, zclient
, afi
, type
,
1844 instance
, bgp
->vrf_id
);
1850 bgp_redistribute_resend (struct bgp
*bgp
, afi_t afi
, int type
, u_short instance
)
1852 /* Don't try to send if we're not connected to Zebra or Zebra doesn't
1853 * know of this instance.
1855 if (!bgp_install_info_to_zebra (bgp
))
1858 if (BGP_DEBUG (zebra
, ZEBRA
))
1859 zlog_debug("Tx redistribute del/add VRF %u afi %d %s %d",
1861 zebra_route_string(type
), instance
);
1863 /* Send distribute add message to zebra. */
1864 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE
, zclient
, afi
, type
,
1865 instance
, bgp
->vrf_id
);
1866 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD
, zclient
, afi
, type
,
1867 instance
, bgp
->vrf_id
);
1872 /* Redistribute with route-map specification. */
1874 bgp_redistribute_rmap_set (struct bgp_redist
*red
, const char *name
)
1877 && (strcmp (red
->rmap
.name
, name
) == 0))
1881 XFREE(MTYPE_ROUTE_MAP_NAME
, red
->rmap
.name
);
1882 red
->rmap
.name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, name
);
1883 red
->rmap
.map
= route_map_lookup_by_name (name
);
1888 /* Redistribute with metric specification. */
1890 bgp_redistribute_metric_set (struct bgp
*bgp
, struct bgp_redist
*red
, afi_t afi
,
1891 int type
, u_int32_t metric
)
1893 struct bgp_node
*rn
;
1894 struct bgp_info
*ri
;
1896 if (red
->redist_metric_flag
1897 && red
->redist_metric
== metric
)
1900 red
->redist_metric_flag
= 1;
1901 red
->redist_metric
= metric
;
1903 for (rn
= bgp_table_top(bgp
->rib
[afi
][SAFI_UNICAST
]); rn
; rn
= bgp_route_next(rn
))
1905 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1907 if (ri
->sub_type
== BGP_ROUTE_REDISTRIBUTE
&&
1909 ri
->instance
== red
->instance
)
1911 struct attr
*old_attr
;
1912 struct attr new_attr
;
1913 struct attr_extra new_extra
;
1915 new_attr
.extra
= &new_extra
;
1916 bgp_attr_dup (&new_attr
, ri
->attr
);
1917 new_attr
.med
= red
->redist_metric
;
1918 old_attr
= ri
->attr
;
1919 ri
->attr
= bgp_attr_intern (&new_attr
);
1920 bgp_attr_unintern (&old_attr
);
1922 bgp_info_set_flag(rn
, ri
, BGP_INFO_ATTR_CHANGED
);
1923 bgp_process(bgp
, rn
, afi
, SAFI_UNICAST
);
1931 /* Unset redistribution. */
1933 bgp_redistribute_unreg (struct bgp
*bgp
, afi_t afi
, int type
, u_short instance
)
1935 struct bgp_redist
*red
;
1937 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
1941 /* Return if zebra connection is disabled. */
1944 if (!redist_check_instance(&zclient
->mi_redist
[afi
][type
], instance
))
1946 redist_del_instance(&zclient
->mi_redist
[afi
][type
], instance
);
1950 if (! vrf_bitmap_check (zclient
->redist
[afi
][type
], bgp
->vrf_id
))
1952 vrf_bitmap_unset (zclient
->redist
[afi
][type
], bgp
->vrf_id
);
1956 if (bgp
->vrf_id
== VRF_DEFAULT
&&
1957 type
== ZEBRA_ROUTE_VNC_DIRECT
) {
1958 vnc_export_bgp_disable(bgp
, afi
);
1962 if (bgp_install_info_to_zebra (bgp
))
1964 /* Send distribute delete message to zebra. */
1965 if (BGP_DEBUG (zebra
, ZEBRA
))
1966 zlog_debug("Tx redistribute del VRF %u afi %d %s %d",
1967 bgp
->vrf_id
, afi
, zebra_route_string(type
), instance
);
1968 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE
, zclient
, afi
, type
, instance
,
1972 /* Withdraw redistributed routes from current BGP's routing table. */
1973 bgp_redistribute_withdraw (bgp
, afi
, type
, instance
);
1978 /* Unset redistribution. */
1980 bgp_redistribute_unset (struct bgp
*bgp
, afi_t afi
, int type
, u_short instance
)
1982 struct bgp_redist
*red
;
1984 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
1988 bgp_redistribute_unreg(bgp
, afi
, type
, instance
);
1990 /* Unset route-map. */
1992 XFREE(MTYPE_ROUTE_MAP_NAME
, red
->rmap
.name
);
1993 red
->rmap
.name
= NULL
;
1994 red
->rmap
.map
= NULL
;
1997 red
->redist_metric_flag
= 0;
1998 red
->redist_metric
= 0;
2000 bgp_redist_del(bgp
, afi
, type
, instance
);
2005 /* Update redistribute vrf bitmap during triggers like
2006 restart networking or delete/add VRFs */
2008 bgp_update_redist_vrf_bitmaps (struct bgp
*bgp
, vrf_id_t old_vrf_id
)
2013 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2014 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
2015 if (vrf_bitmap_check (zclient
->redist
[afi
][i
], old_vrf_id
))
2017 vrf_bitmap_unset (zclient
->redist
[afi
][i
], old_vrf_id
);
2018 vrf_bitmap_set (zclient
->redist
[afi
][i
], bgp
->vrf_id
);
2024 bgp_zclient_reset (void)
2026 zclient_reset (zclient
);
2029 /* Register this instance with Zebra. Invoked upon connect (for
2030 * default instance) and when other VRFs are learnt (or created and
2034 bgp_zebra_instance_register (struct bgp
*bgp
)
2036 /* Don't try to register if we're not connected to Zebra */
2037 if (!zclient
|| zclient
->sock
< 0)
2040 if (BGP_DEBUG (zebra
, ZEBRA
))
2041 zlog_debug("Registering VRF %u", bgp
->vrf_id
);
2043 /* Register for router-id, interfaces, redistributed routes. */
2044 zclient_send_reg_requests (zclient
, bgp
->vrf_id
);
2047 /* Deregister this instance with Zebra. Invoked upon the instance
2048 * being deleted (default or VRF) and it is already registered.
2051 bgp_zebra_instance_deregister (struct bgp
*bgp
)
2053 /* Don't try to deregister if we're not connected to Zebra */
2054 if (zclient
->sock
< 0)
2057 if (BGP_DEBUG (zebra
, ZEBRA
))
2058 zlog_debug("Deregistering VRF %u", bgp
->vrf_id
);
2060 /* Deregister for router-id, interfaces, redistributed routes. */
2061 zclient_send_dereg_requests (zclient
, bgp
->vrf_id
);
2065 bgp_zebra_initiate_radv (struct bgp
*bgp
, struct peer
*peer
)
2067 int ra_interval
= BGP_UNNUM_DEFAULT_RA_INTERVAL
;
2069 /* Don't try to initiate if we're not connected to Zebra */
2070 if (zclient
->sock
< 0)
2073 if (BGP_DEBUG (zebra
, ZEBRA
))
2074 zlog_debug("%u: Initiating RA for peer %s", bgp
->vrf_id
, peer
->host
);
2076 zclient_send_interface_radv_req (zclient
, bgp
->vrf_id
, peer
->ifp
, 1, ra_interval
);
2080 bgp_zebra_terminate_radv (struct bgp
*bgp
, struct peer
*peer
)
2082 /* Don't try to terminate if we're not connected to Zebra */
2083 if (zclient
->sock
< 0)
2086 if (BGP_DEBUG (zebra
, ZEBRA
))
2087 zlog_debug("%u: Terminating RA for peer %s", bgp
->vrf_id
, peer
->host
);
2089 zclient_send_interface_radv_req (zclient
, bgp
->vrf_id
, peer
->ifp
, 0, 0);
2092 /* BGP has established connection with Zebra. */
2094 bgp_zebra_connected (struct zclient
*zclient
)
2098 zclient_num_connects
++; /* increment even if not responding */
2100 /* At this point, we may or may not have BGP instances configured, but
2101 * we're only interested in the default VRF (others wouldn't have learnt
2102 * the VRF from Zebra yet.)
2104 bgp
= bgp_get_default();
2108 bgp_zebra_instance_register (bgp
);
2110 /* Send the client registration */
2111 bfd_client_sendmsg(zclient
, ZEBRA_BFD_CLIENT_REGISTER
);
2113 /* TODO - What if we have peers and networks configured, do we have to
2120 bgp_zebra_init (struct thread_master
*master
)
2122 zclient_num_connects
= 0;
2124 /* Set default values. */
2125 zclient
= zclient_new (master
);
2126 zclient_init (zclient
, ZEBRA_ROUTE_BGP
, 0);
2127 zclient
->zebra_connected
= bgp_zebra_connected
;
2128 zclient
->router_id_update
= bgp_router_id_update
;
2129 zclient
->interface_add
= bgp_interface_add
;
2130 zclient
->interface_delete
= bgp_interface_delete
;
2131 zclient
->interface_address_add
= bgp_interface_address_add
;
2132 zclient
->interface_address_delete
= bgp_interface_address_delete
;
2133 zclient
->interface_nbr_address_add
= bgp_interface_nbr_address_add
;
2134 zclient
->interface_nbr_address_delete
= bgp_interface_nbr_address_delete
;
2135 zclient
->interface_vrf_update
= bgp_interface_vrf_update
;
2136 zclient
->redistribute_route_ipv4_add
= zebra_read_ipv4
;
2137 zclient
->redistribute_route_ipv4_del
= zebra_read_ipv4
;
2138 zclient
->interface_up
= bgp_interface_up
;
2139 zclient
->interface_down
= bgp_interface_down
;
2140 zclient
->redistribute_route_ipv6_add
= zebra_read_ipv6
;
2141 zclient
->redistribute_route_ipv6_del
= zebra_read_ipv6
;
2142 zclient
->nexthop_update
= bgp_read_nexthop_update
;
2143 zclient
->import_check_update
= bgp_read_import_check_update
;
2145 bgp_nexthop_buf
= stream_new(BGP_NEXTHOP_BUF_SIZE
);
2146 bgp_ifindices_buf
= stream_new(BGP_IFINDICES_BUF_SIZE
);
2150 bgp_zebra_destroy(void)
2152 if (zclient
== NULL
)
2154 zclient_stop(zclient
);
2155 zclient_free(zclient
);
2160 bgp_zebra_num_connects(void)
2162 return zclient_num_connects
;