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