2 * BIRD -- The Border Gateway Protocol
4 * (c) 2000 Martin Mares <mj@ucw.cz>
6 * Can be freely distributed and used under the terms of the GNU GPL.
10 * DOC: Border Gateway Protocol
12 * The BGP protocol is implemented in three parts: |bgp.c| which takes care of the
13 * connection and most of the interface with BIRD core, |packets.c| handling
14 * both incoming and outgoing BGP packets and |attrs.c| containing functions for
15 * manipulation with BGP attribute lists.
17 * As opposed to the other existing routing daemons, BIRD has a sophisticated core
18 * architecture which is able to keep all the information needed by BGP in the
19 * primary routing table, therefore no complex data structures like a central
20 * BGP table are needed. This increases memory footprint of a BGP router with
21 * many connections, but not too much and, which is more important, it makes
22 * BGP much easier to implement.
24 * Each instance of BGP (corresponding to a single BGP peer) is described by a &bgp_proto
25 * structure to which are attached individual connections represented by &bgp_connection
26 * (usually, there exists only one connection, but during BGP session setup, there
27 * can be more of them). The connections are handled according to the BGP state machine
28 * defined in the RFC with all the timers and all the parameters configurable.
30 * In incoming direction, we listen on the connection's socket and each time we receive
31 * some input, we pass it to bgp_rx(). It decodes packet headers and the markers and
32 * passes complete packets to bgp_rx_packet() which distributes the packet according
35 * In outgoing direction, we gather all the routing updates and sort them to buckets
36 * (&bgp_bucket) according to their attributes (we keep a hash table for fast comparison
37 * of &rta's and a &fib which helps us to find if we already have another route for
38 * the same destination queued for sending, so that we can replace it with the new one
39 * immediately instead of sending both updates). There also exists a special bucket holding
40 * all the route withdrawals which cannot be queued anywhere else as they don't have any
41 * attributes. If we have any packet to send (due to either new routes or the connection
42 * tracking code wanting to send a Open, Keepalive or Notification message), we call
43 * bgp_schedule_packet() which sets the corresponding bit in a @packet_to_send
44 * bit field in &bgp_conn and as soon as the transmit socket buffer becomes empty,
45 * we call bgp_fire_tx(). It inspects state of all the packet type bits and calls
46 * the corresponding bgp_create_xx() functions, eventually rescheduling the same packet
47 * type if we have more data of the same type to send.
49 * The processing of attributes consists of two functions: bgp_decode_attrs() for checking
50 * of the attribute blocks and translating them to the language of BIRD's extended attributes
51 * and bgp_encode_attrs() which does the converse. Both functions are built around a
52 * @bgp_attr_table array describing all important characteristics of all known attributes.
53 * Unknown transitive attributes are attached to the route as %EAF_TYPE_OPAQUE byte streams.
55 * BGP protocol implements graceful restart in both restarting (local restart)
56 * and receiving (neighbor restart) roles. The first is handled mostly by the
57 * graceful restart code in the nest, BGP protocol just handles capabilities,
58 * sets @gr_wait and locks graceful restart until end-of-RIB mark is received.
59 * The second is implemented by internal restart of the BGP state to %BS_IDLE
60 * and protocol state to %PS_START, but keeping the protocol up from the core
61 * point of view and therefore maintaining received routes. Routing table
62 * refresh cycle (rt_refresh_begin(), rt_refresh_end()) is used for removing
63 * stale routes after reestablishment of BGP session during graceful restart.
68 #include "nest/bird.h"
69 #include "nest/iface.h"
70 #include "nest/protocol.h"
71 #include "nest/route.h"
73 #include "nest/locks.h"
74 #include "conf/conf.h"
75 #include "lib/socket.h"
76 #include "lib/resource.h"
77 #include "lib/string.h"
82 struct linpool
*bgp_linpool
; /* Global temporary pool */
83 static sock
*bgp_listen_sk
; /* Global listening socket */
84 static int bgp_counter
; /* Number of protocol instances using the listening socket */
86 static void bgp_close(struct bgp_proto
*p
, int apply_md5
);
87 static void bgp_connect(struct bgp_proto
*p
);
88 static void bgp_active(struct bgp_proto
*p
);
89 static sock
*bgp_setup_listen_sk(ip_addr addr
, unsigned port
, u32 flags
);
90 static void bgp_update_bfd(struct bgp_proto
*p
, int use_bfd
);
94 * bgp_open - open a BGP instance
97 * This function allocates and configures shared BGP resources.
98 * Should be called as the last step during initialization
99 * (when lock is acquired and neighbor is ready).
100 * When error, state changed to PS_DOWN, -1 is returned and caller
101 * should return immediately.
104 bgp_open(struct bgp_proto
*p
)
106 struct config
*cfg
= p
->cf
->c
.global
;
110 bgp_listen_sk
= bgp_setup_listen_sk(cfg
->listen_bgp_addr
, cfg
->listen_bgp_port
, cfg
->listen_bgp_flags
);
114 errcode
= BEM_NO_SOCKET
;
119 bgp_linpool
= lp_new(&root_pool
, 4080);
124 if (sk_set_md5_auth(bgp_listen_sk
, p
->cf
->source_addr
, p
->cf
->remote_ip
,
125 p
->cf
->iface
, p
->cf
->password
, p
->cf
->setkey
) < 0)
127 sk_log_error(bgp_listen_sk
, p
->p
.name
);
129 errcode
= BEM_INVALID_MD5
;
137 bgp_store_error(p
, NULL
, BE_MISC
, errcode
);
138 proto_notify_state(&p
->p
, PS_DOWN
);
143 bgp_startup(struct bgp_proto
*p
)
145 BGP_TRACE(D_EVENTS
, "Started");
146 p
->start_state
= p
->cf
->capabilities
? BSS_CONNECT
: BSS_CONNECT_NOCAP
;
153 bgp_startup_timeout(timer
*t
)
155 bgp_startup(t
->data
);
160 bgp_initiate(struct bgp_proto
*p
)
162 int rv
= bgp_open(p
);
167 bgp_update_bfd(p
, p
->cf
->bfd
);
169 if (p
->startup_delay
)
171 p
->start_state
= BSS_DELAY
;
172 BGP_TRACE(D_EVENTS
, "Startup delayed by %d seconds due to errors", p
->startup_delay
);
173 bgp_start_timer(p
->startup_timer
, p
->startup_delay
);
180 * bgp_close - close a BGP instance
182 * @apply_md5: 0 to disable unsetting MD5 auth
184 * This function frees and deconfigures shared BGP resources.
185 * @apply_md5 is set to 0 when bgp_close is called as a cleanup
186 * from failed bgp_open().
189 bgp_close(struct bgp_proto
*p
, int apply_md5
)
194 if (p
->cf
->password
&& apply_md5
)
195 if (sk_set_md5_auth(bgp_listen_sk
, p
->cf
->source_addr
, p
->cf
->remote_ip
,
196 p
->cf
->iface
, NULL
, p
->cf
->setkey
) < 0)
197 sk_log_error(bgp_listen_sk
, p
->p
.name
);
201 rfree(bgp_listen_sk
);
202 bgp_listen_sk
= NULL
;
209 * bgp_start_timer - start a BGP timer
211 * @value: time to fire (0 to disable the timer)
213 * This functions calls tm_start() on @t with time @value and the
214 * amount of randomization suggested by the BGP standard. Please use
215 * it for all BGP timers.
218 bgp_start_timer(timer
*t
, int value
)
222 /* The randomization procedure is specified in RFC 1771: 9.2.3.3 */
223 t
->randomize
= value
/ 4;
224 tm_start(t
, value
- t
->randomize
);
231 * bgp_close_conn - close a BGP connection
232 * @conn: connection to close
234 * This function takes a connection described by the &bgp_conn structure,
235 * closes its socket and frees all resources associated with it.
238 bgp_close_conn(struct bgp_conn
*conn
)
240 // struct bgp_proto *p = conn->bgp;
242 DBG("BGP: Closing connection\n");
243 conn
->packets_to_send
= 0;
244 rfree(conn
->connect_retry_timer
);
245 conn
->connect_retry_timer
= NULL
;
246 rfree(conn
->keepalive_timer
);
247 conn
->keepalive_timer
= NULL
;
248 rfree(conn
->hold_timer
);
249 conn
->hold_timer
= NULL
;
258 * bgp_update_startup_delay - update a startup delay
261 * This function updates a startup delay that is used to postpone next BGP connect.
262 * It also handles disable_after_error and might stop BGP instance when error
263 * happened and disable_after_error is on.
265 * It should be called when BGP protocol error happened.
268 bgp_update_startup_delay(struct bgp_proto
*p
)
270 struct bgp_config
*cf
= p
->cf
;
272 DBG("BGP: Updating startup delay\n");
274 if (p
->last_proto_error
&& ((now
- p
->last_proto_error
) >= (int) cf
->error_amnesia_time
))
275 p
->startup_delay
= 0;
277 p
->last_proto_error
= now
;
279 if (cf
->disable_after_error
)
281 p
->startup_delay
= 0;
286 if (!p
->startup_delay
)
287 p
->startup_delay
= cf
->error_delay_time_min
;
289 p
->startup_delay
= MIN(2 * p
->startup_delay
, cf
->error_delay_time_max
);
293 bgp_graceful_close_conn(struct bgp_conn
*conn
, unsigned subcode
)
302 bgp_conn_enter_idle_state(conn
);
307 bgp_error(conn
, 6, subcode
, NULL
, 0);
310 bug("bgp_graceful_close_conn: Unknown state %d", conn
->state
);
315 bgp_down(struct bgp_proto
*p
)
317 if (p
->start_state
> BSS_PREPARE
)
320 BGP_TRACE(D_EVENTS
, "Down");
321 proto_notify_state(&p
->p
, PS_DOWN
);
325 bgp_decision(void *vp
)
327 struct bgp_proto
*p
= vp
;
329 DBG("BGP: Decision start\n");
330 if ((p
->p
.proto_state
== PS_START
)
331 && (p
->outgoing_conn
.state
== BS_IDLE
)
332 && (p
->incoming_conn
.state
!= BS_OPENCONFIRM
)
333 && (!p
->cf
->passive
))
336 if ((p
->p
.proto_state
== PS_STOP
)
337 && (p
->outgoing_conn
.state
== BS_IDLE
)
338 && (p
->incoming_conn
.state
== BS_IDLE
))
343 bgp_stop(struct bgp_proto
*p
, unsigned subcode
)
345 proto_notify_state(&p
->p
, PS_STOP
);
346 bgp_graceful_close_conn(&p
->outgoing_conn
, subcode
);
347 bgp_graceful_close_conn(&p
->incoming_conn
, subcode
);
348 ev_schedule(p
->event
);
352 bgp_conn_set_state(struct bgp_conn
*conn
, unsigned new_state
)
354 if (conn
->bgp
->p
.mrtdump
& MD_STATES
)
355 mrt_dump_bgp_state_change(conn
, conn
->state
, new_state
);
357 conn
->state
= new_state
;
361 bgp_conn_enter_openconfirm_state(struct bgp_conn
*conn
)
363 /* Really, most of the work is done in bgp_rx_open(). */
364 bgp_conn_set_state(conn
, BS_OPENCONFIRM
);
368 bgp_conn_enter_established_state(struct bgp_conn
*conn
)
370 struct bgp_proto
*p
= conn
->bgp
;
372 BGP_TRACE(D_EVENTS
, "BGP session established");
375 /* For multi-hop BGP sessions */
376 if (ipa_zero(p
->source_addr
))
377 p
->source_addr
= conn
->sk
->saddr
;
379 conn
->sk
->fast_rx
= 0;
382 p
->last_error_class
= 0;
383 p
->last_error_code
= 0;
384 p
->feed_state
= BFS_NONE
;
385 p
->load_state
= BFS_NONE
;
386 bgp_init_bucket_table(p
);
387 bgp_init_prefix_table(p
, 8);
389 int peer_gr_ready
= conn
->peer_gr_aware
&& !(conn
->peer_gr_flags
& BGP_GRF_RESTART
);
391 if (p
->p
.gr_recovery
&& !peer_gr_ready
)
392 proto_graceful_restart_unlock(&p
->p
);
394 if (p
->p
.gr_recovery
&& (p
->cf
->gr_mode
== BGP_GR_ABLE
) && peer_gr_ready
)
398 tm_stop(p
->gr_timer
);
400 if (p
->gr_active
&& (!conn
->peer_gr_able
|| !(conn
->peer_gr_aflags
& BGP_GRF_FORWARDING
)))
401 bgp_graceful_restart_done(p
);
403 /* GR capability implies that neighbor will send End-of-RIB */
404 if (conn
->peer_gr_aware
)
405 p
->load_state
= BFS_LOADING
;
407 /* proto_notify_state() will likely call bgp_feed_begin(), setting p->feed_state */
409 bgp_conn_set_state(conn
, BS_ESTABLISHED
);
410 proto_notify_state(&p
->p
, PS_UP
);
414 bgp_conn_leave_established_state(struct bgp_proto
*p
)
416 BGP_TRACE(D_EVENTS
, "BGP session closed");
419 if (p
->p
.proto_state
== PS_UP
)
424 bgp_conn_enter_close_state(struct bgp_conn
*conn
)
426 struct bgp_proto
*p
= conn
->bgp
;
427 int os
= conn
->state
;
429 bgp_conn_set_state(conn
, BS_CLOSE
);
430 tm_stop(conn
->keepalive_timer
);
431 conn
->sk
->rx_hook
= NULL
;
433 /* Timeout for CLOSE state, if we cannot send notification soon then we just hangup */
434 bgp_start_timer(conn
->hold_timer
, 10);
436 if (os
== BS_ESTABLISHED
)
437 bgp_conn_leave_established_state(p
);
441 bgp_conn_enter_idle_state(struct bgp_conn
*conn
)
443 struct bgp_proto
*p
= conn
->bgp
;
444 int os
= conn
->state
;
446 bgp_close_conn(conn
);
447 bgp_conn_set_state(conn
, BS_IDLE
);
448 ev_schedule(p
->event
);
450 if (os
== BS_ESTABLISHED
)
451 bgp_conn_leave_established_state(p
);
455 * bgp_handle_graceful_restart - handle detected BGP graceful restart
458 * This function is called when a BGP graceful restart of the neighbor is
459 * detected (when the TCP connection fails or when a new TCP connection
460 * appears). The function activates processing of the restart - starts routing
461 * table refresh cycle and activates BGP restart timer. The protocol state goes
462 * back to %PS_START, but changing BGP state back to %BS_IDLE is left for the
466 bgp_handle_graceful_restart(struct bgp_proto
*p
)
468 ASSERT(p
->conn
&& (p
->conn
->state
== BS_ESTABLISHED
) && p
->gr_ready
);
470 BGP_TRACE(D_EVENTS
, "Neighbor graceful restart detected%s",
471 p
->gr_active
? " - already pending" : "");
472 proto_notify_state(&p
->p
, PS_START
);
475 rt_refresh_end(p
->p
.main_ahook
->table
, p
->p
.main_ahook
);
478 bgp_start_timer(p
->gr_timer
, p
->conn
->peer_gr_time
);
479 rt_refresh_begin(p
->p
.main_ahook
->table
, p
->p
.main_ahook
);
483 * bgp_graceful_restart_done - finish active BGP graceful restart
486 * This function is called when the active BGP graceful restart of the neighbor
487 * should be finished - either successfully (the neighbor sends all paths and
488 * reports end-of-RIB on the new session) or unsuccessfully (the neighbor does
489 * not support BGP graceful restart on the new session). The function ends
490 * routing table refresh cycle and stops BGP restart timer.
493 bgp_graceful_restart_done(struct bgp_proto
*p
)
495 BGP_TRACE(D_EVENTS
, "Neighbor graceful restart done");
497 tm_stop(p
->gr_timer
);
498 rt_refresh_end(p
->p
.main_ahook
->table
, p
->p
.main_ahook
);
502 * bgp_graceful_restart_timeout - timeout of graceful restart 'restart timer'
505 * This function is a timeout hook for @gr_timer, implementing BGP restart time
506 * limit for reestablisment of the BGP session after the graceful restart. When
507 * fired, we just proceed with the usual protocol restart.
511 bgp_graceful_restart_timeout(timer
*t
)
513 struct bgp_proto
*p
= t
->data
;
515 BGP_TRACE(D_EVENTS
, "Neighbor graceful restart timeout");
521 * bgp_refresh_begin - start incoming enhanced route refresh sequence
524 * This function is called when an incoming enhanced route refresh sequence is
525 * started by the neighbor, demarcated by the BoRR packet. The function updates
526 * the load state and starts the routing table refresh cycle. Note that graceful
527 * restart also uses routing table refresh cycle, but RFC 7313 and load states
528 * ensure that these two sequences do not overlap.
531 bgp_refresh_begin(struct bgp_proto
*p
)
533 if (p
->load_state
== BFS_LOADING
)
534 { log(L_WARN
"%s: BEGIN-OF-RR received before END-OF-RIB, ignoring", p
->p
.name
); return; }
536 p
->load_state
= BFS_REFRESHING
;
537 rt_refresh_begin(p
->p
.main_ahook
->table
, p
->p
.main_ahook
);
541 * bgp_refresh_end - finish incoming enhanced route refresh sequence
544 * This function is called when an incoming enhanced route refresh sequence is
545 * finished by the neighbor, demarcated by the EoRR packet. The function updates
546 * the load state and ends the routing table refresh cycle. Routes not received
547 * during the sequence are removed by the nest.
550 bgp_refresh_end(struct bgp_proto
*p
)
552 if (p
->load_state
!= BFS_REFRESHING
)
553 { log(L_WARN
"%s: END-OF-RR received without prior BEGIN-OF-RR, ignoring", p
->p
.name
); return; }
555 p
->load_state
= BFS_NONE
;
556 rt_refresh_end(p
->p
.main_ahook
->table
, p
->p
.main_ahook
);
561 bgp_send_open(struct bgp_conn
*conn
)
563 conn
->start_state
= conn
->bgp
->start_state
;
565 // Default values, possibly changed by receiving capabilities.
566 conn
->advertised_as
= 0;
567 conn
->peer_refresh_support
= 0;
568 conn
->peer_as4_support
= 0;
569 conn
->peer_add_path
= 0;
570 conn
->peer_enhanced_refresh_support
= 0;
571 conn
->peer_gr_aware
= 0;
572 conn
->peer_gr_able
= 0;
573 conn
->peer_gr_time
= 0;
574 conn
->peer_gr_flags
= 0;
575 conn
->peer_gr_aflags
= 0;
576 conn
->peer_ext_messages_support
= 0;
578 DBG("BGP: Sending open\n");
579 conn
->sk
->rx_hook
= bgp_rx
;
580 conn
->sk
->tx_hook
= bgp_tx
;
581 tm_stop(conn
->connect_retry_timer
);
582 bgp_schedule_packet(conn
, PKT_OPEN
);
583 bgp_conn_set_state(conn
, BS_OPENSENT
);
584 bgp_start_timer(conn
->hold_timer
, conn
->bgp
->cf
->initial_hold_time
);
588 bgp_connected(sock
*sk
)
590 struct bgp_conn
*conn
= sk
->data
;
591 struct bgp_proto
*p
= conn
->bgp
;
593 BGP_TRACE(D_EVENTS
, "Connected");
598 bgp_connect_timeout(timer
*t
)
600 struct bgp_conn
*conn
= t
->data
;
601 struct bgp_proto
*p
= conn
->bgp
;
603 DBG("BGP: connect_timeout\n");
604 if (p
->p
.proto_state
== PS_START
)
606 bgp_close_conn(conn
);
610 bgp_conn_enter_idle_state(conn
);
614 bgp_sock_err(sock
*sk
, int err
)
616 struct bgp_conn
*conn
= sk
->data
;
617 struct bgp_proto
*p
= conn
->bgp
;
620 * This error hook may be called either asynchronously from main
621 * loop, or synchronously from sk_send(). But sk_send() is called
622 * only from bgp_tx() and bgp_kick_tx(), which are both called
623 * asynchronously from main loop. Moreover, they end if err hook is
624 * called. Therefore, we could suppose that it is always called
628 bgp_store_error(p
, conn
, BE_SOCKET
, err
);
631 BGP_TRACE(D_EVENTS
, "Connection lost (%M)", err
);
633 BGP_TRACE(D_EVENTS
, "Connection closed");
635 if ((conn
->state
== BS_ESTABLISHED
) && p
->gr_ready
)
636 bgp_handle_graceful_restart(p
);
638 bgp_conn_enter_idle_state(conn
);
642 bgp_hold_timeout(timer
*t
)
644 struct bgp_conn
*conn
= t
->data
;
645 struct bgp_proto
*p
= conn
->bgp
;
647 DBG("BGP: Hold timeout\n");
649 /* We are already closing the connection - just do hangup */
650 if (conn
->state
== BS_CLOSE
)
652 BGP_TRACE(D_EVENTS
, "Connection stalled");
653 bgp_conn_enter_idle_state(conn
);
657 /* If there is something in input queue, we are probably congested
658 and perhaps just not processed BGP packets in time. */
660 if (sk_rx_ready(conn
->sk
) > 0)
661 bgp_start_timer(conn
->hold_timer
, 10);
663 bgp_error(conn
, 4, 0, NULL
, 0);
667 bgp_keepalive_timeout(timer
*t
)
669 struct bgp_conn
*conn
= t
->data
;
671 DBG("BGP: Keepalive timer\n");
672 bgp_schedule_packet(conn
, PKT_KEEPALIVE
);
674 /* Kick TX a bit faster */
675 if (ev_active(conn
->tx_ev
))
680 bgp_setup_conn(struct bgp_proto
*p
, struct bgp_conn
*conn
)
686 conn
->packets_to_send
= 0;
688 t
= conn
->connect_retry_timer
= tm_new(p
->p
.pool
);
689 t
->hook
= bgp_connect_timeout
;
691 t
= conn
->hold_timer
= tm_new(p
->p
.pool
);
692 t
->hook
= bgp_hold_timeout
;
694 t
= conn
->keepalive_timer
= tm_new(p
->p
.pool
);
695 t
->hook
= bgp_keepalive_timeout
;
697 conn
->tx_ev
= ev_new(p
->p
.pool
);
698 conn
->tx_ev
->hook
= bgp_kick_tx
;
699 conn
->tx_ev
->data
= conn
;
703 bgp_setup_sk(struct bgp_conn
*conn
, sock
*s
)
706 s
->err_hook
= bgp_sock_err
;
712 bgp_active(struct bgp_proto
*p
)
714 int delay
= MAX(1, p
->cf
->connect_delay_time
);
715 struct bgp_conn
*conn
= &p
->outgoing_conn
;
717 BGP_TRACE(D_EVENTS
, "Connect delayed by %d seconds", delay
);
718 bgp_setup_conn(p
, conn
);
719 bgp_conn_set_state(conn
, BS_ACTIVE
);
720 bgp_start_timer(conn
->connect_retry_timer
, delay
);
724 * bgp_connect - initiate an outgoing connection
727 * The bgp_connect() function creates a new &bgp_conn and initiates
728 * a TCP connection to the peer. The rest of connection setup is governed
729 * by the BGP state machine as described in the standard.
732 bgp_connect(struct bgp_proto
*p
) /* Enter Connect state and start establishing connection */
735 struct bgp_conn
*conn
= &p
->outgoing_conn
;
736 int hops
= p
->cf
->multihop
? : 1;
738 DBG("BGP: Connecting\n");
739 s
= sk_new(p
->p
.pool
);
740 s
->type
= SK_TCP_ACTIVE
;
741 s
->saddr
= p
->source_addr
;
742 s
->daddr
= p
->cf
->remote_ip
;
743 s
->dport
= p
->cf
->remote_port
;
744 s
->iface
= p
->neigh
? p
->neigh
->iface
: NULL
;
745 s
->ttl
= p
->cf
->ttl_security
? 255 : hops
;
746 s
->rbsize
= p
->cf
->enable_extended_messages
? BGP_RX_BUFFER_EXT_SIZE
: BGP_RX_BUFFER_SIZE
;
747 s
->tbsize
= p
->cf
->enable_extended_messages
? BGP_TX_BUFFER_EXT_SIZE
: BGP_TX_BUFFER_SIZE
;
748 s
->tos
= IP_PREC_INTERNET_CONTROL
;
749 s
->password
= p
->cf
->password
;
750 s
->tx_hook
= bgp_connected
;
751 BGP_TRACE(D_EVENTS
, "Connecting to %I%J from local address %I%J", s
->daddr
, p
->cf
->iface
,
752 s
->saddr
, ipa_is_link_local(s
->saddr
) ? s
->iface
: NULL
);
753 bgp_setup_conn(p
, conn
);
754 bgp_setup_sk(conn
, s
);
755 bgp_conn_set_state(conn
, BS_CONNECT
);
760 /* Set minimal receive TTL if needed */
761 if (p
->cf
->ttl_security
)
762 if (sk_set_min_ttl(s
, 256 - hops
) < 0)
765 DBG("BGP: Waiting for connect success\n");
766 bgp_start_timer(conn
->connect_retry_timer
, p
->cf
->connect_retry_time
);
770 sk_log_error(s
, p
->p
.name
);
776 * bgp_find_proto - find existing proto for incoming connection
780 static struct bgp_proto
*
781 bgp_find_proto(sock
*sk
)
783 struct proto_config
*pc
;
785 WALK_LIST(pc
, config
->protos
)
786 if ((pc
->protocol
== &proto_bgp
) && pc
->proto
)
788 struct bgp_proto
*p
= (struct bgp_proto
*) pc
->proto
;
789 if (ipa_equal(p
->cf
->remote_ip
, sk
->daddr
) &&
790 (!ipa_is_link_local(sk
->daddr
) || (p
->cf
->iface
== sk
->iface
)))
798 * bgp_incoming_connection - handle an incoming connection
802 * This function serves as a socket hook for accepting of new BGP
803 * connections. It searches a BGP instance corresponding to the peer
804 * which has connected and if such an instance exists, it creates a
805 * &bgp_conn structure, attaches it to the instance and either sends
806 * an Open message or (if there already is an active connection) it
807 * closes the new connection by sending a Notification message.
810 bgp_incoming_connection(sock
*sk
, uint dummy UNUSED
)
815 DBG("BGP: Incoming connection from %I port %d\n", sk
->daddr
, sk
->dport
);
816 p
= bgp_find_proto(sk
);
819 log(L_WARN
"BGP: Unexpected connect from unknown address %I%J (port %d)",
820 sk
->daddr
, ipa_is_link_local(sk
->daddr
) ? sk
->iface
: NULL
, sk
->dport
);
826 * BIRD should keep multiple incoming connections in OpenSent state (for
827 * details RFC 4271 8.2.1 par 3), but it keeps just one. Duplicate incoming
828 * connections are rejected istead. The exception is the case where an
829 * incoming connection triggers a graceful restart.
832 acc
= (p
->p
.proto_state
== PS_START
|| p
->p
.proto_state
== PS_UP
) &&
833 (p
->start_state
>= BSS_CONNECT
) && (!p
->incoming_conn
.sk
);
835 if (p
->conn
&& (p
->conn
->state
== BS_ESTABLISHED
) && p
->gr_ready
)
837 bgp_store_error(p
, NULL
, BE_MISC
, BEM_GRACEFUL_RESTART
);
838 bgp_handle_graceful_restart(p
);
839 bgp_conn_enter_idle_state(p
->conn
);
842 /* There might be separate incoming connection in OpenSent state */
843 if (p
->incoming_conn
.state
> BS_ACTIVE
)
844 bgp_close_conn(&p
->incoming_conn
);
847 BGP_TRACE(D_EVENTS
, "Incoming connection from %I%J (port %d) %s",
848 sk
->daddr
, ipa_is_link_local(sk
->daddr
) ? sk
->iface
: NULL
,
849 sk
->dport
, acc
? "accepted" : "rejected");
857 hops
= p
->cf
->multihop
? : 1;
859 if (sk_set_ttl(sk
, p
->cf
->ttl_security
? 255 : hops
) < 0)
862 if (p
->cf
->ttl_security
)
863 if (sk_set_min_ttl(sk
, 256 - hops
) < 0)
866 if (p
->cf
->enable_extended_messages
)
868 sk
->rbsize
= BGP_RX_BUFFER_EXT_SIZE
;
869 sk
->tbsize
= BGP_TX_BUFFER_EXT_SIZE
;
873 bgp_setup_conn(p
, &p
->incoming_conn
);
874 bgp_setup_sk(&p
->incoming_conn
, sk
);
875 bgp_send_open(&p
->incoming_conn
);
879 sk_log_error(sk
, p
->p
.name
);
880 log(L_ERR
"%s: Incoming connection aborted", p
->p
.name
);
886 bgp_listen_sock_err(sock
*sk UNUSED
, int err
)
888 if (err
== ECONNABORTED
)
889 log(L_WARN
"BGP: Incoming connection aborted");
891 log(L_ERR
"BGP: Error on listening socket: %M", err
);
895 bgp_setup_listen_sk(ip_addr addr
, unsigned port
, u32 flags
)
897 sock
*s
= sk_new(&root_pool
);
898 DBG("BGP: Creating listening socket\n");
899 s
->type
= SK_TCP_PASSIVE
;
902 s
->sport
= port
? port
: BGP_PORT
;
903 s
->flags
= flags
? 0 : SKF_V6ONLY
;
904 s
->tos
= IP_PREC_INTERNET_CONTROL
;
905 s
->rbsize
= BGP_RX_BUFFER_SIZE
;
906 s
->tbsize
= BGP_TX_BUFFER_SIZE
;
907 s
->rx_hook
= bgp_incoming_connection
;
908 s
->err_hook
= bgp_listen_sock_err
;
916 sk_log_error(s
, "BGP");
917 log(L_ERR
"BGP: Cannot open listening socket");
923 bgp_start_neighbor(struct bgp_proto
*p
)
925 /* Called only for single-hop BGP sessions */
927 if (ipa_zero(p
->source_addr
))
928 p
->source_addr
= p
->neigh
->ifa
->ip
;
933 p
->local_link
= IPA_NONE
;
934 WALK_LIST(a
, p
->neigh
->iface
->addrs
)
935 if (a
->scope
== SCOPE_LINK
)
937 p
->local_link
= a
->ip
;
941 if (! ipa_nonzero(p
->local_link
))
942 log(L_WARN
"%s: Missing link local address on interface %s", p
->p
.name
, p
->neigh
->iface
->name
);
944 DBG("BGP: Selected link-level address %I\n", p
->local_link
);
952 bgp_neigh_notify(neighbor
*n
)
954 struct bgp_proto
*p
= (struct bgp_proto
*) n
->proto
;
955 int ps
= p
->p
.proto_state
;
960 if ((ps
== PS_DOWN
) || (ps
== PS_STOP
))
963 int prepare
= (ps
== PS_START
) && (p
->start_state
== BSS_PREPARE
);
969 BGP_TRACE(D_EVENTS
, "Neighbor lost");
970 bgp_store_error(p
, NULL
, BE_MISC
, BEM_NEIGHBOR_LOST
);
971 /* Perhaps also run bgp_update_startup_delay(p)? */
975 else if (p
->cf
->check_link
&& !(n
->iface
->flags
& IF_LINK_UP
))
979 BGP_TRACE(D_EVENTS
, "Link down");
980 bgp_store_error(p
, NULL
, BE_MISC
, BEM_LINK_DOWN
);
982 bgp_update_startup_delay(p
);
990 BGP_TRACE(D_EVENTS
, "Neighbor ready");
991 bgp_start_neighbor(p
);
997 bgp_bfd_notify(struct bfd_request
*req
)
999 struct bgp_proto
*p
= req
->data
;
1000 int ps
= p
->p
.proto_state
;
1002 if (req
->down
&& ((ps
== PS_START
) || (ps
== PS_UP
)))
1004 BGP_TRACE(D_EVENTS
, "BFD session down");
1005 bgp_store_error(p
, NULL
, BE_MISC
, BEM_BFD_DOWN
);
1007 bgp_update_startup_delay(p
);
1013 bgp_update_bfd(struct bgp_proto
*p
, int use_bfd
)
1015 if (use_bfd
&& !p
->bfd_req
)
1016 p
->bfd_req
= bfd_request_session(p
->p
.pool
, p
->cf
->remote_ip
, p
->source_addr
,
1017 p
->cf
->multihop
? NULL
: p
->neigh
->iface
,
1020 if (!use_bfd
&& p
->bfd_req
)
1028 bgp_reload_routes(struct proto
*P
)
1030 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1031 if (!p
->conn
|| !p
->conn
->peer_refresh_support
)
1034 bgp_schedule_packet(p
->conn
, PKT_ROUTE_REFRESH
);
1039 bgp_feed_begin(struct proto
*P
, int initial
)
1041 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1043 /* This should not happen */
1047 if (initial
&& p
->cf
->gr_mode
)
1048 p
->feed_state
= BFS_LOADING
;
1050 /* It is refeed and both sides support enhanced route refresh */
1051 if (!initial
&& p
->cf
->enable_refresh
&&
1052 p
->conn
->peer_enhanced_refresh_support
)
1054 /* BoRR must not be sent before End-of-RIB */
1055 if (p
->feed_state
== BFS_LOADING
|| p
->feed_state
== BFS_LOADED
)
1058 p
->feed_state
= BFS_REFRESHING
;
1059 bgp_schedule_packet(p
->conn
, PKT_BEGIN_REFRESH
);
1064 bgp_feed_end(struct proto
*P
)
1066 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1068 /* This should not happen */
1072 /* Non-demarcated feed ended, nothing to do */
1073 if (p
->feed_state
== BFS_NONE
)
1076 /* Schedule End-of-RIB packet */
1077 if (p
->feed_state
== BFS_LOADING
)
1078 p
->feed_state
= BFS_LOADED
;
1080 /* Schedule EoRR packet */
1081 if (p
->feed_state
== BFS_REFRESHING
)
1082 p
->feed_state
= BFS_REFRESHED
;
1085 bgp_schedule_packet(p
->conn
, PKT_UPDATE
);
1090 bgp_start_locked(struct object_lock
*lock
)
1092 struct bgp_proto
*p
= lock
->data
;
1093 struct bgp_config
*cf
= p
->cf
;
1095 if (p
->p
.proto_state
!= PS_START
)
1097 DBG("BGP: Got lock in different state %d\n", p
->p
.proto_state
);
1101 DBG("BGP: Got lock\n");
1105 /* Multi-hop sessions do not use neighbor entries */
1110 neighbor
*n
= neigh_find2(&p
->p
, &cf
->remote_ip
, cf
->iface
, NEF_STICKY
);
1113 log(L_ERR
"%s: Invalid remote address %I%J", p
->p
.name
, cf
->remote_ip
, cf
->iface
);
1114 /* As we do not start yet, we can just disable protocol */
1116 bgp_store_error(p
, NULL
, BE_MISC
, BEM_INVALID_NEXT_HOP
);
1117 proto_notify_state(&p
->p
, PS_DOWN
);
1124 BGP_TRACE(D_EVENTS
, "Waiting for %I%J to become my neighbor", cf
->remote_ip
, cf
->iface
);
1125 else if (p
->cf
->check_link
&& !(n
->iface
->flags
& IF_LINK_UP
))
1126 BGP_TRACE(D_EVENTS
, "Waiting for link on %s", n
->iface
->name
);
1128 bgp_start_neighbor(p
);
1132 bgp_start(struct proto
*P
)
1134 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1135 struct object_lock
*lock
;
1137 DBG("BGP: Startup.\n");
1138 p
->start_state
= BSS_PREPARE
;
1139 p
->outgoing_conn
.state
= BS_IDLE
;
1140 p
->incoming_conn
.state
= BS_IDLE
;
1146 rt_lock_table(p
->igp_table
);
1148 p
->event
= ev_new(p
->p
.pool
);
1149 p
->event
->hook
= bgp_decision
;
1152 p
->startup_timer
= tm_new(p
->p
.pool
);
1153 p
->startup_timer
->hook
= bgp_startup_timeout
;
1154 p
->startup_timer
->data
= p
;
1156 p
->gr_timer
= tm_new(p
->p
.pool
);
1157 p
->gr_timer
->hook
= bgp_graceful_restart_timeout
;
1158 p
->gr_timer
->data
= p
;
1160 p
->local_id
= proto_get_router_id(P
->cf
);
1162 p
->rr_cluster_id
= p
->cf
->rr_cluster_id
? p
->cf
->rr_cluster_id
: p
->local_id
;
1165 p
->source_addr
= p
->cf
->source_addr
;
1167 if (p
->p
.gr_recovery
&& p
->cf
->gr_mode
)
1168 proto_graceful_restart_lock(P
);
1171 * Before attempting to create the connection, we need to lock the
1172 * port, so that are sure we're the only instance attempting to talk
1173 * with that neighbor.
1176 lock
= p
->lock
= olock_new(P
->pool
);
1177 lock
->addr
= p
->cf
->remote_ip
;
1178 lock
->port
= p
->cf
->remote_port
;
1179 lock
->iface
= p
->cf
->iface
;
1180 lock
->type
= OBJLOCK_TCP
;
1181 lock
->hook
= bgp_start_locked
;
1183 olock_acquire(lock
);
1188 extern int proto_restart
;
1191 bgp_shutdown(struct proto
*P
)
1193 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1194 unsigned subcode
= 0;
1196 BGP_TRACE(D_EVENTS
, "Shutdown requested");
1198 switch (P
->down_code
)
1201 case PDC_CF_DISABLE
:
1202 subcode
= 3; // Errcode 6, 3 - peer de-configured
1205 case PDC_CF_RESTART
:
1206 subcode
= 6; // Errcode 6, 6 - other configuration change
1209 case PDC_CMD_DISABLE
:
1210 case PDC_CMD_SHUTDOWN
:
1211 subcode
= 2; // Errcode 6, 2 - administrative shutdown
1214 case PDC_CMD_RESTART
:
1215 subcode
= 4; // Errcode 6, 4 - administrative reset
1218 case PDC_RX_LIMIT_HIT
:
1219 case PDC_IN_LIMIT_HIT
:
1220 subcode
= 1; // Errcode 6, 1 - max number of prefixes reached
1221 /* log message for compatibility */
1222 log(L_WARN
"%s: Route limit exceeded, shutting down", p
->p
.name
);
1225 case PDC_OUT_LIMIT_HIT
:
1226 subcode
= proto_restart
? 4 : 2; // Administrative reset or shutdown
1229 bgp_store_error(p
, NULL
, BE_AUTO_DOWN
, BEA_ROUTE_LIMIT_EXCEEDED
);
1231 bgp_update_startup_delay(p
);
1233 p
->startup_delay
= 0;
1237 bgp_store_error(p
, NULL
, BE_MAN_DOWN
, 0);
1238 p
->startup_delay
= 0;
1241 bgp_stop(p
, subcode
);
1242 return p
->p
.proto_state
;
1246 bgp_cleanup(struct proto
*P
)
1248 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1249 rt_unlock_table(p
->igp_table
);
1253 get_igp_table(struct bgp_config
*cf
)
1255 return cf
->igp_table
? cf
->igp_table
->table
: cf
->c
.table
->table
;
1258 static struct proto
*
1259 bgp_init(struct proto_config
*C
)
1261 struct proto
*P
= proto_new(C
, sizeof(struct bgp_proto
));
1262 struct bgp_config
*c
= (struct bgp_config
*) C
;
1263 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1265 P
->accept_ra_types
= c
->secondary
? RA_ACCEPTED
: RA_OPTIMAL
;
1266 P
->rt_notify
= bgp_rt_notify
;
1267 P
->import_control
= bgp_import_control
;
1268 P
->neigh_notify
= bgp_neigh_notify
;
1269 P
->reload_routes
= bgp_reload_routes
;
1270 P
->feed_begin
= bgp_feed_begin
;
1271 P
->feed_end
= bgp_feed_end
;
1272 P
->rte_better
= bgp_rte_better
;
1273 P
->rte_mergable
= bgp_rte_mergable
;
1274 P
->rte_recalculate
= c
->deterministic_med
? bgp_rte_recalculate
: NULL
;
1277 p
->local_as
= c
->local_as
;
1278 p
->remote_as
= c
->remote_as
;
1279 p
->is_internal
= (c
->local_as
== c
->remote_as
);
1280 p
->rs_client
= c
->rs_client
;
1281 p
->rr_client
= c
->rr_client
;
1282 p
->igp_table
= get_igp_table(c
);
1289 bgp_check_config(struct bgp_config
*c
)
1291 int internal
= (c
->local_as
== c
->remote_as
);
1293 /* Do not check templates at all */
1294 if (c
->c
.class == SYM_TEMPLATE
)
1298 /* EBGP direct by default, IBGP multihop by default */
1299 if (c
->multihop
< 0)
1300 c
->multihop
= internal
? 64 : 0;
1302 /* Different default for gw_mode */
1304 c
->gw_mode
= c
->multihop
? GW_RECURSIVE
: GW_DIRECT
;
1306 /* Different default based on rs_client */
1307 if (!c
->missing_lladdr
)
1308 c
->missing_lladdr
= c
->rs_client
? MLL_IGNORE
: MLL_SELF
;
1310 /* Disable after error incompatible with restart limit action */
1311 if (c
->c
.in_limit
&& (c
->c
.in_limit
->action
== PLA_RESTART
) && c
->disable_after_error
)
1312 c
->c
.in_limit
->action
= PLA_DISABLE
;
1316 cf_error("Local AS number must be set");
1318 if (ipa_zero(c
->remote_ip
))
1319 cf_error("Neighbor must be configured");
1322 cf_error("Remote AS number must be set");
1324 // if (ipa_is_link_local(c->remote_ip) && !c->iface)
1325 // cf_error("Link-local neighbor address requires specified interface");
1327 if (!ipa_is_link_local(c
->remote_ip
) != !c
->iface
)
1328 cf_error("Link-local address and interface scope must be used together");
1330 if (!(c
->capabilities
&& c
->enable_as4
) && (c
->remote_as
> 0xFFFF))
1331 cf_error("Neighbor AS number out of range (AS4 not available)");
1333 if (!internal
&& c
->rr_client
)
1334 cf_error("Only internal neighbor can be RR client");
1336 if (internal
&& c
->rs_client
)
1337 cf_error("Only external neighbor can be RS client");
1339 if (c
->multihop
&& (c
->gw_mode
== GW_DIRECT
))
1340 cf_error("Multihop BGP cannot use direct gateway mode");
1342 if (c
->multihop
&& (ipa_is_link_local(c
->remote_ip
) ||
1343 ipa_is_link_local(c
->source_addr
)))
1344 cf_error("Multihop BGP cannot be used with link-local addresses");
1346 if (c
->multihop
&& c
->check_link
)
1347 cf_error("Multihop BGP cannot depend on link state");
1349 if (c
->multihop
&& c
->bfd
&& ipa_zero(c
->source_addr
))
1350 cf_error("Multihop BGP with BFD requires specified source address");
1352 if ((c
->gw_mode
== GW_RECURSIVE
) && c
->c
.table
->sorted
)
1353 cf_error("BGP in recursive mode prohibits sorted table");
1355 if (c
->deterministic_med
&& c
->c
.table
->sorted
)
1356 cf_error("BGP with deterministic MED prohibits sorted table");
1358 if (c
->secondary
&& !c
->c
.table
->sorted
)
1359 cf_error("BGP with secondary option requires sorted table");
1363 bgp_reconfigure(struct proto
*P
, struct proto_config
*C
)
1365 struct bgp_config
*new = (struct bgp_config
*) C
;
1366 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1367 struct bgp_config
*old
= p
->cf
;
1369 if (proto_get_router_id(C
) != p
->local_id
)
1372 int same
= !memcmp(((byte
*) old
) + sizeof(struct proto_config
),
1373 ((byte
*) new) + sizeof(struct proto_config
),
1374 // password item is last and must be checked separately
1375 OFFSETOF(struct bgp_config
, password
) - sizeof(struct proto_config
))
1376 && ((!old
->password
&& !new->password
)
1377 || (old
->password
&& new->password
&& !strcmp(old
->password
, new->password
)))
1378 && (get_igp_table(old
) == get_igp_table(new));
1380 if (same
&& (p
->start_state
> BSS_PREPARE
))
1381 bgp_update_bfd(p
, new->bfd
);
1383 /* We should update our copy of configuration ptr as old configuration will be freed */
1391 bgp_copy_config(struct proto_config
*dest
, struct proto_config
*src
)
1393 /* Just a shallow copy */
1394 proto_copy_rest(dest
, src
, sizeof(struct bgp_config
));
1399 * bgp_error - report a protocol error
1401 * @code: error code (according to the RFC)
1402 * @subcode: error sub-code
1403 * @data: data to be passed in the Notification message
1404 * @len: length of the data
1406 * bgp_error() sends a notification packet to tell the other side that a protocol
1407 * error has occurred (including the data considered erroneous if possible) and
1408 * closes the connection.
1411 bgp_error(struct bgp_conn
*c
, unsigned code
, unsigned subcode
, byte
*data
, int len
)
1413 struct bgp_proto
*p
= c
->bgp
;
1415 if (c
->state
== BS_CLOSE
)
1418 bgp_log_error(p
, BE_BGP_TX
, "Error", code
, subcode
, data
, (len
> 0) ? len
: -len
);
1419 bgp_store_error(p
, c
, BE_BGP_TX
, (code
<< 16) | subcode
);
1420 bgp_conn_enter_close_state(c
);
1422 c
->notify_code
= code
;
1423 c
->notify_subcode
= subcode
;
1424 c
->notify_data
= data
;
1425 c
->notify_size
= (len
> 0) ? len
: 0;
1426 bgp_schedule_packet(c
, PKT_NOTIFICATION
);
1430 bgp_update_startup_delay(p
);
1436 * bgp_store_error - store last error for status report
1439 * @class: error class (BE_xxx constants)
1440 * @code: error code (class specific)
1442 * bgp_store_error() decides whether given error is interesting enough
1443 * and store that error to last_error variables of @p
1446 bgp_store_error(struct bgp_proto
*p
, struct bgp_conn
*c
, u8
class, u32 code
)
1448 /* During PS_UP, we ignore errors on secondary connection */
1449 if ((p
->p
.proto_state
== PS_UP
) && c
&& (c
!= p
->conn
))
1452 /* During PS_STOP, we ignore any errors, as we want to report
1453 * the error that caused transition to PS_STOP
1455 if (p
->p
.proto_state
== PS_STOP
)
1458 p
->last_error_class
= class;
1459 p
->last_error_code
= code
;
1462 static char *bgp_state_names
[] = { "Idle", "Connect", "Active", "OpenSent", "OpenConfirm", "Established", "Close" };
1463 static char *bgp_err_classes
[] = { "", "Error: ", "Socket: ", "Received: ", "BGP Error: ", "Automatic shutdown: ", ""};
1464 static char *bgp_misc_errors
[] = { "", "Neighbor lost", "Invalid next hop", "Kernel MD5 auth failed", "No listening socket", "Link down", "BFD session down", "Graceful restart"};
1465 static char *bgp_auto_errors
[] = { "", "Route limit exceeded"};
1468 bgp_last_errmsg(struct bgp_proto
*p
)
1470 switch (p
->last_error_class
)
1473 return bgp_misc_errors
[p
->last_error_code
];
1475 return (p
->last_error_code
== 0) ? "Connection closed" : strerror(p
->last_error_code
);
1478 return bgp_error_dsc(p
->last_error_code
>> 16, p
->last_error_code
& 0xFF);
1480 return bgp_auto_errors
[p
->last_error_code
];
1487 bgp_state_dsc(struct bgp_proto
*p
)
1489 if (p
->p
.proto_state
== PS_DOWN
)
1492 int state
= MAX(p
->incoming_conn
.state
, p
->outgoing_conn
.state
);
1493 if ((state
== BS_IDLE
) && (p
->start_state
>= BSS_CONNECT
) && p
->cf
->passive
)
1496 return bgp_state_names
[state
];
1500 bgp_get_status(struct proto
*P
, byte
*buf
)
1502 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1504 const char *err1
= bgp_err_classes
[p
->last_error_class
];
1505 const char *err2
= bgp_last_errmsg(p
);
1507 if (P
->proto_state
== PS_DOWN
)
1508 bsprintf(buf
, "%s%s", err1
, err2
);
1510 bsprintf(buf
, "%-14s%s%s", bgp_state_dsc(p
), err1
, err2
);
1514 bgp_show_proto_info(struct proto
*P
)
1516 struct bgp_proto
*p
= (struct bgp_proto
*) P
;
1517 struct bgp_conn
*c
= p
->conn
;
1519 proto_show_basic_info(P
);
1521 cli_msg(-1006, " BGP state: %s", bgp_state_dsc(p
));
1522 cli_msg(-1006, " Neighbor address: %I%J", p
->cf
->remote_ip
, p
->cf
->iface
);
1523 cli_msg(-1006, " Neighbor AS: %u", p
->remote_as
);
1526 cli_msg(-1006, " Neighbor graceful restart active");
1528 if (P
->proto_state
== PS_START
)
1530 struct bgp_conn
*oc
= &p
->outgoing_conn
;
1532 if ((p
->start_state
< BSS_CONNECT
) &&
1533 (p
->startup_timer
->expires
))
1534 cli_msg(-1006, " Error wait: %d/%d",
1535 p
->startup_timer
->expires
- now
, p
->startup_delay
);
1537 if ((oc
->state
== BS_ACTIVE
) &&
1538 (oc
->connect_retry_timer
->expires
))
1539 cli_msg(-1006, " Connect delay: %d/%d",
1540 oc
->connect_retry_timer
->expires
- now
, p
->cf
->connect_delay_time
);
1542 if (p
->gr_active
&& p
->gr_timer
->expires
)
1543 cli_msg(-1006, " Restart timer: %d/-", p
->gr_timer
->expires
- now
);
1545 else if (P
->proto_state
== PS_UP
)
1547 cli_msg(-1006, " Neighbor ID: %R", p
->remote_id
);
1548 cli_msg(-1006, " Neighbor caps: %s%s%s%s%s%s%s",
1549 c
->peer_refresh_support
? " refresh" : "",
1550 c
->peer_enhanced_refresh_support
? " enhanced-refresh" : "",
1551 c
->peer_gr_able
? " restart-able" : (c
->peer_gr_aware
? " restart-aware" : ""),
1552 c
->peer_as4_support
? " AS4" : "",
1553 (c
->peer_add_path
& ADD_PATH_RX
) ? " add-path-rx" : "",
1554 (c
->peer_add_path
& ADD_PATH_TX
) ? " add-path-tx" : "",
1555 c
->peer_ext_messages_support
? " ext-messages" : "");
1556 cli_msg(-1006, " Session: %s%s%s%s%s%s%s%s",
1557 p
->is_internal
? "internal" : "external",
1558 p
->cf
->multihop
? " multihop" : "",
1559 p
->rr_client
? " route-reflector" : "",
1560 p
->rs_client
? " route-server" : "",
1561 p
->as4_session
? " AS4" : "",
1562 p
->add_path_rx
? " add-path-rx" : "",
1563 p
->add_path_tx
? " add-path-tx" : "",
1564 p
->ext_messages
? " ext-messages" : "");
1565 cli_msg(-1006, " Source address: %I", p
->source_addr
);
1566 if (P
->cf
->in_limit
)
1567 cli_msg(-1006, " Route limit: %d/%d",
1568 p
->p
.stats
.imp_routes
+ p
->p
.stats
.filt_routes
, P
->cf
->in_limit
->limit
);
1569 cli_msg(-1006, " Hold timer: %d/%d",
1570 tm_remains(c
->hold_timer
), c
->hold_time
);
1571 cli_msg(-1006, " Keepalive timer: %d/%d",
1572 tm_remains(c
->keepalive_timer
), c
->keepalive_time
);
1575 if ((p
->last_error_class
!= BE_NONE
) &&
1576 (p
->last_error_class
!= BE_MAN_DOWN
))
1578 const char *err1
= bgp_err_classes
[p
->last_error_class
];
1579 const char *err2
= bgp_last_errmsg(p
);
1580 cli_msg(-1006, " Last error: %s%s", err1
, err2
);
1584 struct protocol proto_bgp
= {
1586 .template = "bgp%d",
1587 .attr_class
= EAP_BGP
,
1588 .preference
= DEF_PREF_BGP
,
1589 .config_size
= sizeof(struct bgp_config
),
1592 .shutdown
= bgp_shutdown
,
1593 .cleanup
= bgp_cleanup
,
1594 .reconfigure
= bgp_reconfigure
,
1595 .copy_config
= bgp_copy_config
,
1596 .get_status
= bgp_get_status
,
1597 .get_attr
= bgp_get_attr
,
1598 .get_route_info
= bgp_get_route_info
,
1599 .show_proto_info
= bgp_show_proto_info