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 linpool;
  24 struct eattr;
  25
  26
  27 /* Address families */
  28
  29 #define BGP_AFI_IPV4            1
  30 #define BGP_AFI_IPV6            2
  31
  32 #define BGP_SAFI_UNICAST        1
  33 #define BGP_SAFI_MULTICAST      2
  34
  35 /* Internal AF codes */
  36
  37 #define BGP_AF(A, B)            (((u32)(A) << 16) | (u32)(B))
  38 #define BGP_AFI(A)              ((u32)(A) >> 16)
  39 #define BGP_SAFI(A)             ((u32)(A) & 0xFFFF)
  40
  41 #define BGP_AF_IPV4             BGP_AF( BGP_AFI_IPV4, BGP_SAFI_UNICAST )
  42 #define BGP_AF_IPV6             BGP_AF( BGP_AFI_IPV6, BGP_SAFI_UNICAST )
  43 #define BGP_AF_IPV4_MC          BGP_AF( BGP_AFI_IPV4, BGP_SAFI_MULTICAST )
  44 #define BGP_AF_IPV6_MC          BGP_AF( BGP_AFI_IPV6, BGP_SAFI_MULTICAST )
  45
  46
  47 struct bgp_write_state;
  48 struct bgp_parse_state;
  49 struct bgp_export_state;
  50 struct bgp_bucket;
  51
  52 struct bgp_af_desc {
  53   u32 afi;
  54   u32 net;
  55   const char *name;
  56   uint (*encode_nlri)(struct bgp_write_state *s, struct bgp_bucket *buck, byte *buf, uint size);
  57   void (*decode_nlri)(struct bgp_parse_state *s, byte *pos, uint len, rta *a);
  58   void (*update_next_hop)(struct bgp_export_state *s, eattr *nh, ea_list **to);
  59   uint (*encode_next_hop)(struct bgp_write_state *s, eattr *nh, byte *buf, uint size);
  60   void (*decode_next_hop)(struct bgp_parse_state *s, byte *pos, uint len, rta *a);
  61 };
  62
  63
  64 struct bgp_config {
  65   struct proto_config c;
  66   u32 local_as, remote_as;
  67   ip_addr local_ip;                     /* Source address to use */
  68   ip_addr remote_ip;
  69   struct iface *iface;                  /* Interface for link-local addresses */
  70   u16 local_port;                       /* Local listening port */
  71   u16 remote_port;                      /* Neighbor destination port */
  72   int multihop;                         /* Number of hops if multihop */
  73   int strict_bind;                      /* Bind listening socket to local address XXXX */
  74   int ttl_security;                     /* Enable TTL security [RFC 5082] */
  75   int compare_path_lengths;             /* Use path lengths when selecting best route */
  76   int med_metric;                       /* Compare MULTI_EXIT_DISC even between routes from differen ASes */
  77   int igp_metric;                       /* Use IGP metrics when selecting best route */
  78   int prefer_older;                     /* Prefer older routes according to RFC 5004 */
  79   int deterministic_med;                /* Use more complicated algo to have strict RFC 4271 MED comparison */
  80   u32 default_local_pref;               /* Default value for LOCAL_PREF attribute */
  81   u32 default_med;                      /* Default value for MULTI_EXIT_DISC attribute */
  82   int capabilities;                     /* Enable capability handshake [RFC 3392] */
  83   int enable_refresh;                   /* Enable local support for route refresh [RFC 2918] */
  84   int enable_as4;                       /* Enable local support for 4B AS numbers [RFC 4893] */
  85   int enable_extended_messages;         /* Enable local support for extended messages [draft] */
  86   u32 rr_cluster_id;                    /* Route reflector cluster ID, if different from local ID */
  87   int rr_client;                        /* Whether neighbor is RR client of me */
  88   int rs_client;                        /* Whether neighbor is RS client of me */
  89   u32 confederation;                    /* Confederation ID, or zero if confeds not active */
  90   int confederation_member;             /* Whether neighbor AS is member of our confederation */
  91   int passive;                          /* Do not initiate outgoing connection */
  92   int interpret_communities;            /* Hardwired handling of well-known communities */
  93   int allow_local_as;                   /* Allow that number of local ASNs in incoming AS_PATHs */
  94   int gr_mode;                          /* Graceful restart mode (BGP_GR_*) */
  95   int setkey;                           /* Set MD5 password to system SA/SP database */
  96   unsigned gr_time;                     /* Graceful restart timeout */
  97   unsigned connect_delay_time;          /* Minimum delay between connect attempts */
  98   unsigned connect_retry_time;          /* Timeout for connect attempts */
  99   unsigned hold_time, initial_hold_time;
 100   unsigned keepalive_time;
 101   unsigned error_amnesia_time;          /* Errors are forgotten after */
 102   unsigned error_delay_time_min;        /* Time to wait after an error is detected */
 103   unsigned error_delay_time_max;
 104   unsigned disable_after_error;         /* Disable the protocol when error is detected */
 105
 106   char *password;                       /* Password used for MD5 authentication */
 107   int check_link;                       /* Use iface link state for liveness detection */
 108   int bfd;                              /* Use BFD for liveness detection */
 109 };
 110
 111 struct bgp_channel_config {
 112   struct channel_config c;
 113
 114   u32 afi;
 115
 116   ip_addr next_hop_addr;                /* Local address for NEXT_HOP attribute */
 117   u8 next_hop_self;                     /* Always set next hop to local IP address */
 118   u8 next_hop_keep;                     /* Do not touch next hop attribute */
 119   u8 missing_lladdr;                    /* What we will do when we don' know link-local addr, see MLL_* */
 120   u8 gw_mode;                           /* How we compute route gateway from next_hop attr, see GW_* */
 121   u8 secondary;                         /* Accept also non-best routes (i.e. RA_ACCEPTED) */
 122   u8 gr_able;                           /* Allow full graceful restart for the channel */
 123   u8 add_path;                          /* Use ADD-PATH extension [RFC 7911] */
 124
 125   struct rtable_config *igp_table;      /* Table used for recursive next hop lookups */
 126 };
 127
 128 #define MLL_SELF 1
 129 #define MLL_DROP 2
 130 #define MLL_IGNORE 3
 131
 132 #define GW_DIRECT 1
 133 #define GW_RECURSIVE 2
 134
 135 #define BGP_ADD_PATH_RX         1
 136 #define BGP_ADD_PATH_TX         2
 137 #define BGP_ADD_PATH_FULL       3
 138
 139 #define BGP_GR_ABLE             1
 140 #define BGP_GR_AWARE            2
 141
 142 /* For GR capability common flags */
 143 #define BGP_GRF_RESTART 0x80
 144
 145 /* For GR capability per-AF flags */
 146 #define BGP_GRF_FORWARDING 0x80
 147
 148
 149 struct bgp_af_caps {
 150   u32 afi;
 151   u8 ready;                             /* Multiprotocol capability, RFC 4760 */
 152   u8 gr_able;                           /* Graceful restart support, RFC 4724 */
 153   u8 gr_af_flags;                       /* Graceful restart per-AF flags */
 154   u8 add_path;                          /* Multiple paths support,   RFC 7911 */
 155 };
 156
 157 struct bgp_caps {
 158   u32 as4_number;                       /* Announced ASN */
 159
 160   u8 as4_support;                       /* Four-octet AS capability, RFC 6793 */
 161   u8 ext_messages;                      /* Extended message length,  RFC draft */
 162   u8 route_refresh;                     /* Route refresh capability, RFC 2918 */
 163   u8 enhanced_refresh;                  /* Enhanced route refresh,   RFC 7313 */
 164
 165   u8 gr_aware;                          /* Graceful restart capability, RFC 4724 */
 166   u8 gr_flags;                          /* Graceful restart flags */
 167   u16 gr_time;                          /* Graceful restart time in seconds */
 168
 169   u16 af_count;                         /* Number of af_data items */
 170
 171   struct bgp_af_caps af_data[0];        /* Per-AF capability data */
 172 };
 173
 174 struct bgp_socket {
 175   node n;                               /* Node in global bgp_sockets */
 176   sock *sk;                             /* Real listening socket */
 177   u32 uc;                               /* Use count */
 178 };
 179
 180 struct bgp_conn {
 181   struct bgp_proto *bgp;
 182   struct birdsock *sk;
 183   u8 state;                             /* State of connection state machine */
 184   u8 as4_session;                       /* Session uses 4B AS numbers in AS_PATH (both sides support it) */
 185   u8 ext_messages;                      /* Session uses extended message length */
 186
 187   struct bgp_caps *local_caps;
 188   struct bgp_caps *remote_caps;
 189   struct timer *connect_timer;
 190   struct timer *hold_timer;
 191   struct timer *keepalive_timer;
 192   struct event *tx_ev;
 193   u32 packets_to_send;                  /* Bitmap of packet types to be sent */
 194   u32 channels_to_send;                 /* Bitmap of channels with packets to be sent */
 195   u8 last_channel;                      /* Channel used last time for TX */
 196   u8 last_channel_count;                /* Number of times the last channel was used in succession */
 197   int notify_code, notify_subcode, notify_size;
 198   byte *notify_data;
 199
 200   uint hold_time, keepalive_time;       /* Times calculated from my and neighbor's requirements */
 201 };
 202
 203 struct bgp_proto {
 204   struct proto p;
 205   struct bgp_config *cf;                /* Shortcut to BGP configuration */
 206   u32 local_as, remote_as;
 207   u32 public_as;                        /* Externally visible ASN (local_as or confederation id) */
 208   u32 local_id;                         /* BGP identifier of this router */
 209   u32 remote_id;                        /* BGP identifier of the neighbor */
 210   u32 rr_cluster_id;                    /* Route reflector cluster ID */
 211   int start_state;                      /* Substates that partitions BS_START */
 212   u8 is_internal;                       /* Internal BGP session (local_as == remote_as) */
 213   u8 is_interior;                       /* Internal or intra-confederation BGP session */
 214   u8 as4_session;                       /* Session uses 4B AS numbers in AS_PATH (both sides support it) */
 215   u8 rr_client;                         /* Whether neighbor is RR client of me */
 216   u8 rs_client;                         /* Whether neighbor is RS client of me */
 217   u8 route_refresh;                     /* Route refresh allowed to send [RFC 2918] */
 218   u8 enhanced_refresh;                  /* Enhanced refresh is negotiated [RFC 7313] */
 219   u8 gr_ready;                          /* Neighbor could do graceful restart */
 220   u8 gr_active_num;                     /* Neighbor is doing GR, number of active channels */
 221   u8 channel_count;                     /* Number of active channels */
 222   u32 *afi_map;                         /* Map channel index -> AFI */
 223   struct bgp_channel **channel_map;     /* Map channel index -> channel */
 224   struct bgp_conn *conn;                /* Connection we have established */
 225   struct bgp_conn outgoing_conn;        /* Outgoing connection we're working with */
 226   struct bgp_conn incoming_conn;        /* Incoming connection we have neither accepted nor rejected yet */
 227   struct object_lock *lock;             /* Lock for neighbor connection */
 228   struct neighbor *neigh;               /* Neighbor entry corresponding to remote ip, NULL if multihop */
 229   struct bgp_socket *sock;              /* Shared listening socket */
 230   struct bfd_request *bfd_req;          /* BFD request, if BFD is used */
 231   ip_addr source_addr;                  /* Local address used as an advertised next hop */
 232   ip_addr link_addr;                    /* Link-local version of source_addr */
 233   struct event *event;                  /* Event for respawning and shutting process */
 234   struct timer *startup_timer;          /* Timer used to delay protocol startup due to previous errors (startup_delay) */
 235   struct timer *gr_timer;               /* Timer waiting for reestablishment after graceful restart */
 236   unsigned startup_delay;               /* Time to delay protocol startup by due to errors */
 237   bird_clock_t last_proto_error;        /* Time of last error that leads to protocol stop */
 238   u8 last_error_class;                  /* Error class of last error */
 239   u32 last_error_code;                  /* Error code of last error. BGP protocol errors
 240                                            are encoded as (bgp_err_code << 16 | bgp_err_subcode) */
 241 };
 242
 243 struct bgp_channel {
 244   struct channel c;
 245
 246   /* Rest are BGP specific data */
 247   struct bgp_channel_config *cf;
 248   pool *pool; /* XXXX */
 249
 250   u32 afi;
 251   u32 index;
 252   const struct bgp_af_desc *desc;
 253
 254   HASH(struct bgp_bucket) bucket_hash;  /* Hash table of route buckets */
 255   struct bgp_bucket *withdraw_bucket;   /* Withdrawn routes */
 256   list bucket_queue;                    /* Queue of buckets to send (struct bgp_bucket) */
 257
 258   HASH(struct bgp_prefix) prefix_hash;  /* Prefixes to be sent */
 259   slab *prefix_slab;                    /* Slab holding prefix nodes */
 260
 261   rtable *igp_table;                    /* Table used for recursive next hop lookups */
 262   ip_addr next_hop_addr;                /* Local address for NEXT_HOP attribute */
 263   ip_addr link_addr;                    /* Link-local version of next_hop_addr */
 264
 265   u32 packets_to_send;                  /* Bitmap of packet types to be sent */
 266
 267   u8 gr_ready;                          /* Neighbor could do GR on this AF */
 268   u8 gr_active;                         /* Neighbor is doing GR and keeping fwd state */
 269
 270   u8 add_path_rx;                       /* Session expects receive of ADD-PATH extended NLRI */
 271   u8 add_path_tx;                       /* Session expects transmit of ADD-PATH extended NLRI */
 272
 273   u8 feed_state;                        /* Feed state (TX) for EoR, RR packets, see BFS_* */
 274   u8 load_state;                        /* Load state (RX) for EoR, RR packets, see BFS_* */
 275 };
 276
 277 struct bgp_prefix {
 278   node buck_node;                       /* Node in per-bucket list */
 279   struct bgp_prefix *next;              /* Node in prefix hash table */
 280   u32 hash;
 281   u32 path_id;
 282   net_addr net[0];
 283 };
 284
 285 struct bgp_bucket {
 286   node send_node;                       /* Node in send queue */
 287   struct bgp_bucket *next;              /* Node in bucket hash table */
 288   list prefixes;                        /* Prefixes in this bucket (struct bgp_prefix) */
 289   u32 hash;                             /* Hash over extended attributes */
 290   ea_list eattrs[0];                    /* Per-bucket extended attributes */
 291 };
 292
 293 struct bgp_export_state {
 294   struct bgp_proto *proto;
 295   struct bgp_channel *channel;
 296   struct linpool *pool;
 297
 298   struct bgp_proto *src;
 299   rte *route;
 300
 301   u32 attrs_seen[1];
 302   uint err_withdraw;
 303 };
 304
 305 struct bgp_write_state {
 306   struct bgp_proto *proto;
 307   struct bgp_channel *channel;
 308   struct linpool *pool;
 309
 310   int as4_session;
 311   int add_path;
 312
 313   eattr *mp_next_hop;
 314 };
 315
 316 struct bgp_parse_state {
 317   struct bgp_proto *proto;
 318   struct bgp_channel *channel;
 319   struct linpool *pool;
 320
 321   int as4_session;
 322   int add_path;
 323
 324   u32 attrs_seen[256/32];
 325
 326   u32 mp_reach_af;
 327   u32 mp_unreach_af;
 328
 329   uint attr_len;
 330   uint ip_reach_len;
 331   uint ip_unreach_len;
 332   uint ip_next_hop_len;
 333   uint mp_reach_len;
 334   uint mp_unreach_len;
 335   uint mp_next_hop_len;
 336
 337   byte *attrs;
 338   byte *ip_reach_nlri;
 339   byte *ip_unreach_nlri;
 340   byte *ip_next_hop_data;
 341   byte *mp_reach_nlri;
 342   byte *mp_unreach_nlri;
 343   byte *mp_next_hop_data;
 344
 345   uint err_withdraw;
 346   uint err_subcode;
 347   jmp_buf err_jmpbuf;
 348
 349   /* Cached state for bgp_rte_update() */
 350   u32 last_id;
 351   struct rte_src *last_src;
 352   rta *cached_rta;
 353 };
 354
 355 #define BGP_PORT                179
 356 #define BGP_VERSION             4
 357 #define BGP_HEADER_LENGTH       19
 358 #define BGP_MAX_MESSAGE_LENGTH  4096
 359 #define BGP_MAX_EXT_MSG_LENGTH  65535
 360 #define BGP_RX_BUFFER_SIZE      4096
 361 #define BGP_TX_BUFFER_SIZE      4096
 362 #define BGP_RX_BUFFER_EXT_SIZE  65535
 363 #define BGP_TX_BUFFER_EXT_SIZE  65535
 364
 365 static inline int bgp_channel_is_ipv4(struct bgp_channel *c)
 366 { return BGP_AFI(c->afi) == BGP_AFI_IPV4; }
 367
 368 static inline int bgp_channel_is_ipv6(struct bgp_channel *c)
 369 { return BGP_AFI(c->afi) == BGP_AFI_IPV6; }
 370
 371 static inline uint bgp_max_packet_length(struct bgp_conn *conn)
 372 { return conn->ext_messages ? BGP_MAX_EXT_MSG_LENGTH : BGP_MAX_MESSAGE_LENGTH; }
 373
 374 static inline void
 375 bgp_parse_error(struct bgp_parse_state *s, uint subcode)
 376 {
 377   s->err_subcode = subcode;
 378   longjmp(s->err_jmpbuf, 1);
 379 }
 380
 381 extern struct linpool *bgp_linpool;
 382
 383
 384 void bgp_start_timer(struct timer *t, int value);
 385 void bgp_check_config(struct bgp_config *c);
 386 void bgp_error(struct bgp_conn *c, unsigned code, unsigned subcode, byte *data, int len);
 387 void bgp_close_conn(struct bgp_conn *c);
 388 void bgp_update_startup_delay(struct bgp_proto *p);
 389 void bgp_conn_enter_openconfirm_state(struct bgp_conn *conn);
 390 void bgp_conn_enter_established_state(struct bgp_conn *conn);
 391 void bgp_conn_enter_close_state(struct bgp_conn *conn);
 392 void bgp_conn_enter_idle_state(struct bgp_conn *conn);
 393 void bgp_handle_graceful_restart(struct bgp_proto *p);
 394 void bgp_graceful_restart_done(struct bgp_channel *c);
 395 void bgp_refresh_begin(struct bgp_channel *c);
 396 void bgp_refresh_end(struct bgp_channel *c);
 397 void bgp_store_error(struct bgp_proto *p, struct bgp_conn *c, u8 class, u32 code);
 398 void bgp_stop(struct bgp_proto *p, unsigned subcode);
 399
 400 struct rte_source *bgp_find_source(struct bgp_proto *p, u32 path_id);
 401 struct rte_source *bgp_get_source(struct bgp_proto *p, u32 path_id);
 402
 403
 404
 405 #ifdef LOCAL_DEBUG
 406 #define BGP_FORCE_DEBUG 1
 407 #else
 408 #define BGP_FORCE_DEBUG 0
 409 #endif
 410 #define BGP_TRACE(flags, msg, args...) do { if ((p->p.debug & flags) || BGP_FORCE_DEBUG) \
 411         log(L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
 412
 413 #define BGP_TRACE_RL(rl, flags, msg, args...) do { if ((p->p.debug & flags) || BGP_FORCE_DEBUG) \
 414         log_rl(rl, L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
 415
 416
 417 /* attrs.c */
 418
 419 static inline eattr *
 420 bgp_find_attr(ea_list *attrs, uint code)
 421 {
 422   return ea_find(attrs, EA_CODE(EAP_BGP, code));
 423 }
 424
 425 eattr *
 426 bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, uintptr_t val);
 427
 428 static inline void
 429 bgp_set_attr_u32(ea_list **to, struct linpool *pool, uint code, uint flags, u32 val)
 430 { bgp_set_attr(to, pool, code, flags, (uintptr_t) val); }
 431
 432 static inline void
 433 bgp_set_attr_ptr(ea_list **to, struct linpool *pool, uint code, uint flags, struct adata *val)
 434 { bgp_set_attr(to, pool, code, flags, (uintptr_t) val); }
 435
 436 static inline void
 437 bgp_set_attr_data(ea_list **to, struct linpool *pool, uint code, uint flags, void *data, uint len)
 438 {
 439   struct adata *a = lp_alloc_adata(pool, len);
 440   memcpy(a->data, data, len);
 441   bgp_set_attr(to, pool, code, flags, (uintptr_t) a);
 442 }
 443
 444 static inline void
 445 bgp_unset_attr(ea_list **to, struct linpool *pool, uint code)
 446 { eattr *e = bgp_set_attr(to, pool, code, 0, 0); e->type = EAF_TYPE_UNDEF; }
 447
 448
 449
 450
 451 /* Hack: although BA_NEXT_HOP attribute has type EAF_TYPE_IP_ADDRESS, in IPv6
 452  * we store two addesses in it - a global address and a link local address.
 453  */
 454 #ifdef XXX
 455 #define NEXT_HOP_LENGTH (2*sizeof(ip_addr))
 456 static inline void set_next_hop(byte *b, ip_addr addr) { ((ip_addr *) b)[0] = addr; ((ip_addr *) b)[1] = IPA_NONE; }
 457 #define NEXT_HOP_LENGTH sizeof(ip_addr)
 458 static inline void set_next_hop(byte *b, ip_addr addr) { ((ip_addr *) b)[0] = addr; }
 459 #endif
 460
 461 int bgp_encode_attrs(struct bgp_write_state *s, ea_list *attrs, byte *buf, byte *end);
 462 ea_list * bgp_decode_attrs(struct bgp_parse_state *s, byte *data, uint len);
 463
 464 void bgp_init_bucket_table(struct bgp_channel *c);
 465 void bgp_free_bucket(struct bgp_channel *c, struct bgp_bucket *b);
 466 void bgp_defer_bucket(struct bgp_channel *c, struct bgp_bucket *b);
 467 void bgp_withdraw_bucket(struct bgp_channel *c, struct bgp_bucket *b);
 468
 469 void bgp_init_prefix_table(struct bgp_channel *c);
 470 void bgp_free_prefix(struct bgp_channel *c, struct bgp_prefix *bp);
 471
 472 int bgp_rte_better(struct rte *, struct rte *);
 473 int bgp_rte_mergable(rte *pri, rte *sec);
 474 int bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best);
 475 void bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old, ea_list *attrs);
 476 int bgp_import_control(struct proto *, struct rte **, struct ea_list **, struct linpool *);
 477 int bgp_get_attr(struct eattr *e, byte *buf, int buflen);
 478 void bgp_get_route_info(struct rte *, byte *buf, struct ea_list *attrs);
 479
 480
 481 /* packets.c */
 482
 483 void mrt_dump_bgp_state_change(struct bgp_conn *conn, unsigned old, unsigned new);
 484 const struct bgp_af_desc *bgp_get_af_desc(u32 afi);
 485 const struct bgp_af_caps *bgp_find_af_caps(struct bgp_caps *caps, u32 afi);
 486 void bgp_schedule_packet(struct bgp_conn *conn, struct bgp_channel *c, int type);
 487 void bgp_kick_tx(void *vconn);
 488 void bgp_tx(struct birdsock *sk);
 489 int bgp_rx(struct birdsock *sk, uint size);
 490 const char * bgp_error_dsc(unsigned code, unsigned subcode);
 491 void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsigned subcode, byte *data, unsigned len);
 492
 493 void bgp_update_next_hop(struct bgp_export_state *s, eattr *a, ea_list **to);
 494
 495
 496 /* Packet types */
 497
 498 #define PKT_OPEN                0x01
 499 #define PKT_UPDATE              0x02
 500 #define PKT_NOTIFICATION        0x03
 501 #define PKT_KEEPALIVE           0x04
 502 #define PKT_ROUTE_REFRESH       0x05    /* [RFC2918] */
 503 #define PKT_BEGIN_REFRESH       0x1e    /* Dummy type for BoRR packet [RFC7313] */
 504 #define PKT_SCHEDULE_CLOSE      0x1f    /* Used internally to schedule socket close */
 505
 506 /* Attributes */
 507
 508 #define BAF_OPTIONAL            0x80
 509 #define BAF_TRANSITIVE          0x40
 510 #define BAF_PARTIAL             0x20
 511 #define BAF_EXT_LEN             0x10
 512
 513 #define BA_ORIGIN               0x01    /* [RFC1771] */         /* WM */
 514 #define BA_AS_PATH              0x02                            /* WM */
 515 #define BA_NEXT_HOP             0x03                            /* WM */
 516 #define BA_MULTI_EXIT_DISC      0x04                            /* ON */
 517 #define BA_LOCAL_PREF           0x05                            /* WD */
 518 #define BA_ATOMIC_AGGR          0x06                            /* WD */
 519 #define BA_AGGREGATOR           0x07                            /* OT */
 520 #define BA_COMMUNITY            0x08    /* [RFC1997] */         /* OT */
 521 #define BA_ORIGINATOR_ID        0x09    /* [RFC1966] */         /* ON */
 522 #define BA_CLUSTER_LIST         0x0a                            /* ON */
 523 /* We don't support these: */
 524 #define BA_DPA                  0x0b    /* ??? */
 525 #define BA_ADVERTISER           0x0c    /* [RFC1863] */
 526 #define BA_RCID_PATH            0x0d
 527 #define BA_MP_REACH_NLRI        0x0e    /* [RFC2283] */
 528 #define BA_MP_UNREACH_NLRI      0x0f
 529 #define BA_EXT_COMMUNITY        0x10    /* RFC 4360 */
 530 #define BA_AS4_PATH             0x11    /* RFC 6793 */
 531 #define BA_AS4_AGGREGATOR       0x12    /* RFC 6793 */
 532 #define BA_LARGE_COMMUNITY      0x20    /* [draft-ietf-idr-large-community] */
 533
 534 /* BGP connection states */
 535
 536 #define BS_IDLE                 0
 537 #define BS_CONNECT              1       /* Attempting to connect */
 538 #define BS_ACTIVE               2       /* Waiting for connection retry & listening */
 539 #define BS_OPENSENT             3
 540 #define BS_OPENCONFIRM          4
 541 #define BS_ESTABLISHED          5
 542 #define BS_CLOSE                6       /* Used during transition to BS_IDLE */
 543
 544 #define BS_MAX                  7
 545
 546 /* BGP start states
 547  *
 548  * Used in PS_START for fine-grained specification of starting state.
 549  *
 550  * When BGP protocol is started by core, it goes to BSS_PREPARE. When BGP
 551  * protocol done what is neccessary to start itself (like acquiring the lock),
 552  * it goes to BSS_CONNECT.
 553  */
 554
 555 #define BSS_PREPARE             0       /* Used before ordinary BGP started, i. e. waiting for lock */
 556 #define BSS_DELAY               1       /* Startup delay due to previous errors */
 557 #define BSS_CONNECT             2       /* Ordinary BGP connecting */
 558
 559
 560 /* BGP feed states (TX)
 561  *
 562  * RFC 4724 specifies that an initial feed should end with End-of-RIB mark.
 563  *
 564  * RFC 7313 specifies that a route refresh should be demarcated by BoRR and EoRR packets.
 565  *
 566  * These states (stored in c->feed_state) are used to keep track of these
 567  * requirements. When such feed is started, BFS_LOADING / BFS_REFRESHING is
 568  * set. When it ended, BFS_LOADED / BFS_REFRESHED is set to schedule End-of-RIB
 569  * or EoRR packet. When the packet is sent, the state returned to BFS_NONE.
 570  *
 571  * Note that when a non-demarcated feed (e.g. plain RFC 4271 initial load
 572  * without End-of-RIB or plain RFC 2918 route refresh without BoRR/EoRR
 573  * demarcation) is active, BFS_NONE is set.
 574  *
 575  * BFS_NONE, BFS_LOADING and BFS_REFRESHING are also used as load states (RX)
 576  * with correspondent semantics (-, expecting End-of-RIB, expecting EoRR).
 577  */
 578
 579 #define BFS_NONE                0       /* No feed or original non-demarcated feed */
 580 #define BFS_LOADING             1       /* Initial feed active, End-of-RIB planned */
 581 #define BFS_LOADED              2       /* Loading done, End-of-RIB marker scheduled */
 582 #define BFS_REFRESHING          3       /* Route refresh (introduced by BoRR) active */
 583 #define BFS_REFRESHED           4       /* Refresh done, EoRR packet scheduled */
 584
 585
 586 /* Error classes */
 587
 588 #define BE_NONE                 0
 589 #define BE_MISC                 1       /* Miscellaneous error */
 590 #define BE_SOCKET               2       /* Socket error */
 591 #define BE_BGP_RX               3       /* BGP protocol error notification received */
 592 #define BE_BGP_TX               4       /* BGP protocol error notification sent */
 593 #define BE_AUTO_DOWN            5       /* Automatic shutdown */
 594 #define BE_MAN_DOWN             6       /* Manual shutdown */
 595
 596 /* Misc error codes */
 597
 598 #define BEM_NEIGHBOR_LOST       1
 599 #define BEM_INVALID_NEXT_HOP    2
 600 #define BEM_INVALID_MD5         3       /* MD5 authentication kernel request failed (possibly not supported) */
 601 #define BEM_NO_SOCKET           4
 602 #define BEM_LINK_DOWN           5
 603 #define BEM_BFD_DOWN            6
 604 #define BEM_GRACEFUL_RESTART    7
 605
 606 /* Automatic shutdown error codes */
 607
 608 #define BEA_ROUTE_LIMIT_EXCEEDED 1
 609
 610 /* Well-known communities */
 611
 612 #define BGP_COMM_NO_EXPORT              0xffffff01      /* Don't export outside local AS / confed. */
 613 #define BGP_COMM_NO_ADVERTISE           0xffffff02      /* Don't export at all */
 614 #define BGP_COMM_NO_EXPORT_SUBCONFED    0xffffff03      /* NO_EXPORT even in local confederation */
 615
 616 /* Origins */
 617
 618 #define ORIGIN_IGP              0
 619 #define ORIGIN_EGP              1
 620 #define ORIGIN_INCOMPLETE       2
 621
 622
 623 #endif