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 "rfapi_backend.h"
51 # include "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
];
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 /* Router-id update message from zebra. */
114 bgp_router_id_update (int command
, struct zclient
*zclient
, zebra_size_t length
,
117 struct prefix router_id
;
119 zebra_router_id_update_read(zclient
->ibuf
,&router_id
);
121 if (BGP_DEBUG (zebra
, ZEBRA
))
123 char buf
[PREFIX2STR_BUFFER
];
124 prefix2str(&router_id
, buf
, sizeof(buf
));
125 zlog_debug("Rx Router Id update VRF %u Id %s", vrf_id
, buf
);
128 bgp_router_id_zebra_bump (vrf_id
, &router_id
);
132 /* Nexthop update message from zebra. */
134 bgp_read_nexthop_update (int command
, struct zclient
*zclient
,
135 zebra_size_t length
, vrf_id_t vrf_id
)
137 bgp_parse_nexthop_update(command
, vrf_id
);
142 bgp_read_import_check_update(int command
, struct zclient
*zclient
,
143 zebra_size_t length
, vrf_id_t vrf_id
)
145 bgp_parse_nexthop_update(command
, vrf_id
);
149 /* Set or clear interface on which unnumbered neighbor is configured. This
150 * would in turn cause BGP to initiate or turn off IPv6 RAs on this
154 bgp_update_interface_nbrs (struct bgp
*bgp
, struct interface
*ifp
,
155 struct interface
*upd_ifp
)
157 struct listnode
*node
, *nnode
;
160 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
163 (strcmp (peer
->conf_if
, ifp
->name
) == 0))
168 bgp_zebra_initiate_radv (bgp
, peer
);
172 bgp_zebra_terminate_radv (bgp
, peer
);
180 bgp_start_interface_nbrs (struct bgp
*bgp
, struct interface
*ifp
)
182 struct listnode
*node
, *nnode
;
185 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
188 (strcmp (peer
->conf_if
, ifp
->name
) == 0) &&
189 peer
->status
!= Established
)
191 if (peer_active(peer
))
192 BGP_EVENT_ADD (peer
, BGP_Stop
);
193 BGP_EVENT_ADD (peer
, BGP_Start
);
199 bgp_nbr_connected_add (struct bgp
*bgp
, struct nbr_connected
*ifc
)
201 struct listnode
*node
;
202 struct connected
*connected
;
203 struct interface
*ifp
;
206 /* Kick-off the FSM for any relevant peers only if there is a
207 * valid local address on the interface.
210 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, node
, connected
))
212 p
= connected
->address
;
213 if (p
->family
== AF_INET6
&&
214 IN6_IS_ADDR_LINKLOCAL (&p
->u
.prefix6
))
220 bgp_start_interface_nbrs (bgp
, ifp
);
224 bgp_nbr_connected_delete (struct bgp
*bgp
, struct nbr_connected
*ifc
, int del
)
226 struct listnode
*node
, *nnode
;
228 struct interface
*ifp
;
230 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
232 if (peer
->conf_if
&& (strcmp (peer
->conf_if
, ifc
->ifp
->name
) == 0))
234 peer
->last_reset
= PEER_DOWN_NBR_ADDR_DEL
;
235 BGP_EVENT_ADD (peer
, BGP_Stop
);
238 /* Free neighbor also, if we're asked to. */
242 listnode_delete (ifp
->nbr_connected
, ifc
);
243 nbr_connected_free (ifc
);
247 /* Inteface addition message from zebra. */
249 bgp_interface_add (int command
, struct zclient
*zclient
, zebra_size_t length
,
252 struct interface
*ifp
;
255 ifp
= zebra_interface_add_read (zclient
->ibuf
, vrf_id
);
256 if (!ifp
) // unexpected
259 if (BGP_DEBUG (zebra
, ZEBRA
) && ifp
)
260 zlog_debug("Rx Intf add VRF %u IF %s", vrf_id
, ifp
->name
);
262 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
266 bgp_update_interface_nbrs (bgp
, ifp
, ifp
);
271 bgp_interface_delete (int command
, struct zclient
*zclient
,
272 zebra_size_t length
, vrf_id_t vrf_id
)
275 struct interface
*ifp
;
279 ifp
= zebra_interface_state_read (s
, vrf_id
);
280 if (!ifp
) /* This may happen if we've just unregistered for a VRF. */
283 ifp
->ifindex
= IFINDEX_DELETED
;
285 if (BGP_DEBUG (zebra
, ZEBRA
))
286 zlog_debug("Rx Intf del VRF %u IF %s", vrf_id
, ifp
->name
);
288 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
292 bgp_update_interface_nbrs (bgp
, ifp
, NULL
);
297 bgp_interface_up (int command
, struct zclient
*zclient
, zebra_size_t length
,
301 struct interface
*ifp
;
303 struct nbr_connected
*nc
;
304 struct listnode
*node
, *nnode
;
308 ifp
= zebra_interface_state_read (s
, vrf_id
);
313 if (BGP_DEBUG (zebra
, ZEBRA
))
314 zlog_debug("Rx Intf up VRF %u IF %s", vrf_id
, ifp
->name
);
316 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
320 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, c
))
321 bgp_connected_add (bgp
, c
);
323 for (ALL_LIST_ELEMENTS (ifp
->nbr_connected
, node
, nnode
, nc
))
324 bgp_nbr_connected_add (bgp
, nc
);
330 bgp_interface_down (int command
, struct zclient
*zclient
, zebra_size_t length
,
334 struct interface
*ifp
;
336 struct nbr_connected
*nc
;
337 struct listnode
*node
, *nnode
;
341 ifp
= zebra_interface_state_read (s
, vrf_id
);
345 if (BGP_DEBUG (zebra
, ZEBRA
))
346 zlog_debug("Rx Intf down VRF %u IF %s", vrf_id
, ifp
->name
);
348 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
352 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, c
))
353 bgp_connected_delete (bgp
, c
);
355 for (ALL_LIST_ELEMENTS (ifp
->nbr_connected
, node
, nnode
, nc
))
356 bgp_nbr_connected_delete (bgp
, nc
, 1);
358 /* Fast external-failover */
362 if (CHECK_FLAG (bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
365 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
367 #if defined(HAVE_CUMULUS)
368 /* Take down directly connected EBGP peers as well as 1-hop BFD
369 * tracked (directly connected) IBGP peers.
371 if ((peer
->ttl
!= 1) && (peer
->gtsm_hops
!= 1) &&
372 (!peer
->bfd_info
|| bgp_bfd_is_peer_multihop(peer
)))
374 /* Take down directly connected EBGP peers */
375 if ((peer
->ttl
!= 1) && (peer
->gtsm_hops
!= 1))
379 if (ifp
== peer
->nexthop
.ifp
)
381 BGP_EVENT_ADD (peer
, BGP_Stop
);
382 peer
->last_reset
= PEER_DOWN_IF_DOWN
;
391 bgp_interface_address_add (int command
, struct zclient
*zclient
,
392 zebra_size_t length
, vrf_id_t vrf_id
)
394 struct connected
*ifc
;
396 ifc
= zebra_interface_address_read (command
, zclient
->ibuf
, vrf_id
);
401 if (bgp_debug_zebra(ifc
->address
))
403 char buf
[PREFIX2STR_BUFFER
];
404 prefix2str(ifc
->address
, buf
, sizeof(buf
));
405 zlog_debug("Rx Intf address add VRF %u IF %s addr %s",
406 vrf_id
, ifc
->ifp
->name
, buf
);
409 if (if_is_operative (ifc
->ifp
))
413 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
417 bgp_connected_add (bgp
, ifc
);
418 /* If we have learnt of any neighbors on this interface,
419 * check to kick off any BGP interface-based neighbors,
420 * but only if this is a link-local address.
422 if (IN6_IS_ADDR_LINKLOCAL(&ifc
->address
->u
.prefix6
) &&
423 !list_isempty(ifc
->ifp
->nbr_connected
))
424 bgp_start_interface_nbrs (bgp
, ifc
->ifp
);
431 bgp_interface_address_delete (int command
, struct zclient
*zclient
,
432 zebra_size_t length
, vrf_id_t vrf_id
)
434 struct connected
*ifc
;
437 ifc
= zebra_interface_address_read (command
, zclient
->ibuf
, vrf_id
);
442 if (bgp_debug_zebra(ifc
->address
))
444 char buf
[PREFIX2STR_BUFFER
];
445 prefix2str(ifc
->address
, buf
, sizeof(buf
));
446 zlog_debug("Rx Intf address del VRF %u IF %s addr %s",
447 vrf_id
, ifc
->ifp
->name
, buf
);
450 if (if_is_operative (ifc
->ifp
))
452 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
454 bgp_connected_delete (bgp
, ifc
);
457 connected_free (ifc
);
463 bgp_interface_nbr_address_add (int command
, struct zclient
*zclient
,
464 zebra_size_t length
, vrf_id_t vrf_id
)
466 struct nbr_connected
*ifc
= NULL
;
469 ifc
= zebra_interface_nbr_address_read (command
, zclient
->ibuf
, vrf_id
);
474 if (bgp_debug_zebra(ifc
->address
))
476 char buf
[PREFIX2STR_BUFFER
];
477 prefix2str(ifc
->address
, buf
, sizeof(buf
));
478 zlog_debug("Rx Intf neighbor add VRF %u IF %s addr %s",
479 vrf_id
, ifc
->ifp
->name
, buf
);
482 if (if_is_operative (ifc
->ifp
))
484 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
486 bgp_nbr_connected_add (bgp
, ifc
);
493 bgp_interface_nbr_address_delete (int command
, struct zclient
*zclient
,
494 zebra_size_t length
, vrf_id_t vrf_id
)
496 struct nbr_connected
*ifc
= NULL
;
499 ifc
= zebra_interface_nbr_address_read (command
, zclient
->ibuf
, vrf_id
);
504 if (bgp_debug_zebra(ifc
->address
))
506 char buf
[PREFIX2STR_BUFFER
];
507 prefix2str(ifc
->address
, buf
, sizeof(buf
));
508 zlog_debug("Rx Intf neighbor del VRF %u IF %s addr %s",
509 vrf_id
, ifc
->ifp
->name
, buf
);
512 if (if_is_operative (ifc
->ifp
))
514 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
516 bgp_nbr_connected_delete (bgp
, ifc
, 0);
519 nbr_connected_free (ifc
);
524 /* VRF update for an interface. */
526 bgp_interface_vrf_update (int command
, struct zclient
*zclient
, zebra_size_t length
,
529 struct interface
*ifp
;
532 struct nbr_connected
*nc
;
533 struct listnode
*node
, *nnode
;
536 ifp
= zebra_interface_vrf_update_read (zclient
->ibuf
, vrf_id
, &new_vrf_id
);
540 if (BGP_DEBUG (zebra
, ZEBRA
) && ifp
)
541 zlog_debug("Rx Intf VRF change VRF %u IF %s NewVRF %u",
542 vrf_id
, ifp
->name
, new_vrf_id
);
544 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
548 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, c
))
549 bgp_connected_delete (bgp
, c
);
551 for (ALL_LIST_ELEMENTS (ifp
->nbr_connected
, node
, nnode
, nc
))
552 bgp_nbr_connected_delete (bgp
, nc
, 1);
554 /* Fast external-failover */
558 if (CHECK_FLAG (bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
561 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
563 if ((peer
->ttl
!= 1) && (peer
->gtsm_hops
!= 1))
566 if (ifp
== peer
->nexthop
.ifp
)
567 BGP_EVENT_ADD (peer
, BGP_Stop
);
571 if_update_vrf (ifp
, ifp
->name
, strlen (ifp
->name
), new_vrf_id
);
573 bgp
= bgp_lookup_by_vrf_id (new_vrf_id
);
577 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, c
))
578 bgp_connected_add (bgp
, c
);
580 for (ALL_LIST_ELEMENTS (ifp
->nbr_connected
, node
, nnode
, nc
))
581 bgp_nbr_connected_add (bgp
, nc
);
585 /* Zebra route add and delete treatment. */
587 zebra_read_ipv4 (int command
, struct zclient
*zclient
, zebra_size_t length
,
591 struct zapi_ipv4 api
;
592 struct in_addr nexthop
;
593 struct prefix_ipv4 p
;
594 unsigned int ifindex
;
598 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
605 /* Type, flags, message. */
606 api
.type
= stream_getc (s
);
607 api
.instance
= stream_getw (s
);
608 api
.flags
= stream_getl (s
);
609 api
.message
= stream_getc (s
);
612 memset (&p
, 0, sizeof (struct prefix_ipv4
));
614 p
.prefixlen
= MIN(IPV4_MAX_PREFIXLEN
, stream_getc (s
));
615 stream_get (&p
.prefix
, s
, PSIZE (p
.prefixlen
));
617 /* Nexthop, ifindex, distance, metric. */
618 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
))
620 api
.nexthop_num
= stream_getc (s
);
621 nexthop
.s_addr
= stream_get_ipv4 (s
);
624 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_IFINDEX
))
626 api
.ifindex_num
= stream_getc (s
);
627 ifindex
= stream_getl (s
); /* ifindex, unused */
634 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_DISTANCE
))
635 api
.distance
= stream_getc (s
);
637 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
))
638 api
.metric
= stream_getl (s
);
642 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_TAG
))
643 api
.tag
= stream_getw (s
);
647 if (command
== ZEBRA_REDISTRIBUTE_IPV4_ADD
)
649 if (bgp_debug_zebra((struct prefix
*)&p
))
651 char buf
[2][INET_ADDRSTRLEN
];
652 zlog_debug("Rx IPv4 route add VRF %u %s[%d] %s/%d nexthop %s metric %u tag %d",
654 zebra_route_string(api
.type
), api
.instance
,
655 inet_ntop(AF_INET
, &p
.prefix
, buf
[0], sizeof(buf
[0])),
657 inet_ntop(AF_INET
, &nexthop
, buf
[1], sizeof(buf
[1])),
663 * The ADD message is actually an UPDATE and there is no explicit DEL
664 * for a prior redistributed route, if any. So, perform an implicit
665 * DEL processing for the same redistributed route from any other
668 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
671 bgp_redistribute_delete(bgp
, (struct prefix
*)&p
, i
, api
.instance
);
674 /* Now perform the add/update. */
675 bgp_redistribute_add(bgp
, (struct prefix
*)&p
, &nexthop
, NULL
, ifindex
,
676 api
.metric
, api
.type
, api
.instance
, api
.tag
);
678 else if (command
== ZEBRA_REDISTRIBUTE_IPV4_DEL
)
680 if (bgp_debug_zebra((struct prefix
*)&p
))
682 char buf
[2][INET_ADDRSTRLEN
];
683 zlog_debug("Rx IPv4 route delete VRF %u %s[%d] %s/%d "
684 "nexthop %s metric %u tag %d",
686 zebra_route_string(api
.type
), api
.instance
,
687 inet_ntop(AF_INET
, &p
.prefix
, buf
[0], sizeof(buf
[0])),
689 inet_ntop(AF_INET
, &nexthop
, buf
[1], sizeof(buf
[1])),
693 bgp_redistribute_delete(bgp
, (struct prefix
*)&p
, api
.type
, api
.instance
);
700 /* Zebra route add and delete treatment. */
702 zebra_read_ipv6 (int command
, struct zclient
*zclient
, zebra_size_t length
,
706 struct zapi_ipv6 api
;
707 struct in6_addr nexthop
;
708 struct prefix_ipv6 p
;
709 unsigned int ifindex
;
713 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
718 memset (&nexthop
, 0, sizeof (struct in6_addr
));
720 /* Type, flags, message. */
721 api
.type
= stream_getc (s
);
722 api
.instance
= stream_getw (s
);
723 api
.flags
= stream_getl (s
);
724 api
.message
= stream_getc (s
);
727 memset (&p
, 0, sizeof (struct prefix_ipv6
));
729 p
.prefixlen
= MIN(IPV6_MAX_PREFIXLEN
, stream_getc (s
));
730 stream_get (&p
.prefix
, s
, PSIZE (p
.prefixlen
));
732 /* Nexthop, ifindex, distance, metric. */
733 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
))
735 api
.nexthop_num
= stream_getc (s
);
736 stream_get (&nexthop
, s
, 16);
739 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_IFINDEX
))
741 api
.ifindex_num
= stream_getc (s
);
742 ifindex
= stream_getl (s
); /* ifindex, unused */
749 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_DISTANCE
))
750 api
.distance
= stream_getc (s
);
754 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
))
755 api
.metric
= stream_getl (s
);
759 if (CHECK_FLAG (api
.message
, ZAPI_MESSAGE_TAG
))
760 api
.tag
= stream_getw (s
);
764 /* Simply ignore link-local address. */
765 if (IN6_IS_ADDR_LINKLOCAL (&p
.prefix
))
768 if (command
== ZEBRA_REDISTRIBUTE_IPV6_ADD
)
770 if (bgp_debug_zebra((struct prefix
*)&p
))
772 char buf
[2][INET6_ADDRSTRLEN
];
773 zlog_debug("Rx IPv6 route add VRF %u %s[%d] %s/%d nexthop %s metric %u tag %d",
775 zebra_route_string(api
.type
), api
.instance
,
776 inet_ntop(AF_INET6
, &p
.prefix
, buf
[0], sizeof(buf
[0])),
778 inet_ntop(AF_INET
, &nexthop
, buf
[1], sizeof(buf
[1])),
784 * The ADD message is actually an UPDATE and there is no explicit DEL
785 * for a prior redistributed route, if any. So, perform an implicit
786 * DEL processing for the same redistributed route from any other
789 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
792 bgp_redistribute_delete(bgp
, (struct prefix
*)&p
, i
, api
.instance
);
795 bgp_redistribute_add (bgp
, (struct prefix
*)&p
, NULL
, &nexthop
, ifindex
,
796 api
.metric
, api
.type
, api
.instance
, api
.tag
);
798 else if (command
== ZEBRA_REDISTRIBUTE_IPV6_DEL
)
800 if (bgp_debug_zebra((struct prefix
*)&p
))
802 char buf
[2][INET6_ADDRSTRLEN
];
803 zlog_debug("Rx IPv6 route delete VRF %u %s[%d] %s/%d "
804 "nexthop %s metric %u tag %d",
806 zebra_route_string(api
.type
), api
.instance
,
807 inet_ntop(AF_INET6
, &p
.prefix
, buf
[0], sizeof(buf
[0])),
809 inet_ntop(AF_INET6
, &nexthop
, buf
[1], sizeof(buf
[1])),
813 bgp_redistribute_delete (bgp
, (struct prefix
*) &p
, api
.type
, api
.instance
);
818 #endif /* HAVE_IPV6 */
821 if_lookup_by_ipv4 (struct in_addr
*addr
, vrf_id_t vrf_id
)
823 struct listnode
*ifnode
;
824 struct listnode
*cnode
;
825 struct interface
*ifp
;
826 struct connected
*connected
;
827 struct prefix_ipv4 p
;
832 p
.prefixlen
= IPV4_MAX_BITLEN
;
834 for (ALL_LIST_ELEMENTS_RO (vrf_iflist(vrf_id
), ifnode
, ifp
))
836 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
838 cp
= connected
->address
;
840 if (cp
->family
== AF_INET
)
841 if (prefix_match (cp
, (struct prefix
*)&p
))
849 if_lookup_by_ipv4_exact (struct in_addr
*addr
, vrf_id_t vrf_id
)
851 struct listnode
*ifnode
;
852 struct listnode
*cnode
;
853 struct interface
*ifp
;
854 struct connected
*connected
;
857 for (ALL_LIST_ELEMENTS_RO (vrf_iflist(vrf_id
), ifnode
, ifp
))
859 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
861 cp
= connected
->address
;
863 if (cp
->family
== AF_INET
)
864 if (IPV4_ADDR_SAME (&cp
->u
.prefix4
, addr
))
873 if_lookup_by_ipv6 (struct in6_addr
*addr
, ifindex_t ifindex
, vrf_id_t vrf_id
)
875 struct listnode
*ifnode
;
876 struct listnode
*cnode
;
877 struct interface
*ifp
;
878 struct connected
*connected
;
879 struct prefix_ipv6 p
;
884 p
.prefixlen
= IPV6_MAX_BITLEN
;
886 for (ALL_LIST_ELEMENTS_RO (vrf_iflist(vrf_id
), ifnode
, ifp
))
888 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
890 cp
= connected
->address
;
892 if (cp
->family
== AF_INET6
)
893 if (prefix_match (cp
, (struct prefix
*)&p
))
895 if (IN6_IS_ADDR_LINKLOCAL(&cp
->u
.prefix6
))
897 if (ifindex
== ifp
->ifindex
)
909 if_lookup_by_ipv6_exact (struct in6_addr
*addr
, ifindex_t ifindex
, vrf_id_t vrf_id
)
911 struct listnode
*ifnode
;
912 struct listnode
*cnode
;
913 struct interface
*ifp
;
914 struct connected
*connected
;
917 for (ALL_LIST_ELEMENTS_RO (vrf_iflist(vrf_id
), ifnode
, ifp
))
919 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
921 cp
= connected
->address
;
923 if (cp
->family
== AF_INET6
)
924 if (IPV6_ADDR_SAME (&cp
->u
.prefix6
, addr
))
926 if (IN6_IS_ADDR_LINKLOCAL(&cp
->u
.prefix6
))
928 if (ifindex
== ifp
->ifindex
)
940 if_get_ipv6_global (struct interface
*ifp
, struct in6_addr
*addr
)
942 struct listnode
*cnode
;
943 struct connected
*connected
;
946 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
948 cp
= connected
->address
;
950 if (cp
->family
== AF_INET6
)
951 if (! IN6_IS_ADDR_LINKLOCAL (&cp
->u
.prefix6
))
953 memcpy (addr
, &cp
->u
.prefix6
, IPV6_MAX_BYTELEN
);
961 if_get_ipv6_local (struct interface
*ifp
, struct in6_addr
*addr
)
963 struct listnode
*cnode
;
964 struct connected
*connected
;
967 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
969 cp
= connected
->address
;
971 if (cp
->family
== AF_INET6
)
972 if (IN6_IS_ADDR_LINKLOCAL (&cp
->u
.prefix6
))
974 memcpy (addr
, &cp
->u
.prefix6
, IPV6_MAX_BYTELEN
);
980 #endif /* HAVE_IPV6 */
983 if_get_ipv4_address (struct interface
*ifp
, struct in_addr
*addr
)
985 struct listnode
*cnode
;
986 struct connected
*connected
;
989 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, connected
))
991 cp
= connected
->address
;
992 if ((cp
->family
== AF_INET
) && !ipv4_martian(&(cp
->u
.prefix4
)))
994 *addr
= cp
->u
.prefix4
;
1002 bgp_nexthop_set (union sockunion
*local
, union sockunion
*remote
,
1003 struct bgp_nexthop
*nexthop
, struct peer
*peer
)
1006 struct interface
*ifp
= NULL
;
1008 memset (nexthop
, 0, sizeof (struct bgp_nexthop
));
1015 if (local
->sa
.sa_family
== AF_INET
)
1017 nexthop
->v4
= local
->sin
.sin_addr
;
1018 if (peer
->update_if
)
1019 ifp
= if_lookup_by_name_vrf (peer
->update_if
, peer
->bgp
->vrf_id
);
1021 ifp
= if_lookup_by_ipv4_exact (&local
->sin
.sin_addr
, peer
->bgp
->vrf_id
);
1024 if (local
->sa
.sa_family
== AF_INET6
)
1026 if (IN6_IS_ADDR_LINKLOCAL (&local
->sin6
.sin6_addr
))
1028 if (peer
->conf_if
|| peer
->ifname
)
1029 ifp
= if_lookup_by_name_vrf (peer
->conf_if
? peer
->conf_if
: peer
->ifname
, peer
->bgp
->vrf_id
);
1031 else if (peer
->update_if
)
1032 ifp
= if_lookup_by_name_vrf (peer
->update_if
, peer
->bgp
->vrf_id
);
1034 ifp
= if_lookup_by_ipv6_exact (&local
->sin6
.sin6_addr
,
1035 local
->sin6
.sin6_scope_id
,
1038 #endif /* HAVE_IPV6 */
1045 /* IPv4 connection, fetch and store IPv6 local address(es) if any. */
1046 if (local
->sa
.sa_family
== AF_INET
)
1050 ret
= if_get_ipv6_global (ifp
, &nexthop
->v6_global
);
1054 /* There is no global nexthop. Use link-local address as both the
1055 * global and link-local nexthop. In this scenario, the expectation
1056 * for interop is that the network admin would use a route-map to
1057 * specify the global IPv6 nexthop.
1059 if_get_ipv6_local (ifp
, &nexthop
->v6_global
);
1060 memcpy (&nexthop
->v6_local
, &nexthop
->v6_global
,
1064 if_get_ipv6_local (ifp
, &nexthop
->v6_local
);
1066 if (if_lookup_by_ipv4 (&remote
->sin
.sin_addr
, peer
->bgp
->vrf_id
))
1067 peer
->shared_network
= 1;
1069 peer
->shared_network
= 0;
1070 #endif /* HAVE_IPV6 */
1074 /* IPv6 connection, fetch and store IPv4 local address if any. */
1075 if (local
->sa
.sa_family
== AF_INET6
)
1077 struct interface
*direct
= NULL
;
1080 ret
= if_get_ipv4_address(ifp
, &nexthop
->v4
);
1081 if (!ret
&& peer
->local_id
.s_addr
)
1082 nexthop
->v4
= peer
->local_id
;
1085 if (! IN6_IS_ADDR_LINKLOCAL (&local
->sin6
.sin6_addr
))
1087 memcpy (&nexthop
->v6_global
, &local
->sin6
.sin6_addr
,
1090 /* If directory connected set link-local address. */
1091 direct
= if_lookup_by_ipv6 (&remote
->sin6
.sin6_addr
,
1092 remote
->sin6
.sin6_scope_id
, peer
->bgp
->vrf_id
);
1094 if_get_ipv6_local (ifp
, &nexthop
->v6_local
);
1097 /* Link-local address. */
1099 ret
= if_get_ipv6_global (ifp
, &nexthop
->v6_global
);
1101 /* If there is no global address. Set link-local address as
1102 global. I know this break RFC specification... */
1103 /* In this scenario, the expectation for interop is that the
1104 * network admin would use a route-map to specify the global
1108 memcpy (&nexthop
->v6_global
, &local
->sin6
.sin6_addr
,
1110 /* Always set the link-local address */
1111 memcpy (&nexthop
->v6_local
, &local
->sin6
.sin6_addr
,
1115 if (IN6_IS_ADDR_LINKLOCAL (&local
->sin6
.sin6_addr
) ||
1116 if_lookup_by_ipv6 (&remote
->sin6
.sin6_addr
, remote
->sin6
.sin6_scope_id
,
1118 peer
->shared_network
= 1;
1120 peer
->shared_network
= 0;
1123 /* KAME stack specific treatment. */
1125 if (IN6_IS_ADDR_LINKLOCAL (&nexthop
->v6_global
)
1126 && IN6_LINKLOCAL_IFINDEX (nexthop
->v6_global
))
1128 SET_IN6_LINKLOCAL_IFINDEX (nexthop
->v6_global
, 0);
1130 if (IN6_IS_ADDR_LINKLOCAL (&nexthop
->v6_local
)
1131 && IN6_LINKLOCAL_IFINDEX (nexthop
->v6_local
))
1133 SET_IN6_LINKLOCAL_IFINDEX (nexthop
->v6_local
, 0);
1136 #endif /* HAVE_IPV6 */
1138 /* If we have identified the local interface, there is no error for now. */
1142 static struct in6_addr
*
1143 bgp_info_to_ipv6_nexthop (struct bgp_info
*info
)
1145 struct in6_addr
*nexthop
= NULL
;
1147 /* Only global address nexthop exists. */
1148 if (info
->attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL
)
1149 nexthop
= &info
->attr
->extra
->mp_nexthop_global
;
1151 /* If both global and link-local address present. */
1152 if (info
->attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
1154 /* Check if route-map is set to prefer global over link-local */
1155 if (info
->attr
->extra
->mp_nexthop_prefer_global
)
1156 nexthop
= &info
->attr
->extra
->mp_nexthop_global
;
1159 /* Workaround for Cisco's nexthop bug. */
1160 if (IN6_IS_ADDR_UNSPECIFIED (&info
->attr
->extra
->mp_nexthop_global
)
1161 && info
->peer
->su_remote
->sa
.sa_family
== AF_INET6
)
1162 nexthop
= &info
->peer
->su_remote
->sin6
.sin6_addr
;
1164 nexthop
= &info
->attr
->extra
->mp_nexthop_local
;
1172 bgp_table_map_apply (struct route_map
*map
, struct prefix
*p
,
1173 struct bgp_info
*info
)
1175 if (route_map_apply(map
, p
, RMAP_BGP
, info
) != RMAP_DENYMATCH
)
1178 if (bgp_debug_zebra(p
))
1180 if (p
->family
== AF_INET
)
1182 char buf
[2][INET_ADDRSTRLEN
];
1183 zlog_debug("Zebra rmap deny: IPv4 route %s/%d nexthop %s",
1184 inet_ntop(AF_INET
, &p
->u
.prefix4
, buf
[0], sizeof(buf
[0])),
1186 inet_ntop(AF_INET
, &info
->attr
->nexthop
, buf
[1],
1189 if (p
->family
== AF_INET6
)
1191 char buf
[2][INET6_ADDRSTRLEN
];
1192 zlog_debug("Zebra rmap deny: IPv6 route %s/%d nexthop %s",
1193 inet_ntop(AF_INET6
, &p
->u
.prefix6
, buf
[0], sizeof(buf
[0])),
1195 inet_ntop(AF_INET6
, bgp_info_to_ipv6_nexthop(info
), buf
[1],
1203 bgp_zebra_announce (struct prefix
*p
, struct bgp_info
*info
, struct bgp
*bgp
,
1204 afi_t afi
, safi_t safi
)
1209 struct bgp_info
*mpinfo
;
1210 size_t oldsize
, newsize
;
1211 u_int32_t nhcount
, metric
;
1212 struct bgp_info local_info
;
1213 struct bgp_info
*info_cp
= &local_info
;
1216 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1217 * know of this instance.
1219 if (!bgp_install_info_to_zebra (bgp
))
1222 if ((p
->family
== AF_INET
&&
1223 !vrf_bitmap_check (zclient
->redist
[AFI_IP
][ZEBRA_ROUTE_BGP
], bgp
->vrf_id
))
1224 || (p
->family
== AF_INET6
&&
1225 !vrf_bitmap_check (zclient
->redist
[AFI_IP6
][ZEBRA_ROUTE_BGP
], bgp
->vrf_id
)))
1228 if (bgp
->main_zebra_update_hold
)
1234 if ((info
->attr
->extra
) && (info
->attr
->extra
->tag
!= 0))
1235 tag
= info
->attr
->extra
->tag
;
1239 /* When we create an aggregate route we must also install a Null0 route in
1241 if (info
->sub_type
== BGP_ROUTE_AGGREGATE
)
1242 SET_FLAG (flags
, ZEBRA_FLAG_BLACKHOLE
);
1244 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->sort
== BGP_PEER_CONFED
||
1245 info
->sub_type
== BGP_ROUTE_AGGREGATE
)
1247 SET_FLAG (flags
, ZEBRA_FLAG_IBGP
);
1248 SET_FLAG (flags
, ZEBRA_FLAG_INTERNAL
);
1251 if ((peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
!= 1)
1252 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)
1253 || bgp_flag_check(bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
1255 SET_FLAG (flags
, ZEBRA_FLAG_INTERNAL
);
1257 nhcount
= 1 + bgp_info_mpath_count (info
);
1259 if (p
->family
== AF_INET
&& !BGP_ATTR_NEXTHOP_AFI_IP6(info
->attr
))
1261 struct zapi_ipv4 api
;
1262 struct in_addr
*nexthop
;
1263 char buf
[2][INET_ADDRSTRLEN
];
1264 int valid_nh_count
= 0;
1266 /* resize nexthop buffer size if necessary */
1267 if ((oldsize
= stream_get_size (bgp_nexthop_buf
)) <
1268 (sizeof (struct in_addr
*) * nhcount
))
1270 newsize
= (sizeof (struct in_addr
*) * nhcount
);
1271 newsize
= stream_resize (bgp_nexthop_buf
, newsize
);
1272 if (newsize
== oldsize
)
1274 zlog_err ("can't resize nexthop buffer");
1278 stream_reset (bgp_nexthop_buf
);
1281 /* Metric is currently based on the best-path only. */
1282 metric
= info
->attr
->med
;
1284 if (bgp
->table_map
[afi
][safi
].name
)
1286 BGP_INFO_ATTR_BUF_INIT();
1288 /* Copy info and attributes, so the route-map apply doesn't modify the
1290 BGP_INFO_ATTR_BUF_COPY(info
, info_cp
);
1291 if (bgp_table_map_apply(bgp
->table_map
[afi
][safi
].map
, p
, info_cp
))
1293 metric
= info_cp
->attr
->med
;
1294 nexthop
= &info_cp
->attr
->nexthop
;
1296 if (info_cp
->attr
->extra
)
1297 tag
= info_cp
->attr
->extra
->tag
;
1299 BGP_INFO_ATTR_BUF_FREE(info_cp
);
1303 nexthop
= &info
->attr
->nexthop
;
1308 stream_put (bgp_nexthop_buf
, &nexthop
, sizeof (struct in_addr
*));
1312 for (mpinfo
= bgp_info_mpath_first (info
); mpinfo
;
1313 mpinfo
= bgp_info_mpath_next (mpinfo
))
1317 if (bgp
->table_map
[afi
][safi
].name
)
1319 /* Copy info and attributes, so the route-map apply doesn't modify the
1321 BGP_INFO_ATTR_BUF_COPY(mpinfo
, info_cp
);
1322 if (bgp_table_map_apply(bgp
->table_map
[afi
][safi
].map
, p
, info_cp
))
1323 nexthop
= &info_cp
->attr
->nexthop
;
1324 BGP_INFO_ATTR_BUF_FREE(info_cp
);
1328 nexthop
= &mpinfo
->attr
->nexthop
;
1331 if (nexthop
== NULL
)
1334 stream_put (bgp_nexthop_buf
, &nexthop
, sizeof (struct in_addr
*));
1338 api
.vrf_id
= bgp
->vrf_id
;
1340 api
.type
= ZEBRA_ROUTE_BGP
;
1344 SET_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
);
1346 /* Note that this currently only applies to Null0 routes for aggregates.
1347 * ZEBRA_FLAG_BLACKHOLE signals zapi_ipv4_route to encode a special
1348 * BLACKHOLE nexthop. We want to set api.nexthop_num to zero since we
1349 * do not want to also encode the 0.0.0.0 nexthop for the aggregate route.
1351 if (CHECK_FLAG(flags
, ZEBRA_FLAG_BLACKHOLE
))
1352 api
.nexthop_num
= 0;
1354 api
.nexthop_num
= valid_nh_count
;
1356 api
.nexthop
= (struct in_addr
**)STREAM_DATA (bgp_nexthop_buf
);
1357 api
.ifindex_num
= 0;
1358 SET_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
);
1359 api
.metric
= metric
;
1364 SET_FLAG (api
.message
, ZAPI_MESSAGE_TAG
);
1368 distance
= bgp_distance_apply (p
, info
, bgp
);
1372 SET_FLAG (api
.message
, ZAPI_MESSAGE_DISTANCE
);
1373 api
.distance
= distance
;
1376 if (bgp_debug_zebra(p
))
1379 zlog_debug("Tx IPv4 route %s VRF %u %s/%d metric %u tag %d"
1380 " count %d", (valid_nh_count
? "add":"delete"),
1382 inet_ntop(AF_INET
, &p
->u
.prefix4
, buf
[0], sizeof(buf
[0])),
1383 p
->prefixlen
, api
.metric
, api
.tag
, api
.nexthop_num
);
1384 for (i
= 0; i
< api
.nexthop_num
; i
++)
1385 zlog_debug(" IPv4 [nexthop %d] %s", i
+1,
1386 inet_ntop(AF_INET
, api
.nexthop
[i
], buf
[1], sizeof(buf
[1])));
1389 zapi_ipv4_route (valid_nh_count
? ZEBRA_IPV4_ROUTE_ADD
: ZEBRA_IPV4_ROUTE_DELETE
,
1390 zclient
, (struct prefix_ipv4
*) p
, &api
);
1394 /* We have to think about a IPv6 link-local address curse. */
1395 if (p
->family
== AF_INET6
||
1396 (p
->family
== AF_INET
&& BGP_ATTR_NEXTHOP_AFI_IP6(info
->attr
)))
1399 struct in6_addr
*nexthop
;
1400 struct zapi_ipv6 api
;
1401 int valid_nh_count
= 0;
1402 char buf
[2][INET6_ADDRSTRLEN
];
1404 /* resize nexthop buffer size if necessary */
1405 if ((oldsize
= stream_get_size (bgp_nexthop_buf
)) <
1406 (sizeof (struct in6_addr
*) * nhcount
))
1408 newsize
= (sizeof (struct in6_addr
*) * nhcount
);
1409 newsize
= stream_resize (bgp_nexthop_buf
, newsize
);
1410 if (newsize
== oldsize
)
1412 zlog_err ("can't resize nexthop buffer");
1416 stream_reset (bgp_nexthop_buf
);
1418 /* resize ifindices buffer size if necessary */
1419 if ((oldsize
= stream_get_size (bgp_ifindices_buf
)) <
1420 (sizeof (unsigned int) * nhcount
))
1422 newsize
= (sizeof (unsigned int) * nhcount
);
1423 newsize
= stream_resize (bgp_ifindices_buf
, newsize
);
1424 if (newsize
== oldsize
)
1426 zlog_err ("can't resize nexthop buffer");
1430 stream_reset (bgp_ifindices_buf
);
1435 assert (info
->attr
->extra
);
1437 /* Metric is currently based on the best-path only. */
1438 metric
= info
->attr
->med
;
1440 if (bgp
->table_map
[afi
][safi
].name
)
1442 BGP_INFO_ATTR_BUF_INIT();
1444 /* Copy info and attributes, so the route-map apply doesn't modify the
1446 BGP_INFO_ATTR_BUF_COPY(info
, info_cp
);
1447 if (bgp_table_map_apply(bgp
->table_map
[afi
][safi
].map
, p
, info_cp
))
1449 metric
= info_cp
->attr
->med
;
1450 nexthop
= bgp_info_to_ipv6_nexthop(info_cp
);
1452 if (info_cp
->attr
->extra
)
1453 tag
= info_cp
->attr
->extra
->tag
;
1455 BGP_INFO_ATTR_BUF_FREE(info_cp
);
1459 nexthop
= bgp_info_to_ipv6_nexthop(info
);
1464 if (info
->attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
1465 if (info
->peer
->nexthop
.ifp
)
1466 ifindex
= info
->peer
->nexthop
.ifp
->ifindex
;
1470 if (info
->peer
->conf_if
|| info
->peer
->ifname
)
1471 ifindex
= if_nametoindex (info
->peer
->conf_if
? info
->peer
->conf_if
: info
->peer
->ifname
);
1472 else if (info
->peer
->nexthop
.ifp
)
1473 ifindex
= info
->peer
->nexthop
.ifp
->ifindex
;
1475 stream_put (bgp_nexthop_buf
, &nexthop
, sizeof (struct in6_addr
*));
1476 stream_put (bgp_ifindices_buf
, &ifindex
, sizeof (unsigned int));
1480 for (mpinfo
= bgp_info_mpath_first (info
); mpinfo
;
1481 mpinfo
= bgp_info_mpath_next (mpinfo
))
1486 if (bgp
->table_map
[afi
][safi
].name
)
1488 /* Copy info and attributes, so the route-map apply doesn't modify the
1490 BGP_INFO_ATTR_BUF_COPY(mpinfo
, info_cp
);
1491 if (bgp_table_map_apply(bgp
->table_map
[afi
][safi
].map
, p
, info_cp
))
1492 nexthop
= bgp_info_to_ipv6_nexthop(info_cp
);
1493 BGP_INFO_ATTR_BUF_FREE(info_cp
);
1497 nexthop
= bgp_info_to_ipv6_nexthop(mpinfo
);
1500 if (nexthop
== NULL
)
1503 if (mpinfo
->attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
1504 if (mpinfo
->peer
->nexthop
.ifp
)
1505 ifindex
= mpinfo
->peer
->nexthop
.ifp
->ifindex
;
1509 if (mpinfo
->peer
->conf_if
|| mpinfo
->peer
->ifname
)
1510 ifindex
= ifname2ifindex (mpinfo
->peer
->conf_if
? mpinfo
->peer
->conf_if
: mpinfo
->peer
->ifname
);
1511 else if (mpinfo
->peer
->nexthop
.ifp
)
1512 ifindex
= mpinfo
->peer
->nexthop
.ifp
->ifindex
;
1517 stream_put (bgp_nexthop_buf
, &nexthop
, sizeof (struct in6_addr
*));
1518 stream_put (bgp_ifindices_buf
, &ifindex
, sizeof (unsigned int));
1522 /* Make Zebra API structure. */
1523 api
.vrf_id
= bgp
->vrf_id
;
1525 api
.type
= ZEBRA_ROUTE_BGP
;
1529 SET_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
);
1531 /* Note that this currently only applies to Null0 routes for aggregates.
1532 * ZEBRA_FLAG_BLACKHOLE signals zapi_ipv6_route to encode a special
1533 * BLACKHOLE nexthop. We want to set api.nexthop_num to zero since we
1534 * do not want to also encode the :: nexthop for the aggregate route.
1536 if (CHECK_FLAG(flags
, ZEBRA_FLAG_BLACKHOLE
))
1537 api
.nexthop_num
= 0;
1539 api
.nexthop_num
= valid_nh_count
;
1541 api
.nexthop
= (struct in6_addr
**)STREAM_DATA (bgp_nexthop_buf
);
1542 SET_FLAG (api
.message
, ZAPI_MESSAGE_IFINDEX
);
1543 api
.ifindex_num
= valid_nh_count
;
1544 api
.ifindex
= (ifindex_t
*)STREAM_DATA (bgp_ifindices_buf
);
1545 SET_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
);
1546 api
.metric
= metric
;
1551 SET_FLAG (api
.message
, ZAPI_MESSAGE_TAG
);
1555 if (p
->family
== AF_INET
)
1557 if (bgp_debug_zebra(p
))
1560 zlog_debug("Tx IPv4 route %s VRF %u %s/%d metric %u tag %d",
1561 valid_nh_count
? "add" : "delete", bgp
->vrf_id
,
1562 inet_ntop(AF_INET
, &p
->u
.prefix4
, buf
[0], sizeof(buf
[0])),
1563 p
->prefixlen
, api
.metric
, api
.tag
);
1564 for (i
= 0; i
< api
.nexthop_num
; i
++)
1565 zlog_debug(" IPv6 [nexthop %d] %s", i
+1,
1566 inet_ntop(AF_INET6
, api
.nexthop
[i
], buf
[1], sizeof(buf
[1])));
1570 zapi_ipv4_route_ipv6_nexthop (ZEBRA_IPV4_ROUTE_IPV6_NEXTHOP_ADD
,
1571 zclient
, (struct prefix_ipv4
*) p
,
1572 (struct zapi_ipv6
*)&api
);
1574 zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE
,
1575 zclient
, (struct prefix_ipv4
*) p
, (struct zapi_ipv4
*)&api
);
1579 if (bgp_debug_zebra(p
))
1582 zlog_debug("Tx IPv6 route %s VRF %u %s/%d metric %u tag %d",
1583 valid_nh_count
? "add" : "delete", bgp
->vrf_id
,
1584 inet_ntop(AF_INET6
, &p
->u
.prefix6
, buf
[0], sizeof(buf
[0])),
1585 p
->prefixlen
, api
.metric
, api
.tag
);
1586 for (i
= 0; i
< api
.nexthop_num
; i
++)
1587 zlog_debug(" IPv6 [nexthop %d] %s", i
+1,
1588 inet_ntop(AF_INET6
, api
.nexthop
[i
], buf
[1], sizeof(buf
[1])));
1591 zapi_ipv6_route (valid_nh_count
?
1592 ZEBRA_IPV6_ROUTE_ADD
: ZEBRA_IPV6_ROUTE_DELETE
,
1593 zclient
, (struct prefix_ipv6
*) p
, &api
);
1596 #endif /* HAVE_IPV6 */
1599 /* Announce all routes of a table to zebra */
1601 bgp_zebra_announce_table (struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1603 struct bgp_node
*rn
;
1604 struct bgp_table
*table
;
1605 struct bgp_info
*ri
;
1607 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1608 * know of this instance.
1610 if (!bgp_install_info_to_zebra (bgp
))
1613 table
= bgp
->rib
[afi
][safi
];
1616 for (rn
= bgp_table_top (table
); rn
; rn
= bgp_route_next (rn
))
1617 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1618 if (CHECK_FLAG (ri
->flags
, BGP_INFO_SELECTED
)
1619 && ri
->type
== ZEBRA_ROUTE_BGP
1620 && ri
->sub_type
== BGP_ROUTE_NORMAL
)
1621 bgp_zebra_announce (&rn
->p
, ri
, bgp
, afi
, safi
);
1625 bgp_zebra_withdraw (struct prefix
*p
, struct bgp_info
*info
, safi_t safi
)
1633 /* Don't try to install if we're not connected to Zebra or Zebra doesn't
1634 * know of this instance.
1636 if (!bgp_install_info_to_zebra (peer
->bgp
))
1639 if ((p
->family
== AF_INET
&&
1640 !vrf_bitmap_check (zclient
->redist
[AFI_IP
][ZEBRA_ROUTE_BGP
], peer
->bgp
->vrf_id
))
1641 || (p
->family
== AF_INET6
&&
1642 !vrf_bitmap_check (zclient
->redist
[AFI_IP6
][ZEBRA_ROUTE_BGP
], peer
->bgp
->vrf_id
)))
1647 if (peer
->sort
== BGP_PEER_IBGP
)
1649 SET_FLAG (flags
, ZEBRA_FLAG_INTERNAL
);
1650 SET_FLAG (flags
, ZEBRA_FLAG_IBGP
);
1653 if ((peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
!= 1)
1654 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)
1655 || bgp_flag_check(peer
->bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
1656 SET_FLAG (flags
, ZEBRA_FLAG_INTERNAL
);
1658 if (p
->family
== AF_INET
)
1660 struct zapi_ipv4 api
;
1662 api
.vrf_id
= peer
->bgp
->vrf_id
;
1665 api
.type
= ZEBRA_ROUTE_BGP
;
1669 SET_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
);
1670 api
.nexthop_num
= 0;
1672 api
.ifindex_num
= 0;
1673 SET_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
);
1674 api
.metric
= info
->attr
->med
;
1677 if ((info
->attr
->extra
) && (info
->attr
->extra
->tag
!= 0))
1679 SET_FLAG(api
.message
, ZAPI_MESSAGE_TAG
);
1680 api
.tag
= info
->attr
->extra
->tag
;
1683 if (bgp_debug_zebra(p
))
1685 char buf
[2][INET_ADDRSTRLEN
];
1686 zlog_debug("Tx IPv4 route delete VRF %u %s/%d metric %u tag %d",
1688 inet_ntop(AF_INET
, &p
->u
.prefix4
, buf
[0], sizeof(buf
[0])),
1689 p
->prefixlen
, api
.metric
, api
.tag
);
1692 zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE
, zclient
,
1693 (struct prefix_ipv4
*) p
, &api
);
1696 /* We have to think about a IPv6 link-local address curse. */
1697 if (p
->family
== AF_INET6
)
1699 struct zapi_ipv6 api
;
1701 assert (info
->attr
->extra
);
1703 api
.vrf_id
= peer
->bgp
->vrf_id
;
1705 api
.type
= ZEBRA_ROUTE_BGP
;
1709 SET_FLAG (api
.message
, ZAPI_MESSAGE_NEXTHOP
);
1710 api
.nexthop_num
= 0;
1712 api
.ifindex_num
= 0;
1713 SET_FLAG (api
.message
, ZAPI_MESSAGE_METRIC
);
1714 api
.metric
= info
->attr
->med
;
1717 if ((info
->attr
->extra
) && (info
->attr
->extra
->tag
!= 0))
1719 SET_FLAG(api
.message
, ZAPI_MESSAGE_TAG
);
1720 api
.tag
= info
->attr
->extra
->tag
;
1723 if (bgp_debug_zebra(p
))
1725 char buf
[2][INET6_ADDRSTRLEN
];
1726 zlog_debug("Tx IPv6 route delete VRF %u %s/%d metric %u tag %d",
1728 inet_ntop(AF_INET6
, &p
->u
.prefix6
, buf
[0], sizeof(buf
[0])),
1729 p
->prefixlen
, api
.metric
, api
.tag
);
1732 zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE
, zclient
,
1733 (struct prefix_ipv6
*) p
, &api
);
1735 #endif /* HAVE_IPV6 */
1738 bgp_redist_lookup (struct bgp
*bgp
, afi_t afi
, u_char type
, u_short instance
)
1740 struct list
*red_list
;
1741 struct listnode
*node
;
1742 struct bgp_redist
*red
;
1744 red_list
= bgp
->redist
[afi
][type
];
1748 for (ALL_LIST_ELEMENTS_RO(red_list
, node
, red
))
1749 if (red
->instance
== instance
)
1756 bgp_redist_add (struct bgp
*bgp
, afi_t afi
, u_char type
, u_short instance
)
1758 struct list
*red_list
;
1759 struct bgp_redist
*red
;
1761 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
1765 if (!bgp
->redist
[afi
][type
])
1766 bgp
->redist
[afi
][type
] = list_new();
1768 red_list
= bgp
->redist
[afi
][type
];
1769 red
= (struct bgp_redist
*)XCALLOC(MTYPE_BGP_REDIST
, sizeof(struct bgp_redist
));
1770 red
->instance
= instance
;
1772 listnode_add(red_list
, red
);
1778 bgp_redist_del (struct bgp
*bgp
, afi_t afi
, u_char type
, u_short instance
)
1780 struct bgp_redist
*red
;
1782 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
1786 listnode_delete(bgp
->redist
[afi
][type
], red
);
1787 if (!bgp
->redist
[afi
][type
]->count
)
1789 list_free(bgp
->redist
[afi
][type
]);
1790 bgp
->redist
[afi
][type
] = NULL
;
1795 /* Other routes redistribution into BGP. */
1797 bgp_redistribute_set (struct bgp
*bgp
, afi_t afi
, int type
, u_short instance
)
1800 /* Return if already redistribute flag is set. */
1803 if (redist_check_instance(&zclient
->mi_redist
[afi
][type
], instance
))
1806 redist_add_instance(&zclient
->mi_redist
[afi
][type
], instance
);
1810 if (vrf_bitmap_check (zclient
->redist
[afi
][type
], bgp
->vrf_id
))
1814 if (bgp
->vrf_id
== VRF_DEFAULT
&&
1815 type
== ZEBRA_ROUTE_VNC_DIRECT
) {
1816 vnc_export_bgp_enable(bgp
, afi
); /* only enables if mode bits cfg'd */
1820 vrf_bitmap_set (zclient
->redist
[afi
][type
], bgp
->vrf_id
);
1823 /* Don't try to register if we're not connected to Zebra or Zebra doesn't
1824 * know of this instance.
1826 if (!bgp_install_info_to_zebra (bgp
))
1829 if (BGP_DEBUG (zebra
, ZEBRA
))
1830 zlog_debug("Tx redistribute add VRF %u afi %d %s %d",
1832 zebra_route_string(type
), instance
);
1834 /* Send distribute add message to zebra. */
1835 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD
, zclient
, afi
, type
,
1836 instance
, bgp
->vrf_id
);
1842 bgp_redistribute_resend (struct bgp
*bgp
, afi_t afi
, int type
, u_short instance
)
1844 /* Don't try to send if we're not connected to Zebra or Zebra doesn't
1845 * know of this instance.
1847 if (!bgp_install_info_to_zebra (bgp
))
1850 if (BGP_DEBUG (zebra
, ZEBRA
))
1851 zlog_debug("Tx redistribute del/add VRF %u afi %d %s %d",
1853 zebra_route_string(type
), instance
);
1855 /* Send distribute add message to zebra. */
1856 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE
, zclient
, afi
, type
,
1857 instance
, bgp
->vrf_id
);
1858 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD
, zclient
, afi
, type
,
1859 instance
, bgp
->vrf_id
);
1864 /* Redistribute with route-map specification. */
1866 bgp_redistribute_rmap_set (struct bgp_redist
*red
, const char *name
)
1869 && (strcmp (red
->rmap
.name
, name
) == 0))
1873 XFREE(MTYPE_ROUTE_MAP_NAME
, red
->rmap
.name
);
1874 red
->rmap
.name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, name
);
1875 red
->rmap
.map
= route_map_lookup_by_name (name
);
1880 /* Redistribute with metric specification. */
1882 bgp_redistribute_metric_set (struct bgp
*bgp
, struct bgp_redist
*red
, afi_t afi
,
1883 int type
, u_int32_t metric
)
1885 struct bgp_node
*rn
;
1886 struct bgp_info
*ri
;
1888 if (red
->redist_metric_flag
1889 && red
->redist_metric
== metric
)
1892 red
->redist_metric_flag
= 1;
1893 red
->redist_metric
= metric
;
1895 for (rn
= bgp_table_top(bgp
->rib
[afi
][SAFI_UNICAST
]); rn
; rn
= bgp_route_next(rn
))
1897 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1899 if (ri
->sub_type
== BGP_ROUTE_REDISTRIBUTE
&&
1901 ri
->instance
== red
->instance
)
1903 struct attr
*old_attr
;
1904 struct attr new_attr
;
1905 struct attr_extra new_extra
;
1907 new_attr
.extra
= &new_extra
;
1908 bgp_attr_dup (&new_attr
, ri
->attr
);
1909 new_attr
.med
= red
->redist_metric
;
1910 old_attr
= ri
->attr
;
1911 ri
->attr
= bgp_attr_intern (&new_attr
);
1912 bgp_attr_unintern (&old_attr
);
1914 bgp_info_set_flag(rn
, ri
, BGP_INFO_ATTR_CHANGED
);
1915 bgp_process(bgp
, rn
, afi
, SAFI_UNICAST
);
1923 /* Unset redistribution. */
1925 bgp_redistribute_unreg (struct bgp
*bgp
, afi_t afi
, int type
, u_short instance
)
1927 struct bgp_redist
*red
;
1929 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
1933 /* Return if zebra connection is disabled. */
1936 if (!redist_check_instance(&zclient
->mi_redist
[afi
][type
], instance
))
1938 redist_del_instance(&zclient
->mi_redist
[afi
][type
], instance
);
1942 if (! vrf_bitmap_check (zclient
->redist
[afi
][type
], bgp
->vrf_id
))
1944 vrf_bitmap_unset (zclient
->redist
[afi
][type
], bgp
->vrf_id
);
1948 if (bgp
->vrf_id
== VRF_DEFAULT
&&
1949 type
== ZEBRA_ROUTE_VNC_DIRECT
) {
1950 vnc_export_bgp_disable(bgp
, afi
);
1954 if (bgp_install_info_to_zebra (bgp
))
1956 /* Send distribute delete message to zebra. */
1957 if (BGP_DEBUG (zebra
, ZEBRA
))
1958 zlog_debug("Tx redistribute del VRF %u afi %d %s %d",
1959 bgp
->vrf_id
, afi
, zebra_route_string(type
), instance
);
1960 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE
, zclient
, afi
, type
, instance
,
1964 /* Withdraw redistributed routes from current BGP's routing table. */
1965 bgp_redistribute_withdraw (bgp
, afi
, type
, instance
);
1970 /* Unset redistribution. */
1972 bgp_redistribute_unset (struct bgp
*bgp
, afi_t afi
, int type
, u_short instance
)
1974 struct bgp_redist
*red
;
1976 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
1980 bgp_redistribute_unreg(bgp
, afi
, type
, instance
);
1982 /* Unset route-map. */
1984 XFREE(MTYPE_ROUTE_MAP_NAME
, red
->rmap
.name
);
1985 red
->rmap
.name
= NULL
;
1986 red
->rmap
.map
= NULL
;
1989 red
->redist_metric_flag
= 0;
1990 red
->redist_metric
= 0;
1992 bgp_redist_del(bgp
, afi
, type
, instance
);
1997 /* Update redistribute vrf bitmap during triggers like
1998 restart networking or delete/add VRFs */
2000 bgp_update_redist_vrf_bitmaps (struct bgp
*bgp
, vrf_id_t old_vrf_id
)
2005 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2006 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
2007 if (vrf_bitmap_check (zclient
->redist
[afi
][i
], old_vrf_id
))
2009 vrf_bitmap_unset (zclient
->redist
[afi
][i
], old_vrf_id
);
2010 vrf_bitmap_set (zclient
->redist
[afi
][i
], bgp
->vrf_id
);
2016 bgp_zclient_reset (void)
2018 zclient_reset (zclient
);
2021 /* Register this instance with Zebra. Invoked upon connect (for
2022 * default instance) and when other VRFs are learnt (or created and
2026 bgp_zebra_instance_register (struct bgp
*bgp
)
2028 /* Don't try to register if we're not connected to Zebra */
2029 if (!zclient
|| zclient
->sock
< 0)
2032 if (BGP_DEBUG (zebra
, ZEBRA
))
2033 zlog_debug("Registering VRF %u", bgp
->vrf_id
);
2035 /* Register for router-id, interfaces, redistributed routes. */
2036 zclient_send_reg_requests (zclient
, bgp
->vrf_id
);
2039 /* Deregister this instance with Zebra. Invoked upon the instance
2040 * being deleted (default or VRF) and it is already registered.
2043 bgp_zebra_instance_deregister (struct bgp
*bgp
)
2045 /* Don't try to deregister if we're not connected to Zebra */
2046 if (zclient
->sock
< 0)
2049 if (BGP_DEBUG (zebra
, ZEBRA
))
2050 zlog_debug("Deregistering VRF %u", bgp
->vrf_id
);
2052 /* Deregister for router-id, interfaces, redistributed routes. */
2053 zclient_send_dereg_requests (zclient
, bgp
->vrf_id
);
2057 bgp_zebra_initiate_radv (struct bgp
*bgp
, struct peer
*peer
)
2059 int ra_interval
= BGP_UNNUM_DEFAULT_RA_INTERVAL
;
2061 /* Don't try to initiate if we're not connected to Zebra */
2062 if (zclient
->sock
< 0)
2065 if (BGP_DEBUG (zebra
, ZEBRA
))
2066 zlog_debug("%u: Initiating RA for peer %s", bgp
->vrf_id
, peer
->host
);
2068 zclient_send_interface_radv_req (zclient
, bgp
->vrf_id
, peer
->ifp
, 1, ra_interval
);
2072 bgp_zebra_terminate_radv (struct bgp
*bgp
, struct peer
*peer
)
2074 /* Don't try to terminate if we're not connected to Zebra */
2075 if (zclient
->sock
< 0)
2078 if (BGP_DEBUG (zebra
, ZEBRA
))
2079 zlog_debug("%u: Terminating RA for peer %s", bgp
->vrf_id
, peer
->host
);
2081 zclient_send_interface_radv_req (zclient
, bgp
->vrf_id
, peer
->ifp
, 0, 0);
2084 /* BGP has established connection with Zebra. */
2086 bgp_zebra_connected (struct zclient
*zclient
)
2090 /* At this point, we may or may not have BGP instances configured, but
2091 * we're only interested in the default VRF (others wouldn't have learnt
2092 * the VRF from Zebra yet.)
2094 bgp
= bgp_get_default();
2098 bgp_zebra_instance_register (bgp
);
2100 /* Send the client registration */
2101 bfd_client_sendmsg(zclient
, ZEBRA_BFD_CLIENT_REGISTER
);
2103 /* TODO - What if we have peers and networks configured, do we have to
2110 bgp_zebra_init (struct thread_master
*master
)
2112 /* Set default values. */
2113 zclient
= zclient_new (master
);
2114 zclient_init (zclient
, ZEBRA_ROUTE_BGP
, 0);
2115 zclient
->zebra_connected
= bgp_zebra_connected
;
2116 zclient
->router_id_update
= bgp_router_id_update
;
2117 zclient
->interface_add
= bgp_interface_add
;
2118 zclient
->interface_delete
= bgp_interface_delete
;
2119 zclient
->interface_address_add
= bgp_interface_address_add
;
2120 zclient
->interface_address_delete
= bgp_interface_address_delete
;
2121 zclient
->interface_nbr_address_add
= bgp_interface_nbr_address_add
;
2122 zclient
->interface_nbr_address_delete
= bgp_interface_nbr_address_delete
;
2123 zclient
->interface_vrf_update
= bgp_interface_vrf_update
;
2124 zclient
->redistribute_route_ipv4_add
= zebra_read_ipv4
;
2125 zclient
->redistribute_route_ipv4_del
= zebra_read_ipv4
;
2126 zclient
->interface_up
= bgp_interface_up
;
2127 zclient
->interface_down
= bgp_interface_down
;
2128 zclient
->redistribute_route_ipv6_add
= zebra_read_ipv6
;
2129 zclient
->redistribute_route_ipv6_del
= zebra_read_ipv6
;
2130 zclient
->nexthop_update
= bgp_read_nexthop_update
;
2131 zclient
->import_check_update
= bgp_read_import_check_update
;
2133 bgp_nexthop_buf
= stream_new(BGP_NEXTHOP_BUF_SIZE
);
2134 bgp_ifindices_buf
= stream_new(BGP_IFINDICES_BUF_SIZE
);
2138 bgp_zebra_destroy(void)
2140 if (zclient
== NULL
)
2142 zclient_stop(zclient
);
2143 zclient_free(zclient
);