Statistics
| Branch: | Revision:

iof-bird-daemon / proto / bgp / bgp.h @ c8236a50

History | View | Annotate | Download (28 KB)

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
#include "map.h"
24

    
25
struct linpool;
26
struct eattr;
27

    
28

    
29
/* Address families */
30

    
31
#define BGP_AFI_IPV4                1
32
#define BGP_AFI_IPV6                2
33

    
34
#define BGP_SAFI_UNICAST        1
35
#define BGP_SAFI_MULTICAST        2
36
#define BGP_SAFI_MPLS                4
37
#define BGP_SAFI_MPLS_VPN        128
38
#define BGP_SAFI_VPN_MULTICAST        129
39
#define BGP_SAFI_FLOW                133
40

    
41
/* Internal AF codes */
42

    
43
#define BGP_AF(A, B)                (((u32)(A) << 16) | (u32)(B))
44
#define BGP_AFI(A)                ((u32)(A) >> 16)
45
#define BGP_SAFI(A)                ((u32)(A) & 0xFFFF)
46

    
47
#define BGP_AF_IPV4                BGP_AF( BGP_AFI_IPV4, BGP_SAFI_UNICAST )
48
#define BGP_AF_IPV6                BGP_AF( BGP_AFI_IPV6, BGP_SAFI_UNICAST )
49
#define BGP_AF_IPV4_MC                BGP_AF( BGP_AFI_IPV4, BGP_SAFI_MULTICAST )
50
#define BGP_AF_IPV6_MC                BGP_AF( BGP_AFI_IPV6, BGP_SAFI_MULTICAST )
51
#define BGP_AF_IPV4_MPLS        BGP_AF( BGP_AFI_IPV4, BGP_SAFI_MPLS )
52
#define BGP_AF_IPV6_MPLS        BGP_AF( BGP_AFI_IPV6, BGP_SAFI_MPLS )
53
#define BGP_AF_VPN4_MPLS        BGP_AF( BGP_AFI_IPV4, BGP_SAFI_MPLS_VPN )
54
#define BGP_AF_VPN6_MPLS        BGP_AF( BGP_AFI_IPV6, BGP_SAFI_MPLS_VPN )
55
#define BGP_AF_VPN4_MC                BGP_AF( BGP_AFI_IPV4, BGP_SAFI_VPN_MULTICAST )
56
#define BGP_AF_VPN6_MC                BGP_AF( BGP_AFI_IPV6, BGP_SAFI_VPN_MULTICAST )
57
#define BGP_AF_FLOW4                BGP_AF( BGP_AFI_IPV4, BGP_SAFI_FLOW )
58
#define BGP_AF_FLOW6                BGP_AF( BGP_AFI_IPV6, BGP_SAFI_FLOW )
59

    
60

    
61
struct bgp_write_state;
62
struct bgp_parse_state;
63
struct bgp_export_state;
64
struct bgp_bucket;
65

    
66
struct bgp_config {
67
  struct proto_config c;
68
  u32 local_as, remote_as;
69
  ip_addr local_ip;                        /* Source address to use */
70
  ip_addr remote_ip;
71
  struct iface *iface;                        /* Interface for link-local addresses */
72
  u16 local_port;                        /* Local listening port */
73
  u16 remote_port;                         /* Neighbor destination port */
74
  int multihop;                                /* Number of hops if multihop */
75
  int strict_bind;                        /* Bind listening socket to local address */
76
  int ttl_security;                        /* Enable TTL security [RFC 5082] */
77
  int compare_path_lengths;                /* Use path lengths when selecting best route */
78
  int med_metric;                        /* Compare MULTI_EXIT_DISC even between routes from differen ASes */
79
  int igp_metric;                        /* Use IGP metrics when selecting best route */
80
  int prefer_older;                        /* Prefer older routes according to RFC 5004 */
81
  int deterministic_med;                /* Use more complicated algo to have strict RFC 4271 MED comparison */
82
  u32 default_local_pref;                /* Default value for LOCAL_PREF attribute */
83
  u32 default_med;                        /* Default value for MULTI_EXIT_DISC attribute */
84
  int capabilities;                        /* Enable capability handshake [RFC 5492] */
85
  int enable_refresh;                        /* Enable local support for route refresh [RFC 2918] */
86
  int enable_as4;                        /* Enable local support for 4B AS numbers [RFC 6793] */
87
  int enable_extended_messages;                /* Enable local support for extended messages [draft] */
88
  u32 rr_cluster_id;                        /* Route reflector cluster ID, if different from local ID */
89
  int rr_client;                        /* Whether neighbor is RR client of me */
90
  int rs_client;                        /* Whether neighbor is RS client of me */
91
  u32 confederation;                        /* Confederation ID, or zero if confeds not active */
92
  int confederation_member;                /* Whether neighbor AS is member of our confederation */
93
  int passive;                                /* Do not initiate outgoing connection */
94
  int interpret_communities;                /* Hardwired handling of well-known communities */
95
  int allow_local_as;                        /* Allow that number of local ASNs in incoming AS_PATHs */
96
  int allow_local_pref;                        /* Allow LOCAL_PREF in EBGP sessions */
97
  int gr_mode;                                /* Graceful restart mode (BGP_GR_*) */
98
  int setkey;                                /* Set MD5 password to system SA/SP database */
99
  /* Times below are in seconds */
100
  unsigned gr_time;                        /* Graceful restart timeout */
101
  unsigned connect_delay_time;                /* Minimum delay between connect attempts */
102
  unsigned connect_retry_time;                /* Timeout for connect attempts */
103
  unsigned hold_time, initial_hold_time;
104
  unsigned mrai_time;       /* MRAI TIMER */
105
  unsigned mrai_type;       /* MRAI TYPE, 0 PEER-BASED MRAI, !0 DESTINATION-BASED mrai */
106
  unsigned mrai_jitter;
107
  unsigned keepalive_time;
108
  unsigned error_amnesia_time;                /* Errors are forgotten after */
109
  unsigned error_delay_time_min;        /* Time to wait after an error is detected */
110
  unsigned error_delay_time_max;
111
  unsigned disable_after_error;                /* Disable the protocol when error is detected */
112

    
113
  char *password;                        /* Password used for MD5 authentication */
114
  int check_link;                        /* Use iface link state for liveness detection */
115
  int bfd;                                /* Use BFD for liveness detection */
116
};
117

    
118
struct bgp_channel_config {
119
  struct channel_config c;
120

    
121
  u32 afi;
122
  const struct bgp_af_desc *desc;
123

    
124
  ip_addr next_hop_addr;                /* Local address for NEXT_HOP attribute */
125
  u8 next_hop_self;                        /* Always set next hop to local IP address */
126
  u8 next_hop_keep;                        /* Do not touch next hop attribute */
127
  u8 missing_lladdr;                        /* What we will do when we don' know link-local addr, see MLL_* */
128
  u8 gw_mode;                                /* How we compute route gateway from next_hop attr, see GW_* */
129
  u8 secondary;                                /* Accept also non-best routes (i.e. RA_ACCEPTED) */
130
  u8 gr_able;                                /* Allow full graceful restart for the channel */
131
  u8 ext_next_hop;                        /* Allow both IPv4 and IPv6 next hops */
132
  u8 add_path;                                /* Use ADD-PATH extension [RFC 7911] */
133

    
134
  uint rest[0];                                /* Remaining items are reconfigured separately */
135
  struct rtable_config *igp_table_ip4;        /* Table for recursive IPv4 next hop lookups */
136
  struct rtable_config *igp_table_ip6;        /* Table for recursive IPv6 next hop lookups */
137
};
138

    
139
#define MLL_SELF 1
140
#define MLL_DROP 2
141
#define MLL_IGNORE 3
142

    
143
#define GW_DIRECT 1
144
#define GW_RECURSIVE 2
145

    
146
#define BGP_ADD_PATH_RX                1
147
#define BGP_ADD_PATH_TX                2
148
#define BGP_ADD_PATH_FULL        3
149

    
150
#define BGP_GR_ABLE                1
151
#define BGP_GR_AWARE                2
152

    
153
/* For GR capability common flags */
154
#define BGP_GRF_RESTART 0x80
155

    
156
/* For GR capability per-AF flags */
157
#define BGP_GRF_FORWARDING 0x80
158

    
159

    
160
struct bgp_af_caps {
161
  u32 afi;
162
  u8 ready;                                /* Multiprotocol capability, RFC 4760 */
163
  u8 gr_able;                                /* Graceful restart support, RFC 4724 */
164
  u8 gr_af_flags;                        /* Graceful restart per-AF flags */
165
  u8 ext_next_hop;                        /* Extended IPv6 next hop,   RFC 5549 */
166
  u8 add_path;                                /* Multiple paths support,   RFC 7911 */
167
};
168

    
169
struct bgp_caps {
170
  u32 as4_number;                        /* Announced ASN */
171

    
172
  u8 as4_support;                        /* Four-octet AS capability, RFC 6793 */
173
  u8 ext_messages;                        /* Extended message length,  RFC draft */
174
  u8 route_refresh;                        /* Route refresh capability, RFC 2918 */
175
  u8 enhanced_refresh;                        /* Enhanced route refresh,   RFC 7313 */
176

    
177
  u8 gr_aware;                                /* Graceful restart capability, RFC 4724 */
178
  u8 gr_flags;                                /* Graceful restart flags */
179
  u16 gr_time;                                /* Graceful restart time in seconds */
180

    
181
  u16 af_count;                                /* Number of af_data items */
182

    
183
  struct bgp_af_caps af_data[0];        /* Per-AF capability data */
184
};
185

    
186
#define WALK_AF_CAPS(caps,ac) \
187
  for (ac = caps->af_data; ac < &caps->af_data[caps->af_count]; ac++)
188

    
189

    
190
struct bgp_socket {
191
  node n;                                /* Node in global bgp_sockets */
192
  sock *sk;                                /* Real listening socket */
193
  u32 uc;                                /* Use count */
194
};
195

    
196
struct bgp_conn {
197
  struct bgp_proto *bgp;
198
  struct birdsock *sk;
199
  u8 state;                                /* State of connection state machine */
200
  u8 as4_session;                        /* Session uses 4B AS numbers in AS_PATH (both sides support it) */
201
  u8 ext_messages;                        /* Session uses extended message length */
202

    
203
  struct bgp_caps *local_caps;
204
  struct bgp_caps *remote_caps;
205
  timer *connect_timer;
206
  timer *hold_timer;
207
  timer *keepalive_timer;
208

    
209
  /* My personal timers */
210
  timer *conn_mrai_timer;
211

    
212
  event *tx_ev;
213
  u32 packets_to_send;                        /* Bitmap of packet types to be sent */
214
  u32 channels_to_send;                        /* Bitmap of channels with packets to be sent */
215
  u8 last_channel;                        /* Channel used last time for TX */
216
  u8 last_channel_count;                /* Number of times the last channel was used in succession */
217
  int notify_code, notify_subcode, notify_size;
218
  byte *notify_data;
219

    
220
  uint hold_time, keepalive_time;        /* Times calculated from my and neighbor's requirements */
221
};
222

    
223
struct bgp_af_desc {
224
    u32 afi;
225
    u32 net;
226
    u8 mpls;
227
    u8 no_igp;
228
    const char *name;
229
    uint (*encode_nlri)(struct bgp_write_state *s, struct bgp_bucket *buck, byte *buf, uint size);
230
    uint (*encode_nlri_mrai)(struct bgp_conn *conn, struct bgp_write_state *s, struct bgp_bucket *buck, byte *buf, uint size);
231
    void (*decode_nlri)(struct bgp_parse_state *s, byte *pos, uint len, rta *a);
232
    void (*update_next_hop)(struct bgp_export_state *s, eattr *nh, ea_list **to);
233
    uint (*encode_next_hop)(struct bgp_write_state *s, eattr *nh, byte *buf, uint size);
234
    void (*decode_next_hop)(struct bgp_parse_state *s, byte *pos, uint len, rta *a);
235
};
236

    
237
struct bgp_proto {
238
  struct proto p;
239
  struct bgp_config *cf;                /* Shortcut to BGP configuration */
240
  u32 local_as, remote_as;
241
  u32 public_as;                        /* Externally visible ASN (local_as or confederation id) */
242
  u32 local_id;                                /* BGP identifier of this router */
243
  u32 remote_id;                        /* BGP identifier of the neighbor */
244
  u32 rr_cluster_id;                        /* Route reflector cluster ID */
245
  int start_state;                        /* Substates that partitions BS_START */
246
  u8 is_internal;                        /* Internal BGP session (local_as == remote_as) */
247
  u8 is_interior;                        /* Internal or intra-confederation BGP session */
248
  u8 as4_session;                        /* Session uses 4B AS numbers in AS_PATH (both sides support it) */
249
  u8 rr_client;                                /* Whether neighbor is RR client of me */
250
  u8 rs_client;                                /* Whether neighbor is RS client of me */
251
  u8 route_refresh;                        /* Route refresh allowed to send [RFC 2918] */
252
  u8 enhanced_refresh;                        /* Enhanced refresh is negotiated [RFC 7313] */
253
  u8 gr_ready;                                /* Neighbor could do graceful restart */
254
  u8 gr_active_num;                        /* Neighbor is doing GR, number of active channels */
255
  u8 channel_count;                        /* Number of active channels */
256
  u32 *afi_map;                                /* Map channel index -> AFI */
257
  struct bgp_channel **channel_map;        /* Map channel index -> channel */
258
  struct bgp_conn *conn;                /* Connection we have established */
259
  struct bgp_conn outgoing_conn;        /* Outgoing connection we're working with */
260
  struct bgp_conn incoming_conn;        /* Incoming connection we have neither accepted nor rejected yet */
261
  struct object_lock *lock;                /* Lock for neighbor connection */
262
  struct neighbor *neigh;                /* Neighbor entry corresponding to remote ip, NULL if multihop */
263
  struct bgp_socket *sock;                /* Shared listening socket */
264
  struct bfd_request *bfd_req;                /* BFD request, if BFD is used */
265
  ip_addr source_addr;                        /* Local address used as an advertised next hop */
266
  ip_addr link_addr;                        /* Link-local version of source_addr */
267
  event *event;                                /* Event for respawning and shutting process */
268
  timer *startup_timer;                        /* Timer used to delay protocol startup due to previous errors (startup_delay) */
269
  timer *gr_timer;                        /* Timer waiting for reestablishment after graceful restart */
270
  uint startup_delay;                        /* Delay (in seconds) of protocol startup due to previous errors */
271
  btime last_proto_error;                /* Time of last error that leads to protocol stop */
272
  u8 last_error_class;                         /* Error class of last error */
273
  u32 last_error_code;                        /* Error code of last error. BGP protocol errors
274
                                           are encoded as (bgp_err_code << 16 | bgp_err_subcode) */
275
  unsigned int number_of_update_sent;
276

    
277
  //TODO insert variables in the protocol and not in general
278
};
279

    
280
struct bgp_channel {
281
  struct channel c;
282

    
283
  /* Rest are BGP specific data */
284
  struct bgp_channel_config *cf;
285
  pool *pool; /* XXXX */
286

    
287
  u32 afi;
288
  u32 index;
289
  const struct bgp_af_desc *desc;
290

    
291
  HASH(struct bgp_bucket) bucket_hash;        /* Hash table of route buckets */
292
  struct bgp_bucket *withdraw_bucket;        /* Withdrawn routes */
293
  list bucket_queue;                        /* Queue of buckets to send (struct bgp_bucket) */
294

    
295
  HASH(struct bgp_prefix) prefix_hash;        /* Prefixes to be sent */
296
  slab *prefix_slab;                        /* Slab holding prefix nodes */
297

    
298
  rtable *igp_table_ip4;                /* Table for recursive IPv4 next hop lookups */
299
  rtable *igp_table_ip6;                /* Table for recursive IPv6 next hop lookups */
300
  ip_addr next_hop_addr;                /* Local address for NEXT_HOP attribute */
301
  ip_addr link_addr;                        /* Link-local version of next_hop_addr */
302

    
303
  u32 packets_to_send;                        /* Bitmap of packet types to be sent */
304

    
305
  u8 gr_ready;                                /* Neighbor could do GR on this AF */
306
  u8 gr_active;                                /* Neighbor is doing GR and keeping fwd state */
307

    
308
  u8 ext_next_hop;                        /* Session allows both IPv4 and IPv6 next hops */
309

    
310
  u8 add_path_rx;                        /* Session expects receive of ADD-PATH extended NLRI */
311
  u8 add_path_tx;                        /* Session expects transmit of ADD-PATH extended NLRI */
312

    
313
  u8 feed_state;                        /* Feed state (TX) for EoR, RR packets, see BFS_* */
314
  u8 load_state;                        /* Load state (RX) for EoR, RR packets, see BFS_* */
315

    
316
  /* MRAI components */
317
  //HASH(struct bgp_bucket) pending_bucket_hash;
318
  //list pending_bucket_queue;
319
};
320

    
321
/* Global list for prefixes already sent */
322
struct bgp_bucket *delayed_bucket;
323
HASH(struct bgp_prefix) sent_prefix_hash;        /* Prefixes already sent */
324
slab *sent_prefix_slab;                        /* Slab holding prefix nodes */
325
int prefixAdded;
326

    
327
/* Data structur for the conn list */
328
struct conn_list_node {
329
    node conn_node;
330
    struct conn_list_node *next;
331
    struct bgp_conn *conn;
332
};
333

    
334
slab *connections_slab;
335

    
336
struct bgp_prefix {
337
  node buck_node;                        /* Node in per-bucket list */
338
  struct bgp_prefix *next;                /* Node in prefix hash table */
339
  u32 hash;
340
  u32 path_id;
341
  btime sharing_time;   /* timestamp to memorize the last time this prefix was sent */
342
  btime end_mrai;       /* Timestamp when the MRAI will finish */
343
  timer *dest_mrai_timer; /* Timer to trigger the MRAI */
344
  list connections;     /* List of connection that needs to be triggered at the end of MRAI */
345
  struct bgp_conn *next_mrai_conn;
346
  net_addr net[0];
347
};
348

    
349
struct bgp_bucket {
350
  node send_node;                        /* Node in send queue */
351
  struct bgp_bucket *next;                /* Node in bucket hash table */
352
  list prefixes;                        /* Prefixes in this bucket (struct bgp_prefix) */
353
  u32 hash;                                /* Hash over extended attributes */
354
  ea_list eattrs[0];                        /* Per-bucket extended attributes */
355
};
356

    
357
struct bgp_export_state {
358
  struct bgp_proto *proto;
359
  struct bgp_channel *channel;
360
  struct linpool *pool;
361

    
362
  struct bgp_proto *src;
363
  rte *route;
364
  int mpls;
365

    
366
  u32 attrs_seen[1];
367
  uint err_withdraw;
368
};
369

    
370
struct bgp_write_state {
371
  struct bgp_proto *proto;
372
  struct bgp_channel *channel;
373
  struct linpool *pool;
374

    
375
  int as4_session;
376
  int add_path;
377
  int mpls;
378

    
379
  eattr *mp_next_hop;
380
  adata *mpls_labels;
381
};
382

    
383
struct bgp_parse_state {
384
  struct bgp_proto *proto;
385
  struct bgp_channel *channel;
386
  struct linpool *pool;
387

    
388
  int as4_session;
389
  int add_path;
390
  int mpls;
391

    
392
  u32 attrs_seen[256/32];
393

    
394
  u32 mp_reach_af;
395
  u32 mp_unreach_af;
396

    
397
  uint attr_len;
398
  uint ip_reach_len;
399
  uint ip_unreach_len;
400
  uint ip_next_hop_len;
401
  uint mp_reach_len;
402
  uint mp_unreach_len;
403
  uint mp_next_hop_len;
404

    
405
  byte *attrs;
406
  byte *ip_reach_nlri;
407
  byte *ip_unreach_nlri;
408
  byte *ip_next_hop_data;
409
  byte *mp_reach_nlri;
410
  byte *mp_unreach_nlri;
411
  byte *mp_next_hop_data;
412

    
413
  uint err_withdraw;
414
  uint err_subcode;
415
  jmp_buf err_jmpbuf;
416

    
417
  struct hostentry *hostentry;
418
  adata *mpls_labels;
419

    
420
  /* Cached state for bgp_rte_update() */
421
  u32 last_id;
422
  struct rte_src *last_src;
423
  rta *cached_rta;
424
};
425

    
426
#define BGP_PORT                179
427
#define BGP_VERSION                4
428
#define BGP_HEADER_LENGTH        19
429
#define BGP_MAX_MESSAGE_LENGTH        4096
430
#define BGP_MAX_EXT_MSG_LENGTH        65535
431
#define BGP_RX_BUFFER_SIZE        4096
432
#define BGP_TX_BUFFER_SIZE        4096
433
#define BGP_RX_BUFFER_EXT_SIZE        65535
434
#define BGP_TX_BUFFER_EXT_SIZE        65535
435

    
436
static inline int bgp_channel_is_ipv4(struct bgp_channel *c)
437
{ return BGP_AFI(c->afi) == BGP_AFI_IPV4; }
438

    
439
static inline int bgp_channel_is_ipv6(struct bgp_channel *c)
440
{ return BGP_AFI(c->afi) == BGP_AFI_IPV6; }
441

    
442
static inline int bgp_cc_is_ipv4(struct bgp_channel_config *c)
443
{ return BGP_AFI(c->afi) == BGP_AFI_IPV4; }
444

    
445
static inline int bgp_cc_is_ipv6(struct bgp_channel_config *c)
446
{ return BGP_AFI(c->afi) == BGP_AFI_IPV6; }
447

    
448
static inline uint bgp_max_packet_length(struct bgp_conn *conn)
449
{ return conn->ext_messages ? BGP_MAX_EXT_MSG_LENGTH : BGP_MAX_MESSAGE_LENGTH; }
450

    
451
static inline void
452
bgp_parse_error(struct bgp_parse_state *s, uint subcode)
453
{
454
  s->err_subcode = subcode;
455
  longjmp(s->err_jmpbuf, 1);
456
}
457

    
458
extern struct linpool *bgp_linpool;
459
extern struct linpool *bgp_linpool2;
460

    
461

    
462
void bgp_start_timer(timer *t, uint value);
463
void bgp_start_ms_timer(timer *t, uint value, uint jitter);
464
void bgp_check_config(struct bgp_config *c);
465
void bgp_error(struct bgp_conn *c, unsigned code, unsigned subcode, byte *data, int len);
466
void bgp_close_conn(struct bgp_conn *c);
467
void bgp_update_startup_delay(struct bgp_proto *p);
468
void bgp_conn_enter_openconfirm_state(struct bgp_conn *conn);
469
void bgp_conn_enter_established_state(struct bgp_conn *conn);
470
void bgp_conn_enter_close_state(struct bgp_conn *conn);
471
void bgp_conn_enter_idle_state(struct bgp_conn *conn);
472
void bgp_handle_graceful_restart(struct bgp_proto *p);
473
void bgp_graceful_restart_done(struct bgp_channel *c);
474
void bgp_refresh_begin(struct bgp_channel *c);
475
void bgp_refresh_end(struct bgp_channel *c);
476
void bgp_store_error(struct bgp_proto *p, struct bgp_conn *c, u8 class, u32 code);
477
void bgp_stop(struct bgp_proto *p, uint subcode, byte *data, uint len);
478

    
479
struct rte_source *bgp_find_source(struct bgp_proto *p, u32 path_id);
480
struct rte_source *bgp_get_source(struct bgp_proto *p, u32 path_id);
481

    
482
//Aggiunta a manina
483
//Potrebbe essere utile in alcune situaizoni per avere un recap del protocollo
484
//void bgp_show_proto_info_mine(struct bgp_proto *P);
485

    
486
#ifdef LOCAL_DEBUG
487
#define BGP_FORCE_DEBUG 1
488
#else
489
#define BGP_FORCE_DEBUG 0
490
#endif
491
#define BGP_TRACE(flags, msg, args...) do { if ((p->p.debug & flags) || BGP_FORCE_DEBUG) \
492
        log(L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
493

    
494
#define BGP_TRACE_RL(rl, flags, msg, args...) do { if ((p->p.debug & flags) || BGP_FORCE_DEBUG) \
495
        log_rl(rl, L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
496

    
497

    
498
/* attrs.c */
499

    
500
static inline eattr *
501
bgp_find_attr(ea_list *attrs, uint code)
502
{
503
  return ea_find(attrs, EA_CODE(EAP_BGP, code));
504
}
505

    
506
eattr *
507
bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, uintptr_t val);
508

    
509
static inline void
510
bgp_set_attr_u32(ea_list **to, struct linpool *pool, uint code, uint flags, u32 val)
511
{ bgp_set_attr(to, pool, code, flags, (uintptr_t) val); }
512

    
513
eattr *
514
bgp_set_attr_load(ea_list **attrs, struct linpool *pool, uint code, uint flags, uintptr_t val);
515

    
516
static inline void
517
bgp_set_attr_load_u32(ea_list **to, struct linpool *pool, uint code, uint flags, double val)
518
{ bgp_set_attr_load(to, pool, code, flags, (uintptr_t) val); }
519

    
520
static inline void
521
bgp_set_attr_ptr(ea_list **to, struct linpool *pool, uint code, uint flags, struct adata *val)
522
{ bgp_set_attr(to, pool, code, flags, (uintptr_t) val); }
523

    
524
static inline void
525
bgp_set_attr_data(ea_list **to, struct linpool *pool, uint code, uint flags, void *data, uint len)
526
{
527
  struct adata *a = lp_alloc_adata(pool, len);
528
  memcpy(a->data, data, len);
529
  bgp_set_attr(to, pool, code, flags, (uintptr_t) a);
530
}
531

    
532
static inline void
533
bgp_unset_attr(ea_list **to, struct linpool *pool, uint code)
534
{ eattr *e = bgp_set_attr(to, pool, code, 0, 0); e->type = EAF_TYPE_UNDEF; }
535

    
536
void
537
conn_mrai_timeout(timer *t);
538

    
539
void
540
dest_mrai_timeout(timer *t);
541

    
542
int bgp_encode_attrs(struct bgp_write_state *s, ea_list *attrs, byte *buf, byte *end);
543
ea_list * bgp_decode_attrs(struct bgp_parse_state *s, byte *data, uint len);
544

    
545
void bgp_init_bucket_table(struct bgp_channel *c);
546
void bgp_free_bucket_table(struct bgp_channel *c);
547
void bgp_free_bucket(struct bgp_channel *c, struct bgp_bucket *b);
548
void bgp_defer_bucket(struct bgp_channel *c, struct bgp_bucket *b);
549
void bgp_withdraw_bucket(struct bgp_channel *c, struct bgp_bucket *b);
550

    
551
void bgp_init_prefix_table(struct bgp_channel *c);
552
void bgp_free_prefix_table(struct bgp_channel *c);
553
void bgp_free_prefix(struct bgp_channel *c, struct bgp_prefix *bp);
554
void bgp_free_conn_from_prefix(struct conn_list_node *conn_node);
555
void bgp_free_delayed_prefix(struct bgp_prefix *px);
556

    
557
int bgp_rte_better(struct rte *, struct rte *);
558
int bgp_rte_mergable(rte *pri, rte *sec);
559
int bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best);
560
void bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old, ea_list *attrs);
561
int bgp_import_control(struct proto *, struct rte **, struct ea_list **, struct linpool *);
562
int bgp_get_attr(struct eattr *e, byte *buf, int buflen);
563
void bgp_get_route_info(struct rte *, byte *buf, struct ea_list *attrs);
564

    
565
/* attrs.c */ //TODO all this functions was static and not in the .h
566
ea_list *bgp_update_attrs(struct bgp_proto *p, struct bgp_channel *c, rte *e, ea_list *attrs0, struct linpool *pool);
567
struct bgp_bucket *bgp_get_bucket(struct bgp_channel *c, ea_list *new);
568
struct bgp_prefix *bgp_get_prefix(struct bgp_channel *c, net_addr *net, u32 path_id);
569
void bgp_copy_bucket_list(struct bgp_channel *c, list from_queue, list to_queue);
570
void bgp_free_pending_bucket(struct bgp_channel *c, struct bgp_bucket *b);
571

    
572
/* packets.c */
573

    
574
void mrt_dump_bgp_state_change(struct bgp_conn *conn, unsigned old, unsigned new);
575
const struct bgp_af_desc *bgp_get_af_desc(u32 afi);
576
const struct bgp_af_caps *bgp_find_af_caps(struct bgp_caps *caps, u32 afi);
577
void bgp_schedule_packet(struct bgp_conn *conn, struct bgp_channel *c, int type);
578
void bgp_kick_tx(void *vconn);
579
void bgp_tx(struct birdsock *sk);
580
int bgp_rx(struct birdsock *sk, uint size);
581
const char * bgp_error_dsc(unsigned code, unsigned subcode);
582
void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsigned subcode, byte *data, unsigned len);
583

    
584
void bgp_update_next_hop(struct bgp_export_state *s, eattr *a, ea_list **to);
585

    
586

    
587
/* Packet types */
588

    
589
#define PKT_OPEN                0x01
590
#define PKT_UPDATE                0x02
591
#define PKT_NOTIFICATION        0x03
592
#define PKT_KEEPALIVE                0x04
593
#define PKT_ROUTE_REFRESH        0x05        /* [RFC2918] */
594
#define PKT_BEGIN_REFRESH        0x1e        /* Dummy type for BoRR packet [RFC7313] */
595
#define PKT_SCHEDULE_CLOSE        0x1f        /* Used internally to schedule socket close */
596

    
597
/* Attributes */
598

    
599
#define BAF_OPTIONAL                0x80
600
#define BAF_TRANSITIVE                0x40
601
#define BAF_PARTIAL                0x20
602
#define BAF_EXT_LEN                0x10
603

    
604
#define BA_ORIGIN                0x01        /* RFC 4271 */                /* WM */
605
#define BA_AS_PATH                0x02                                /* WM */
606
#define BA_NEXT_HOP                0x03                                /* WM */
607
#define BA_MULTI_EXIT_DISC        0x04                                /* ON */
608
#define BA_LOCAL_PREF                0x05                                /* WD */
609
#define BA_ATOMIC_AGGR                0x06                                /* WD */
610
#define BA_AGGREGATOR                0x07                                /* OT */
611
#define BA_COMMUNITY                0x08        /* RFC 1997 */                /* OT */
612
#define BA_ORIGINATOR_ID        0x09        /* RFC 4456 */                /* ON */
613
#define BA_CLUSTER_LIST                0x0a        /* RFC 4456 */                /* ON */
614
#define BA_MP_REACH_NLRI        0x0e        /* RFC 4760 */
615
#define BA_MP_UNREACH_NLRI        0x0f        /* RFC 4760 */
616
#define BA_EXT_COMMUNITY        0x10        /* RFC 4360 */
617
#define BA_AS4_PATH             0x11        /* RFC 6793 */
618
#define BA_AS4_AGGREGATOR       0x12        /* RFC 6793 */
619
#define BA_LARGE_COMMUNITY        0x20        /* RFC 8092 */
620

    
621
//#define BA_LOAD_OUT 0x22
622
//#define BA_AS_NH_LIST                0x23
623
//#define BA_AS_LOAD  0x24
624

    
625
//TODO refactor position of this functions
626
//void
627
//statoAttualeDellaMappa(void);
628
//void
629
//statoAttualeDellaMappaMinimal(void);
630
//void
631
//updateNHmap(int);
632

    
633
//void initRTmap(void);
634

    
635
/*
636
 * Punto ad utilizzare una mappa delle destinazioni
637
 * Chiave della mappa: net_addr_ip4 in modo da identificare univocamente una destinazione
638
 * d -> identifica la chiave ed è anche elemento interno in modo da poterlo usare se necessario
639
 * m -> identificata la metrica, essenzialmente in bgp non ci interessa per mantenere una sola metrica
640
 * NH-> Lista dei next hop per raggiungere la destinazione, è l'AS_PATH
641
 * loadin -> mappa per i previus hop ed i loro contributi, in sostanza quelli a cui manderò la rotta, con relativo contributo
642
 * load -> centralità di d conosciuta dal nodo
643
*/
644

    
645
/*typedef struct {
646
  net_addr *d;
647
  int interno; //0 = interno, 1 = esterno
648
  map_int_t NH;
649
  map_float_t loadin;
650
  float load;
651
  //Needed for the rt_notify
652
  struct proto *P;
653
  struct channel *C;
654
  net *n;
655
  rte *rtElem;
656
  ea_list *ea;
657
  int primaVolta;
658
} RTable;*/
659

    
660
/*typedef struct {
661
    u32 remote_as;
662
} remoteAS;*/
663

    
664
//typedef map_t(remoteAS) RemoteAS_map_t;
665

    
666
/*typedef struct {
667
    float load;
668
    int metrica;
669
    int changed;
670
    RemoteAS_map_t remoteMap;
671
} ASLoad;*/
672

    
673
//TODO insert this tables in the protocol
674
//typedef map_t(RTable) RTable_map_t;
675
//typedef map_t(ASLoad) ASLoad_map_t;
676

    
677
//map_int_t ExternalDestinationMap;
678
//RTable_map_t RTmap;
679
//ASLoad_map_t ASLoad_map;
680

    
681
//TODO put somewhere else this definition
682
//RTable initRTableElement(net_addr*, int, int);
683

    
684
//TODO check each single variable if is needed or could be replaced or already taken into account by the protcol,
685
// the needed one needs to be inserted into the protocol class
686
int withdraw_checker;
687
//int rilevatoLoop;
688
int nhKey;
689
int ASRicezione;
690
//int sonoIlNH;
691
//int numeroNHarrivati;
692
//float loadOutRilevato;
693
float loadComplessivo;
694
char cKey[12];
695
byte buf_old_best_as_path[500];
696
byte buf_new_best_as_path[500];
697
byte buf_as_path[500];
698
char next_hop_ip[NET_MAX_TEXT_LENGTH+1];
699
char dest_ip[NET_MAX_TEXT_LENGTH+1];
700
char nhCKey[12];
701
//int NhVecchio;
702
//int esportoDestinazioni;
703
char ASLocale[12];
704
//float loadOut;
705

    
706
int bgp_fire_tx(struct bgp_conn *conn);
707

    
708
unsigned int total_number_of_update_sent;
709

    
710
/* Bird's private internal BGP attributes */
711
#define BA_MPLS_LABEL_STACK        0xfe        /* MPLS label stack transfer attribute */
712

    
713
/* BGP connection states */
714

    
715
#define BS_IDLE                        0
716
#define BS_CONNECT                1        /* Attempting to connect */
717
#define BS_ACTIVE                2        /* Waiting for connection retry & listening */
718
#define BS_OPENSENT                3
719
#define BS_OPENCONFIRM                4
720
#define BS_ESTABLISHED                5
721
#define BS_CLOSE                6        /* Used during transition to BS_IDLE */
722

    
723
#define BS_MAX                        7
724

    
725
/* BGP start states
726
 *
727
 * Used in PS_START for fine-grained specification of starting state.
728
 *
729
 * When BGP protocol is started by core, it goes to BSS_PREPARE. When BGP
730
 * protocol done what is neccessary to start itself (like acquiring the lock),
731
 * it goes to BSS_CONNECT.
732
 */
733

    
734
#define BSS_PREPARE                0        /* Used before ordinary BGP started, i. e. waiting for lock */
735
#define BSS_DELAY                1        /* Startup delay due to previous errors */
736
#define BSS_CONNECT                2        /* Ordinary BGP connecting */
737

    
738

    
739
/* BGP feed states (TX)
740
 *
741
 * RFC 4724 specifies that an initial feed should end with End-of-RIB mark.
742
 *
743
 * RFC 7313 specifies that a route refresh should be demarcated by BoRR and EoRR packets.
744
 *
745
 * These states (stored in c->feed_state) are used to keep track of these
746
 * requirements. When such feed is started, BFS_LOADING / BFS_REFRESHING is
747
 * set. When it ended, BFS_LOADED / BFS_REFRESHED is set to schedule End-of-RIB
748
 * or EoRR packet. When the packet is sent, the state returned to BFS_NONE.
749
 *
750
 * Note that when a non-demarcated feed (e.g. plain RFC 4271 initial load
751
 * without End-of-RIB or plain RFC 2918 route refresh without BoRR/EoRR
752
 * demarcation) is active, BFS_NONE is set.
753
 *
754
 * BFS_NONE, BFS_LOADING and BFS_REFRESHING are also used as load states (RX)
755
 * with correspondent semantics (-, expecting End-of-RIB, expecting EoRR).
756
 */
757

    
758
#define BFS_NONE                0        /* No feed or original non-demarcated feed */
759
#define BFS_LOADING                1        /* Initial feed active, End-of-RIB planned */
760
#define BFS_LOADED                2        /* Loading done, End-of-RIB marker scheduled */
761
#define BFS_REFRESHING                3        /* Route refresh (introduced by BoRR) active */
762
#define BFS_REFRESHED                4        /* Refresh done, EoRR packet scheduled */
763

    
764

    
765
/* Error classes */
766

    
767
#define BE_NONE                        0
768
#define BE_MISC                        1        /* Miscellaneous error */
769
#define BE_SOCKET                2        /* Socket error */
770
#define BE_BGP_RX                3        /* BGP protocol error notification received */
771
#define BE_BGP_TX                4        /* BGP protocol error notification sent */
772
#define BE_AUTO_DOWN                5        /* Automatic shutdown */
773
#define BE_MAN_DOWN                6        /* Manual shutdown */
774

    
775
/* Misc error codes */
776

    
777
#define BEM_NEIGHBOR_LOST        1
778
#define BEM_INVALID_NEXT_HOP        2
779
#define BEM_INVALID_MD5                3        /* MD5 authentication kernel request failed (possibly not supported) */
780
#define BEM_NO_SOCKET                4
781
#define BEM_LINK_DOWN                5
782
#define BEM_BFD_DOWN                6
783
#define BEM_GRACEFUL_RESTART        7
784

    
785
/* Automatic shutdown error codes */
786

    
787
#define BEA_ROUTE_LIMIT_EXCEEDED 1
788

    
789
/* Well-known communities */
790

    
791
#define BGP_COMM_NO_EXPORT                0xffffff01        /* Don't export outside local AS / confed. */
792
#define BGP_COMM_NO_ADVERTISE                0xffffff02        /* Don't export at all */
793
#define BGP_COMM_NO_EXPORT_SUBCONFED        0xffffff03        /* NO_EXPORT even in local confederation */
794

    
795
/* Origins */
796

    
797
#define ORIGIN_IGP                0
798
#define ORIGIN_EGP                1
799
#define ORIGIN_INCOMPLETE        2
800

    
801

    
802
#endif