proto/bgp/bgp.h

   1 /*
   2  *      BIRD -- The Border Gateway Protocol
   3  *
   4  *      (c) 2000 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 #ifndef _BIRD_BGP_H_
  10 #define _BIRD_BGP_H_
  11
  12 #include <stdint.h>
  13 #include "nest/route.h"
  14 #include "nest/bfd.h"
  15 #include "lib/hash.h"
  16
  17 struct linpool;
  18 struct eattr;
  19
  20 struct bgp_config {
  21   struct proto_config c;
  22   u32 local_as, remote_as;
  23   ip_addr remote_ip;
  24   ip_addr source_addr;                  /* Source address to use */
  25   struct iface *iface;                  /* Interface for link-local addresses */
  26   u16 remote_port;                      /* Neighbor destination port */
  27   int multihop;                         /* Number of hops if multihop */
  28   int ttl_security;                     /* Enable TTL security [RFC5082] */
  29   int next_hop_self;                    /* Always set next hop to local IP address */
  30   int next_hop_keep;                    /* Do not touch next hop attribute */
  31   int missing_lladdr;                   /* What we will do when we don' know link-local addr, see MLL_* */
  32   int gw_mode;                          /* How we compute route gateway from next_hop attr, see GW_* */
  33   int compare_path_lengths;             /* Use path lengths when selecting best route */
  34   int med_metric;                       /* Compare MULTI_EXIT_DISC even between routes from differen ASes */
  35   int igp_metric;                       /* Use IGP metrics when selecting best route */
  36   int prefer_older;                     /* Prefer older routes according to RFC 5004 */
  37   int deterministic_med;                /* Use more complicated algo to have strict RFC 4271 MED comparison */
  38   u32 default_local_pref;               /* Default value for LOCAL_PREF attribute */
  39   u32 default_med;                      /* Default value for MULTI_EXIT_DISC attribute */
  40   int capabilities;                     /* Enable capability handshake [RFC3392] */
  41   int enable_refresh;                   /* Enable local support for route refresh [RFC2918] */
  42   int enable_as4;                       /* Enable local support for 4B AS numbers [RFC4893] */
  43   int enable_extended_messages;         /* Enable local support for extended messages [draft] */
  44   u32 rr_cluster_id;                    /* Route reflector cluster ID, if different from local ID */
  45   int rr_client;                        /* Whether neighbor is RR client of me */
  46   int rs_client;                        /* Whether neighbor is RS client of me */
  47   int advertise_ipv4;                   /* Whether we should add IPv4 capability advertisement to OPEN message */
  48   int passive;                          /* Do not initiate outgoing connection */
  49   int interpret_communities;            /* Hardwired handling of well-known communities */
  50   int secondary;                        /* Accept also non-best routes (i.e. RA_ACCEPTED) */
  51   int add_path;                         /* Use ADD-PATH extension [RFC7911] */
  52   int allow_local_as;                   /* Allow that number of local ASNs in incoming AS_PATHs */
  53   int allow_local_pref;                 /* Allow LOCAL_PREF in EBGP sessions */
  54   int gr_mode;                          /* Graceful restart mode (BGP_GR_*) */
  55   int setkey;                           /* Set MD5 password to system SA/SP database */
  56   unsigned gr_time;                     /* Graceful restart timeout */
  57   unsigned connect_delay_time;          /* Minimum delay between connect attempts */
  58   unsigned connect_retry_time;          /* Timeout for connect attempts */
  59   unsigned hold_time, initial_hold_time;
  60   unsigned keepalive_time;
  61   unsigned error_amnesia_time;          /* Errors are forgotten after */
  62   unsigned error_delay_time_min;        /* Time to wait after an error is detected */
  63   unsigned error_delay_time_max;
  64   unsigned disable_after_error;         /* Disable the protocol when error is detected */
  65   u32 disable_after_cease;              /* Disable it when cease is received, bitfield */
  66
  67   char *password;                       /* Password used for MD5 authentication */
  68   struct rtable_config *igp_table;      /* Table used for recursive next hop lookups */
  69   int check_link;                       /* Use iface link state for liveness detection */
  70   int bfd;                              /* Use BFD for liveness detection */
  71 };
  72
  73 #define MLL_SELF 1
  74 #define MLL_DROP 2
  75 #define MLL_IGNORE 3
  76
  77 #define GW_DIRECT 1
  78 #define GW_RECURSIVE 2
  79
  80 #define ADD_PATH_RX 1
  81 #define ADD_PATH_TX 2
  82 #define ADD_PATH_FULL 3
  83
  84 #define BGP_GR_ABLE 1
  85 #define BGP_GR_AWARE 2
  86
  87 /* For peer_gr_flags */
  88 #define BGP_GRF_RESTART 0x80
  89
  90 /* For peer_gr_aflags */
  91 #define BGP_GRF_FORWARDING 0x80
  92
  93
  94 struct bgp_conn {
  95   struct bgp_proto *bgp;
  96   struct birdsock *sk;
  97   uint state;                           /* State of connection state machine */
  98   struct timer *connect_retry_timer;
  99   struct timer *hold_timer;
 100   struct timer *keepalive_timer;
 101   struct event *tx_ev;
 102   int packets_to_send;                  /* Bitmap of packet types to be sent */
 103   int notify_code, notify_subcode, notify_size;
 104   byte *notify_data;
 105   u32 advertised_as;                    /* Temporary value for AS number received */
 106   int start_state;                      /* protocol start_state snapshot when connection established */
 107   u8 peer_refresh_support;              /* Peer supports route refresh [RFC2918] */
 108   u8 peer_as4_support;                  /* Peer supports 4B AS numbers [RFC4893] */
 109   u8 peer_add_path;                     /* Peer supports ADD-PATH [RFC7911] */
 110   u8 peer_enhanced_refresh_support;     /* Peer supports enhanced refresh [RFC7313] */
 111   u8 peer_gr_aware;
 112   u8 peer_gr_able;
 113   u16 peer_gr_time;
 114   u8 peer_gr_flags;
 115   u8 peer_gr_aflags;
 116   u8 peer_ext_messages_support;         /* Peer supports extended message length [draft] */
 117   unsigned hold_time, keepalive_time;   /* Times calculated from my and neighbor's requirements */
 118 };
 119
 120 struct bgp_proto {
 121   struct proto p;
 122   struct bgp_config *cf;                /* Shortcut to BGP configuration */
 123   u32 local_as, remote_as;
 124   int start_state;                      /* Substates that partitions BS_START */
 125   u8 is_internal;                       /* Internal BGP connection (local_as == remote_as) */
 126   u8 as4_session;                       /* Session uses 4B AS numbers in AS_PATH (both sides support it) */
 127   u8 add_path_rx;                       /* Session expects receive of ADD-PATH extended NLRI */
 128   u8 add_path_tx;                       /* Session expects transmit of ADD-PATH extended NLRI */
 129   u8 ext_messages;                      /* Session allows to use extended messages (both sides support it) */
 130   u32 local_id;                         /* BGP identifier of this router */
 131   u32 remote_id;                        /* BGP identifier of the neighbor */
 132   u32 rr_cluster_id;                    /* Route reflector cluster ID */
 133   int rr_client;                        /* Whether neighbor is RR client of me */
 134   int rs_client;                        /* Whether neighbor is RS client of me */
 135   u8 gr_ready;                          /* Neighbor could do graceful restart */
 136   u8 gr_active;                         /* Neighbor is doing graceful restart */
 137   u8 feed_state;                        /* Feed state (TX) for EoR, RR packets, see BFS_* */
 138   u8 load_state;                        /* Load state (RX) for EoR, RR packets, see BFS_* */
 139   struct bgp_conn *conn;                /* Connection we have established */
 140   struct bgp_conn outgoing_conn;        /* Outgoing connection we're working with */
 141   struct bgp_conn incoming_conn;        /* Incoming connection we have neither accepted nor rejected yet */
 142   struct object_lock *lock;             /* Lock for neighbor connection */
 143   struct neighbor *neigh;               /* Neighbor entry corresponding to remote ip, NULL if multihop */
 144   struct bfd_request *bfd_req;          /* BFD request, if BFD is used */
 145   ip_addr source_addr;                  /* Local address used as an advertised next hop */
 146   rtable *igp_table;                    /* Table used for recursive next hop lookups */
 147   struct event *event;                  /* Event for respawning and shutting process */
 148   struct timer *startup_timer;          /* Timer used to delay protocol startup due to previous errors (startup_delay) */
 149   struct timer *gr_timer;               /* Timer waiting for reestablishment after graceful restart */
 150   struct bgp_bucket **bucket_hash;      /* Hash table of attribute buckets */
 151   uint hash_size, hash_count, hash_limit;
 152   HASH(struct bgp_prefix) prefix_hash;  /* Prefixes to be sent */
 153   slab *prefix_slab;                    /* Slab holding prefix nodes */
 154   list bucket_queue;                    /* Queue of buckets to send */
 155   struct bgp_bucket *withdraw_bucket;   /* Withdrawn routes */
 156   unsigned startup_delay;               /* Time to delay protocol startup by due to errors */
 157   bird_clock_t last_proto_error;        /* Time of last error that leads to protocol stop */
 158   u8 last_error_class;                  /* Error class of last error */
 159   u32 last_error_code;                  /* Error code of last error. BGP protocol errors
 160                                            are encoded as (bgp_err_code << 16 | bgp_err_subcode) */
 161 #ifdef IPV6
 162   byte *mp_reach_start, *mp_unreach_start; /* Multiprotocol BGP attribute notes */
 163   unsigned mp_reach_len, mp_unreach_len;
 164   ip_addr local_link;                   /* Link-level version of source_addr */
 165 #endif
 166 };
 167
 168 struct bgp_prefix {
 169   struct {
 170     ip_addr prefix;
 171     int pxlen;
 172   } n;
 173   u32 path_id;
 174   struct bgp_prefix *next;
 175   node bucket_node;                     /* Node in per-bucket list */
 176 };
 177
 178 struct bgp_bucket {
 179   node send_node;                       /* Node in send queue */
 180   struct bgp_bucket *hash_next, *hash_prev;     /* Node in bucket hash table */
 181   unsigned hash;                        /* Hash over extended attributes */
 182   list prefixes;                        /* Prefixes in this buckets */
 183   ea_list eattrs[0];                    /* Per-bucket extended attributes */
 184 };
 185
 186 #define BGP_PORT                179
 187 #define BGP_VERSION             4
 188 #define BGP_HEADER_LENGTH       19
 189 #define BGP_MAX_MESSAGE_LENGTH  4096
 190 #define BGP_MAX_EXT_MSG_LENGTH  65535
 191 #define BGP_RX_BUFFER_SIZE      4096
 192 #define BGP_TX_BUFFER_SIZE      4096
 193 #define BGP_RX_BUFFER_EXT_SIZE  65535
 194 #define BGP_TX_BUFFER_EXT_SIZE  65535
 195
 196 static inline uint bgp_max_packet_length(struct bgp_proto *p)
 197 { return p->ext_messages ? BGP_MAX_EXT_MSG_LENGTH : BGP_MAX_MESSAGE_LENGTH; }
 198
 199 extern struct linpool *bgp_linpool;
 200
 201
 202 void bgp_start_timer(struct timer *t, int value);
 203 void bgp_check_config(struct bgp_config *c);
 204 void bgp_error(struct bgp_conn *c, unsigned code, unsigned subcode, byte *data, int len);
 205 void bgp_close_conn(struct bgp_conn *c);
 206 void bgp_update_startup_delay(struct bgp_proto *p);
 207 void bgp_conn_enter_openconfirm_state(struct bgp_conn *conn);
 208 void bgp_conn_enter_established_state(struct bgp_conn *conn);
 209 void bgp_conn_enter_close_state(struct bgp_conn *conn);
 210 void bgp_conn_enter_idle_state(struct bgp_conn *conn);
 211 void bgp_handle_graceful_restart(struct bgp_proto *p);
 212 void bgp_graceful_restart_done(struct bgp_proto *p);
 213 void bgp_refresh_begin(struct bgp_proto *p);
 214 void bgp_refresh_end(struct bgp_proto *p);
 215 void bgp_store_error(struct bgp_proto *p, struct bgp_conn *c, u8 class, u32 code);
 216 void bgp_stop(struct bgp_proto *p, uint subcode, byte *data, uint len);
 217
 218 struct rte_source *bgp_find_source(struct bgp_proto *p, u32 path_id);
 219 struct rte_source *bgp_get_source(struct bgp_proto *p, u32 path_id);
 220
 221
 222
 223 #ifdef LOCAL_DEBUG
 224 #define BGP_FORCE_DEBUG 1
 225 #else
 226 #define BGP_FORCE_DEBUG 0
 227 #endif
 228 #define BGP_TRACE(flags, msg, args...) do { if ((p->p.debug & flags) || BGP_FORCE_DEBUG) \
 229         log(L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
 230
 231 #define BGP_TRACE_RL(rl, flags, msg, args...) do { if ((p->p.debug & flags) || BGP_FORCE_DEBUG) \
 232         log_rl(rl, L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
 233
 234
 235 /* attrs.c */
 236
 237 /* Hack: although BA_NEXT_HOP attribute has type EAF_TYPE_IP_ADDRESS, in IPv6
 238  * we store two addesses in it - a global address and a link local address.
 239  */
 240 #ifdef IPV6
 241 #define NEXT_HOP_LENGTH (2*sizeof(ip_addr))
 242 static inline void set_next_hop(byte *b, ip_addr addr) { ((ip_addr *) b)[0] = addr; ((ip_addr *) b)[1] = IPA_NONE; }
 243 #else
 244 #define NEXT_HOP_LENGTH sizeof(ip_addr)
 245 static inline void set_next_hop(byte *b, ip_addr addr) { ((ip_addr *) b)[0] = addr; }
 246 #endif
 247
 248 void bgp_attach_attr(struct ea_list **to, struct linpool *pool, unsigned attr, uintptr_t val);
 249 byte *bgp_attach_attr_wa(struct ea_list **to, struct linpool *pool, unsigned attr, unsigned len);
 250 struct rta *bgp_decode_attrs(struct bgp_conn *conn, byte *a, uint len, struct linpool *pool, int mandatory);
 251 int bgp_get_attr(struct eattr *e, byte *buf, int buflen);
 252 int bgp_rte_better(struct rte *, struct rte *);
 253 int bgp_rte_mergable(rte *pri, rte *sec);
 254 int bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best);
 255 void bgp_rt_notify(struct proto *P, rtable *tbl UNUSED, net *n, rte *new, rte *old UNUSED, ea_list *attrs);
 256 int bgp_import_control(struct proto *, struct rte **, struct ea_list **, struct linpool *);
 257 void bgp_init_bucket_table(struct bgp_proto *);
 258 void bgp_free_bucket_table(struct bgp_proto *p);
 259 void bgp_free_bucket(struct bgp_proto *p, struct bgp_bucket *buck);
 260 void bgp_init_prefix_table(struct bgp_proto *p, u32 order);
 261 void bgp_free_prefix_table(struct bgp_proto *p);
 262 void bgp_free_prefix(struct bgp_proto *p, struct bgp_prefix *bp);
 263 uint bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains);
 264 void bgp_get_route_info(struct rte *, byte *buf, struct ea_list *attrs);
 265
 266 inline static void bgp_attach_attr_ip(struct ea_list **to, struct linpool *pool, unsigned attr, ip_addr a)
 267 { *(ip_addr *) bgp_attach_attr_wa(to, pool, attr, sizeof(ip_addr)) = a; }
 268
 269 /* packets.c */
 270
 271 void mrt_dump_bgp_state_change(struct bgp_conn *conn, unsigned old, unsigned new);
 272 void bgp_schedule_packet(struct bgp_conn *conn, int type);
 273 void bgp_kick_tx(void *vconn);
 274 void bgp_tx(struct birdsock *sk);
 275 int bgp_rx(struct birdsock *sk, uint size);
 276 const char * bgp_error_dsc(unsigned code, unsigned subcode);
 277 void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsigned subcode, byte *data, unsigned len);
 278
 279 /* Packet types */
 280
 281 #define PKT_OPEN                0x01
 282 #define PKT_UPDATE              0x02
 283 #define PKT_NOTIFICATION        0x03
 284 #define PKT_KEEPALIVE           0x04
 285 #define PKT_ROUTE_REFRESH       0x05    /* [RFC2918] */
 286 #define PKT_BEGIN_REFRESH       0x1e    /* Dummy type for BoRR packet [RFC7313] */
 287 #define PKT_SCHEDULE_CLOSE      0x1f    /* Used internally to schedule socket close */
 288
 289 /* Attributes */
 290
 291 #define BAF_OPTIONAL            0x80
 292 #define BAF_TRANSITIVE          0x40
 293 #define BAF_PARTIAL             0x20
 294 #define BAF_EXT_LEN             0x10
 295
 296 #define BA_ORIGIN               0x01    /* [RFC1771] */         /* WM */
 297 #define BA_AS_PATH              0x02                            /* WM */
 298 #define BA_NEXT_HOP             0x03                            /* WM */
 299 #define BA_MULTI_EXIT_DISC      0x04                            /* ON */
 300 #define BA_LOCAL_PREF           0x05                            /* WD */
 301 #define BA_ATOMIC_AGGR          0x06                            /* WD */
 302 #define BA_AGGREGATOR           0x07                            /* OT */
 303 #define BA_COMMUNITY            0x08    /* [RFC1997] */         /* OT */
 304 #define BA_ORIGINATOR_ID        0x09    /* [RFC1966] */         /* ON */
 305 #define BA_CLUSTER_LIST         0x0a                            /* ON */
 306 /* We don't support these: */
 307 #define BA_DPA                  0x0b    /* ??? */
 308 #define BA_ADVERTISER           0x0c    /* [RFC1863] */
 309 #define BA_RCID_PATH            0x0d
 310 #define BA_MP_REACH_NLRI        0x0e    /* [RFC2283] */
 311 #define BA_MP_UNREACH_NLRI      0x0f
 312 #define BA_EXT_COMMUNITY        0x10    /* [RFC4360] */
 313 #define BA_AS4_PATH             0x11    /* [RFC4893] */
 314 #define BA_AS4_AGGREGATOR       0x12
 315 #define BA_LARGE_COMMUNITY      0x20    /* [RFC8092] */
 316
 317 /* BGP connection states */
 318
 319 #define BS_IDLE                 0
 320 #define BS_CONNECT              1       /* Attempting to connect */
 321 #define BS_ACTIVE               2       /* Waiting for connection retry & listening */
 322 #define BS_OPENSENT             3
 323 #define BS_OPENCONFIRM          4
 324 #define BS_ESTABLISHED          5
 325 #define BS_CLOSE                6       /* Used during transition to BS_IDLE */
 326
 327 #define BS_MAX                  7
 328
 329 /* BGP start states
 330  *
 331  * Used in PS_START for fine-grained specification of starting state.
 332  *
 333  * When BGP protocol is started by core, it goes to BSS_PREPARE. When BGP
 334  * protocol done what is neccessary to start itself (like acquiring the lock),
 335  * it goes to BSS_CONNECT.  When some connection attempt failed because of
 336  * option or capability error, it goes to BSS_CONNECT_NOCAP.
 337  */
 338
 339 #define BSS_PREPARE             0       /* Used before ordinary BGP started, i. e. waiting for lock */
 340 #define BSS_DELAY               1       /* Startup delay due to previous errors */
 341 #define BSS_CONNECT             2       /* Ordinary BGP connecting */
 342 #define BSS_CONNECT_NOCAP       3       /* Legacy BGP connecting (without capabilities) */
 343
 344
 345 /* BGP feed states (TX)
 346  *
 347  * RFC 4724 specifies that an initial feed should end with End-of-RIB mark.
 348  *
 349  * RFC 7313 specifies that a route refresh should be demarcated by BoRR and EoRR packets.
 350  *
 351  * These states (stored in p->feed_state) are used to keep track of these
 352  * requirements. When such feed is started, BFS_LOADING / BFS_REFRESHING is
 353  * set. When it ended, BFS_LOADED / BFS_REFRESHED is set to schedule End-of-RIB
 354  * or EoRR packet. When the packet is sent, the state returned to BFS_NONE.
 355  *
 356  * Note that when a non-demarcated feed (e.g. plain RFC 4271 initial load
 357  * without End-of-RIB or plain RFC 2918 route refresh without BoRR/EoRR
 358  * demarcation) is active, BFS_NONE is set.
 359  *
 360  * BFS_NONE, BFS_LOADING and BFS_REFRESHING are also used as load states (RX)
 361  * with correspondent semantics (-, expecting End-of-RIB, expecting EoRR).
 362  */
 363
 364 #define BFS_NONE                0       /* No feed or original non-demarcated feed */
 365 #define BFS_LOADING             1       /* Initial feed active, End-of-RIB planned */
 366 #define BFS_LOADED              2       /* Loading done, End-of-RIB marker scheduled */
 367 #define BFS_REFRESHING          3       /* Route refresh (introduced by BoRR) active */
 368 #define BFS_REFRESHED           4       /* Refresh done, EoRR packet scheduled */
 369
 370
 371 /* Error classes */
 372
 373 #define BE_NONE                 0
 374 #define BE_MISC                 1       /* Miscellaneous error */
 375 #define BE_SOCKET               2       /* Socket error */
 376 #define BE_BGP_RX               3       /* BGP protocol error notification received */
 377 #define BE_BGP_TX               4       /* BGP protocol error notification sent */
 378 #define BE_AUTO_DOWN            5       /* Automatic shutdown */
 379 #define BE_MAN_DOWN             6       /* Manual shutdown */
 380
 381 /* Misc error codes */
 382
 383 #define BEM_NEIGHBOR_LOST       1
 384 #define BEM_INVALID_NEXT_HOP    2
 385 #define BEM_INVALID_MD5         3       /* MD5 authentication kernel request failed (possibly not supported) */
 386 #define BEM_NO_SOCKET           4
 387 #define BEM_LINK_DOWN           5
 388 #define BEM_BFD_DOWN            6
 389 #define BEM_GRACEFUL_RESTART    7
 390
 391 /* Automatic shutdown error codes */
 392
 393 #define BEA_ROUTE_LIMIT_EXCEEDED 1
 394
 395 /* Well-known communities */
 396
 397 #define BGP_COMM_NO_EXPORT              0xffffff01      /* Don't export outside local AS / confed. */
 398 #define BGP_COMM_NO_ADVERTISE           0xffffff02      /* Don't export at all */
 399 #define BGP_COMM_NO_EXPORT_SUBCONFED    0xffffff03      /* NO_EXPORT even in local confederation */
 400
 401 /* Origins */
 402
 403 #define ORIGIN_IGP              0
 404 #define ORIGIN_EGP              1
 405 #define ORIGIN_INCOMPLETE       2
 406
 407 /* Address families */
 408
 409 #define BGP_AF_IPV4             1
 410 #define BGP_AF_IPV6             2
 411
 412 #ifdef IPV6
 413 #define BGP_AF BGP_AF_IPV6
 414 #else
 415 #define BGP_AF BGP_AF_IPV4
 416 #endif
 417
 418 #endif