1414codeforge
/
ubgpsuite
mirror of https://codeberg.org/1414codeforge/ubgpsuite.git
1
0
Fork 0
Code Packages Projects Releases Activity
ubgpsuite/lonetix/include/df/bgp/mrt.h

889 lines
24 KiB
C
Executable File
Raw Blame History

// SPDX-License-Identifier: LGPL-3.0-or-later
/**
* \file bgp/mrt.h
*
* Multithreaded Routing Toolkit (MRT) types and functions.
*
* \copyright The DoubleFourteen Code Forge (C) All Rights Reserved
* \author Lorenzo Cogotti
*/
#ifndef DF_BGP_MRT_H_
#define DF_BGP_MRT_H_
#include "bgp/bgp.h"
#include "stm.h"
/**
* \name MRT record types
*
* \note Values are in network order (big endian)
*
* @{
*/
#define MRT_NULL BE16(0) // Deprecated
#define MRT_START BE16(1) // Deprecated
#define MRT_DIE BE16(2) // Deprecated
#define MRT_I_AM_DEAD BE16(3) // Deprecated
#define MRT_PEER_DOWN BE16(4) // Deprecated
#define MRT_BGP BE16(5) // Deprecated, also known as ZEBRA_BGP
#define MRT_RIP BE16(6) // Deprecated
#define MRT_IDRP BE16(7) // Deprecated
#define MRT_RIPNG BE16(8) // Deprecated
#define MRT_BGP4PLUS BE16(9) // Deprecated
#define MRT_BGP4PLUS_01 BE16(10) // Deprecated
#define MRT_OSPFV2 BE16(11)
#define MRT_TABLE_DUMP BE16(12)
#define MRT_TABLE_DUMPV2 BE16(13)
#define MRT_BGP4MP BE16(16)
#define MRT_BGP4MP_ET BE16(17)
#define MRT_ISIS BE16(32)
#define MRT_ISIS_ET BE16(33)
#define MRT_OSPFV3 BE16(48)
#define MRT_OSPFV3_ET BE16(49)
/// 2-octets type for MRT record header type field, network byte order (big endian).
typedef Uint16 MrtType;
/** @} */
/**
* \name MRT subtypes enumeration for records of type BGP/ZEBRA
*
* \warning ZEBRA BGP has been deprecated in favor of BGP4MP.
*
* \see `MrtSubType`
*
* @{
*/
#define ZEBRA_NULL BE16(0)
#define ZEBRA_UPDATE BE16(1)
#define ZEBRA_PREF_UPDATE BE16(2)
#define ZEBRA_STATE_CHANGE BE16(3)
#define ZEBRA_SYNC BE16(4)
#define ZEBRA_OPEN BE16(5)
#define ZEBRA_NOTIFY BE16(6)
#define ZEBRA_KEEPALIVE BE16(7)
/** @} */
/**
* \name MRT subtypes for records of type BGP4MP
*
* BGP4MP is defined in [RFC 6396](https://tools.ietf.org/html/rfc6396#section-4.2),
* and extended by [RFC 8050](https://tools.ietf.org/html/rfc8050#page-2).
*
* \see [IANA BGP4MP Subtype Codes](https://www.iana.org/assignments/mrt/mrt.xhtml#BGP4MP-codes)
* \see `MrtSubType`
*
* @{
*/
#define BGP4MP_STATE_CHANGE BE16(0) ///< RFC 6396
#define BGP4MP_MESSAGE BE16(1) ///< RFC 6396
#define BGP4MP_ENTRY BE16(2) ///< Deprecated
#define BGP4MP_SNAPSHOT BE16(3) ///< Deprecated
#define BGP4MP_MESSAGE_AS4 BE16(4) ///< RFC 6396
#define BGP4MP_STATE_CHANGE_AS4 BE16(5) ///< RFC 6396
#define BGP4MP_MESSAGE_LOCAL BE16(6) ///< RFC 6396
#define BGP4MP_MESSAGE_AS4_LOCAL BE16(7) ///< RFC 6396
#define BGP4MP_MESSAGE_ADDPATH BE16(8) ///< RFC 8050
#define BGP4MP_MESSAGE_AS4_ADDPATH BE16(9) ///< RFC 8050
#define BGP4MP_MESSAGE_LOCAL_ADDPATH BE16(10) ///< RFC 8050
#define BGP4MP_MESSAGE_AS4_LOCAL_ADDPATH BE16(11) ///< RFC 8050
/** @} */
/**
* \name MRT subtypes for records of type TABLE_DUMPV2
*
* Table Dump version 2 is defined in [RFC 6396](https://tools.ietf.org/html/rfc6396#section-4.3).
*
* \see [IANA Table Dump version 2 Subtype Codes](https://www.iana.org/assignments/mrt/mrt.xhtml#table-dump-v2-subtype-codes)
* \see `MrtSubType`
*
* @{
*/
#define TABLE_DUMPV2_PEER_INDEX_TABLE BE16(1) ///< RFC 6396
#define TABLE_DUMPV2_RIB_IPV4_UNICAST BE16(2) ///< RFC 6396
#define TABLE_DUMPV2_RIB_IPV4_MULTICAST BE16(3) ///< RFC 6396
#define TABLE_DUMPV2_RIB_IPV6_UNICAST BE16(4) ///< RFC 6396
#define TABLE_DUMPV2_RIB_IPV6_MULTICAST BE16(5) ///< RFC 6396
#define TABLE_DUMPV2_RIB_GENERIC BE16(6) ///< RFC 6396
#define TABLE_DUMPV2_GEO_PEER_TABLE BE16(7) ///< RFC 6397
#define TABLE_DUMPV2_RIB_IPV4_UNICAST_ADDPATH BE16(8) ///< RFC 8050
#define TABLE_DUMPV2_RIB_IPV4_MULTICAST_ADDPATH BE16(9) ///< RFC 8050
#define TABLE_DUMPV2_RIB_IPV6_UNICAST_ADDPATH BE16(10) ///< RFC 8050
#define TABLE_DUMPV2_RIB_IPV6_MULTICAST_ADDPATH BE16(11) ///< RFC 8050
#define TABLE_DUMPV2_RIB_GENERIC_ADDPATH BE16(12) ///< RFC 8050
/** @} */
/// Type for MRT header subtype field, 2-octets type, network byte order (big endian).
typedef Uint16 MrtSubType;
/// Lookup table for TABLE_DUMPV2 PEER_INDEX.
typedef struct {
// NOTE: Data in this table is accessed atomically,
// despite these fields being signed they are effectively treated as
// unsigned by the library.
Sint16 validCount; ///< Count of valid entries inside `offsets`
Sint16 peerCount; ///< Cached PEER_INDEX_TABLE peer count value
Sint32 offsets[FLEX_ARRAY]; ///< Offset table, `peerCount` entries
} Mrtpeertabv2;
/**
* \brief MRT record type.
*
* Behaves in a similar way to `Bgpmsg`.
* Performs allocations via possibly custom allocator defined in fields
* `allocp` and `memOps`.
* If those fields are left `NULL', it uses `Mem_StdOps`.
*/
typedef struct {
Uint8 *buf; ///< Raw MRT record contents
void *allocp; ///< Optional custom memory allocator
const MemOps *memOps; ///< Optional custom memory operations
/**
* Fast peer offset table, only meaningful for
* `TABLE_DUMPV2` `PEER_INDEX_TABLE`.
*
* \note This is an atomic pointer to a [Mrtpeertabv2](\ref Mrtpeertabv2).
*
* \warning Honest, this field **MUST NOT** be accessed directly.
*/
void *peerOffTab;
} Mrtrecord;
/// Move `Mrtrecord` contents from `src` to `dest`, leaving `src` empty.
FORCE_INLINE void MRT_MOVEREC(Mrtrecord *dest, Mrtrecord *src)
{
EXTERNC void *memcpy(void *, const void *, size_t);
memcpy(dest, src, sizeof(*dest));
src->buf = NULL;
src->peerOffTab = NULL;
}
// Retrieve `MemOps` associated with record `rec`.
FORCE_INLINE const MemOps *MRT_MEMOPS(const Mrtrecord *rec)
{
return rec->memOps ? rec->memOps : Mem_StdOps;
}
#define _MRT_EXHDRMASK ( \
BIT(BE16(MRT_BGP4MP_ET)) | \
BIT(BE16(MRT_ISIS_ET)) | \
BIT(BE16(MRT_OSPFV3_ET)) \
)
#define _TABLE_DUMPV2_RIBMASK ( \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_UNICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_MULTICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_UNICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_MULTICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_GENERIC)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_UNICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_MULTICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_UNICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_MULTICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_GENERIC_ADDPATH)) \
)
#define _TABLE_DUMPV2_V4RIBMASK ( \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_UNICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_MULTICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_UNICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_MULTICAST_ADDPATH)) \
)
#define _TABLE_DUMPV2_V6RIBMASK ( \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_UNICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_MULTICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_UNICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_MULTICAST_ADDPATH)) \
)
#define _TABLE_DUMPV2_UNICASTRIBMASK ( \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_UNICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_UNICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_UNICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_UNICAST_ADDPATH)) \
)
#define _TABLE_DUMPV2_MULTICASTRIBMASK ( \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_MULTICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_MULTICAST)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_MULTICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_MULTICAST_ADDPATH)) \
)
#define _TABLE_DUMPV2_ADDPATHRIBMASK ( \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_UNICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV4_MULTICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_UNICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_IPV6_MULTICAST_ADDPATH)) | \
BIT(BE16(TABLE_DUMPV2_RIB_GENERIC_ADDPATH)) \
)
#define _BGP4MP_AS4MASK ( \
BIT(BE16(BGP4MP_MESSAGE_AS4)) | \
BIT(BE16(BGP4MP_STATE_CHANGE_AS4)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4_LOCAL)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4_ADDPATH)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4_LOCAL_ADDPATH)) \
)
#define _BGP4MP_ADDPATHMASK ( \
BIT(BE16(BGP4MP_MESSAGE_ADDPATH)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4_ADDPATH)) | \
BIT(BE16(BGP4MP_MESSAGE_LOCAL_ADDPATH)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4_LOCAL_ADDPATH)) \
)
#define _BGP4MP_MESSAGEMASK ( \
BIT(BE16(BGP4MP_MESSAGE)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4)) | \
BIT(BE16(BGP4MP_MESSAGE_LOCAL)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4_LOCAL)) | \
BIT(BE16(BGP4MP_MESSAGE_ADDPATH)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4_ADDPATH)) | \
BIT(BE16(BGP4MP_MESSAGE_LOCAL_ADDPATH)) | \
BIT(BE16(BGP4MP_MESSAGE_AS4_LOCAL_ADDPATH)) \
)
#define _ZEBRA_MESSAGEMASK ( \
BIT(BE16(ZEBRA_UPDATE)) | \
BIT(BE16(ZEBRA_OPEN)) | \
BIT(BE16(ZEBRA_NOTIFY)) | \
BIT(BE16(ZEBRA_KEEPALIVE)) \
)
/// Test whether a MRT record type provides extended precision timestamp header.
FORCE_INLINE Boolean MRT_ISEXHDRTYPE(MrtType type)
{
return BE16(type) <= 49 && (_MRT_EXHDRMASK & BIT(BE16(type))) != 0;
}
/// Test whether a MRT record type is BGP4MP.
FORCE_INLINE Boolean MRT_ISBGP4MP(MrtType type)
{
return type == MRT_BGP4MP || type == MRT_BGP4MP_ET;
}
/// Test whether a MRT record type is ISIS.
FORCE_INLINE Boolean MRT_ISISIS(MrtType type)
{
return type == MRT_ISIS || type == MRT_ISIS_ET;
}
/// Test whether a MRT record type is OSPFV3.
FORCE_INLINE Boolean MRT_ISOSPFV3(MrtType type)
{
return type == MRT_OSPFV3 || type == MRT_OSPFV3_ET;
}
/// Test whether a BGP4MP MRT record subtype contains 32-bits ASN.
FORCE_INLINE Boolean BGP4MP_ISASN32BIT(MrtSubType subtype)
{
return BE16(subtype) <= 11 && (_BGP4MP_AS4MASK & BIT(BE16(subtype))) != 0;
}
/// Test whether a BGP4MP MRT subtype belongs has ADD_PATH information.
FORCE_INLINE Boolean BGP4MP_ISADDPATH(MrtSubType subtype)
{
return BE16(subtype) <= 11 &&
(_BGP4MP_ADDPATHMASK & BIT(BE16(subtype))) != 0;
}
/**
* \brief Test whether a BGP4MP MRT subtype wraps a BGP message.
*
* \see `Bgp_UnwrapBgp4mp()`
*/
FORCE_INLINE Boolean BGP4MP_ISMESSAGE(MrtSubType subtype)
{
return BE16(subtype) <= 11 &&
(_BGP4MP_MESSAGEMASK & BIT(BE16(subtype))) != 0;
}
FORCE_INLINE Boolean BGP4MP_ISSTATECHANGE(MrtSubType subtype)
{
return subtype == BGP4MP_STATE_CHANGE ||
subtype == BGP4MP_STATE_CHANGE_AS4;
}
FORCE_INLINE Boolean TABLE_DUMPV2_ISRIB(MrtSubType subtype)
{
return BE16(subtype) <= 12 &&
(_TABLE_DUMPV2_RIBMASK & BIT(BE16(subtype))) != 0;
}
FORCE_INLINE Boolean TABLE_DUMPV2_ISIPV4RIB(MrtSubType subtype)
{
return BE16(subtype) <= 12 &&
(_TABLE_DUMPV2_V4RIBMASK & BIT(BE16(subtype))) != 0;
}
FORCE_INLINE Boolean TABLE_DUMPV2_ISIPV6RIB(MrtSubType subtype)
{
return BE16(subtype) <= 12 &&
(_TABLE_DUMPV2_V6RIBMASK & BIT(BE16(subtype))) != 0;
}
FORCE_INLINE Boolean TABLE_DUMPV2_ISGENERICRIB(MrtSubType subtype)
{
return subtype == TABLE_DUMPV2_RIB_GENERIC ||
subtype == TABLE_DUMPV2_RIB_GENERIC_ADDPATH;
}
FORCE_INLINE Boolean TABLE_DUMPV2_ISUNICASTRIB(MrtSubType subtype)
{
return BE16(subtype) <= 12 &&
(_TABLE_DUMPV2_UNICASTRIBMASK & BIT(BE16(subtype))) != 0;
}
FORCE_INLINE Boolean TABLE_DUMPV2_ISMULTICASTRIB(MrtSubType subtype)
{
return BE16(subtype) <= 12 &&
(_TABLE_DUMPV2_MULTICASTRIBMASK & BIT(BE16(subtype))) != 0;
}
FORCE_INLINE Boolean TABLE_DUMPV2_ISADDPATHRIB(MrtSubType subtype)
{
return BE16(subtype) <= 12 &&
(_TABLE_DUMPV2_ADDPATHRIBMASK & BIT(BE16(subtype))) != 0;
}
/**
* \brief Test whether a ZEBRA BGP message wraps BGP message.
*
* \see `Bgp_UnwrapZebra()`
*/
FORCE_INLINE Boolean ZEBRA_ISMESSAGE(MrtSubType subtype)
{
return BE16(subtype) <= 7 &&
(_ZEBRA_MESSAGEMASK & BIT(BE16(subtype))) != 0;
}
#pragma pack(push, 1)
/**
* \brief MRT header type.
*
* \warning **Misaligned struct**.
* \note Fields are in network order (big endian).
*/
typedef ALIGNED(1, struct) {
Uint32 timestamp; ///< Unix timestamp
MrtType type; ///< MRT record type
MrtSubType subtype; ///< MRT record subtype
Uint32 len; ///< Record length in bytes **not including** header itself
} Mrthdr;
/**
* \brief Extended MRT header, includes microseconds information.
*
* \warning **Misaligned struct**.
* \note Fields are in network order (big endian).
*
* \see `Mrthdr`
*/
typedef ALIGNED(1, struct) {
Uint32 timestamp;
MrtType type;
MrtSubType subtype;
Uint32 len;
Uint32 microsecs;
} Mrthdrex;
typedef ALIGNED(1, struct) {
Uint32 peerBgpId; ///< Peer BGP identifier
Uint16 viewNameLen; ///< `viewName` field length in chars
char viewName[FLEX_ARRAY]; ///< Optional view name, **not** `\0` terminated
// Uint16 peerCount;
// Mrtpeerent peers[FLEX_ARRAY];
} Mrtpeeridx;
#define MRT_PEER_IP6 BIT(0)
#define MRT_PEER_ASN32BIT BIT(1)
typedef ALIGNED(1, struct) {
Uint8 type;
Uint32 bgpId;
union {
struct {
Ipv4adr addr;
Asn16 asn;
} a16v4;
struct {
Ipv4adr addr;
Asn32 asn;
} a32v4;
struct {
Ipv6adr addr;
Asn16 asn;
} a16v6;
struct {
Ipv6adr addr;
Asn32 asn;
} a32v6;
};
} Mrtpeerentv2;
FORCE_INLINE Boolean MRT_ISPEERIPV6(Uint8 type)
{
return (type & MRT_PEER_IP6) != 0;
}
FORCE_INLINE Boolean MRT_ISPEERASN32BIT(Uint8 type)
{
return (type & MRT_PEER_ASN32BIT) != 0;
}
FORCE_INLINE Asn MRT_GETPEERADDR(Ipadr *dest, const Mrtpeerentv2 *peer)
{
switch (peer->type & (MRT_PEER_IP6|MRT_PEER_ASN32BIT)) {
case MRT_PEER_IP6|MRT_PEER_ASN32BIT:
dest->family = IP6;
dest->v6 = peer->a32v6.addr;
return ASN32BIT(peer->a32v6.asn);
case MRT_PEER_IP6:
dest->family = IP6;
dest->v6 = peer->a16v6.addr;
return ASN16BIT(peer->a16v6.asn);
case MRT_PEER_ASN32BIT:
dest->family = IP4;
dest->v4 = peer->a32v4.addr;
return ASN32BIT(peer->a32v4.asn);
default:
dest->family = IP4;
dest->v4 = peer->a16v4.addr;
return ASN16BIT(peer->a16v4.asn);
}
}
#define _MRT_RIBENT_FIELDS(IpT) \
IpT prefix; \
Uint8 prefixLen; \
Uint8 status; \
Uint32 originatedTime; \
IpT peerAddr; \
Uint16 peerAs; \
Uint16 attrLen
/**
* \brief Legacy TABLE_DUMP RIB entry.
*
* \warning **Misaligned struct**.
* \note Fields are in network order (big endian).
*/
typedef ALIGNED(1, struct) {
Uint16 viewno;
Uint16 seqno;
union {
struct {
_MRT_RIBENT_FIELDS(Ipv4adr);
// Uint8 attrs[FLEX_ARRAY];
} v4;
struct {
_MRT_RIBENT_FIELDS(Ipv6adr);
// Uint8 attrs[FLEX_ARRAY];
} v6;
};
} Mrtribent;
FORCE_INLINE Boolean RIB_GETPFX(Afi afi,
RawPrefix *dest,
const Mrtribent *rib)
{
EXTERNC void *memcpy(void *, const void *, size_t);
switch (afi) {
case AFI_IP:
if (rib->v4.prefixLen > IPV4_WIDTH)
return FALSE;
dest->width = rib->v4.prefixLen;
memcpy(dest->bytes, &rib->v4.prefix, PFXLEN(rib->v4.prefixLen));
return TRUE;
case AFI_IP6:
if (rib->v6.prefixLen > IPV6_WIDTH)
return FALSE;
dest->width = rib->v6.prefixLen;
memcpy(dest->bytes, &rib->v6.prefix, PFXLEN(rib->v6.prefixLen));
return TRUE;
default:
UNREACHABLE;
return FALSE;
}
}
FORCE_INLINE Uint32 RIB_GETORIGINATED(Afi afi, const Mrtribent *rib)
{
switch (afi) {
case AFI_IP: return rib->v4.originatedTime;
case AFI_IP6: return rib->v6.originatedTime;
default:
UNREACHABLE;
return 0;
}
}
FORCE_INLINE Asn RIB_GETPEERADDR(Afi afi, Ipadr *dest, const Mrtribent *rib)
{
switch (afi) {
case AFI_IP:
dest->family = afi;
dest->v4 = rib->v4.peerAddr;
return ASN16BIT(rib->v4.peerAs);
case AFI_IP6:
dest->family = afi;
dest->v6 = rib->v6.peerAddr;
return ASN16BIT(rib->v6.peerAs);
default:
UNREACHABLE;
return -1;
}
}
// NOTE: RIB AFI is stored inside `Mrthdr subtype` field.
FORCE_INLINE Bgpattrseg *RIB_GETATTRIBS(Afi afi, const Mrtribent *rib)
{
switch (afi) {
case AFI_IP: return (Bgpattrseg *) &rib->v4.attrLen;
case AFI_IP6: return (Bgpattrseg *) &rib->v6.attrLen;
default: UNREACHABLE; return NULL;
}
}
typedef ALIGNED(1, struct) {
Uint32 seqno;
union {
RawPrefix nlri;
struct {
Afi afi;
Safi safi;
RawPrefix nlri;
} gen;
};
} Mrtribhdrv2;
FORCE_INLINE Mrtribhdrv2 *RIBV2_HDR(const Mrthdr *hdr)
{
return (Mrtribhdrv2 *) (hdr + 1);
}
typedef ALIGNED(1, struct) {
Uint16 entryCount;
Uint8 entries[FLEX_ARRAY];
} Mrtribentriesv2;
/**
* \brief TABLE_DUMPV2 RIB entry.
*
* \warning **Misaligned struct**.
* \note Fields are in network order (big endian).
*/
typedef ALIGNED(1, struct) {
Uint16 peerIndex; ///< `Mrtpeerentv2` index inside PEER_INDEX_TABLE
Uint32 originatedTime;
Uint8 data[FLEX_ARRAY];
} Mrtribentv2;
FORCE_INLINE Bgpattrseg *RIBV2_GETATTRIBS(MrtSubType subtype,
const Mrtribentv2 *rib)
{
return (Bgpattrseg *) (TABLE_DUMPV2_ISADDPATHRIB(subtype) ?
rib->data + 4 :
rib->data);
}
FORCE_INLINE Uint32 RIBV2_GETPATHID(const Mrtribentv2 *ent)
{
EXTERNC void *memcpy(void *, const void *, size_t);
Uint32 pathid;
memcpy(&pathid, ent->data, sizeof(pathid));
return pathid;
}
FORCE_INLINE void RIBV2_SETPATHID(Mrtribentv2 *ent, Uint32 pathid)
{
EXTERNC void *memcpy(void *, const void *, size_t);
memcpy(ent->data, &pathid, sizeof(pathid));
}
FORCE_INLINE void RIBV2_GETNLRI(MrtSubType subtype,
Prefix *dest,
const Mrtribhdrv2 *hdr,
const Mrtribentv2 *ent)
{
EXTERNC void *memcpy(void *, const void *, size_t);
if (TABLE_DUMPV2_ISGENERICRIB(subtype)) {
dest->afi = hdr->gen.afi;
dest->safi = hdr->gen.safi;
memcpy(PLAINPFX(dest), &hdr->gen.nlri, 1 + PFXLEN(hdr->gen.nlri.width));
} else {
dest->afi = TABLE_DUMPV2_ISIPV6RIB(subtype) ?
AFI_IP6 :
AFI_IP;
dest->safi = TABLE_DUMPV2_ISMULTICASTRIB(subtype) ?
SAFI_MULTICAST :
SAFI_UNICAST;
memcpy(PLAINPFX(dest), &hdr->nlri, 1 + PFXLEN(hdr->nlri.width));
}
dest->isAddPath = TABLE_DUMPV2_ISADDPATHRIB(subtype);
dest->pathId = (dest->isAddPath) ? RIBV2_GETPATHID(ent) : 0;
}
#define _MRT_BGP4MP_COMFIELDS(AsnT) \
AsnT peerAs, localAs; \
Uint16 iface; \
Afi afi
#define _MRT_BGP4MP_HDRFIELDS(AsnT, IpT) \
_MRT_BGP4MP_COMFIELDS(AsnT); \
IpT peerAddr, localAddr
/// Common header fields to all BGP4MP MRT records.
typedef ALIGNED(1, union) {
struct {
_MRT_BGP4MP_COMFIELDS(Asn32);
} a32;
struct {
_MRT_BGP4MP_COMFIELDS(Asn16);
} a16;
struct {
_MRT_BGP4MP_HDRFIELDS(Asn16, Ipv4adr);
} a16v4;
struct {
_MRT_BGP4MP_HDRFIELDS(Asn16, Ipv6adr);
} a16v6;
struct {
_MRT_BGP4MP_HDRFIELDS(Asn32, Ipv4adr);
} a32v4;
struct {
_MRT_BGP4MP_HDRFIELDS(Asn32, Ipv6adr);
} a32v6;
} Bgp4mphdr;
FORCE_INLINE Bgp4mphdr *BGP4MP_HDR(const Mrthdr *hdr)
{
return (hdr->type == MRT_BGP4MP_ET) ?
(Bgp4mphdr *) ((const Mrthdrex *) hdr + 1) :
(Bgp4mphdr *) (hdr + 1);
}
FORCE_INLINE Asn BGP4MP_GETPEERADDR(MrtSubType subtype,
Ipadr *dest,
const Bgp4mphdr *bgp4mp)
{
if (BGP4MP_ISASN32BIT(subtype)) {
switch (bgp4mp->a32.afi) {
case AFI_IP:
dest->family = IP4;
dest->v4 = bgp4mp->a32v4.peerAddr;
break;
case AFI_IP6:
dest->family = IP6;
dest->v6 = bgp4mp->a32v6.peerAddr;
break;
default:
UNREACHABLE;
break;
}
return ASN32BIT(bgp4mp->a32.peerAs);
} else {
switch (bgp4mp->a16.afi) {
case AFI_IP:
dest->family = IP4;
dest->v4 = bgp4mp->a16v4.peerAddr;
break;
case AFI_IP6:
dest->family = IP6;
dest->v6 = bgp4mp->a16v6.peerAddr;
break;
default:
UNREACHABLE;
break;
}
return ASN16BIT(bgp4mp->a16.peerAs);
}
}
FORCE_INLINE Asn BGP4MP_GETLOCALADDR(MrtSubType subtype,
Ipadr *dest,
const Bgp4mphdr *bgp4mp)
{
if (BGP4MP_ISASN32BIT(subtype)) {
switch (bgp4mp->a32.afi) {
case AFI_IP:
dest->family = IP4;
dest->v4 = bgp4mp->a32v4.localAddr;
break;
case AFI_IP6:
dest->family = IP6;
dest->v6 = bgp4mp->a32v6.localAddr;
break;
default:
UNREACHABLE;
return -1;
}
return ASN32BIT(bgp4mp->a32.localAs);
} else {
switch (bgp4mp->a16.afi) {
case AFI_IP:
dest->family = IP4;
dest->v4 = bgp4mp->a16v4.localAddr;
break;
case AFI_IP6:
dest->family = IP6;
dest->v6 = bgp4mp->a16v6.localAddr;
break;
default:
UNREACHABLE;
return -1;
}
return ASN16BIT(bgp4mp->a16.localAs);
}
}
/// BGP4MP message providing BGP Finite State Machine (FSM) state change information.
typedef ALIGNED(1, union) {
Bgp4mphdr hdr;
struct {
_MRT_BGP4MP_HDRFIELDS(Asn16, Ipv4adr);
BgpFsmState oldState, newState;
} a16v4;
struct {
_MRT_BGP4MP_HDRFIELDS(Asn16, Ipv6adr);
BgpFsmState oldState, newState;
} a16v6;
struct {
_MRT_BGP4MP_HDRFIELDS(Asn32, Ipv4adr);
BgpFsmState oldState, newState;
} a32v4;
struct {
_MRT_BGP4MP_HDRFIELDS(Asn32, Ipv6adr);
BgpFsmState oldState, newState;
} a32v6;
} Bgp4mpstatchng;
typedef ALIGNED(1, struct) {
Uint16 peerAs;
Ipv4adr peerAddr;
} Zebrahdr;
FORCE_INLINE Zebrahdr *ZEBRA_HDR(const Mrthdr *hdr)
{
return (Zebrahdr *) (hdr + 1);
}
typedef ALIGNED(1, struct) {
Zebrahdr hdr;
Uint16 localAs;
Ipv4adr localAddr;
Uint8 msg[FLEX_ARRAY];
} Zebramsghdr;
typedef ALIGNED(1, struct) {
Zebrahdr hdr;
BgpFsmState oldState, newState;
} Zebrastatchng;
#pragma pack(pop)
/// MRT record header size in bytes.
#define MRT_HDRSIZ (4uLL + 2uLL + 2uLL + 4uLL)
/// Extended timestamp MRT record header size in bytes.
#define MRT_EXHDRSIZ (MRT_HDRSIZ + 4uLL)
STATIC_ASSERT(MRT_HDRSIZ == sizeof(Mrthdr), "MRT_HDRSIZ vs Mrthdr size mismatch");
STATIC_ASSERT(MRT_EXHDRSIZ == sizeof(Mrthdrex), "MRT_EXHDRSIZ vs Mrthdrex size mismatch");
/// Retrieve a pointer to a MRT record header.
FORCE_INLINE Mrthdr *MRT_HDR(const Mrtrecord *rec)
{
return (Mrthdr *) rec->buf;
}
typedef struct {
Uint8 *base, *lim;
Uint8 *ptr;
Uint16 peerCount;
Uint16 nextIdx;
} Mrtpeeriterv2;
typedef struct {
Uint8 *base, *lim;
Uint8 *ptr;
Boolean8 isAddPath;
Uint16 entryCount;
Uint16 nextIdx;
} Mrtribiterv2;
Judgement Bgp_MrtFromBuf(Mrtrecord *rec, const void *data, size_t nbytes);
Judgement Bgp_ReadMrt(Mrtrecord *rec, void *streamp, const StmOps *ops);
void Bgp_ClearMrt(Mrtrecord *rec);
// =========================================
// TABLE_DUMPV2 - PEER_INDEX_TABLE
Mrtpeeridx *Bgp_GetMrtPeerIndex(Mrtrecord *rec);
void *Bgp_GetMrtPeerIndexPeers(Mrtrecord *rec, size_t *peersCount, size_t *nbytes);
Judgement Bgp_StartMrtPeersv2(Mrtpeeriterv2 *it, Mrtrecord *rec);
Mrtpeerentv2 *Bgp_NextMrtPeerv2(Mrtpeeriterv2 *it);
Mrtpeerentv2 *Bgp_GetMrtPeerByIndex(Mrtrecord *rec, Uint16 idx);
// =========================================
// TABLE_DUMPV2 - RIB SubTypes
Mrtribhdrv2 *Bgp_GetMrtRibHdrv2(Mrtrecord *rec, size_t *nbytes);
Mrtribentriesv2 *Bgp_GetMrtRibEntriesv2(Mrtrecord *rec, size_t *nbytes);
Judgement Bgp_StartMrtRibEntriesv2(Mrtribiterv2 *it, Mrtrecord *rec);
Mrtribentv2 *Bgp_NextRibEntryv2(Mrtribiterv2 *rec);
// =========================================
// BGP4MP
Bgp4mphdr *Bgp_GetBgp4mpHdr(Mrtrecord *rec, size_t *nbytes);
Judgement Bgp_UnwrapBgp4mp(Mrtrecord *rec, Bgpmsg *msg, unsigned flags);
// =========================================
// DEPRECATED - TABLE_DUMP
Mrtribent *Bgp_GetMrtRibHdr(Mrtrecord *rec);
void *Bgp_GetMrtRibEntry(Mrtrecord *rec, size_t *nbytes);
// =========================================
// DEPRECATED - ZEBRA
Zebrahdr *Bgp_GetZebraHdr(Mrtrecord *rec, size_t *nbytes);
Judgement Bgp_UnwrapZebra(Mrtrecord *rec, Bgpmsg *msg, unsigned flags);
// ==========================================
// RIB attribute segment encoding formats
Judgement Bgp_StartAllRibv2NextHops(Nexthopiter *it,
const Mrthdr *hdr,
const Bgpattrseg *tpa,
Bgpattrtab tab);
Judgement Bgp_RebuildMsgFromRib(const Prefix *nlri,
const Bgpattrseg *tpa,
Bgpmsg *msg,
unsigned flags);
#endif
View Git Blame Copy Permalink