// SPDX-License-Identifier: GPL-2.0-or-later /** * bgp_updgrp_packet.c: BGP update group packet handling routines * * @copyright Copyright (C) 2014 Cumulus Networks, Inc. * * @author Avneesh Sachdev * @author Rajesh Varadarajan * @author Pradosh Mohapatra */ #include #include "prefix.h" #include "frrevent.h" #include "buffer.h" #include "stream.h" #include "command.h" #include "sockunion.h" #include "network.h" #include "memory.h" #include "filter.h" #include "routemap.h" #include "log.h" #include "plist.h" #include "linklist.h" #include "workqueue.h" #include "hash.h" #include "queue.h" #include "mpls.h" #include "bgpd/bgpd.h" #include "bgpd/bgp_debug.h" #include "bgpd/bgp_errors.h" #include "bgpd/bgp_fsm.h" #include "bgpd/bgp_route.h" #include "bgpd/bgp_packet.h" #include "bgpd/bgp_advertise.h" #include "bgpd/bgp_updgrp.h" #include "bgpd/bgp_nexthop.h" #include "bgpd/bgp_nht.h" #include "bgpd/bgp_mplsvpn.h" #include "bgpd/bgp_label.h" #include "bgpd/bgp_addpath.h" /******************** * PRIVATE FUNCTIONS ********************/ /******************** * PUBLIC FUNCTIONS ********************/ struct bpacket *bpacket_alloc(void) { struct bpacket *pkt; pkt = XCALLOC(MTYPE_BGP_PACKET, sizeof(struct bpacket)); return pkt; } void bpacket_free(struct bpacket *pkt) { if (pkt->buffer) stream_free(pkt->buffer); pkt->buffer = NULL; XFREE(MTYPE_BGP_PACKET, pkt); } void bpacket_queue_init(struct bpacket_queue *q) { TAILQ_INIT(&(q->pkts)); } /* * bpacket_queue_add_packet * * Internal function of bpacket_queue - and adds a * packet entry to the end of the list. * * Users of bpacket_queue should use bpacket_queue_add instead. */ static void bpacket_queue_add_packet(struct bpacket_queue *q, struct bpacket *pkt) { struct bpacket *last_pkt; if (TAILQ_EMPTY(&(q->pkts))) TAILQ_INSERT_TAIL(&(q->pkts), pkt, pkt_train); else { last_pkt = bpacket_queue_last(q); TAILQ_INSERT_AFTER(&(q->pkts), last_pkt, pkt, pkt_train); } q->curr_count++; if (q->hwm_count < q->curr_count) q->hwm_count = q->curr_count; } /* * Adds a packet to the bpacket_queue. * * The stream passed is consumed by this function. So, the caller should * not free or use the stream after * invoking this function. */ struct bpacket *bpacket_queue_add(struct bpacket_queue *q, struct stream *s, struct bpacket_attr_vec_arr *vecarrp) { struct bpacket *pkt; struct bpacket *last_pkt; pkt = bpacket_alloc(); if (TAILQ_EMPTY(&(q->pkts))) { pkt->ver = 1; pkt->buffer = s; if (vecarrp) memcpy(&pkt->arr, vecarrp, sizeof(struct bpacket_attr_vec_arr)); else bpacket_attr_vec_arr_reset(&pkt->arr); bpacket_queue_add_packet(q, pkt); return pkt; } /* * Fill in the new information into the current sentinel and create a * new sentinel. */ last_pkt = bpacket_queue_last(q); assert(last_pkt->buffer == NULL); last_pkt->buffer = s; if (vecarrp) memcpy(&last_pkt->arr, vecarrp, sizeof(struct bpacket_attr_vec_arr)); else bpacket_attr_vec_arr_reset(&last_pkt->arr); pkt->ver = last_pkt->ver; pkt->ver++; bpacket_queue_add_packet(q, pkt); return last_pkt; } struct bpacket *bpacket_queue_first(struct bpacket_queue *q) { return (TAILQ_FIRST(&(q->pkts))); } struct bpacket *bpacket_queue_last(struct bpacket_queue *q) { return TAILQ_LAST(&(q->pkts), pkt_queue); } struct bpacket *bpacket_queue_remove(struct bpacket_queue *q) { struct bpacket *first; first = bpacket_queue_first(q); if (first) { TAILQ_REMOVE(&(q->pkts), first, pkt_train); q->curr_count--; } return first; } unsigned int bpacket_queue_length(struct bpacket_queue *q) { return q->curr_count - 1; } unsigned int bpacket_queue_hwm_length(struct bpacket_queue *q) { return q->hwm_count - 1; } bool bpacket_queue_is_full(struct bgp *bgp, struct bpacket_queue *q) { if (q->curr_count >= bgp->default_subgroup_pkt_queue_max) return true; return false; } void bpacket_add_peer(struct bpacket *pkt, struct peer_af *paf) { if (!pkt || !paf) return; LIST_INSERT_HEAD(&(pkt->peers), paf, pkt_train); paf->next_pkt_to_send = pkt; } /* * bpacket_queue_cleanup */ void bpacket_queue_cleanup(struct bpacket_queue *q) { struct bpacket *pkt; while ((pkt = bpacket_queue_remove(q))) { bpacket_free(pkt); } } /* * bpacket_queue_compact * * Delete packets that do not need to be transmitted to any peer from * the queue. * * @return the number of packets deleted. */ static int bpacket_queue_compact(struct bpacket_queue *q) { int num_deleted; struct bpacket *pkt, *removed_pkt; num_deleted = 0; while (1) { pkt = bpacket_queue_first(q); if (!pkt) break; /* * Don't delete the sentinel. */ if (!pkt->buffer) break; if (!LIST_EMPTY(&(pkt->peers))) break; removed_pkt = bpacket_queue_remove(q); assert(pkt == removed_pkt); bpacket_free(removed_pkt); num_deleted++; } return num_deleted; } void bpacket_queue_advance_peer(struct peer_af *paf) { struct bpacket *pkt; struct bpacket *old_pkt; old_pkt = paf->next_pkt_to_send; if (old_pkt->buffer == NULL) /* Already at end of list */ return; LIST_REMOVE(paf, pkt_train); pkt = TAILQ_NEXT(old_pkt, pkt_train); bpacket_add_peer(pkt, paf); if (!bpacket_queue_compact(PAF_PKTQ(paf))) return; /* * Deleted one or more packets. Check if we can now merge this * peer's subgroup into another subgroup. */ update_subgroup_check_merge(paf->subgroup, "advanced peer in queue"); } /* * bpacket_queue_remove_peer * * Remove the peer from the packet queue of the subgroup it belongs * to. */ void bpacket_queue_remove_peer(struct peer_af *paf) { struct bpacket_queue *q; q = PAF_PKTQ(paf); assert(q); LIST_REMOVE(paf, pkt_train); paf->next_pkt_to_send = NULL; bpacket_queue_compact(q); } unsigned int bpacket_queue_virtual_length(struct peer_af *paf) { struct bpacket *pkt; struct bpacket *last; struct bpacket_queue *q; pkt = paf->next_pkt_to_send; if (!pkt || (pkt->buffer == NULL)) /* Already at end of list */ return 0; q = PAF_PKTQ(paf); if (TAILQ_EMPTY(&(q->pkts))) return 0; last = TAILQ_LAST(&(q->pkts), pkt_queue); if (last->ver >= pkt->ver) return last->ver - pkt->ver; /* sequence # rolled over */ return (UINT_MAX - pkt->ver + 1) + last->ver; } /* * Dump the bpacket queue */ void bpacket_queue_show_vty(struct bpacket_queue *q, struct vty *vty) { struct bpacket *pkt; struct peer_af *paf; pkt = bpacket_queue_first(q); while (pkt) { vty_out(vty, " Packet %p ver %u buffer %p\n", pkt, pkt->ver, pkt->buffer); LIST_FOREACH (paf, &(pkt->peers), pkt_train) { vty_out(vty, " - %s\n", paf->peer->host); } pkt = bpacket_next(pkt); } return; } struct stream *bpacket_reformat_for_peer(struct bpacket *pkt, struct peer_af *paf) { struct stream *s = NULL; bpacket_attr_vec *vec; struct peer *peer; struct bgp_filter *filter; s = stream_dup(pkt->buffer); peer = PAF_PEER(paf); vec = &pkt->arr.entries[BGP_ATTR_VEC_NH]; if (!CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_UPDATED)) return s; uint8_t nhlen; afi_t nhafi; int route_map_sets_nh; nhlen = stream_getc_from(s, vec->offset); filter = &peer->filter[paf->afi][paf->safi]; if (peer_cap_enhe(peer, paf->afi, paf->safi)) nhafi = AFI_IP6; else nhafi = BGP_NEXTHOP_AFI_FROM_NHLEN(nhlen); if (nhafi == AFI_IP) { struct in_addr v4nh, *mod_v4nh; int nh_modified = 0; size_t offset_nh = vec->offset + 1; route_map_sets_nh = (CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_IPV4_NH_CHANGED) || CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_VPNV4_NH_CHANGED) || CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS)); switch (nhlen) { case BGP_ATTR_NHLEN_IPV4: break; case BGP_ATTR_NHLEN_VPNV4: offset_nh += 8; break; default: /* TODO: handle IPv6 nexthops */ flog_warn( EC_BGP_INVALID_NEXTHOP_LENGTH, "%s: %s: invalid MP nexthop length (AFI IP): %u", __func__, peer->host, nhlen); stream_free(s); return NULL; } stream_get_from(&v4nh, s, offset_nh, IPV4_MAX_BYTELEN); mod_v4nh = &v4nh; /* * If route-map has set the nexthop, that is normally * used; if it is specified as peer-address, the peering * address is picked up. Otherwise, if NH is unavailable * from attribute, the peering addr is picked up; the * "NH unavailable" case also covers next-hop-self and * some other scenarios - see subgroup_announce_check(). * In all other cases, use the nexthop carried in the * attribute unless it is EBGP non-multiaccess and there * is no next-hop-unchanged setting or the peer is EBGP * and the route-map that changed the next-hop value * was applied inbound rather than outbound. Updates to * an EBGP peer should only modify the next-hop if it * was set in an outbound route-map to that peer. * Note: It is assumed route-map cannot set the nexthop * to an invalid value. */ if (route_map_sets_nh && ((peer->sort != BGP_PEER_EBGP) || ROUTE_MAP_OUT(filter))) { if (CHECK_FLAG( vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS)) { mod_v4nh = &peer->nexthop.v4; nh_modified = 1; } } else if (v4nh.s_addr == INADDR_ANY) { mod_v4nh = &peer->nexthop.v4; nh_modified = 1; } else if (peer->sort == BGP_PEER_EBGP && (bgp_multiaccess_check_v4(v4nh, peer) == 0) && !CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_NH_UNCHANGED) && !peer_af_flag_check( peer, paf->afi, paf->safi, PEER_FLAG_NEXTHOP_UNCHANGED)) { /* NOTE: not handling case where NH has new AFI */ mod_v4nh = &peer->nexthop.v4; nh_modified = 1; } if (nh_modified) /* allow for VPN RD */ stream_put_in_addr_at(s, offset_nh, mod_v4nh); if (bgp_debug_update(peer, NULL, NULL, 0)) zlog_debug("u%" PRIu64 ":s%" PRIu64 " %s send UPDATE w/ nexthop %pI4%s", PAF_SUBGRP(paf)->update_group->id, PAF_SUBGRP(paf)->id, peer->host, mod_v4nh, (nhlen == BGP_ATTR_NHLEN_VPNV4 ? " and RD" : "")); } else if (nhafi == AFI_IP6) { struct in6_addr v6nhglobal, *mod_v6nhg; struct in6_addr v6nhlocal, *mod_v6nhl; int gnh_modified, lnh_modified; size_t offset_nhglobal = vec->offset + 1; size_t offset_nhlocal = vec->offset + 1; gnh_modified = lnh_modified = 0; mod_v6nhg = &v6nhglobal; mod_v6nhl = &v6nhlocal; route_map_sets_nh = (CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_IPV6_GNH_CHANGED) || CHECK_FLAG( vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_VPNV6_GNH_CHANGED) || CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS)); /* * The logic here is rather similar to that for IPv4, the * additional work being to handle 1 or 2 nexthops. * Also, 3rd party nexthop is not propagated for EBGP * right now. */ switch (nhlen) { case BGP_ATTR_NHLEN_IPV6_GLOBAL: break; case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL: offset_nhlocal += IPV6_MAX_BYTELEN; break; case BGP_ATTR_NHLEN_VPNV6_GLOBAL: offset_nhglobal += 8; break; case BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL: offset_nhglobal += 8; offset_nhlocal += 8 * 2 + IPV6_MAX_BYTELEN; break; default: /* TODO: handle IPv4 nexthops */ flog_warn( EC_BGP_INVALID_NEXTHOP_LENGTH, "%s: %s: invalid MP nexthop length (AFI IP6): %u", __func__, peer->host, nhlen); stream_free(s); return NULL; } stream_get_from(&v6nhglobal, s, offset_nhglobal, IPV6_MAX_BYTELEN); /* * Updates to an EBGP peer should only modify the * next-hop if it was set in an outbound route-map * to that peer. */ if (route_map_sets_nh && ((peer->sort != BGP_PEER_EBGP) || ROUTE_MAP_OUT(filter))) { if (CHECK_FLAG( vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS)) { mod_v6nhg = &peer->nexthop.v6_global; gnh_modified = 1; } } else if (IN6_IS_ADDR_UNSPECIFIED(&v6nhglobal)) { mod_v6nhg = &peer->nexthop.v6_global; gnh_modified = 1; } else if ((peer->sort == BGP_PEER_EBGP) && (!bgp_multiaccess_check_v6(v6nhglobal, peer)) && !CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_RMAP_NH_UNCHANGED) && !peer_af_flag_check( peer, paf->afi, paf->safi, PEER_FLAG_NEXTHOP_UNCHANGED)) { /* NOTE: not handling case where NH has new AFI */ mod_v6nhg = &peer->nexthop.v6_global; gnh_modified = 1; } if (IN6_IS_ADDR_UNSPECIFIED(mod_v6nhg)) { if (peer->nexthop.v4.s_addr != INADDR_ANY) { ipv4_to_ipv4_mapped_ipv6(mod_v6nhg, peer->nexthop.v4); } } if (IS_MAPPED_IPV6(&peer->nexthop.v6_global)) { mod_v6nhg = &peer->nexthop.v6_global; gnh_modified = 1; } if (nhlen == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL || nhlen == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL) { stream_get_from(&v6nhlocal, s, offset_nhlocal, IPV6_MAX_BYTELEN); if (IN6_IS_ADDR_UNSPECIFIED(&v6nhlocal)) { mod_v6nhl = &peer->nexthop.v6_local; lnh_modified = 1; } } if (gnh_modified) stream_put_in6_addr_at(s, offset_nhglobal, mod_v6nhg); if (lnh_modified) stream_put_in6_addr_at(s, offset_nhlocal, mod_v6nhl); if (bgp_debug_update(peer, NULL, NULL, 0)) { if (nhlen == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL || nhlen == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL) zlog_debug( "u%" PRIu64 ":s%" PRIu64 " %s send UPDATE w/ mp_nexthops %pI6, %pI6%s", PAF_SUBGRP(paf)->update_group->id, PAF_SUBGRP(paf)->id, peer->host, mod_v6nhg, mod_v6nhl, (nhlen == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL ? " and RD" : "")); else zlog_debug( "u%" PRIu64 ":s%" PRIu64 " %s send UPDATE w/ mp_nexthop %pI6%s", PAF_SUBGRP(paf)->update_group->id, PAF_SUBGRP(paf)->id, peer->host, mod_v6nhg, (nhlen == BGP_ATTR_NHLEN_VPNV6_GLOBAL ? " and RD" : "")); } } else if (paf->afi == AFI_L2VPN) { struct in_addr v4nh, *mod_v4nh; int nh_modified = 0; stream_get_from(&v4nh, s, vec->offset + 1, 4); mod_v4nh = &v4nh; /* No route-map changes allowed for EVPN nexthops. */ if (v4nh.s_addr == INADDR_ANY) { mod_v4nh = &peer->nexthop.v4; nh_modified = 1; } if (nh_modified) stream_put_in_addr_at(s, vec->offset + 1, mod_v4nh); if (bgp_debug_update(peer, NULL, NULL, 0)) zlog_debug("u%" PRIu64 ":s%" PRIu64 " %s send UPDATE w/ nexthop %pI4", PAF_SUBGRP(paf)->update_group->id, PAF_SUBGRP(paf)->id, peer->host, mod_v4nh); } return s; } /* * Update the vecarr offsets to go beyond 'pos' bytes, i.e. add 'pos' * to each offset. */ static void bpacket_attr_vec_arr_update(struct bpacket_attr_vec_arr *vecarr, size_t pos) { int i; if (!vecarr) return; for (i = 0; i < BGP_ATTR_VEC_MAX; i++) vecarr->entries[i].offset += pos; } /* * Return if there are packets to build for this subgroup. */ bool subgroup_packets_to_build(struct update_subgroup *subgrp) { struct bgp_advertise *adv; if (!subgrp) return false; adv = bgp_adv_fifo_first(&subgrp->sync->withdraw); if (adv) return true; adv = bgp_adv_fifo_first(&subgrp->sync->update); if (adv) return true; return false; } /* Make BGP update packet. */ struct bpacket *subgroup_update_packet(struct update_subgroup *subgrp) { struct bpacket_attr_vec_arr vecarr; struct bpacket *pkt; struct peer *peer; struct stream *s; struct stream *snlri; struct stream *packet; struct bgp_adj_out *adj; struct bgp_advertise *adv; struct bgp_dest *dest = NULL; struct bgp_path_info *path = NULL; bgp_size_t total_attr_len = 0; unsigned long attrlen_pos = 0; size_t mpattrlen_pos = 0; size_t mpattr_pos = 0; afi_t afi; safi_t safi; int space_remaining = 0; int space_needed = 0; char send_attr_str[BUFSIZ]; int send_attr_printed = 0; int num_pfx = 0; bool addpath_capable = false; int addpath_overhead = 0; uint32_t addpath_tx_id = 0; struct prefix_rd *prd = NULL; mpls_label_t label = MPLS_INVALID_LABEL, *label_pnt = NULL; uint32_t num_labels = 0; if (!subgrp) return NULL; if (bpacket_queue_is_full(SUBGRP_INST(subgrp), SUBGRP_PKTQ(subgrp))) return NULL; peer = SUBGRP_PEER(subgrp); afi = SUBGRP_AFI(subgrp); safi = SUBGRP_SAFI(subgrp); s = subgrp->work; stream_reset(s); snlri = subgrp->scratch; stream_reset(snlri); bpacket_attr_vec_arr_reset(&vecarr); addpath_capable = bgp_addpath_encode_tx(peer, afi, safi); addpath_overhead = addpath_capable ? BGP_ADDPATH_ID_LEN : 0; adv = bgp_adv_fifo_first(&subgrp->sync->update); while (adv) { const struct prefix *dest_p; assert(adv->dest); dest = adv->dest; dest_p = bgp_dest_get_prefix(dest); adj = adv->adj; addpath_tx_id = adj->addpath_tx_id; path = adv->pathi; space_remaining = STREAM_CONCAT_REMAIN(s, snlri, STREAM_SIZE(s)) - BGP_MAX_PACKET_SIZE_OVERFLOW; space_needed = BGP_NLRI_LENGTH + addpath_overhead + bgp_packet_mpattr_prefix_size(afi, safi, dest_p); /* When remaining space can't include NLRI and it's length. */ if (space_remaining < space_needed) break; /* If packet is empty, set attribute. */ if (stream_empty(s)) { struct peer *from = NULL; if (path) from = path->peer; /* 1: Write the BGP message header - 16 bytes marker, 2 * bytes length, * one byte message type. */ bgp_packet_set_marker(s, BGP_MSG_UPDATE); /* 2: withdrawn routes length */ stream_putw(s, 0); /* 3: total attributes length - attrlen_pos stores the * position */ attrlen_pos = stream_get_endp(s); stream_putw(s, 0); /* 4: if there is MP_REACH_NLRI attribute, that should * be the first * attribute, according to * draft-ietf-idr-error-handling. Save the * position. */ mpattr_pos = stream_get_endp(s); /* 5: Encode all the attributes, except MP_REACH_NLRI * attr. */ total_attr_len = bgp_packet_attribute( NULL, peer, s, adv->baa->attr, &vecarr, NULL, afi, safi, from, NULL, NULL, 0, 0, 0, path); space_remaining = STREAM_CONCAT_REMAIN(s, snlri, STREAM_SIZE(s)) - BGP_MAX_PACKET_SIZE_OVERFLOW; space_needed = BGP_NLRI_LENGTH + addpath_overhead + bgp_packet_mpattr_prefix_size( afi, safi, dest_p); /* If the attributes alone do not leave any room for * NLRI then * return */ if (space_remaining < space_needed) { flog_err( EC_BGP_UPDGRP_ATTR_LEN, "u%" PRIu64 ":s%" PRIu64" attributes too long, cannot send UPDATE", subgrp->update_group->id, subgrp->id); /* Flush the FIFO update queue */ while (adv) adv = bgp_advertise_clean_subgroup( subgrp, adj); return NULL; } if (BGP_DEBUG(update, UPDATE_OUT) || BGP_DEBUG(update, UPDATE_PREFIX)) { memset(send_attr_str, 0, BUFSIZ); send_attr_printed = 0; bgp_dump_attr(adv->baa->attr, send_attr_str, sizeof(send_attr_str)); } } if ((afi == AFI_IP && safi == SAFI_UNICAST) && !peer_cap_enhe(peer, afi, safi)) stream_put_prefix_addpath(s, dest_p, addpath_capable, addpath_tx_id); else { /* Encode the prefix in MP_REACH_NLRI attribute */ if (dest->pdest) prd = (struct prefix_rd *)bgp_dest_get_prefix( dest->pdest); if (safi == SAFI_LABELED_UNICAST) { label = bgp_adv_label(dest, path, peer, afi, safi); label_pnt = &label; num_labels = 1; } else if (path && path->extra) { label_pnt = &path->extra->label[0]; num_labels = path->extra->num_labels; } if (stream_empty(snlri)) mpattrlen_pos = bgp_packet_mpattr_start( snlri, peer, afi, safi, &vecarr, adv->baa->attr); bgp_packet_mpattr_prefix(snlri, afi, safi, dest_p, prd, label_pnt, num_labels, addpath_capable, addpath_tx_id, adv->baa->attr); } num_pfx++; if (bgp_debug_update(NULL, dest_p, subgrp->update_group, 0)) { char pfx_buf[BGP_PRD_PATH_STRLEN]; if (!send_attr_printed) { zlog_debug("u%" PRIu64 ":s%" PRIu64" send UPDATE w/ attr: %s", subgrp->update_group->id, subgrp->id, send_attr_str); if (!stream_empty(snlri)) { iana_afi_t pkt_afi; iana_safi_t pkt_safi; pkt_afi = afi_int2iana(afi); pkt_safi = safi_int2iana(safi); zlog_debug( "u%" PRIu64 ":s%" PRIu64 " send MP_REACH for afi/safi %s/%s", subgrp->update_group->id, subgrp->id, iana_afi2str(pkt_afi), iana_safi2str(pkt_safi)); } send_attr_printed = 1; } bgp_debug_rdpfxpath2str(afi, safi, prd, dest_p, label_pnt, num_labels, addpath_capable, addpath_tx_id, &adv->baa->attr->evpn_overlay, pfx_buf, sizeof(pfx_buf)); zlog_debug("u%" PRIu64 ":s%" PRIu64 " send UPDATE %s", subgrp->update_group->id, subgrp->id, pfx_buf); } /* Synchnorize attribute. */ if (adj->attr) bgp_attr_unintern(&adj->attr); else subgrp->scount++; adj->attr = bgp_attr_intern(adv->baa->attr); adv = bgp_advertise_clean_subgroup(subgrp, adj); } if (!stream_empty(s)) { if (!stream_empty(snlri)) { bgp_packet_mpattr_end(snlri, mpattrlen_pos); total_attr_len += stream_get_endp(snlri); } /* set the total attribute length correctly */ stream_putw_at(s, attrlen_pos, total_attr_len); if (!stream_empty(snlri)) { packet = stream_dupcat(s, snlri, mpattr_pos); bpacket_attr_vec_arr_update(&vecarr, mpattr_pos); } else packet = stream_dup(s); bgp_packet_set_size(packet); if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0)) zlog_debug( "u%" PRIu64 ":s%" PRIu64 " send UPDATE len %zd (max message len: %hu) numpfx %d", subgrp->update_group->id, subgrp->id, (stream_get_endp(packet) - stream_get_getp(packet)), peer->max_packet_size, num_pfx); pkt = bpacket_queue_add(SUBGRP_PKTQ(subgrp), packet, &vecarr); stream_reset(s); stream_reset(snlri); return pkt; } return NULL; } /* Make BGP withdraw packet. */ /* For ipv4 unicast: 16-octet marker | 2-octet length | 1-octet type | 2-octet withdrawn route length | withdrawn prefixes | 2-octet attrlen (=0) */ /* For other afi/safis: 16-octet marker | 2-octet length | 1-octet type | 2-octet withdrawn route length (=0) | 2-octet attrlen | mp_unreach attr type | attr len | afi | safi | withdrawn prefixes */ struct bpacket *subgroup_withdraw_packet(struct update_subgroup *subgrp) { struct bpacket *pkt; struct stream *s; struct bgp_adj_out *adj; struct bgp_advertise *adv; struct peer *peer; struct bgp_dest *dest; bgp_size_t unfeasible_len; bgp_size_t total_attr_len; size_t mp_start = 0; size_t attrlen_pos = 0; size_t mplen_pos = 0; uint8_t first_time = 1; afi_t afi; safi_t safi; int space_remaining = 0; int space_needed = 0; int num_pfx = 0; bool addpath_capable = false; int addpath_overhead = 0; uint32_t addpath_tx_id = 0; const struct prefix_rd *prd = NULL; if (!subgrp) return NULL; if (bpacket_queue_is_full(SUBGRP_INST(subgrp), SUBGRP_PKTQ(subgrp))) return NULL; peer = SUBGRP_PEER(subgrp); afi = SUBGRP_AFI(subgrp); safi = SUBGRP_SAFI(subgrp); s = subgrp->work; stream_reset(s); addpath_capable = bgp_addpath_encode_tx(peer, afi, safi); addpath_overhead = addpath_capable ? BGP_ADDPATH_ID_LEN : 0; while ((adv = bgp_adv_fifo_first(&subgrp->sync->withdraw)) != NULL) { const struct prefix *dest_p; assert(adv->dest); adj = adv->adj; dest = adv->dest; dest_p = bgp_dest_get_prefix(dest); addpath_tx_id = adj->addpath_tx_id; space_remaining = STREAM_WRITEABLE(s) - BGP_MAX_PACKET_SIZE_OVERFLOW; space_needed = BGP_NLRI_LENGTH + addpath_overhead + BGP_TOTAL_ATTR_LEN + bgp_packet_mpattr_prefix_size(afi, safi, dest_p); if (space_remaining < space_needed) break; if (stream_empty(s)) { bgp_packet_set_marker(s, BGP_MSG_UPDATE); stream_putw(s, 0); /* unfeasible routes length */ } else first_time = 0; if (afi == AFI_IP && safi == SAFI_UNICAST && !peer_cap_enhe(peer, afi, safi)) stream_put_prefix_addpath(s, dest_p, addpath_capable, addpath_tx_id); else { if (dest->pdest) prd = (struct prefix_rd *)bgp_dest_get_prefix( dest->pdest); /* If first time, format the MP_UNREACH header */ if (first_time) { iana_afi_t pkt_afi; iana_safi_t pkt_safi; pkt_afi = afi_int2iana(afi); pkt_safi = safi_int2iana(safi); attrlen_pos = stream_get_endp(s); /* total attr length = 0 for now. * reevaluate later */ stream_putw(s, 0); mp_start = stream_get_endp(s); mplen_pos = bgp_packet_mpunreach_start(s, afi, safi); if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0)) zlog_debug( "u%" PRIu64 ":s%" PRIu64 " send MP_UNREACH for afi/safi %s/%s", subgrp->update_group->id, subgrp->id, iana_afi2str(pkt_afi), iana_safi2str(pkt_safi)); } bgp_packet_mpunreach_prefix(s, dest_p, afi, safi, prd, NULL, 0, addpath_capable, addpath_tx_id, NULL); } num_pfx++; if (bgp_debug_update(NULL, dest_p, subgrp->update_group, 0)) { char pfx_buf[BGP_PRD_PATH_STRLEN]; bgp_debug_rdpfxpath2str(afi, safi, prd, dest_p, NULL, 0, addpath_capable, addpath_tx_id, NULL, pfx_buf, sizeof(pfx_buf)); zlog_debug("u%" PRIu64 ":s%" PRIu64" send UPDATE %s -- unreachable", subgrp->update_group->id, subgrp->id, pfx_buf); } subgrp->scount--; bgp_adj_out_remove_subgroup(dest, adj, subgrp); } if (!stream_empty(s)) { if (afi == AFI_IP && safi == SAFI_UNICAST && !peer_cap_enhe(peer, afi, safi)) { unfeasible_len = stream_get_endp(s) - BGP_HEADER_SIZE - BGP_UNFEASIBLE_LEN; stream_putw_at(s, BGP_HEADER_SIZE, unfeasible_len); stream_putw(s, 0); } else { /* Set the mp_unreach attr's length */ bgp_packet_mpunreach_end(s, mplen_pos); /* Set total path attribute length. */ total_attr_len = stream_get_endp(s) - mp_start; stream_putw_at(s, attrlen_pos, total_attr_len); } bgp_packet_set_size(s); if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0)) zlog_debug("u%" PRIu64 ":s%" PRIu64" send UPDATE (withdraw) len %zd numpfx %d", subgrp->update_group->id, subgrp->id, (stream_get_endp(s) - stream_get_getp(s)), num_pfx); pkt = bpacket_queue_add(SUBGRP_PKTQ(subgrp), stream_dup(s), NULL); stream_reset(s); return pkt; } return NULL; } void subgroup_default_update_packet(struct update_subgroup *subgrp, struct attr *attr, struct peer *from) { struct stream *s; struct peer *peer; struct prefix p; unsigned long pos; bgp_size_t total_attr_len; afi_t afi; safi_t safi; struct bpacket_attr_vec_arr vecarr; bool addpath_capable = false; uint8_t default_originate_label[4] = {0x80, 0x00, 0x00}; mpls_label_t *label = NULL; uint32_t num_labels = 0; if (DISABLE_BGP_ANNOUNCE) return; if (!subgrp) return; peer = SUBGRP_PEER(subgrp); afi = SUBGRP_AFI(subgrp); safi = SUBGRP_SAFI(subgrp); bpacket_attr_vec_arr_reset(&vecarr); addpath_capable = bgp_addpath_encode_tx(peer, afi, safi); if (safi == SAFI_LABELED_UNICAST) { label = (mpls_label_t *)default_originate_label; num_labels = 1; } memset(&p, 0, sizeof(p)); p.family = afi2family(afi); p.prefixlen = 0; /* Logging the attribute. */ if (bgp_debug_update(NULL, &p, subgrp->update_group, 0)) { char attrstr[BUFSIZ]; /* ' with addpath ID ' 17 * max strlen of uint32 + 10 * +/- (just in case) + 1 * null terminator + 1 * ============================ 29 */ char tx_id_buf[30]; attrstr[0] = '\0'; bgp_dump_attr(attr, attrstr, sizeof(attrstr)); if (addpath_capable) snprintf(tx_id_buf, sizeof(tx_id_buf), " with addpath ID %u", BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE); else tx_id_buf[0] = '\0'; zlog_debug("u%" PRIu64 ":s%" PRIu64 " send UPDATE %pFX%s %s", (SUBGRP_UPDGRP(subgrp))->id, subgrp->id, &p, tx_id_buf, attrstr); } s = stream_new(peer->max_packet_size); /* Make BGP update packet. */ bgp_packet_set_marker(s, BGP_MSG_UPDATE); /* Unfeasible Routes Length. */ stream_putw(s, 0); /* Make place for total attribute length. */ pos = stream_get_endp(s); stream_putw(s, 0); total_attr_len = bgp_packet_attribute( NULL, peer, s, attr, &vecarr, &p, afi, safi, from, NULL, label, num_labels, addpath_capable, BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE, NULL); /* Set Total Path Attribute Length. */ stream_putw_at(s, pos, total_attr_len); /* NLRI set. */ if (p.family == AF_INET && safi == SAFI_UNICAST && !peer_cap_enhe(peer, afi, safi)) stream_put_prefix_addpath( s, &p, addpath_capable, BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE); /* Set size. */ bgp_packet_set_size(s); (void)bpacket_queue_add(SUBGRP_PKTQ(subgrp), s, &vecarr); subgroup_trigger_write(subgrp); if (!CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_PEER_DEFAULT_ORIGINATED)) { subgrp->scount++; SET_FLAG(subgrp->sflags, SUBGRP_STATUS_PEER_DEFAULT_ORIGINATED); } } void subgroup_default_withdraw_packet(struct update_subgroup *subgrp) { struct peer *peer; struct stream *s; struct prefix p; unsigned long attrlen_pos = 0; unsigned long cp; bgp_size_t unfeasible_len; bgp_size_t total_attr_len = 0; size_t mp_start = 0; size_t mplen_pos = 0; afi_t afi; safi_t safi; bool addpath_capable = false; if (DISABLE_BGP_ANNOUNCE) return; peer = SUBGRP_PEER(subgrp); afi = SUBGRP_AFI(subgrp); safi = SUBGRP_SAFI(subgrp); addpath_capable = bgp_addpath_encode_tx(peer, afi, safi); memset(&p, 0, sizeof(p)); p.family = afi2family(afi); p.prefixlen = 0; if (bgp_debug_update(NULL, &p, subgrp->update_group, 0)) { /* ' with addpath ID ' 17 * max strlen of uint32 + 10 * +/- (just in case) + 1 * null terminator + 1 * ============================ 29 */ char tx_id_buf[30]; if (addpath_capable) snprintf(tx_id_buf, sizeof(tx_id_buf), " with addpath ID %u", BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE); zlog_debug("u%" PRIu64 ":s%" PRIu64 " send UPDATE %pFX%s -- unreachable", (SUBGRP_UPDGRP(subgrp))->id, subgrp->id, &p, tx_id_buf); } s = stream_new(peer->max_packet_size); /* Make BGP update packet. */ bgp_packet_set_marker(s, BGP_MSG_UPDATE); /* Unfeasible Routes Length. */; cp = stream_get_endp(s); stream_putw(s, 0); /* Withdrawn Routes. */ if (p.family == AF_INET && safi == SAFI_UNICAST && !peer_cap_enhe(peer, afi, safi)) { stream_put_prefix_addpath( s, &p, addpath_capable, BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE); unfeasible_len = stream_get_endp(s) - cp - 2; /* Set unfeasible len. */ stream_putw_at(s, cp, unfeasible_len); /* Set total path attribute length. */ stream_putw(s, 0); } else { attrlen_pos = stream_get_endp(s); stream_putw(s, 0); mp_start = stream_get_endp(s); mplen_pos = bgp_packet_mpunreach_start(s, afi, safi); bgp_packet_mpunreach_prefix( s, &p, afi, safi, NULL, NULL, 0, addpath_capable, BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE, NULL); /* Set the mp_unreach attr's length */ bgp_packet_mpunreach_end(s, mplen_pos); /* Set total path attribute length. */ total_attr_len = stream_get_endp(s) - mp_start; stream_putw_at(s, attrlen_pos, total_attr_len); } bgp_packet_set_size(s); (void)bpacket_queue_add(SUBGRP_PKTQ(subgrp), s, NULL); subgroup_trigger_write(subgrp); if (CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_PEER_DEFAULT_ORIGINATED)) { subgrp->scount--; UNSET_FLAG(subgrp->sflags, SUBGRP_STATUS_PEER_DEFAULT_ORIGINATED); } } static void bpacket_vec_arr_inherit_attr_flags(struct bpacket_attr_vec_arr *vecarr, enum bpacket_attr_vec_type type, struct attr *attr) { if (CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_NEXTHOP_PEER_ADDRESS)) SET_FLAG(vecarr->entries[BGP_ATTR_VEC_NH].flags, BPKT_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS); if (CHECK_FLAG(attr->rmap_change_flags, BATTR_REFLECTED)) SET_FLAG(vecarr->entries[BGP_ATTR_VEC_NH].flags, BPKT_ATTRVEC_FLAGS_REFLECTED); if (CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_NEXTHOP_UNCHANGED)) SET_FLAG(vecarr->entries[BGP_ATTR_VEC_NH].flags, BPKT_ATTRVEC_FLAGS_RMAP_NH_UNCHANGED); if (CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_IPV4_NHOP_CHANGED)) SET_FLAG(vecarr->entries[BGP_ATTR_VEC_NH].flags, BPKT_ATTRVEC_FLAGS_RMAP_IPV4_NH_CHANGED); if (CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_IPV6_GLOBAL_NHOP_CHANGED)) SET_FLAG(vecarr->entries[BGP_ATTR_VEC_NH].flags, BPKT_ATTRVEC_FLAGS_RMAP_IPV6_GNH_CHANGED); if (CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_VPNV4_NHOP_CHANGED)) SET_FLAG(vecarr->entries[BGP_ATTR_VEC_NH].flags, BPKT_ATTRVEC_FLAGS_RMAP_VPNV4_NH_CHANGED); if (CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_VPNV6_GLOBAL_NHOP_CHANGED)) SET_FLAG(vecarr->entries[BGP_ATTR_VEC_NH].flags, BPKT_ATTRVEC_FLAGS_RMAP_VPNV6_GNH_CHANGED); if (CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_IPV6_LL_NHOP_CHANGED)) SET_FLAG(vecarr->entries[BGP_ATTR_VEC_NH].flags, BPKT_ATTRVEC_FLAGS_RMAP_IPV6_LNH_CHANGED); } /* Reset the Attributes vector array. The vector array is used to override * certain output parameters in the packet for a particular peer */ void bpacket_attr_vec_arr_reset(struct bpacket_attr_vec_arr *vecarr) { int i; if (!vecarr) return; i = 0; while (i < BGP_ATTR_VEC_MAX) { vecarr->entries[i].flags = 0; vecarr->entries[i].offset = 0; i++; } } /* Setup a particular node entry in the vecarr */ void bpacket_attr_vec_arr_set_vec(struct bpacket_attr_vec_arr *vecarr, enum bpacket_attr_vec_type type, struct stream *s, struct attr *attr) { if (!vecarr) return; assert(type < BGP_ATTR_VEC_MAX); SET_FLAG(vecarr->entries[type].flags, BPKT_ATTRVEC_FLAGS_UPDATED); vecarr->entries[type].offset = stream_get_endp(s); if (attr) bpacket_vec_arr_inherit_attr_flags(vecarr, type, attr); }