proto/bgp/bgp.h

   1 /*
   2  *      BIRD -- The Border Gateway Protocol
   3  *
   4  *      (c) 2000 Martin Mares <mj@ucw.cz>
   5  *      (c) 2008--2016 Ondrej Zajicek <santiago@crfreenet.org>
   6  *      (c) 2008--2016 CZ.NIC z.s.p.o.
   7  *
   8  *      Can be freely distributed and used under the terms of the GNU GPL.
   9  */
  10
  11 #ifndef _BIRD_BGP_H_
  12 #define _BIRD_BGP_H_
  13
  14 #include <stdint.h>
  15 #include <setjmp.h>
  16 #include "nest/bird.h"
  17 #include "nest/route.h"
  18 #include "nest/bfd.h"
  19 //#include "lib/lists.h"
  20 #include "lib/hash.h"
  21 #include "lib/socket.h"
  22
  23 struct eattr;
  24
  25
  26 /* Address families */
  27
  28 #define BGP_AFI_IPV4            1
  29 #define BGP_AFI_IPV6            2
  30
  31 #define BGP_SAFI_UNICAST        1
  32 #define BGP_SAFI_MULTICAST      2
  33 #define BGP_SAFI_MPLS           4
  34 #define BGP_SAFI_MPLS_VPN       128
  35 #define BGP_SAFI_VPN_MULTICAST  129
  36 #define BGP_SAFI_FLOW           133
  37
  38 /* Internal AF codes */
  39
  40 #define BGP_AF(A, B)            (((u32)(A) << 16) | (u32)(B))
  41 #define BGP_AFI(A)              ((u32)(A) >> 16)
  42 #define BGP_SAFI(A)             ((u32)(A) & 0xFFFF)
  43
  44 #define BGP_AF_IPV4             BGP_AF( BGP_AFI_IPV4, BGP_SAFI_UNICAST )
  45 #define BGP_AF_IPV6             BGP_AF( BGP_AFI_IPV6, BGP_SAFI_UNICAST )
  46 #define BGP_AF_IPV4_MC          BGP_AF( BGP_AFI_IPV4, BGP_SAFI_MULTICAST )
  47 #define BGP_AF_IPV6_MC          BGP_AF( BGP_AFI_IPV6, BGP_SAFI_MULTICAST )
  48 #define BGP_AF_IPV4_MPLS        BGP_AF( BGP_AFI_IPV4, BGP_SAFI_MPLS )
  49 #define BGP_AF_IPV6_MPLS        BGP_AF( BGP_AFI_IPV6, BGP_SAFI_MPLS )
  50 #define BGP_AF_VPN4_MPLS        BGP_AF( BGP_AFI_IPV4, BGP_SAFI_MPLS_VPN )
  51 #define BGP_AF_VPN6_MPLS        BGP_AF( BGP_AFI_IPV6, BGP_SAFI_MPLS_VPN )
  52 #define BGP_AF_VPN4_MC          BGP_AF( BGP_AFI_IPV4, BGP_SAFI_VPN_MULTICAST )
  53 #define BGP_AF_VPN6_MC          BGP_AF( BGP_AFI_IPV6, BGP_SAFI_VPN_MULTICAST )
  54 #define BGP_AF_FLOW4            BGP_AF( BGP_AFI_IPV4, BGP_SAFI_FLOW )
  55 #define BGP_AF_FLOW6            BGP_AF( BGP_AFI_IPV6, BGP_SAFI_FLOW )
  56
  57
  58 struct bgp_write_state;
  59 struct bgp_parse_state;
  60 struct bgp_export_state;
  61 struct bgp_bucket;
  62
  63 struct bgp_af_desc {
  64   u32 afi;
  65   u32 net;
  66   u8 mpls;
  67   u8 no_igp;
  68   const char *name;
  69   uint (*encode_nlri)(struct bgp_write_state *s, struct bgp_bucket *buck, byte *buf, uint size);
  70   void (*decode_nlri)(struct bgp_parse_state *s, byte *pos, uint len, rta *a);
  71   void (*update_next_hop)(struct bgp_export_state *s, eattr *nh, ea_list **to);
  72   uint (*encode_next_hop)(struct bgp_write_state *s, eattr *nh, byte *buf, uint size);
  73   void (*decode_next_hop)(struct bgp_parse_state *s, byte *pos, uint len, rta *a);
  74 };
  75
  76
  77 struct bgp_config {
  78   struct proto_config c;
  79   u32 local_as, remote_as;
  80   ip_addr local_ip;                     /* Source address to use */
  81   ip_addr remote_ip;
  82   struct iface *iface;                  /* Interface for link-local addresses */
  83   u16 local_port;                       /* Local listening port */
  84   u16 remote_port;                      /* Neighbor destination port */
  85   int peer_type;                        /* Internal or external BGP (BGP_PT_*, optional) */
  86   int multihop;                         /* Number of hops if multihop */
  87   int strict_bind;                      /* Bind listening socket to local address */
  88   int free_bind;                        /* Bind listening socket with SKF_FREEBIND */
  89   int ttl_security;                     /* Enable TTL security [RFC 5082] */
  90   int compare_path_lengths;             /* Use path lengths when selecting best route */
  91   int med_metric;                       /* Compare MULTI_EXIT_DISC even between routes from differen ASes */
  92   int igp_metric;                       /* Use IGP metrics when selecting best route */
  93   int prefer_older;                     /* Prefer older routes according to RFC 5004 */
  94   int deterministic_med;                /* Use more complicated algo to have strict RFC 4271 MED comparison */
  95   u32 default_local_pref;               /* Default value for LOCAL_PREF attribute */
  96   u32 default_med;                      /* Default value for MULTI_EXIT_DISC attribute */
  97   int capabilities;                     /* Enable capability handshake [RFC 5492] */
  98   int enable_refresh;                   /* Enable local support for route refresh [RFC 2918] */
  99   int enable_as4;                       /* Enable local support for 4B AS numbers [RFC 6793] */
 100   int enable_extended_messages;         /* Enable local support for extended messages [draft] */
 101   int enable_hostname;                  /* Enable local support for hostname [draft] */
 102   u32 rr_cluster_id;                    /* Route reflector cluster ID, if different from local ID */
 103   int rr_client;                        /* Whether neighbor is RR client of me */
 104   int rs_client;                        /* Whether neighbor is RS client of me */
 105   u32 confederation;                    /* Confederation ID, or zero if confeds not active */
 106   int confederation_member;             /* Whether neighbor AS is member of our confederation */
 107   int passive;                          /* Do not initiate outgoing connection */
 108   int interpret_communities;            /* Hardwired handling of well-known communities */
 109   int allow_local_as;                   /* Allow that number of local ASNs in incoming AS_PATHs */
 110   int allow_local_pref;                 /* Allow LOCAL_PREF in EBGP sessions */
 111   int allow_as_sets;                    /* Allow AS_SETs in incoming AS_PATHs */
 112   int enforce_first_as;                 /* Enable check for neighbor AS as first AS in AS_PATH */
 113   int gr_mode;                          /* Graceful restart mode (BGP_GR_*) */
 114   int llgr_mode;                        /* Long-lived graceful restart mode (BGP_LLGR_*) */
 115   int setkey;                           /* Set MD5 password to system SA/SP database */
 116   u8  local_role;                       /* Set peering role with neighbor [RFC 9234] */
 117   int require_roles;                    /* Require configured roles on both sides */
 118   /* Times below are in seconds */
 119   unsigned gr_time;                     /* Graceful restart timeout */
 120   unsigned llgr_time;                   /* Long-lived graceful restart stale time */
 121   unsigned connect_delay_time;          /* Minimum delay between connect attempts */
 122   unsigned connect_retry_time;          /* Timeout for connect attempts */
 123   unsigned hold_time, initial_hold_time;
 124   unsigned keepalive_time;
 125   unsigned error_amnesia_time;          /* Errors are forgotten after */
 126   unsigned error_delay_time_min;        /* Time to wait after an error is detected */
 127   unsigned error_delay_time_max;
 128   unsigned disable_after_error;         /* Disable the protocol when error is detected */
 129   u32 disable_after_cease;              /* Disable it when cease is received, bitfield */
 130
 131   const char *password;                 /* Password used for MD5 authentication */
 132   net_addr *remote_range;               /* Allowed neighbor range for dynamic BGP */
 133   const char *dynamic_name;             /* Name pattern for dynamic BGP */
 134   int dynamic_name_digits;              /* Minimum number of digits for dynamic names */
 135   int check_link;                       /* Use iface link state for liveness detection */
 136   struct bfd_options *bfd;              /* Use BFD for liveness detection */
 137 };
 138
 139 struct bgp_channel_config {
 140   struct channel_config c;
 141
 142   u32 afi;
 143   const struct bgp_af_desc *desc;
 144
 145   ip_addr next_hop_addr;                /* Local address for NEXT_HOP attribute */
 146   u8 next_hop_self;                     /* Always set next hop to local IP address (NH_*) */
 147   u8 next_hop_keep;                     /* Do not modify next hop attribute (NH_*) */
 148   u8 next_hop_prefer;                   /* Prefer global or link-local next hop (NHP_*) */
 149   u8 mandatory;                         /* Channel is mandatory in capability negotiation */
 150   u8 gw_mode;                           /* How we compute route gateway from next_hop attr, see GW_* */
 151   u8 secondary;                         /* Accept also non-best routes (i.e. RA_ACCEPTED) */
 152   u8 validate;                          /* Validate Flowspec per RFC 8955 (6) */
 153   u8 gr_able;                           /* Allow full graceful restart for the channel */
 154   u8 llgr_able;                         /* Allow full long-lived GR for the channel */
 155   uint llgr_time;                       /* Long-lived graceful restart stale time */
 156   u8 ext_next_hop;                      /* Allow both IPv4 and IPv6 next hops */
 157   u8 add_path;                          /* Use ADD-PATH extension [RFC 7911] */
 158   u8 aigp;                              /* AIGP is allowed on this session */
 159   u8 aigp_originate;                    /* AIGP is originated automatically */
 160   u32 cost;                             /* IGP cost for direct next hops */
 161   u8 import_table;                      /* Use c.in_table as Adj-RIB-In */
 162   u8 export_table;                      /* Use c.out_table as Adj-RIB-Out */
 163
 164   struct rtable_config *igp_table_ip4;  /* Table for recursive IPv4 next hop lookups */
 165   struct rtable_config *igp_table_ip6;  /* Table for recursive IPv6 next hop lookups */
 166   struct rtable_config *base_table;     /* Base table for Flowspec validation */
 167 };
 168
 169 #define BGP_PT_INTERNAL         1
 170 #define BGP_PT_EXTERNAL         2
 171
 172 #define BGP_ROLE_UNDEFINED      255
 173 #define BGP_ROLE_PROVIDER       0
 174 #define BGP_ROLE_RS_SERVER      1
 175 #define BGP_ROLE_RS_CLIENT      2
 176 #define BGP_ROLE_CUSTOMER       3
 177 #define BGP_ROLE_PEER           4
 178
 179 #define NH_NO                   0
 180 #define NH_ALL                  1
 181 #define NH_IBGP                 2
 182 #define NH_EBGP                 3
 183
 184 #define MLL_SELF                1
 185 #define MLL_DROP                2
 186 #define MLL_IGNORE              3
 187
 188 #define GW_DIRECT               1
 189 #define GW_RECURSIVE            2
 190
 191 #define NHP_GLOBAL              1
 192 #define NHP_LOCAL               2
 193
 194 #define BGP_ADD_PATH_RX         1
 195 #define BGP_ADD_PATH_TX         2
 196 #define BGP_ADD_PATH_FULL       3
 197
 198 #define BGP_GR_ABLE             1
 199 #define BGP_GR_AWARE            2
 200
 201 /* For GR capability common flags */
 202 #define BGP_GRF_RESTART 0x80
 203
 204 /* For GR capability per-AF flags */
 205 #define BGP_GRF_FORWARDING 0x80
 206
 207 #define BGP_LLGR_ABLE           1
 208 #define BGP_LLGR_AWARE          2
 209
 210 #define BGP_LLGRF_FORWARDING 0x80
 211
 212 #define BGP_GRS_NONE            0       /* No GR  */
 213 #define BGP_GRS_ACTIVE          1       /* Graceful restart per RFC 4724 */
 214 #define BGP_GRS_LLGR            2       /* Long-lived GR phase (stale timer active) */
 215
 216 #define BGP_BFD_GRACEFUL        2       /* BFD down triggers graceful restart */
 217
 218 /* rte->pflags */
 219 #define BGP_REF_SUPPRESSED      0x1     /* Used for deterministic MED comparison */
 220 #define BGP_REF_STALE           0x2     /* Route is LLGR_STATE */
 221 #define BGP_REF_NOT_STALE       0x4     /* Route is NOT LLGR_STATE */
 222
 223 struct bgp_af_caps {
 224   u32 afi;
 225   u8 ready;                             /* Multiprotocol capability, RFC 4760 */
 226   u8 gr_able;                           /* Graceful restart support, RFC 4724 */
 227   u8 gr_af_flags;                       /* Graceful restart per-AF flags */
 228   u8 llgr_able;                         /* Long-lived GR, RFC draft */
 229   u32 llgr_time;                        /* Long-lived GR stale time */
 230   u8 llgr_flags;                        /* Long-lived GR per-AF flags */
 231   u8 ext_next_hop;                      /* Extended IPv6 next hop,   RFC 5549 */
 232   u8 add_path;                          /* Multiple paths support,   RFC 7911 */
 233 };
 234
 235 struct bgp_caps {
 236   u32 as4_number;                       /* Announced ASN */
 237
 238   u8 as4_support;                       /* Four-octet AS capability, RFC 6793 */
 239   u8 ext_messages;                      /* Extended message length,  RFC draft */
 240   u8 route_refresh;                     /* Route refresh capability, RFC 2918 */
 241   u8 enhanced_refresh;                  /* Enhanced route refresh,   RFC 7313 */
 242   u8 role;                              /* BGP role capability,      RFC 9234 */
 243
 244   u8 gr_aware;                          /* Graceful restart capability, RFC 4724 */
 245   u8 gr_flags;                          /* Graceful restart flags */
 246   u16 gr_time;                          /* Graceful restart time in seconds */
 247
 248   u8 llgr_aware;                        /* Long-lived GR capability, RFC draft */
 249   u8 any_ext_next_hop;                  /* Bitwise OR of per-AF ext_next_hop */
 250   u8 any_add_path;                      /* Bitwise OR of per-AF add_path */
 251
 252   const char *hostname;                 /* Hostname, RFC draft */
 253
 254   u16 af_count;                         /* Number of af_data items */
 255   u16 length;                           /* Length of capabilities in OPEN msg */
 256
 257   struct bgp_af_caps af_data[0];        /* Per-AF capability data */
 258 };
 259
 260 #define WALK_AF_CAPS(caps,ac) \
 261   for (ac = caps->af_data; ac < &caps->af_data[caps->af_count]; ac++)
 262
 263
 264 struct bgp_socket {
 265   node n;                               /* Node in global bgp_sockets */
 266   sock *sk;                             /* Real listening socket */
 267   u32 uc;                               /* Use count */
 268 };
 269
 270 struct bgp_stats {
 271   uint rx_messages, tx_messages;
 272   uint rx_updates, tx_updates;
 273   u64  rx_bytes, tx_bytes;
 274
 275   uint fsm_established_transitions;
 276 };
 277
 278 struct bgp_conn {
 279   struct bgp_proto *bgp;
 280   struct birdsock *sk;
 281   u8 state;                             /* State of connection state machine */
 282   u8 as4_session;                       /* Session uses 4B AS numbers in AS_PATH (both sides support it) */
 283   u8 ext_messages;                      /* Session uses extended message length */
 284   u32 received_as;                      /* ASN received in OPEN message */
 285
 286   struct bgp_caps *local_caps;
 287   struct bgp_caps *remote_caps;
 288   timer *connect_timer;
 289   timer *hold_timer;
 290   timer *keepalive_timer;
 291   event *tx_ev;
 292   u32 packets_to_send;                  /* Bitmap of packet types to be sent */
 293   u32 channels_to_send;                 /* Bitmap of channels with packets to be sent */
 294   u8 last_channel;                      /* Channel used last time for TX */
 295   u8 last_channel_count;                /* Number of times the last channel was used in succession */
 296   int notify_code, notify_subcode, notify_size;
 297   byte *notify_data;
 298
 299   uint hold_time, keepalive_time;       /* Times calculated from my and neighbor's requirements */
 300 };
 301
 302 struct bgp_proto {
 303   struct proto p;
 304   const struct bgp_config *cf;          /* Shortcut to BGP configuration */
 305   ip_addr local_ip, remote_ip;
 306   u32 local_as, remote_as;
 307   u32 public_as;                        /* Externally visible ASN (local_as or confederation id) */
 308   u32 local_id;                         /* BGP identifier of this router */
 309   u32 remote_id;                        /* BGP identifier of the neighbor */
 310   u32 rr_cluster_id;                    /* Route reflector cluster ID */
 311   u8 start_state;                       /* Substates that partitions BS_START */
 312   u8 is_internal;                       /* Internal BGP session (local_as == remote_as) */
 313   u8 is_interior;                       /* Internal or intra-confederation BGP session */
 314   u8 as4_session;                       /* Session uses 4B AS numbers in AS_PATH (both sides support it) */
 315   u8 rr_client;                         /* Whether neighbor is RR client of me */
 316   u8 rs_client;                         /* Whether neighbor is RS client of me */
 317   u8 ipv4;                              /* Use IPv4 connection, i.e. remote_ip is IPv4 */
 318   u8 passive;                           /* Do not initiate outgoing connection */
 319   u8 route_refresh;                     /* Route refresh allowed to send [RFC 2918] */
 320   u8 enhanced_refresh;                  /* Enhanced refresh is negotiated [RFC 7313] */
 321   u8 gr_ready;                          /* Neighbor could do graceful restart */
 322   u8 llgr_ready;                        /* Neighbor could do Long-lived GR, implies gr_ready */
 323   u8 gr_active_num;                     /* Neighbor is doing GR, number of active channels */
 324   u8 channel_count;                     /* Number of active channels */
 325   u8 summary_add_path_rx;               /* Summary state of ADD_PATH RX w.r.t active channels */
 326   u32 *afi_map;                         /* Map channel index -> AFI */
 327   struct bgp_channel **channel_map;     /* Map channel index -> channel */
 328   struct bgp_conn *conn;                /* Connection we have established */
 329   struct bgp_conn outgoing_conn;        /* Outgoing connection we're working with */
 330   struct bgp_conn incoming_conn;        /* Incoming connection we have neither accepted nor rejected yet */
 331   struct object_lock *lock;             /* Lock for neighbor connection */
 332   struct neighbor *neigh;               /* Neighbor entry corresponding to remote ip, NULL if multihop */
 333   struct bgp_socket *sock;              /* Shared listening socket */
 334   struct bfd_request *bfd_req;          /* BFD request, if BFD is used */
 335   struct birdsock *postponed_sk;        /* Postponed incoming socket for dynamic BGP */
 336   struct bgp_stats stats;               /* BGP statistics */
 337   btime last_established;               /* Last time of enter/leave of established state */
 338   btime last_rx_update;                 /* Last time of RX update */
 339   ip_addr link_addr;                    /* Link-local version of local_ip */
 340   event *event;                         /* Event for respawning and shutting process */
 341   timer *startup_timer;                 /* Timer used to delay protocol startup due to previous errors (startup_delay) */
 342   timer *gr_timer;                      /* Timer waiting for reestablishment after graceful restart */
 343   int dynamic_name_counter;             /* Counter for dynamic BGP names */
 344   uint startup_delay;                   /* Delay (in seconds) of protocol startup due to previous errors */
 345   btime last_proto_error;               /* Time of last error that leads to protocol stop */
 346   u8 last_error_class;                  /* Error class of last error */
 347   u32 last_error_code;                  /* Error code of last error. BGP protocol errors
 348                                            are encoded as (bgp_err_code << 16 | bgp_err_subcode) */
 349 };
 350
 351 struct bgp_channel {
 352   struct channel c;
 353
 354   /* Rest are BGP specific data */
 355   struct bgp_channel_config *cf;
 356
 357   u32 afi;
 358   u32 index;
 359   const struct bgp_af_desc *desc;
 360
 361   rtable *igp_table_ip4;                /* Table for recursive IPv4 next hop lookups */
 362   rtable *igp_table_ip6;                /* Table for recursive IPv6 next hop lookups */
 363   rtable *base_table;                   /* Base table for Flowspec validation */
 364
 365   /* Rest are zeroed when down */
 366   pool *pool;
 367   HASH(struct bgp_bucket) bucket_hash;  /* Hash table of route buckets */
 368   struct bgp_bucket *withdraw_bucket;   /* Withdrawn routes */
 369   list bucket_queue;                    /* Queue of buckets to send (struct bgp_bucket) */
 370
 371   HASH(struct bgp_prefix) prefix_hash;  /* Prefixes to be sent */
 372   slab *prefix_slab;                    /* Slab holding prefix nodes */
 373
 374   ip_addr next_hop_addr;                /* Local address for NEXT_HOP attribute */
 375   ip_addr link_addr;                    /* Link-local version of next_hop_addr */
 376
 377   u32 packets_to_send;                  /* Bitmap of packet types to be sent */
 378
 379   u8 ext_next_hop;                      /* Session allows both IPv4 and IPv6 next hops */
 380
 381   u8 gr_ready;                          /* Neighbor could do GR on this AF */
 382   u8 gr_active;                         /* Neighbor is doing GR (BGP_GRS_*) */
 383
 384   timer *stale_timer;                   /* Long-lived stale timer for LLGR */
 385   u32 stale_time;                       /* Stored LLGR stale time from last session */
 386
 387   u8 add_path_rx;                       /* Session expects receive of ADD-PATH extended NLRI */
 388   u8 add_path_tx;                       /* Session expects transmit of ADD-PATH extended NLRI */
 389
 390   u8 feed_state;                        /* Feed state (TX) for EoR, RR packets, see BFS_* */
 391   u8 load_state;                        /* Load state (RX) for EoR, RR packets, see BFS_* */
 392 };
 393
 394 struct bgp_prefix {
 395   node buck_node;                       /* Node in per-bucket list */
 396   struct bgp_prefix *next;              /* Node in prefix hash table */
 397   u32 hash;
 398   u32 path_id;
 399   net_addr net[0];
 400 };
 401
 402 struct bgp_bucket {
 403   node send_node;                       /* Node in send queue */
 404   struct bgp_bucket *next;              /* Node in bucket hash table */
 405   list prefixes;                        /* Prefixes in this bucket (struct bgp_prefix) */
 406   u32 hash;                             /* Hash over extended attributes */
 407   ea_list eattrs[0];                    /* Per-bucket extended attributes */
 408 };
 409
 410 struct bgp_export_state {
 411   struct bgp_proto *proto;
 412   struct bgp_channel *channel;
 413   struct linpool *pool;
 414
 415   struct bgp_proto *src;
 416   rte *route;
 417   int mpls;
 418
 419   u32 attrs_seen[1];
 420   uint err_reject;
 421   uint local_next_hop;
 422 };
 423
 424 struct bgp_write_state {
 425   struct bgp_proto *proto;
 426   struct bgp_channel *channel;
 427   struct linpool *pool;
 428
 429   int mp_reach;
 430   int as4_session;
 431   int add_path;
 432   int mpls;
 433
 434   eattr *mp_next_hop;
 435   const adata *mpls_labels;
 436 };
 437
 438 struct bgp_parse_state {
 439   struct bgp_proto *proto;
 440   struct bgp_channel *channel;
 441   struct linpool *pool;
 442
 443   int as4_session;
 444   int add_path;
 445   int mpls;
 446   int reach_nlri_step;
 447
 448   u32 attrs_seen[256/32];
 449
 450   u32 mp_reach_af;
 451   u32 mp_unreach_af;
 452
 453   uint attr_len;
 454   uint ip_reach_len;
 455   uint ip_unreach_len;
 456   uint ip_next_hop_len;
 457   uint mp_reach_len;
 458   uint mp_unreach_len;
 459   uint mp_next_hop_len;
 460
 461   byte *attrs;
 462   byte *ip_reach_nlri;
 463   byte *ip_unreach_nlri;
 464   byte *ip_next_hop_data;
 465   byte *mp_reach_nlri;
 466   byte *mp_unreach_nlri;
 467   byte *mp_next_hop_data;
 468
 469   uint err_withdraw;
 470   uint err_subcode;
 471   jmp_buf err_jmpbuf;
 472
 473   struct hostentry *hostentry;
 474   adata *mpls_labels;
 475
 476   /* Cached state for bgp_rte_update() */
 477   u32 last_id;
 478   struct rte_src *last_src;
 479   rta *cached_rta;
 480 };
 481
 482 #define BGP_PORT                179
 483 #define BGP_VERSION             4
 484 #define BGP_HEADER_LENGTH       19
 485 #define BGP_MAX_MESSAGE_LENGTH  4096
 486 #define BGP_MAX_EXT_MSG_LENGTH  65535
 487 #define BGP_RX_BUFFER_SIZE      4096
 488 #define BGP_TX_BUFFER_SIZE      4096
 489 #define BGP_RX_BUFFER_EXT_SIZE  65535
 490 #define BGP_TX_BUFFER_EXT_SIZE  65535
 491
 492 #define BGP_CF_WALK_CHANNELS(P,C) WALK_LIST(C, P->c.channels) if (C->c.channel == &channel_bgp)
 493 #define BGP_WALK_CHANNELS(P,C) WALK_LIST(C, P->p.channels) if (C->c.channel == &channel_bgp)
 494
 495 static inline int bgp_channel_is_ipv4(struct bgp_channel *c)
 496 { return BGP_AFI(c->afi) == BGP_AFI_IPV4; }
 497
 498 static inline int bgp_channel_is_ipv6(struct bgp_channel *c)
 499 { return BGP_AFI(c->afi) == BGP_AFI_IPV6; }
 500
 501 static inline int bgp_cc_is_ipv4(struct bgp_channel_config *c)
 502 { return BGP_AFI(c->afi) == BGP_AFI_IPV4; }
 503
 504 static inline int bgp_cc_is_ipv6(struct bgp_channel_config *c)
 505 { return BGP_AFI(c->afi) == BGP_AFI_IPV6; }
 506
 507 static inline int bgp_channel_is_role_applicable(struct bgp_channel *c)
 508 { return (c->afi == BGP_AF_IPV4 || c->afi == BGP_AF_IPV6); }
 509
 510 static inline int bgp_cc_is_role_applicable(struct bgp_channel_config *c)
 511 { return (c->afi == BGP_AF_IPV4 || c->afi == BGP_AF_IPV6); }
 512
 513 static inline uint bgp_max_packet_length(struct bgp_conn *conn)
 514 { return conn->ext_messages ? BGP_MAX_EXT_MSG_LENGTH : BGP_MAX_MESSAGE_LENGTH; }
 515
 516 static inline void
 517 bgp_parse_error(struct bgp_parse_state *s, uint subcode)
 518 {
 519   s->err_subcode = subcode;
 520   longjmp(s->err_jmpbuf, 1);
 521 }
 522
 523
 524 void bgp_start_timer(timer *t, uint value);
 525 void bgp_check_config(struct bgp_config *c);
 526 void bgp_error(struct bgp_conn *c, unsigned code, unsigned subcode, byte *data, int len);
 527 void bgp_close_conn(struct bgp_conn *c);
 528 void bgp_update_startup_delay(struct bgp_proto *p);
 529 void bgp_conn_enter_openconfirm_state(struct bgp_conn *conn);
 530 void bgp_conn_enter_established_state(struct bgp_conn *conn);
 531 void bgp_conn_enter_close_state(struct bgp_conn *conn);
 532 void bgp_conn_enter_idle_state(struct bgp_conn *conn);
 533 void bgp_handle_graceful_restart(struct bgp_proto *p);
 534 void bgp_graceful_restart_done(struct bgp_channel *c);
 535 void bgp_refresh_begin(struct bgp_channel *c);
 536 void bgp_refresh_end(struct bgp_channel *c);
 537 void bgp_store_error(struct bgp_proto *p, struct bgp_conn *c, u8 class, u32 code);
 538 void bgp_stop(struct bgp_proto *p, int subcode, byte *data, uint len);
 539
 540 struct rte_source *bgp_find_source(struct bgp_proto *p, u32 path_id);
 541 struct rte_source *bgp_get_source(struct bgp_proto *p, u32 path_id);
 542
 543 static inline int
 544 rte_resolvable(rte *rt)
 545 {
 546   return rt->attrs->dest != RTD_UNREACHABLE;
 547 }
 548
 549
 550 #ifdef LOCAL_DEBUG
 551 #define BGP_FORCE_DEBUG 1
 552 #else
 553 #define BGP_FORCE_DEBUG 0
 554 #endif
 555 #define BGP_TRACE(flags, msg, args...) do { if ((p->p.debug & flags) || BGP_FORCE_DEBUG) \
 556         log(L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
 557
 558 #define BGP_TRACE_RL(rl, flags, msg, args...) do { if ((p->p.debug & flags) || BGP_FORCE_DEBUG) \
 559         log_rl(rl, L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
 560
 561
 562 /* attrs.c */
 563
 564 static inline eattr *
 565 bgp_find_attr(ea_list *attrs, uint code)
 566 {
 567   return ea_find(attrs, EA_CODE(PROTOCOL_BGP, code));
 568 }
 569
 570 eattr *
 571 bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, uintptr_t val);
 572
 573 static inline void
 574 bgp_set_attr_u32(ea_list **to, struct linpool *pool, uint code, uint flags, u32 val)
 575 { bgp_set_attr(to, pool, code, flags, (uintptr_t) val); }
 576
 577 static inline void
 578 bgp_set_attr_ptr(ea_list **to, struct linpool *pool, uint code, uint flags, const struct adata *val)
 579 { bgp_set_attr(to, pool, code, flags, (uintptr_t) val); }
 580
 581 static inline void
 582 bgp_set_attr_data(ea_list **to, struct linpool *pool, uint code, uint flags, void *data, uint len)
 583 {
 584   struct adata *a = lp_alloc_adata(pool, len);
 585   bmemcpy(a->data, data, len);
 586   bgp_set_attr(to, pool, code, flags, (uintptr_t) a);
 587 }
 588
 589 #define bgp_unset_attr(to, pool, code) ea_unset_attr(to, pool, 0, code)
 590
 591 int bgp_encode_mp_reach_mrt(struct bgp_write_state *s, eattr *a, byte *buf, uint size);
 592
 593 int bgp_encode_attrs(struct bgp_write_state *s, ea_list *attrs, byte *buf, byte *end);
 594 ea_list * bgp_decode_attrs(struct bgp_parse_state *s, byte *data, uint len);
 595 void bgp_finish_attrs(struct bgp_parse_state *s, rta *a);
 596
 597 void bgp_init_bucket_table(struct bgp_channel *c);
 598 void bgp_free_bucket_table(struct bgp_channel *c);
 599 void bgp_free_bucket(struct bgp_channel *c, struct bgp_bucket *b);
 600 void bgp_defer_bucket(struct bgp_channel *c, struct bgp_bucket *b);
 601 void bgp_withdraw_bucket(struct bgp_channel *c, struct bgp_bucket *b);
 602
 603 void bgp_init_prefix_table(struct bgp_channel *c);
 604 void bgp_free_prefix_table(struct bgp_channel *c);
 605 void bgp_free_prefix(struct bgp_channel *c, struct bgp_prefix *bp);
 606
 607 int bgp_rte_better(struct rte *, struct rte *);
 608 int bgp_rte_mergable(rte *pri, rte *sec);
 609 int bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best);
 610 struct rte *bgp_rte_modify_stale(struct rte *r, struct linpool *pool);
 611 u32 bgp_rte_igp_metric(struct rte *);
 612 void bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old);
 613 int bgp_preexport(struct channel *, struct rte *);
 614 int bgp_get_attr(const struct eattr *e, byte *buf, int buflen);
 615 void bgp_get_route_info(struct rte *, byte *buf);
 616 int bgp_total_aigp_metric_(rte *e, u64 *metric, const struct adata **ad);
 617
 618 #define BGP_AIGP_METRIC         1
 619 #define BGP_AIGP_MAX            U64(0xffffffffffffffff)
 620
 621 static inline u64
 622 bgp_total_aigp_metric(rte *r)
 623 {
 624   u64 metric = BGP_AIGP_MAX;
 625   const struct adata *ad;
 626
 627   bgp_total_aigp_metric_(r, &metric, &ad);
 628   return metric;
 629 }
 630
 631
 632 /* packets.c */
 633
 634 void bgp_dump_state_change(struct bgp_conn *conn, uint old, uint new);
 635 void bgp_prepare_capabilities(struct bgp_conn *conn);
 636 const struct bgp_af_desc *bgp_get_af_desc(u32 afi);
 637 const struct bgp_af_caps *bgp_find_af_caps(struct bgp_caps *caps, u32 afi);
 638 void bgp_schedule_packet(struct bgp_conn *conn, struct bgp_channel *c, int type);
 639 void bgp_kick_tx(void *vconn);
 640 void bgp_tx(struct birdsock *sk);
 641 int bgp_rx(struct birdsock *sk, uint size);
 642 const char * bgp_error_dsc(unsigned code, unsigned subcode);
 643 void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsigned subcode, byte *data, unsigned len);
 644
 645 void bgp_update_next_hop(struct bgp_export_state *s, eattr *a, ea_list **to);
 646
 647
 648 /* Packet types */
 649
 650 #define PKT_OPEN                0x01
 651 #define PKT_UPDATE              0x02
 652 #define PKT_NOTIFICATION        0x03
 653 #define PKT_KEEPALIVE           0x04
 654 #define PKT_ROUTE_REFRESH       0x05    /* [RFC2918] */
 655 #define PKT_BEGIN_REFRESH       0x1e    /* Dummy type for BoRR packet [RFC7313] */
 656 #define PKT_SCHEDULE_CLOSE      0x1f    /* Used internally to schedule socket close */
 657
 658 /* Attributes */
 659
 660 #define BAF_OPTIONAL            0x80
 661 #define BAF_TRANSITIVE          0x40
 662 #define BAF_PARTIAL             0x20
 663 #define BAF_EXT_LEN             0x10
 664
 665 #define BAF_DECODE_FLAGS        0x0100  /* Private flag - attribute flags are handled by the decode hook */
 666
 667 #define BA_ORIGIN               0x01    /* RFC 4271 */          /* WM */
 668 #define BA_AS_PATH              0x02                            /* WM */
 669 #define BA_NEXT_HOP             0x03                            /* WM */
 670 #define BA_MULTI_EXIT_DISC      0x04                            /* ON */
 671 #define BA_LOCAL_PREF           0x05                            /* WD */
 672 #define BA_ATOMIC_AGGR          0x06                            /* WD */
 673 #define BA_AGGREGATOR           0x07                            /* OT */
 674 #define BA_COMMUNITY            0x08    /* RFC 1997 */          /* OT */
 675 #define BA_ORIGINATOR_ID        0x09    /* RFC 4456 */          /* ON */
 676 #define BA_CLUSTER_LIST         0x0a    /* RFC 4456 */          /* ON */
 677 #define BA_MP_REACH_NLRI        0x0e    /* RFC 4760 */
 678 #define BA_MP_UNREACH_NLRI      0x0f    /* RFC 4760 */
 679 #define BA_EXT_COMMUNITY        0x10    /* RFC 4360 */
 680 #define BA_AS4_PATH             0x11    /* RFC 6793 */
 681 #define BA_AS4_AGGREGATOR       0x12    /* RFC 6793 */
 682 #define BA_AIGP                 0x1a    /* RFC 7311 */
 683 #define BA_LARGE_COMMUNITY      0x20    /* RFC 8092 */
 684 #define BA_ONLY_TO_CUSTOMER     0x23    /* RFC 9234 */
 685
 686 /* Bird's private internal BGP attributes */
 687 #define BA_MPLS_LABEL_STACK     0xfe    /* MPLS label stack transfer attribute */
 688
 689 /* BGP connection states */
 690
 691 #define BS_IDLE                 0
 692 #define BS_CONNECT              1       /* Attempting to connect */
 693 #define BS_ACTIVE               2       /* Waiting for connection retry & listening */
 694 #define BS_OPENSENT             3
 695 #define BS_OPENCONFIRM          4
 696 #define BS_ESTABLISHED          5
 697 #define BS_CLOSE                6       /* Used during transition to BS_IDLE */
 698
 699 #define BS_MAX                  7
 700
 701 /* BGP start states
 702  *
 703  * Used in PS_START for fine-grained specification of starting state.
 704  *
 705  * When BGP protocol is started by core, it goes to BSS_PREPARE. When BGP
 706  * protocol done what is neccessary to start itself (like acquiring the lock),
 707  * it goes to BSS_CONNECT.
 708  */
 709
 710 #define BSS_PREPARE             0       /* Used before ordinary BGP started, i. e. waiting for lock */
 711 #define BSS_DELAY               1       /* Startup delay due to previous errors */
 712 #define BSS_CONNECT             2       /* Ordinary BGP connecting */
 713
 714
 715 /* BGP feed states (TX)
 716  *
 717  * RFC 4724 specifies that an initial feed should end with End-of-RIB mark.
 718  *
 719  * RFC 7313 specifies that a route refresh should be demarcated by BoRR and EoRR packets.
 720  *
 721  * These states (stored in c->feed_state) are used to keep track of these
 722  * requirements. When such feed is started, BFS_LOADING / BFS_REFRESHING is
 723  * set. When it ended, BFS_LOADED / BFS_REFRESHED is set to schedule End-of-RIB
 724  * or EoRR packet. When the packet is sent, the state returned to BFS_NONE.
 725  *
 726  * Note that when a non-demarcated feed (e.g. plain RFC 4271 initial load
 727  * without End-of-RIB or plain RFC 2918 route refresh without BoRR/EoRR
 728  * demarcation) is active, BFS_NONE is set.
 729  *
 730  * BFS_NONE, BFS_LOADING and BFS_REFRESHING are also used as load states (RX)
 731  * with correspondent semantics (-, expecting End-of-RIB, expecting EoRR).
 732  */
 733
 734 #define BFS_NONE                0       /* No feed or original non-demarcated feed */
 735 #define BFS_LOADING             1       /* Initial feed active, End-of-RIB planned */
 736 #define BFS_LOADED              2       /* Loading done, End-of-RIB marker scheduled */
 737 #define BFS_REFRESHING          3       /* Route refresh (introduced by BoRR) active */
 738 #define BFS_REFRESHED           4       /* Refresh done, EoRR packet scheduled */
 739
 740
 741 /* Error classes */
 742
 743 #define BE_NONE                 0
 744 #define BE_MISC                 1       /* Miscellaneous error */
 745 #define BE_SOCKET               2       /* Socket error */
 746 #define BE_BGP_RX               3       /* BGP protocol error notification received */
 747 #define BE_BGP_TX               4       /* BGP protocol error notification sent */
 748 #define BE_AUTO_DOWN            5       /* Automatic shutdown */
 749 #define BE_MAN_DOWN             6       /* Manual shutdown */
 750
 751 /* Misc error codes */
 752
 753 #define BEM_NEIGHBOR_LOST       1
 754 #define BEM_INVALID_NEXT_HOP    2
 755 #define BEM_INVALID_MD5         3       /* MD5 authentication kernel request failed (possibly not supported) */
 756 #define BEM_NO_SOCKET           4
 757 #define BEM_LINK_DOWN           5
 758 #define BEM_BFD_DOWN            6
 759 #define BEM_GRACEFUL_RESTART    7
 760
 761 /* Automatic shutdown error codes */
 762
 763 #define BEA_ROUTE_LIMIT_EXCEEDED 1
 764
 765 /* Well-known communities */
 766
 767 #define BGP_COMM_NO_EXPORT              0xffffff01      /* Don't export outside local AS / confed. */
 768 #define BGP_COMM_NO_ADVERTISE           0xffffff02      /* Don't export at all */
 769 #define BGP_COMM_NO_EXPORT_SUBCONFED    0xffffff03      /* NO_EXPORT even in local confederation */
 770
 771 #define BGP_COMM_LLGR_STALE             0xffff0006      /* Route is stale according to LLGR */
 772 #define BGP_COMM_NO_LLGR                0xffff0007      /* Do not treat the route according to LLGR */
 773
 774 /* Origins */
 775
 776 #define ORIGIN_IGP              0
 777 #define ORIGIN_EGP              1
 778 #define ORIGIN_INCOMPLETE       2
 779
 780
 781 #endif