1 /* BGP-4 Finite State Machine
2 * From RFC1771 [A Border Gateway Protocol 4 (BGP-4)]
3 * Copyright (C) 1996, 97, 98 Kunihiro Ishiguro
5 * This file is part of GNU Zebra.
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "sockunion.h"
33 #include "workqueue.h"
37 #include "lib_errors.h"
40 #include "bgpd/bgpd.h"
41 #include "bgpd/bgp_attr.h"
42 #include "bgpd/bgp_debug.h"
43 #include "bgpd/bgp_errors.h"
44 #include "bgpd/bgp_fsm.h"
45 #include "bgpd/bgp_packet.h"
46 #include "bgpd/bgp_network.h"
47 #include "bgpd/bgp_route.h"
48 #include "bgpd/bgp_dump.h"
49 #include "bgpd/bgp_open.h"
50 #include "bgpd/bgp_advertise.h"
51 #include "bgpd/bgp_community.h"
52 #include "bgpd/bgp_updgrp.h"
53 #include "bgpd/bgp_nht.h"
54 #include "bgpd/bgp_bfd.h"
55 #include "bgpd/bgp_memory.h"
56 #include "bgpd/bgp_keepalives.h"
57 #include "bgpd/bgp_io.h"
58 #include "bgpd/bgp_zebra.h"
59 #include "bgpd/bgp_vty.h"
61 DEFINE_HOOK(peer_backward_transition
, (struct peer
* peer
), (peer
));
62 DEFINE_HOOK(peer_status_changed
, (struct peer
* peer
), (peer
));
64 enum bgp_fsm_state_progress
{
65 BGP_FSM_FAILURE_AND_DELETE
= -2,
68 BGP_FSM_SUCCESS_STATE_TRANSFER
= 1,
71 /* Definition of display strings corresponding to FSM events. This should be
72 * kept consistent with the events defined in bgpd.h
74 static const char *const bgp_event_str
[] = {
78 "TCP_connection_open",
79 "TCP_connection_open_w_delay",
80 "TCP_connection_closed",
81 "TCP_connection_open_failed",
83 "ConnectRetry_timer_expired",
85 "KeepAlive_timer_expired",
86 "DelayOpen_timer_expired",
87 "Receive_OPEN_message",
88 "Receive_KEEPALIVE_message",
89 "Receive_UPDATE_message",
90 "Receive_NOTIFICATION_message",
94 /* BGP FSM (finite state machine) has three types of functions. Type
95 one is thread functions. Type two is event functions. Type three
96 is FSM functions. Timer functions are set by bgp_timer_set
99 /* BGP event function. */
100 void bgp_event(struct thread
*);
102 /* BGP thread functions. */
103 static void bgp_start_timer(struct thread
*);
104 static void bgp_connect_timer(struct thread
*);
105 static void bgp_holdtime_timer(struct thread
*);
106 static void bgp_delayopen_timer(struct thread
*);
108 /* BGP FSM functions. */
109 static enum bgp_fsm_state_progress
bgp_start(struct peer
*);
111 /* Register peer with NHT */
112 int bgp_peer_reg_with_nht(struct peer
*peer
)
116 if (peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
== BGP_DEFAULT_TTL
117 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)
118 && !CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
121 return bgp_find_or_add_nexthop(
122 peer
->bgp
, peer
->bgp
, family2afi(peer
->su
.sa
.sa_family
),
123 SAFI_UNICAST
, NULL
, peer
, connected
, NULL
);
126 static void peer_xfer_stats(struct peer
*peer_dst
, struct peer
*peer_src
)
128 /* Copy stats over. These are only the pre-established state stats */
129 peer_dst
->open_in
+= peer_src
->open_in
;
130 peer_dst
->open_out
+= peer_src
->open_out
;
131 peer_dst
->keepalive_in
+= peer_src
->keepalive_in
;
132 peer_dst
->keepalive_out
+= peer_src
->keepalive_out
;
133 peer_dst
->notify_in
+= peer_src
->notify_in
;
134 peer_dst
->notify_out
+= peer_src
->notify_out
;
135 peer_dst
->dynamic_cap_in
+= peer_src
->dynamic_cap_in
;
136 peer_dst
->dynamic_cap_out
+= peer_src
->dynamic_cap_out
;
139 static struct peer
*peer_xfer_conn(struct peer
*from_peer
)
145 enum bgp_fsm_status status
, pstatus
;
146 enum bgp_fsm_events last_evt
, last_maj_evt
;
148 assert(from_peer
!= NULL
);
150 peer
= from_peer
->doppelganger
;
152 if (!peer
|| !CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
156 * Let's check that we are not going to loose known configuration
157 * state based upon doppelganger rules.
159 FOREACH_AFI_SAFI (afi
, safi
) {
160 if (from_peer
->afc
[afi
][safi
] != peer
->afc
[afi
][safi
]) {
162 EC_BGP_DOPPELGANGER_CONFIG
,
163 "from_peer->afc[%d][%d] is not the same as what we are overwriting",
169 if (bgp_debug_neighbor_events(peer
))
170 zlog_debug("%s: peer transfer %p fd %d -> %p fd %d)",
171 from_peer
->host
, from_peer
, from_peer
->fd
, peer
,
174 bgp_writes_off(peer
);
176 bgp_writes_off(from_peer
);
177 bgp_reads_off(from_peer
);
180 * Before exchanging FD remove doppelganger from
181 * keepalive peer hash. It could be possible conf peer
182 * fd is set to -1. If blocked on lock then keepalive
183 * thread can access peer pointer with fd -1.
185 bgp_keepalives_off(from_peer
);
187 THREAD_OFF(peer
->t_routeadv
);
188 THREAD_OFF(peer
->t_connect
);
189 THREAD_OFF(peer
->t_delayopen
);
190 THREAD_OFF(peer
->t_connect_check_r
);
191 THREAD_OFF(peer
->t_connect_check_w
);
192 THREAD_OFF(from_peer
->t_routeadv
);
193 THREAD_OFF(from_peer
->t_connect
);
194 THREAD_OFF(from_peer
->t_delayopen
);
195 THREAD_OFF(from_peer
->t_connect_check_r
);
196 THREAD_OFF(from_peer
->t_connect_check_w
);
197 THREAD_OFF(from_peer
->t_process_packet
);
200 * At this point in time, it is possible that there are packets pending
201 * on various buffers. Those need to be transferred or dropped,
202 * otherwise we'll get spurious failures during session establishment.
204 frr_with_mutex (&peer
->io_mtx
, &from_peer
->io_mtx
) {
206 peer
->fd
= from_peer
->fd
;
209 stream_fifo_clean(peer
->ibuf
);
210 stream_fifo_clean(peer
->obuf
);
213 * this should never happen, since bgp_process_packet() is the
214 * only task that sets and unsets the current packet and it
215 * runs in our pthread.
220 "[%s] Dropping pending packet on connection transfer:",
222 /* there used to be a bgp_packet_dump call here, but
223 * that's extremely confusing since there's no way to
224 * identify the packet in MRT dumps or BMP as dropped
225 * due to connection transfer.
227 stream_free(peer
->curr
);
231 // copy each packet from old peer's output queue to new peer
232 while (from_peer
->obuf
->head
)
233 stream_fifo_push(peer
->obuf
,
234 stream_fifo_pop(from_peer
->obuf
));
236 // copy each packet from old peer's input queue to new peer
237 while (from_peer
->ibuf
->head
)
238 stream_fifo_push(peer
->ibuf
,
239 stream_fifo_pop(from_peer
->ibuf
));
241 ringbuf_wipe(peer
->ibuf_work
);
242 ringbuf_copy(peer
->ibuf_work
, from_peer
->ibuf_work
,
243 ringbuf_remain(from_peer
->ibuf_work
));
246 peer
->as
= from_peer
->as
;
247 peer
->v_holdtime
= from_peer
->v_holdtime
;
248 peer
->v_keepalive
= from_peer
->v_keepalive
;
249 peer
->v_routeadv
= from_peer
->v_routeadv
;
250 peer
->v_delayopen
= from_peer
->v_delayopen
;
251 peer
->v_gr_restart
= from_peer
->v_gr_restart
;
252 peer
->cap
= from_peer
->cap
;
253 peer
->remote_role
= from_peer
->remote_role
;
254 status
= peer
->status
;
255 pstatus
= peer
->ostatus
;
256 last_evt
= peer
->last_event
;
257 last_maj_evt
= peer
->last_major_event
;
258 peer
->status
= from_peer
->status
;
259 peer
->ostatus
= from_peer
->ostatus
;
260 peer
->last_event
= from_peer
->last_event
;
261 peer
->last_major_event
= from_peer
->last_major_event
;
262 from_peer
->status
= status
;
263 from_peer
->ostatus
= pstatus
;
264 from_peer
->last_event
= last_evt
;
265 from_peer
->last_major_event
= last_maj_evt
;
266 peer
->remote_id
= from_peer
->remote_id
;
267 peer
->last_reset
= from_peer
->last_reset
;
268 peer
->max_packet_size
= from_peer
->max_packet_size
;
270 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer
->bgp
,
273 if (bgp_peer_gr_mode_get(peer
) == PEER_DISABLE
) {
275 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
277 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
282 if (peer
->hostname
) {
283 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
284 peer
->hostname
= NULL
;
286 if (from_peer
->hostname
!= NULL
) {
287 peer
->hostname
= from_peer
->hostname
;
288 from_peer
->hostname
= NULL
;
291 if (peer
->domainname
) {
292 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
293 peer
->domainname
= NULL
;
295 if (from_peer
->domainname
!= NULL
) {
296 peer
->domainname
= from_peer
->domainname
;
297 from_peer
->domainname
= NULL
;
300 FOREACH_AFI_SAFI (afi
, safi
) {
301 peer
->af_sflags
[afi
][safi
] = from_peer
->af_sflags
[afi
][safi
];
302 peer
->af_cap
[afi
][safi
] = from_peer
->af_cap
[afi
][safi
];
303 peer
->afc_nego
[afi
][safi
] = from_peer
->afc_nego
[afi
][safi
];
304 peer
->afc_adv
[afi
][safi
] = from_peer
->afc_adv
[afi
][safi
];
305 peer
->afc_recv
[afi
][safi
] = from_peer
->afc_recv
[afi
][safi
];
306 peer
->orf_plist
[afi
][safi
] = from_peer
->orf_plist
[afi
][safi
];
307 peer
->llgr
[afi
][safi
] = from_peer
->llgr
[afi
][safi
];
310 if (bgp_getsockname(peer
) < 0) {
313 "%%bgp_getsockname() failed for %s peer %s fd %d (from_peer fd %d)",
314 (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)
317 peer
->host
, peer
->fd
, from_peer
->fd
);
318 BGP_EVENT_ADD(peer
, BGP_Stop
);
319 BGP_EVENT_ADD(from_peer
, BGP_Stop
);
322 if (from_peer
->status
> Active
) {
323 if (bgp_getsockname(from_peer
) < 0) {
326 "%%bgp_getsockname() failed for %s from_peer %s fd %d (peer fd %d)",
328 (CHECK_FLAG(from_peer
->sflags
,
329 PEER_STATUS_ACCEPT_PEER
)
332 from_peer
->host
, from_peer
->fd
, peer
->fd
);
339 // Note: peer_xfer_stats() must be called with I/O turned OFF
341 peer_xfer_stats(peer
, from_peer
);
343 /* Register peer for NHT. This is to allow RAs to be enabled when
344 * needed, even on a passive connection.
346 bgp_peer_reg_with_nht(peer
);
348 bgp_replace_nexthop_by_peer(from_peer
, peer
);
352 thread_add_event(bm
->master
, bgp_process_packet
, peer
, 0,
353 &peer
->t_process_packet
);
358 /* Hook function called after bgp event is occered. And vty's
359 neighbor command invoke this function after making neighbor
361 void bgp_timer_set(struct peer
*peer
)
366 switch (peer
->status
) {
368 /* First entry point of peer's finite state machine. In Idle
369 status start timer is on unless peer is shutdown or peer is
370 inactive. All other timer must be turned off */
371 if (BGP_PEER_START_SUPPRESSED(peer
) || !peer_active(peer
)
372 || peer
->bgp
->vrf_id
== VRF_UNKNOWN
) {
373 THREAD_OFF(peer
->t_start
);
375 BGP_TIMER_ON(peer
->t_start
, bgp_start_timer
,
378 THREAD_OFF(peer
->t_connect
);
379 THREAD_OFF(peer
->t_holdtime
);
380 bgp_keepalives_off(peer
);
381 THREAD_OFF(peer
->t_routeadv
);
382 THREAD_OFF(peer
->t_delayopen
);
386 /* After start timer is expired, the peer moves to Connect
387 status. Make sure start timer is off and connect timer is
389 THREAD_OFF(peer
->t_start
);
390 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER_DELAYOPEN
))
391 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
392 (peer
->v_delayopen
+ peer
->v_connect
));
394 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
397 THREAD_OFF(peer
->t_holdtime
);
398 bgp_keepalives_off(peer
);
399 THREAD_OFF(peer
->t_routeadv
);
403 /* Active is waiting connection from remote peer. And if
404 connect timer is expired, change status to Connect. */
405 THREAD_OFF(peer
->t_start
);
406 /* If peer is passive mode, do not set connect timer. */
407 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)
408 || CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
409 THREAD_OFF(peer
->t_connect
);
411 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER_DELAYOPEN
))
413 peer
->t_connect
, bgp_connect_timer
,
414 (peer
->v_delayopen
+ peer
->v_connect
));
416 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
419 THREAD_OFF(peer
->t_holdtime
);
420 bgp_keepalives_off(peer
);
421 THREAD_OFF(peer
->t_routeadv
);
425 /* OpenSent status. */
426 THREAD_OFF(peer
->t_start
);
427 THREAD_OFF(peer
->t_connect
);
428 if (peer
->v_holdtime
!= 0) {
429 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
432 THREAD_OFF(peer
->t_holdtime
);
434 bgp_keepalives_off(peer
);
435 THREAD_OFF(peer
->t_routeadv
);
436 THREAD_OFF(peer
->t_delayopen
);
440 /* OpenConfirm status. */
441 THREAD_OFF(peer
->t_start
);
442 THREAD_OFF(peer
->t_connect
);
444 /* If the negotiated Hold Time value is zero, then the Hold Time
445 timer and KeepAlive timers are not started. */
446 if (peer
->v_holdtime
== 0) {
447 THREAD_OFF(peer
->t_holdtime
);
448 bgp_keepalives_off(peer
);
450 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
452 bgp_keepalives_on(peer
);
454 THREAD_OFF(peer
->t_routeadv
);
455 THREAD_OFF(peer
->t_delayopen
);
459 /* In Established status start and connect timer is turned
461 THREAD_OFF(peer
->t_start
);
462 THREAD_OFF(peer
->t_connect
);
463 THREAD_OFF(peer
->t_delayopen
);
465 /* Same as OpenConfirm, if holdtime is zero then both holdtime
466 and keepalive must be turned off. */
467 if (peer
->v_holdtime
== 0) {
468 THREAD_OFF(peer
->t_holdtime
);
469 bgp_keepalives_off(peer
);
471 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
473 bgp_keepalives_on(peer
);
477 THREAD_OFF(peer
->t_gr_restart
);
478 THREAD_OFF(peer
->t_gr_stale
);
480 FOREACH_AFI_SAFI (afi
, safi
)
481 THREAD_OFF(peer
->t_llgr_stale
[afi
][safi
]);
483 THREAD_OFF(peer
->t_pmax_restart
);
484 THREAD_OFF(peer
->t_refresh_stalepath
);
487 THREAD_OFF(peer
->t_start
);
488 THREAD_OFF(peer
->t_connect
);
489 THREAD_OFF(peer
->t_holdtime
);
490 bgp_keepalives_off(peer
);
491 THREAD_OFF(peer
->t_routeadv
);
492 THREAD_OFF(peer
->t_delayopen
);
495 flog_err(EC_LIB_DEVELOPMENT
,
496 "BGP_STATUS_MAX while a legal state is not valid state for the FSM");
501 /* BGP start timer. This function set BGP_Start event to thread value
502 and process event. */
503 static void bgp_start_timer(struct thread
*thread
)
507 peer
= THREAD_ARG(thread
);
509 if (bgp_debug_neighbor_events(peer
))
510 zlog_debug("%s [FSM] Timer (start timer expire).", peer
->host
);
512 THREAD_VAL(thread
) = BGP_Start
;
513 bgp_event(thread
); /* bgp_event unlocks peer */
516 /* BGP connect retry timer. */
517 static void bgp_connect_timer(struct thread
*thread
)
521 peer
= THREAD_ARG(thread
);
523 /* stop the DelayOpenTimer if it is running */
524 THREAD_OFF(peer
->t_delayopen
);
526 assert(!peer
->t_write
);
527 assert(!peer
->t_read
);
529 if (bgp_debug_neighbor_events(peer
))
530 zlog_debug("%s [FSM] Timer (connect timer expire)", peer
->host
);
532 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
535 THREAD_VAL(thread
) = ConnectRetry_timer_expired
;
536 bgp_event(thread
); /* bgp_event unlocks peer */
540 /* BGP holdtime timer. */
541 static void bgp_holdtime_timer(struct thread
*thread
)
543 atomic_size_t inq_count
;
546 peer
= THREAD_ARG(thread
);
548 if (bgp_debug_neighbor_events(peer
))
549 zlog_debug("%s [FSM] Timer (holdtime timer expire)",
553 * Given that we do not have any expectation of ordering
554 * for handling packets from a peer -vs- handling
555 * the hold timer for a peer as that they are both
556 * events on the peer. If we have incoming
557 * data on the peers inq, let's give the system a chance
558 * to handle that data. This can be especially true
559 * for systems where we are heavily loaded for one
562 inq_count
= atomic_load_explicit(&peer
->ibuf
->count
,
563 memory_order_relaxed
);
565 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
568 THREAD_VAL(thread
) = Hold_Timer_expired
;
569 bgp_event(thread
); /* bgp_event unlocks peer */
572 void bgp_routeadv_timer(struct thread
*thread
)
576 peer
= THREAD_ARG(thread
);
578 if (bgp_debug_neighbor_events(peer
))
579 zlog_debug("%s [FSM] Timer (routeadv timer expire)",
582 peer
->synctime
= monotime(NULL
);
584 thread_add_timer_msec(bm
->master
, bgp_generate_updgrp_packets
, peer
, 0,
585 &peer
->t_generate_updgrp_packets
);
587 /* MRAI timer will be started again when FIFO is built, no need to
592 /* RFC 4271 DelayOpenTimer */
593 void bgp_delayopen_timer(struct thread
*thread
)
597 peer
= THREAD_ARG(thread
);
599 if (bgp_debug_neighbor_events(peer
))
600 zlog_debug("%s [FSM] Timer (DelayOpentimer expire)",
603 THREAD_VAL(thread
) = DelayOpen_timer_expired
;
604 bgp_event(thread
); /* bgp_event unlocks peer */
607 /* BGP Peer Down Cause */
608 const char *const peer_down_str
[] = {"",
612 "Cluster ID changed",
613 "Confederation identifier changed",
614 "Confederation peer changed",
615 "RR client config change",
616 "RS client config change",
617 "Update source change",
618 "Address family activated",
621 "BGP Notification received",
622 "BGP Notification send",
623 "Peer closed the session",
625 "Peer-group add member",
626 "Peer-group delete member",
627 "Capability changed",
628 "Passive config change",
629 "Multihop config change",
630 "NSF peer closed the session",
631 "Intf peering v6only config change",
634 "Neighbor address lost",
635 "No path to specified Neighbor",
636 "Waiting for Peer IPv6 LLA",
637 "Waiting for VRF to be initialized",
638 "No AFI/SAFI activated for peer",
639 "AS Set config change",
640 "Waiting for peer OPEN",
641 "Reached received prefix count",
643 "Admin. shutdown (RTT)"};
645 static void bgp_graceful_restart_timer_off(struct peer
*peer
)
650 FOREACH_AFI_SAFI (afi
, safi
)
651 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
652 PEER_STATUS_LLGR_WAIT
))
655 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
656 THREAD_OFF(peer
->t_gr_stale
);
658 if (peer_dynamic_neighbor(peer
) &&
659 !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
660 if (bgp_debug_neighbor_events(peer
))
661 zlog_debug("%s (dynamic neighbor) deleted (%s)",
662 peer
->host
, __func__
);
669 static void bgp_llgr_stale_timer_expire(struct thread
*thread
)
676 paf
= THREAD_ARG(thread
);
682 /* If the timer for the "Long-lived Stale Time" expires before the
683 * session is re-established, the helper MUST delete all the
684 * stale routes from the neighbor that it is retaining.
686 if (bgp_debug_neighbor_events(peer
))
687 zlog_debug("%pBP Long-lived stale timer (%s) expired", peer
,
688 get_afi_safi_str(afi
, safi
, false));
690 UNSET_FLAG(peer
->af_sflags
[afi
][safi
], PEER_STATUS_LLGR_WAIT
);
692 bgp_clear_stale_route(peer
, afi
, safi
);
694 bgp_graceful_restart_timer_off(peer
);
697 static void bgp_set_llgr_stale(struct peer
*peer
, afi_t afi
, safi_t safi
)
699 struct bgp_dest
*dest
;
700 struct bgp_path_info
*pi
;
701 struct bgp_table
*table
;
704 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
|| safi
== SAFI_EVPN
) {
705 for (dest
= bgp_table_top(peer
->bgp
->rib
[afi
][safi
]); dest
;
706 dest
= bgp_route_next(dest
)) {
709 table
= bgp_dest_get_bgp_table_info(dest
);
713 for (rm
= bgp_table_top(table
); rm
;
714 rm
= bgp_route_next(rm
))
715 for (pi
= bgp_dest_get_bgp_path_info(rm
); pi
;
717 if (pi
->peer
!= peer
)
720 if (bgp_attr_get_community(pi
->attr
) &&
722 bgp_attr_get_community(
727 if (bgp_debug_neighbor_events(peer
))
729 "%pBP Long-lived set stale community (LLGR_STALE) for: %pFX",
733 bgp_attr_add_llgr_community(&attr
);
734 pi
->attr
= bgp_attr_intern(&attr
);
735 bgp_recalculate_afi_safi_bestpaths(
736 peer
->bgp
, afi
, safi
);
742 for (dest
= bgp_table_top(peer
->bgp
->rib
[afi
][safi
]); dest
;
743 dest
= bgp_route_next(dest
))
744 for (pi
= bgp_dest_get_bgp_path_info(dest
); pi
;
746 if (pi
->peer
!= peer
)
749 if (bgp_attr_get_community(pi
->attr
) &&
751 bgp_attr_get_community(pi
->attr
),
755 if (bgp_debug_neighbor_events(peer
))
757 "%pBP Long-lived set stale community (LLGR_STALE) for: %pFX",
761 bgp_attr_add_llgr_community(&attr
);
762 pi
->attr
= bgp_attr_intern(&attr
);
763 bgp_recalculate_afi_safi_bestpaths(peer
->bgp
,
771 static void bgp_graceful_restart_timer_expire(struct thread
*thread
)
773 struct peer
*peer
, *tmp_peer
;
774 struct listnode
*node
, *nnode
;
779 peer
= THREAD_ARG(thread
);
781 if (bgp_debug_neighbor_events(peer
)) {
782 zlog_debug("%pBP graceful restart timer expired", peer
);
783 zlog_debug("%pBP graceful restart stalepath timer stopped",
787 FOREACH_AFI_SAFI (afi
, safi
) {
788 if (!peer
->nsf
[afi
][safi
])
791 /* Once the "Restart Time" period ends, the LLGR period is
792 * said to have begun and the following procedures MUST be
795 * The helper router MUST start a timer for the
796 * "Long-lived Stale Time".
798 * The helper router MUST attach the LLGR_STALE community
799 * for the stale routes being retained. Note that this
800 * requirement implies that the routes would need to be
801 * readvertised, to disseminate the modified community.
803 if (peer
->llgr
[afi
][safi
].stale_time
) {
804 paf
= peer_af_find(peer
, afi
, safi
);
808 if (bgp_debug_neighbor_events(peer
))
810 "%pBP Long-lived stale timer (%s) started for %d sec",
812 get_afi_safi_str(afi
, safi
, false),
813 peer
->llgr
[afi
][safi
].stale_time
);
815 SET_FLAG(peer
->af_sflags
[afi
][safi
],
816 PEER_STATUS_LLGR_WAIT
);
818 bgp_set_llgr_stale(peer
, afi
, safi
);
819 bgp_clear_stale_route(peer
, afi
, safi
);
821 thread_add_timer(bm
->master
,
822 bgp_llgr_stale_timer_expire
, paf
,
823 peer
->llgr
[afi
][safi
].stale_time
,
824 &peer
->t_llgr_stale
[afi
][safi
]);
826 for (ALL_LIST_ELEMENTS(peer
->bgp
->peer
, node
, nnode
,
828 bgp_announce_route(tmp_peer
, afi
, safi
, false);
830 bgp_clear_stale_route(peer
, afi
, safi
);
834 bgp_graceful_restart_timer_off(peer
);
837 static void bgp_graceful_stale_timer_expire(struct thread
*thread
)
843 peer
= THREAD_ARG(thread
);
845 if (bgp_debug_neighbor_events(peer
))
846 zlog_debug("%pBP graceful restart stalepath timer expired",
849 /* NSF delete stale route */
850 FOREACH_AFI_SAFI_NSF (afi
, safi
)
851 if (peer
->nsf
[afi
][safi
])
852 bgp_clear_stale_route(peer
, afi
, safi
);
855 /* Selection deferral timer processing function */
856 static void bgp_graceful_deferral_timer_expire(struct thread
*thread
)
858 struct afi_safi_info
*info
;
863 info
= THREAD_ARG(thread
);
868 if (BGP_DEBUG(update
, UPDATE_OUT
))
870 "afi %d, safi %d : graceful restart deferral timer expired",
873 bgp
->gr_info
[afi
][safi
].eor_required
= 0;
874 bgp
->gr_info
[afi
][safi
].eor_received
= 0;
875 XFREE(MTYPE_TMP
, info
);
877 /* Best path selection */
878 bgp_best_path_select_defer(bgp
, afi
, safi
);
881 static bool bgp_update_delay_applicable(struct bgp
*bgp
)
883 /* update_delay_over flag should be reset (set to 0) for any new
884 applicability of the update-delay during BGP process lifetime.
885 And it should be set after an occurence of the update-delay is
887 if (!bgp
->update_delay_over
)
892 bool bgp_update_delay_active(struct bgp
*bgp
)
894 if (bgp
->t_update_delay
)
899 bool bgp_update_delay_configured(struct bgp
*bgp
)
901 if (bgp
->v_update_delay
)
906 /* Do the post-processing needed when bgp comes out of the read-only mode
907 on ending the update delay. */
908 void bgp_update_delay_end(struct bgp
*bgp
)
910 THREAD_OFF(bgp
->t_update_delay
);
911 THREAD_OFF(bgp
->t_establish_wait
);
913 /* Reset update-delay related state */
914 bgp
->update_delay_over
= 1;
915 bgp
->established
= 0;
916 bgp
->restarted_peers
= 0;
917 bgp
->implicit_eors
= 0;
918 bgp
->explicit_eors
= 0;
920 frr_timestamp(3, bgp
->update_delay_end_time
,
921 sizeof(bgp
->update_delay_end_time
));
924 * Add an end-of-initial-update marker to the main process queues so
926 * the route advertisement timer for the peers can be started. Also set
927 * the zebra and peer update hold flags. These flags are used to achieve
928 * three stages in the update-delay post processing:
929 * 1. Finish best-path selection for all the prefixes held on the
931 * (routes in BGP are updated, and peers sync queues are populated
933 * 2. As the eoiu mark is reached in the bgp process routine, ship all
935 * routes to zebra. With that zebra should see updates from BGP
938 * 3. Unblock the peer update writes. With that peer update packing
940 * the prefixes should be at its maximum.
942 bgp_add_eoiu_mark(bgp
);
943 bgp
->main_zebra_update_hold
= 1;
944 bgp
->main_peers_update_hold
= 1;
947 * Resume the queue processing. This should trigger the event that would
948 * take care of processing any work that was queued during the read-only
951 work_queue_unplug(bgp
->process_queue
);
957 void bgp_start_routeadv(struct bgp
*bgp
)
959 struct listnode
*node
, *nnode
;
962 zlog_info("%s, update hold status %d", __func__
,
963 bgp
->main_peers_update_hold
);
965 if (bgp
->main_peers_update_hold
)
968 frr_timestamp(3, bgp
->update_delay_peers_resume_time
,
969 sizeof(bgp
->update_delay_peers_resume_time
));
971 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
972 if (!peer_established(peer
))
974 THREAD_OFF(peer
->t_routeadv
);
975 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
982 void bgp_adjust_routeadv(struct peer
*peer
)
984 time_t nowtime
= monotime(NULL
);
986 unsigned long remain
;
988 /* Bypass checks for special case of MRAI being 0 */
989 if (peer
->v_routeadv
== 0) {
990 /* Stop existing timer, just in case it is running for a
992 * duration and schedule write thread immediately.
994 THREAD_OFF(peer
->t_routeadv
);
996 peer
->synctime
= monotime(NULL
);
997 /* If suppress fib pending is enabled, route is advertised to
998 * peers when the status is received from the FIB. The delay
999 * is added to update group packet generate which will allow
1000 * more routes to be sent in the update message
1002 BGP_UPDATE_GROUP_TIMER_ON(&peer
->t_generate_updgrp_packets
,
1003 bgp_generate_updgrp_packets
);
1010 * If the last update was written more than MRAI back, expire the timer
1011 * instantly so that we can send the update out sooner.
1013 * <------- MRAI --------->
1014 * |-----------------|-----------------------|
1015 * <------------- m ------------>
1024 diff
= difftime(nowtime
, peer
->last_update
);
1025 if (diff
> (double)peer
->v_routeadv
) {
1026 THREAD_OFF(peer
->t_routeadv
);
1027 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
1033 * - Find when to expire the MRAI timer.
1034 * If MRAI timer is not active, assume we can start it now.
1036 * <------- MRAI --------->
1037 * |------------|-----------------------|
1038 * <-------- m ----------><----- r ----->
1047 if (peer
->t_routeadv
)
1048 remain
= thread_timer_remain_second(peer
->t_routeadv
);
1050 remain
= peer
->v_routeadv
;
1051 diff
= peer
->v_routeadv
- diff
;
1052 if (diff
<= (double)remain
) {
1053 THREAD_OFF(peer
->t_routeadv
);
1054 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, diff
);
1058 static bool bgp_maxmed_onstartup_applicable(struct bgp
*bgp
)
1060 if (!bgp
->maxmed_onstartup_over
)
1065 bool bgp_maxmed_onstartup_configured(struct bgp
*bgp
)
1067 if (bgp
->v_maxmed_onstartup
!= BGP_MAXMED_ONSTARTUP_UNCONFIGURED
)
1072 bool bgp_maxmed_onstartup_active(struct bgp
*bgp
)
1074 if (bgp
->t_maxmed_onstartup
)
1079 void bgp_maxmed_update(struct bgp
*bgp
)
1081 uint8_t maxmed_active
;
1082 uint32_t maxmed_value
;
1084 if (bgp
->v_maxmed_admin
) {
1086 maxmed_value
= bgp
->maxmed_admin_value
;
1087 } else if (bgp
->t_maxmed_onstartup
) {
1089 maxmed_value
= bgp
->maxmed_onstartup_value
;
1092 maxmed_value
= BGP_MAXMED_VALUE_DEFAULT
;
1095 if (bgp
->maxmed_active
!= maxmed_active
1096 || bgp
->maxmed_value
!= maxmed_value
) {
1097 bgp
->maxmed_active
= maxmed_active
;
1098 bgp
->maxmed_value
= maxmed_value
;
1100 update_group_announce(bgp
);
1104 int bgp_fsm_error_subcode(int status
)
1106 int fsm_err_subcode
= BGP_NOTIFY_FSM_ERR_SUBCODE_UNSPECIFIC
;
1110 fsm_err_subcode
= BGP_NOTIFY_FSM_ERR_SUBCODE_OPENSENT
;
1113 fsm_err_subcode
= BGP_NOTIFY_FSM_ERR_SUBCODE_OPENCONFIRM
;
1116 fsm_err_subcode
= BGP_NOTIFY_FSM_ERR_SUBCODE_ESTABLISHED
;
1122 return fsm_err_subcode
;
1125 /* The maxmed onstartup timer expiry callback. */
1126 static void bgp_maxmed_onstartup_timer(struct thread
*thread
)
1130 zlog_info("Max med on startup ended - timer expired.");
1132 bgp
= THREAD_ARG(thread
);
1133 THREAD_OFF(bgp
->t_maxmed_onstartup
);
1134 bgp
->maxmed_onstartup_over
= 1;
1136 bgp_maxmed_update(bgp
);
1139 static void bgp_maxmed_onstartup_begin(struct bgp
*bgp
)
1141 /* Applicable only once in the process lifetime on the startup */
1142 if (bgp
->maxmed_onstartup_over
)
1145 zlog_info("Begin maxmed onstartup mode - timer %d seconds",
1146 bgp
->v_maxmed_onstartup
);
1148 thread_add_timer(bm
->master
, bgp_maxmed_onstartup_timer
, bgp
,
1149 bgp
->v_maxmed_onstartup
, &bgp
->t_maxmed_onstartup
);
1151 if (!bgp
->v_maxmed_admin
) {
1152 bgp
->maxmed_active
= 1;
1153 bgp
->maxmed_value
= bgp
->maxmed_onstartup_value
;
1156 /* Route announce to all peers should happen after this in
1157 * bgp_establish() */
1160 static void bgp_maxmed_onstartup_process_status_change(struct peer
*peer
)
1162 if (peer_established(peer
) && !peer
->bgp
->established
) {
1163 bgp_maxmed_onstartup_begin(peer
->bgp
);
1167 /* The update delay timer expiry callback. */
1168 static void bgp_update_delay_timer(struct thread
*thread
)
1172 zlog_info("Update delay ended - timer expired.");
1174 bgp
= THREAD_ARG(thread
);
1175 THREAD_OFF(bgp
->t_update_delay
);
1176 bgp_update_delay_end(bgp
);
1179 /* The establish wait timer expiry callback. */
1180 static void bgp_establish_wait_timer(struct thread
*thread
)
1184 zlog_info("Establish wait - timer expired.");
1186 bgp
= THREAD_ARG(thread
);
1187 THREAD_OFF(bgp
->t_establish_wait
);
1188 bgp_check_update_delay(bgp
);
1191 /* Steps to begin the update delay:
1192 - initialize queues if needed
1193 - stop the queue processing
1194 - start the timer */
1195 static void bgp_update_delay_begin(struct bgp
*bgp
)
1197 struct listnode
*node
, *nnode
;
1200 /* Stop the processing of queued work. Enqueue shall continue */
1201 work_queue_plug(bgp
->process_queue
);
1203 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
1204 peer
->update_delay_over
= 0;
1206 /* Start the update-delay timer */
1207 thread_add_timer(bm
->master
, bgp_update_delay_timer
, bgp
,
1208 bgp
->v_update_delay
, &bgp
->t_update_delay
);
1210 if (bgp
->v_establish_wait
!= bgp
->v_update_delay
)
1211 thread_add_timer(bm
->master
, bgp_establish_wait_timer
, bgp
,
1212 bgp
->v_establish_wait
, &bgp
->t_establish_wait
);
1214 frr_timestamp(3, bgp
->update_delay_begin_time
,
1215 sizeof(bgp
->update_delay_begin_time
));
1218 static void bgp_update_delay_process_status_change(struct peer
*peer
)
1220 if (peer_established(peer
)) {
1221 if (!peer
->bgp
->established
++) {
1222 bgp_update_delay_begin(peer
->bgp
);
1224 "Begin read-only mode - update-delay timer %d seconds",
1225 peer
->bgp
->v_update_delay
);
1227 if (CHECK_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
))
1228 bgp_update_restarted_peers(peer
);
1230 if (peer
->ostatus
== Established
1231 && bgp_update_delay_active(peer
->bgp
)) {
1232 /* Adjust the update-delay state to account for this flap.
1233 NOTE: Intentionally skipping adjusting implicit_eors or
1235 counters. Extra sanity check in bgp_check_update_delay()
1237 be enough to take care of any additive discrepancy in bgp eor
1239 peer
->bgp
->established
--;
1240 peer
->update_delay_over
= 0;
1244 /* Called after event occurred, this function change status and reset
1245 read/write and timer thread. */
1246 void bgp_fsm_change_status(struct peer
*peer
, enum bgp_fsm_status status
)
1249 uint32_t peer_count
;
1252 peer_count
= bgp
->established_peers
;
1254 if (status
== Established
)
1255 bgp
->established_peers
++;
1256 else if ((peer_established(peer
)) && (status
!= Established
))
1257 bgp
->established_peers
--;
1259 if (bgp_debug_neighbor_events(peer
)) {
1260 struct vrf
*vrf
= vrf_lookup_by_id(bgp
->vrf_id
);
1262 zlog_debug("%s : vrf %s(%u), Status: %s established_peers %u", __func__
,
1263 vrf
? vrf
->name
: "Unknown", bgp
->vrf_id
,
1264 lookup_msg(bgp_status_msg
, status
, NULL
),
1265 bgp
->established_peers
);
1268 /* Set to router ID to the value provided by RIB if there are no peers
1269 * in the established state and peer count did not change
1271 if ((peer_count
!= bgp
->established_peers
) &&
1272 (bgp
->established_peers
== 0))
1273 bgp_router_id_zebra_bump(bgp
->vrf_id
, NULL
);
1275 /* Transition into Clearing or Deleted must /always/ clear all routes..
1276 * (and must do so before actually changing into Deleted..
1278 if (status
>= Clearing
) {
1279 bgp_clear_route_all(peer
);
1281 /* If no route was queued for the clear-node processing,
1283 * completion event here. This is needed because if there are no
1285 * to trigger the background clear-node thread, the event won't
1287 * generated and the peer would be stuck in Clearing. Note that
1289 * event is for the peer and helps the peer transition out of
1291 * state; it should not be generated per (AFI,SAFI). The event
1293 * directly posted here without calling clear_node_complete() as
1295 * shouldn't do an extra unlock. This event will get processed
1297 * the state change that happens below, so peer will be in
1301 if (!work_queue_is_scheduled(peer
->clear_node_queue
) &&
1303 BGP_EVENT_ADD(peer
, Clearing_Completed
);
1306 /* Preserve old status and change into new status. */
1307 peer
->ostatus
= peer
->status
;
1308 peer
->status
= status
;
1310 /* Reset received keepalives counter on every FSM change */
1311 peer
->rtt_keepalive_rcv
= 0;
1313 /* Fire backward transition hook if that's the case */
1314 if (peer
->ostatus
== Established
&& peer
->status
!= Established
)
1315 hook_call(peer_backward_transition
, peer
);
1317 /* Save event that caused status change. */
1318 peer
->last_major_event
= peer
->cur_event
;
1320 /* Operations after status change */
1321 hook_call(peer_status_changed
, peer
);
1323 if (status
== Established
)
1324 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
1326 /* If max-med processing is applicable, do the necessary. */
1327 if (status
== Established
) {
1328 if (bgp_maxmed_onstartup_configured(peer
->bgp
)
1329 && bgp_maxmed_onstartup_applicable(peer
->bgp
))
1330 bgp_maxmed_onstartup_process_status_change(peer
);
1332 peer
->bgp
->maxmed_onstartup_over
= 1;
1335 /* If update-delay processing is applicable, do the necessary. */
1336 if (bgp_update_delay_configured(peer
->bgp
)
1337 && bgp_update_delay_applicable(peer
->bgp
))
1338 bgp_update_delay_process_status_change(peer
);
1340 if (bgp_debug_neighbor_events(peer
))
1341 zlog_debug("%s fd %d went from %s to %s", peer
->host
, peer
->fd
,
1342 lookup_msg(bgp_status_msg
, peer
->ostatus
, NULL
),
1343 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1346 /* Flush the event queue and ensure the peer is shut down */
1347 static enum bgp_fsm_state_progress
bgp_clearing_completed(struct peer
*peer
)
1349 enum bgp_fsm_state_progress rc
= bgp_stop(peer
);
1351 if (rc
>= BGP_FSM_SUCCESS
)
1352 BGP_EVENT_FLUSH(peer
);
1357 /* Administrative BGP peer stop event. */
1358 /* May be called multiple times for the same peer */
1359 enum bgp_fsm_state_progress
bgp_stop(struct peer
*peer
)
1363 char orf_name
[BUFSIZ
];
1364 enum bgp_fsm_state_progress ret
= BGP_FSM_SUCCESS
;
1365 struct bgp
*bgp
= peer
->bgp
;
1366 struct graceful_restart_info
*gr_info
= NULL
;
1368 peer
->nsf_af_count
= 0;
1370 /* deregister peer */
1371 if (peer
->bfd_config
1372 && peer
->last_reset
== PEER_DOWN_UPDATE_SOURCE_CHANGE
)
1373 bfd_sess_uninstall(peer
->bfd_config
->session
);
1375 if (peer_dynamic_neighbor_no_nsf(peer
) &&
1376 !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
1377 if (bgp_debug_neighbor_events(peer
))
1378 zlog_debug("%s (dynamic neighbor) deleted (%s)",
1379 peer
->host
, __func__
);
1381 return BGP_FSM_FAILURE_AND_DELETE
;
1384 /* Can't do this in Clearing; events are used for state transitions */
1385 if (peer
->status
!= Clearing
) {
1386 /* Delete all existing events of the peer */
1387 BGP_EVENT_FLUSH(peer
);
1390 /* Increment Dropped count. */
1391 if (peer_established(peer
)) {
1394 /* Notify BGP conditional advertisement process */
1395 peer
->advmap_table_change
= true;
1397 /* bgp log-neighbor-changes of neighbor Down */
1398 if (CHECK_FLAG(peer
->bgp
->flags
,
1399 BGP_FLAG_LOG_NEIGHBOR_CHANGES
)) {
1400 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1403 "%%ADJCHANGE: neighbor %pBP in vrf %s Down %s",
1405 vrf
? ((vrf
->vrf_id
!= VRF_DEFAULT
)
1409 peer_down_str
[(int)peer
->last_reset
]);
1412 /* graceful restart */
1413 if (peer
->t_gr_stale
) {
1414 THREAD_OFF(peer
->t_gr_stale
);
1415 if (bgp_debug_neighbor_events(peer
))
1417 "%pBP graceful restart stalepath timer stopped",
1420 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
1421 if (bgp_debug_neighbor_events(peer
)) {
1423 "%pBP graceful restart timer started for %d sec",
1424 peer
, peer
->v_gr_restart
);
1426 "%pBP graceful restart stalepath timer started for %d sec",
1427 peer
, peer
->bgp
->stalepath_time
);
1429 BGP_TIMER_ON(peer
->t_gr_restart
,
1430 bgp_graceful_restart_timer_expire
,
1431 peer
->v_gr_restart
);
1432 BGP_TIMER_ON(peer
->t_gr_stale
,
1433 bgp_graceful_stale_timer_expire
,
1434 peer
->bgp
->stalepath_time
);
1436 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1438 FOREACH_AFI_SAFI_NSF (afi
, safi
)
1439 peer
->nsf
[afi
][safi
] = 0;
1442 /* Stop route-refresh stalepath timer */
1443 if (peer
->t_refresh_stalepath
) {
1444 THREAD_OFF(peer
->t_refresh_stalepath
);
1446 if (bgp_debug_neighbor_events(peer
))
1448 "%pBP route-refresh restart stalepath timer stopped",
1452 /* If peer reset before receiving EOR, decrement EOR count and
1453 * cancel the selection deferral timer if there are no
1454 * pending EOR messages to be received
1456 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)) {
1457 FOREACH_AFI_SAFI (afi
, safi
) {
1458 if (!peer
->afc_nego
[afi
][safi
]
1459 || CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
1460 PEER_STATUS_EOR_RECEIVED
))
1463 gr_info
= &bgp
->gr_info
[afi
][safi
];
1467 if (gr_info
->eor_required
)
1468 gr_info
->eor_required
--;
1470 if (BGP_DEBUG(update
, UPDATE_OUT
))
1471 zlog_debug("peer %s, EOR_required %d",
1473 gr_info
->eor_required
);
1475 /* There is no pending EOR message */
1476 if (gr_info
->eor_required
== 0) {
1477 if (gr_info
->t_select_deferral
) {
1478 void *info
= THREAD_ARG(
1479 gr_info
->t_select_deferral
);
1480 XFREE(MTYPE_TMP
, info
);
1482 THREAD_OFF(gr_info
->t_select_deferral
);
1483 gr_info
->eor_received
= 0;
1488 /* set last reset time */
1489 peer
->resettime
= peer
->uptime
= monotime(NULL
);
1491 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1492 zlog_debug("%s remove from all update group",
1494 update_group_remove_peer_afs(peer
);
1496 /* Reset peer synctime */
1500 /* stop keepalives */
1501 bgp_keepalives_off(peer
);
1503 /* Stop read and write threads. */
1504 bgp_writes_off(peer
);
1505 bgp_reads_off(peer
);
1507 THREAD_OFF(peer
->t_connect_check_r
);
1508 THREAD_OFF(peer
->t_connect_check_w
);
1510 /* Stop all timers. */
1511 THREAD_OFF(peer
->t_start
);
1512 THREAD_OFF(peer
->t_connect
);
1513 THREAD_OFF(peer
->t_holdtime
);
1514 THREAD_OFF(peer
->t_routeadv
);
1515 THREAD_OFF(peer
->t_delayopen
);
1517 /* Clear input and output buffer. */
1518 frr_with_mutex (&peer
->io_mtx
) {
1520 stream_fifo_clean(peer
->ibuf
);
1522 stream_fifo_clean(peer
->obuf
);
1524 if (peer
->ibuf_work
)
1525 ringbuf_wipe(peer
->ibuf_work
);
1526 if (peer
->obuf_work
)
1527 stream_reset(peer
->obuf_work
);
1530 stream_free(peer
->curr
);
1535 /* Close of file descriptor. */
1536 if (peer
->fd
>= 0) {
1541 /* Reset capabilities. */
1544 /* Resetting neighbor role to the default value */
1545 peer
->remote_role
= ROLE_UNDEFINED
;
1547 FOREACH_AFI_SAFI (afi
, safi
) {
1548 /* Reset all negotiated variables */
1549 peer
->afc_nego
[afi
][safi
] = 0;
1550 peer
->afc_adv
[afi
][safi
] = 0;
1551 peer
->afc_recv
[afi
][safi
] = 0;
1553 /* peer address family capability flags*/
1554 peer
->af_cap
[afi
][safi
] = 0;
1556 /* peer address family status flags*/
1557 peer
->af_sflags
[afi
][safi
] = 0;
1559 /* Received ORF prefix-filter */
1560 peer
->orf_plist
[afi
][safi
] = NULL
;
1562 if ((peer
->status
== OpenConfirm
) || (peer_established(peer
))) {
1563 /* ORF received prefix-filter pnt */
1564 snprintf(orf_name
, sizeof(orf_name
), "%s.%d.%d",
1565 peer
->host
, afi
, safi
);
1566 prefix_bgp_orf_remove_all(afi
, orf_name
);
1570 /* Reset keepalive and holdtime */
1571 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER
)) {
1572 peer
->v_keepalive
= peer
->keepalive
;
1573 peer
->v_holdtime
= peer
->holdtime
;
1575 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
1576 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
1579 /* Reset DelayOpenTime */
1580 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER_DELAYOPEN
))
1581 peer
->v_delayopen
= peer
->delayopen
;
1583 peer
->v_delayopen
= peer
->bgp
->default_delayopen
;
1585 peer
->update_time
= 0;
1587 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1588 && !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
1590 ret
= BGP_FSM_FAILURE_AND_DELETE
;
1592 bgp_peer_conf_if_to_su_update(peer
);
1597 /* BGP peer is stoped by the error. */
1598 static enum bgp_fsm_state_progress
bgp_stop_with_error(struct peer
*peer
)
1600 /* Double start timer. */
1603 /* Overflow check. */
1604 if (peer
->v_start
>= (60 * 2))
1605 peer
->v_start
= (60 * 2);
1607 if (peer_dynamic_neighbor_no_nsf(peer
)) {
1608 if (bgp_debug_neighbor_events(peer
))
1609 zlog_debug("%s (dynamic neighbor) deleted (%s)",
1610 peer
->host
, __func__
);
1612 return BGP_FSM_FAILURE
;
1615 return bgp_stop(peer
);
1619 /* something went wrong, send notify and tear down */
1620 static enum bgp_fsm_state_progress
1621 bgp_stop_with_notify(struct peer
*peer
, uint8_t code
, uint8_t sub_code
)
1623 /* Send notify to remote peer */
1624 bgp_notify_send(peer
, code
, sub_code
);
1626 if (peer_dynamic_neighbor_no_nsf(peer
)) {
1627 if (bgp_debug_neighbor_events(peer
))
1628 zlog_debug("%s (dynamic neighbor) deleted (%s)",
1629 peer
->host
, __func__
);
1631 return BGP_FSM_FAILURE
;
1634 /* Clear start timer value to default. */
1635 peer
->v_start
= BGP_INIT_START_TIMER
;
1637 return bgp_stop(peer
);
1641 * Determines whether a TCP session has successfully established for a peer and
1642 * events as appropriate.
1644 * This function is called when setting up a new session. After connect() is
1645 * called on the peer's socket (in bgp_start()), the fd is passed to poll()
1646 * to wait for connection success or failure. When poll() returns, this
1647 * function is called to evaluate the result.
1649 * Due to differences in behavior of poll() on Linux and BSD - specifically,
1650 * the value of .revents in the case of a closed connection - this function is
1651 * scheduled both for a read and a write event. The write event is triggered
1652 * when the connection is established. A read event is triggered when the
1653 * connection is closed. Thus we need to cancel whichever one did not occur.
1655 static void bgp_connect_check(struct thread
*thread
)
1662 peer
= THREAD_ARG(thread
);
1663 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
1664 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
1665 assert(!peer
->t_read
);
1666 assert(!peer
->t_write
);
1668 THREAD_OFF(peer
->t_connect_check_r
);
1669 THREAD_OFF(peer
->t_connect_check_w
);
1671 /* Check file descriptor. */
1672 slen
= sizeof(status
);
1673 ret
= getsockopt(peer
->fd
, SOL_SOCKET
, SO_ERROR
, (void *)&status
,
1676 /* If getsockopt is fail, this is fatal error. */
1678 zlog_err("can't get sockopt for nonblocking connect: %d(%s)",
1679 errno
, safe_strerror(errno
));
1680 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1684 /* When status is 0 then TCP connection is established. */
1686 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER_DELAYOPEN
))
1687 BGP_EVENT_ADD(peer
, TCP_connection_open_w_delay
);
1689 BGP_EVENT_ADD(peer
, TCP_connection_open
);
1692 if (bgp_debug_neighbor_events(peer
))
1693 zlog_debug("%s [Event] Connect failed %d(%s)",
1694 peer
->host
, status
, safe_strerror(status
));
1695 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1700 /* TCP connection open. Next we send open message to remote peer. And
1701 add read thread for reading open message. */
1702 static enum bgp_fsm_state_progress
bgp_connect_success(struct peer
*peer
)
1705 flog_err(EC_BGP_CONNECT
, "%s peer's fd is negative value %d",
1706 __func__
, peer
->fd
);
1707 return bgp_stop(peer
);
1710 if (bgp_getsockname(peer
) < 0) {
1711 flog_err_sys(EC_LIB_SOCKET
,
1712 "%s: bgp_getsockname(): failed for peer %s, fd %d",
1713 __func__
, peer
->host
, peer
->fd
);
1714 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
1715 bgp_fsm_error_subcode(peer
->status
));
1716 bgp_writes_on(peer
);
1717 return BGP_FSM_FAILURE
;
1721 * If we are doing nht for a peer that ls v6 LL based
1722 * massage the event system to make things happy
1724 bgp_nht_interface_events(peer
);
1728 if (bgp_debug_neighbor_events(peer
)) {
1729 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
1730 zlog_debug("%s open active, local address %pSU",
1731 peer
->host
, peer
->su_local
);
1733 zlog_debug("%s passive open", peer
->host
);
1736 /* Send an open message */
1737 bgp_open_send(peer
);
1739 return BGP_FSM_SUCCESS
;
1742 /* TCP connection open with RFC 4271 optional session attribute DelayOpen flag
1745 static enum bgp_fsm_state_progress
1746 bgp_connect_success_w_delayopen(struct peer
*peer
)
1749 flog_err(EC_BGP_CONNECT
, "%s: peer's fd is negative value %d",
1750 __func__
, peer
->fd
);
1751 return bgp_stop(peer
);
1754 if (bgp_getsockname(peer
) < 0) {
1755 flog_err_sys(EC_LIB_SOCKET
,
1756 "%s: bgp_getsockname(): failed for peer %s, fd %d",
1757 __func__
, peer
->host
, peer
->fd
);
1758 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
1759 bgp_fsm_error_subcode(peer
->status
));
1760 bgp_writes_on(peer
);
1761 return BGP_FSM_FAILURE
;
1765 * If we are doing nht for a peer that ls v6 LL based
1766 * massage the event system to make things happy
1768 bgp_nht_interface_events(peer
);
1772 if (bgp_debug_neighbor_events(peer
)) {
1773 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
1774 zlog_debug("%s open active, local address %pSU",
1775 peer
->host
, peer
->su_local
);
1777 zlog_debug("%s passive open", peer
->host
);
1780 /* set the DelayOpenTime to the inital value */
1781 peer
->v_delayopen
= peer
->delayopen
;
1783 /* Start the DelayOpenTimer if it is not already running */
1784 if (!peer
->t_delayopen
)
1785 BGP_TIMER_ON(peer
->t_delayopen
, bgp_delayopen_timer
,
1788 if (bgp_debug_neighbor_events(peer
))
1789 zlog_debug("%s [FSM] BGP OPEN message delayed for %d seconds",
1790 peer
->host
, peer
->delayopen
);
1792 return BGP_FSM_SUCCESS
;
1795 /* TCP connect fail */
1796 static enum bgp_fsm_state_progress
bgp_connect_fail(struct peer
*peer
)
1798 if (peer_dynamic_neighbor_no_nsf(peer
)) {
1799 if (bgp_debug_neighbor_events(peer
))
1800 zlog_debug("%s (dynamic neighbor) deleted (%s)",
1801 peer
->host
, __func__
);
1803 return BGP_FSM_FAILURE_AND_DELETE
;
1807 * If we are doing nht for a peer that ls v6 LL based
1808 * massage the event system to make things happy
1810 bgp_nht_interface_events(peer
);
1812 return bgp_stop(peer
);
1815 /* This function is the first starting point of all BGP connection. It
1816 * try to connect to remote peer with non-blocking IO.
1818 enum bgp_fsm_state_progress
bgp_start(struct peer
*peer
)
1822 bgp_peer_conf_if_to_su_update(peer
);
1824 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
) {
1825 if (bgp_debug_neighbor_events(peer
))
1827 "%s [FSM] Unable to get neighbor's IP address, waiting...",
1829 peer
->last_reset
= PEER_DOWN_NBR_ADDR
;
1830 return BGP_FSM_FAILURE
;
1833 if (BGP_PEER_START_SUPPRESSED(peer
)) {
1834 if (bgp_debug_neighbor_events(peer
))
1835 flog_err(EC_BGP_FSM
,
1836 "%s [FSM] Trying to start suppressed peer - this is never supposed to happen!",
1838 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_RTT_SHUTDOWN
))
1839 peer
->last_reset
= PEER_DOWN_RTT_SHUTDOWN
;
1840 else if (CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
))
1841 peer
->last_reset
= PEER_DOWN_USER_SHUTDOWN
;
1842 else if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_SHUTDOWN
))
1843 peer
->last_reset
= PEER_DOWN_USER_SHUTDOWN
;
1844 else if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
1845 peer
->last_reset
= PEER_DOWN_PFX_COUNT
;
1846 return BGP_FSM_FAILURE
;
1849 /* Scrub some information that might be left over from a previous,
1852 /* Connection information. */
1853 if (peer
->su_local
) {
1854 sockunion_free(peer
->su_local
);
1855 peer
->su_local
= NULL
;
1858 if (peer
->su_remote
) {
1859 sockunion_free(peer
->su_remote
);
1860 peer
->su_remote
= NULL
;
1863 /* Clear remote router-id. */
1864 peer
->remote_id
.s_addr
= INADDR_ANY
;
1866 /* Clear peer capability flag. */
1869 /* If the peer is passive mode, force to move to Active mode. */
1870 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)) {
1871 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1872 return BGP_FSM_SUCCESS
;
1875 if (peer
->bgp
->vrf_id
== VRF_UNKNOWN
) {
1876 if (bgp_debug_neighbor_events(peer
))
1879 "%s [FSM] In a VRF that is not initialised yet",
1881 peer
->last_reset
= PEER_DOWN_VRF_UNINIT
;
1882 return BGP_FSM_FAILURE
;
1885 /* Register peer for NHT. If next hop is already resolved, proceed
1886 * with connection setup, else wait.
1888 if (!bgp_peer_reg_with_nht(peer
)) {
1889 if (bgp_zebra_num_connects()) {
1890 if (bgp_debug_neighbor_events(peer
))
1892 "%s [FSM] Waiting for NHT, no path to neighbor present",
1894 peer
->last_reset
= PEER_DOWN_WAITING_NHT
;
1895 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1896 return BGP_FSM_SUCCESS
;
1900 assert(!peer
->t_write
);
1901 assert(!peer
->t_read
);
1902 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
1903 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
1904 status
= bgp_connect(peer
);
1908 if (bgp_debug_neighbor_events(peer
))
1909 zlog_debug("%s [FSM] Connect error", peer
->host
);
1910 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1912 case connect_success
:
1913 if (bgp_debug_neighbor_events(peer
))
1915 "%s [FSM] Connect immediately success, fd %d",
1916 peer
->host
, peer
->fd
);
1918 BGP_EVENT_ADD(peer
, TCP_connection_open
);
1920 case connect_in_progress
:
1921 /* To check nonblocking connect, we wait until socket is
1922 readable or writable. */
1923 if (bgp_debug_neighbor_events(peer
))
1925 "%s [FSM] Non blocking connect waiting result, fd %d",
1926 peer
->host
, peer
->fd
);
1928 flog_err(EC_BGP_FSM
,
1929 "%s peer's fd is negative value %d", __func__
,
1931 return BGP_FSM_FAILURE
;
1934 * - when the socket becomes ready, poll() will signify POLLOUT
1935 * - if it fails to connect, poll() will signify POLLHUP
1936 * - POLLHUP is handled as a 'read' event by thread.c
1938 * therefore, we schedule both a read and a write event with
1939 * bgp_connect_check() as the handler for each and cancel the
1940 * unused event in that function.
1942 thread_add_read(bm
->master
, bgp_connect_check
, peer
, peer
->fd
,
1943 &peer
->t_connect_check_r
);
1944 thread_add_write(bm
->master
, bgp_connect_check
, peer
, peer
->fd
,
1945 &peer
->t_connect_check_w
);
1948 return BGP_FSM_SUCCESS
;
1951 /* Connect retry timer is expired when the peer status is Connect. */
1952 static enum bgp_fsm_state_progress
bgp_reconnect(struct peer
*peer
)
1954 enum bgp_fsm_state_progress ret
;
1956 ret
= bgp_stop(peer
);
1957 if (ret
< BGP_FSM_SUCCESS
)
1960 /* Send graceful restart capabilty */
1961 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer
->bgp
,
1964 return bgp_start(peer
);
1967 static enum bgp_fsm_state_progress
bgp_fsm_open(struct peer
*peer
)
1969 /* If DelayOpen is active, we may still need to send an open message */
1970 if ((peer
->status
== Connect
) || (peer
->status
== Active
))
1971 bgp_open_send(peer
);
1973 /* Send keepalive and make keepalive timer */
1974 bgp_keepalive_send(peer
);
1976 return BGP_FSM_SUCCESS
;
1979 /* FSM error, unexpected event. This is error of BGP connection. So cut the
1980 peer and change to Idle status. */
1981 static enum bgp_fsm_state_progress
bgp_fsm_event_error(struct peer
*peer
)
1983 flog_err(EC_BGP_FSM
, "%s [FSM] unexpected packet received in state %s",
1984 peer
->host
, lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1986 return bgp_stop_with_notify(peer
, BGP_NOTIFY_FSM_ERR
,
1987 bgp_fsm_error_subcode(peer
->status
));
1990 /* Hold timer expire. This is error of BGP connection. So cut the
1991 peer and change to Idle status. */
1992 static enum bgp_fsm_state_progress
bgp_fsm_holdtime_expire(struct peer
*peer
)
1994 if (bgp_debug_neighbor_events(peer
))
1995 zlog_debug("%s [FSM] Hold timer expire", peer
->host
);
1997 /* RFC8538 updates RFC 4724 by defining an extension that permits
1998 * the Graceful Restart procedures to be performed when the BGP
1999 * speaker receives a BGP NOTIFICATION message or the Hold Time expires.
2001 if (peer_established(peer
) &&
2002 bgp_has_graceful_restart_notification(peer
))
2003 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
))
2004 SET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2006 return bgp_stop_with_notify(peer
, BGP_NOTIFY_HOLD_ERR
, 0);
2009 /* RFC 4271 DelayOpenTimer_Expires event */
2010 static enum bgp_fsm_state_progress
2011 bgp_fsm_delayopen_timer_expire(struct peer
*peer
)
2013 /* Stop the DelayOpenTimer */
2014 THREAD_OFF(peer
->t_delayopen
);
2016 /* Send open message to peer */
2017 bgp_open_send(peer
);
2019 /* Set the HoldTimer to a large value (4 minutes) */
2020 peer
->v_holdtime
= 245;
2022 return BGP_FSM_SUCCESS
;
2025 /* Start the selection deferral timer thread for the specified AFI, SAFI */
2026 static int bgp_start_deferral_timer(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
2027 struct graceful_restart_info
*gr_info
)
2029 struct afi_safi_info
*thread_info
;
2031 /* If the deferral timer is active, then increment eor count */
2032 if (gr_info
->t_select_deferral
) {
2033 gr_info
->eor_required
++;
2037 /* Start the deferral timer when the first peer enabled for the graceful
2038 * restart is established
2040 if (gr_info
->eor_required
== 0) {
2041 thread_info
= XMALLOC(MTYPE_TMP
, sizeof(struct afi_safi_info
));
2043 thread_info
->afi
= afi
;
2044 thread_info
->safi
= safi
;
2045 thread_info
->bgp
= bgp
;
2047 thread_add_timer(bm
->master
, bgp_graceful_deferral_timer_expire
,
2048 thread_info
, bgp
->select_defer_time
,
2049 &gr_info
->t_select_deferral
);
2051 gr_info
->eor_required
++;
2052 /* Send message to RIB indicating route update pending */
2053 if (gr_info
->af_enabled
[afi
][safi
] == false) {
2054 gr_info
->af_enabled
[afi
][safi
] = true;
2055 /* Send message to RIB */
2056 bgp_zebra_update(afi
, safi
, bgp
->vrf_id
,
2057 ZEBRA_CLIENT_ROUTE_UPDATE_PENDING
);
2059 if (BGP_DEBUG(update
, UPDATE_OUT
))
2060 zlog_debug("Started the deferral timer for %s eor_required %d",
2061 get_afi_safi_str(afi
, safi
, false),
2062 gr_info
->eor_required
);
2066 /* Update the graceful restart information for the specified AFI, SAFI */
2067 static int bgp_update_gr_info(struct peer
*peer
, afi_t afi
, safi_t safi
)
2069 struct graceful_restart_info
*gr_info
;
2070 struct bgp
*bgp
= peer
->bgp
;
2073 if ((afi
< AFI_IP
) || (afi
>= AFI_MAX
)) {
2074 if (BGP_DEBUG(update
, UPDATE_OUT
))
2075 zlog_debug("%s : invalid afi %d", __func__
, afi
);
2079 if ((safi
< SAFI_UNICAST
) || (safi
> SAFI_MPLS_VPN
)) {
2080 if (BGP_DEBUG(update
, UPDATE_OUT
))
2081 zlog_debug("%s : invalid safi %d", __func__
, safi
);
2085 /* Restarting router */
2086 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)
2087 && BGP_PEER_RESTARTING_MODE(peer
)) {
2088 /* Check if the forwarding state is preserved */
2089 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_GR_PRESERVE_FWD
)) {
2090 gr_info
= &(bgp
->gr_info
[afi
][safi
]);
2091 ret
= bgp_start_deferral_timer(bgp
, afi
, safi
, gr_info
);
2098 * Transition to Established state.
2100 * Convert peer from stub to full fledged peer, set some timers, and generate
2103 static enum bgp_fsm_state_progress
bgp_establish(struct peer
*peer
)
2107 int nsf_af_count
= 0;
2108 enum bgp_fsm_state_progress ret
= BGP_FSM_SUCCESS
;
2112 other
= peer
->doppelganger
;
2113 hash_release(peer
->bgp
->peerhash
, peer
);
2115 hash_release(peer
->bgp
->peerhash
, other
);
2117 peer
= peer_xfer_conn(peer
);
2119 flog_err(EC_BGP_CONNECT
, "%%Neighbor failed in xfer_conn");
2120 return BGP_FSM_FAILURE
;
2124 ret
= BGP_FSM_SUCCESS_STATE_TRANSFER
;
2126 /* Reset capability open status flag. */
2127 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
))
2128 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
2130 /* Clear start timer value to default. */
2131 peer
->v_start
= BGP_INIT_START_TIMER
;
2133 /* Increment established count. */
2134 peer
->established
++;
2135 bgp_fsm_change_status(peer
, Established
);
2137 /* bgp log-neighbor-changes of neighbor Up */
2138 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)) {
2139 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
2140 zlog_info("%%ADJCHANGE: neighbor %pBP in vrf %s Up", peer
,
2141 vrf
? ((vrf
->vrf_id
!= VRF_DEFAULT
)
2146 /* assign update-group/subgroup */
2147 update_group_adjust_peer_afs(peer
);
2149 /* graceful restart */
2150 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2151 if (bgp_debug_neighbor_events(peer
)) {
2152 if (BGP_PEER_RESTARTING_MODE(peer
))
2153 zlog_debug("%pBP BGP_RESTARTING_MODE", peer
);
2154 else if (BGP_PEER_HELPER_MODE(peer
))
2155 zlog_debug("%pBP BGP_HELPER_MODE", peer
);
2158 FOREACH_AFI_SAFI_NSF (afi
, safi
) {
2159 if (peer
->afc_nego
[afi
][safi
] &&
2160 CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
) &&
2161 CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2162 PEER_CAP_RESTART_AF_RCV
)) {
2163 if (peer
->nsf
[afi
][safi
] &&
2164 !CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2165 PEER_CAP_RESTART_AF_PRESERVE_RCV
))
2166 bgp_clear_stale_route(peer
, afi
, safi
);
2168 peer
->nsf
[afi
][safi
] = 1;
2171 if (peer
->nsf
[afi
][safi
])
2172 bgp_clear_stale_route(peer
, afi
, safi
);
2173 peer
->nsf
[afi
][safi
] = 0;
2175 /* Update the graceful restart information */
2176 if (peer
->afc_nego
[afi
][safi
]) {
2177 if (!BGP_SELECT_DEFER_DISABLE(peer
->bgp
)) {
2178 status
= bgp_update_gr_info(peer
, afi
, safi
);
2181 "Error in updating graceful restart for %s",
2182 get_afi_safi_str(afi
, safi
,
2185 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
) &&
2186 BGP_PEER_RESTARTING_MODE(peer
) &&
2187 CHECK_FLAG(peer
->bgp
->flags
,
2188 BGP_FLAG_GR_PRESERVE_FWD
))
2189 peer
->bgp
->gr_info
[afi
][safi
]
2195 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
)) {
2196 if ((bgp_peer_gr_mode_get(peer
) == PEER_GR
)
2197 || ((bgp_peer_gr_mode_get(peer
) == PEER_GLOBAL_INHERIT
)
2198 && (bgp_global_gr_mode_get(peer
->bgp
) == GLOBAL_GR
))) {
2199 FOREACH_AFI_SAFI (afi
, safi
)
2200 /* Send route processing complete
2203 afi
, safi
, peer
->bgp
->vrf_id
,
2204 ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE
);
2207 /* Peer sends R-bit. In this case, we need to send
2208 * ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE to Zebra. */
2209 if (CHECK_FLAG(peer
->cap
,
2210 PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
)) {
2211 FOREACH_AFI_SAFI (afi
, safi
)
2212 /* Send route processing complete
2215 afi
, safi
, peer
->bgp
->vrf_id
,
2216 ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE
);
2220 peer
->nsf_af_count
= nsf_af_count
;
2223 SET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2225 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2226 if (peer
->t_gr_stale
) {
2227 THREAD_OFF(peer
->t_gr_stale
);
2228 if (bgp_debug_neighbor_events(peer
))
2230 "%pBP graceful restart stalepath timer stopped",
2235 if (peer
->t_gr_restart
) {
2236 THREAD_OFF(peer
->t_gr_restart
);
2237 if (bgp_debug_neighbor_events(peer
))
2238 zlog_debug("%pBP graceful restart timer stopped", peer
);
2241 /* Reset uptime, turn on keepalives, send current table. */
2242 if (!peer
->v_holdtime
)
2243 bgp_keepalives_on(peer
);
2245 peer
->uptime
= monotime(NULL
);
2247 /* Send route-refresh when ORF is enabled.
2248 * Stop Long-lived Graceful Restart timers.
2250 FOREACH_AFI_SAFI (afi
, safi
) {
2251 if (peer
->t_llgr_stale
[afi
][safi
]) {
2252 THREAD_OFF(peer
->t_llgr_stale
[afi
][safi
]);
2253 if (bgp_debug_neighbor_events(peer
))
2255 "%pBP Long-lived stale timer stopped for afi/safi: %d/%d",
2259 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2260 PEER_CAP_ORF_PREFIX_SM_ADV
)) {
2261 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2262 PEER_CAP_ORF_PREFIX_RM_RCV
))
2263 bgp_route_refresh_send(
2264 peer
, afi
, safi
, ORF_TYPE_PREFIX
,
2265 REFRESH_IMMEDIATE
, 0,
2266 BGP_ROUTE_REFRESH_NORMAL
);
2267 else if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2268 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))
2269 bgp_route_refresh_send(
2270 peer
, afi
, safi
, ORF_TYPE_PREFIX_OLD
,
2271 REFRESH_IMMEDIATE
, 0,
2272 BGP_ROUTE_REFRESH_NORMAL
);
2276 /* First update is deferred until ORF or ROUTE-REFRESH is received */
2277 FOREACH_AFI_SAFI (afi
, safi
) {
2278 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2279 PEER_CAP_ORF_PREFIX_RM_ADV
))
2280 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2281 PEER_CAP_ORF_PREFIX_SM_RCV
)
2282 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2283 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
))
2284 SET_FLAG(peer
->af_sflags
[afi
][safi
],
2285 PEER_STATUS_ORF_WAIT_REFRESH
);
2288 bgp_announce_peer(peer
);
2290 /* Start the route advertisement timer to send updates to the peer - if
2292 * is not in read-only mode. If it is, the timer will be started at the
2294 * of read-only mode.
2296 if (!bgp_update_delay_active(peer
->bgp
)) {
2297 THREAD_OFF(peer
->t_routeadv
);
2298 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
2301 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)) {
2302 if (bgp_debug_neighbor_events(peer
))
2304 "[Event] Deleting stub connection for peer %s",
2307 if (peer
->doppelganger
->status
> Active
)
2308 bgp_notify_send(peer
->doppelganger
, BGP_NOTIFY_CEASE
,
2309 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
2311 peer_delete(peer
->doppelganger
);
2315 * If we are replacing the old peer for a doppelganger
2316 * then switch it around in the bgp->peerhash
2317 * the doppelgangers su and this peer's su are the same
2318 * so the hash_release is the same for either.
2320 (void)hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
2322 /* Start BFD peer if not already running. */
2323 if (peer
->bfd_config
)
2324 bgp_peer_bfd_update_source(peer
);
2329 /* Keepalive packet is received. */
2330 static enum bgp_fsm_state_progress
bgp_fsm_keepalive(struct peer
*peer
)
2332 THREAD_OFF(peer
->t_holdtime
);
2333 return BGP_FSM_SUCCESS
;
2336 /* Update packet is received. */
2337 static enum bgp_fsm_state_progress
bgp_fsm_update(struct peer
*peer
)
2339 THREAD_OFF(peer
->t_holdtime
);
2340 return BGP_FSM_SUCCESS
;
2343 /* This is empty event. */
2344 static enum bgp_fsm_state_progress
bgp_ignore(struct peer
*peer
)
2348 "%s [FSM] Ignoring event %s in state %s, prior events %s, %s, fd %d",
2349 peer
->host
, bgp_event_str
[peer
->cur_event
],
2350 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
2351 bgp_event_str
[peer
->last_event
],
2352 bgp_event_str
[peer
->last_major_event
], peer
->fd
);
2353 return BGP_FSM_SUCCESS
;
2356 /* This is to handle unexpected events.. */
2357 static enum bgp_fsm_state_progress
bgp_fsm_exception(struct peer
*peer
)
2361 "%s [FSM] Unexpected event %s in state %s, prior events %s, %s, fd %d",
2362 peer
->host
, bgp_event_str
[peer
->cur_event
],
2363 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
2364 bgp_event_str
[peer
->last_event
],
2365 bgp_event_str
[peer
->last_major_event
], peer
->fd
);
2366 return bgp_stop(peer
);
2369 void bgp_fsm_nht_update(struct peer
*peer
, bool has_valid_nexthops
)
2374 switch (peer
->status
) {
2376 if (has_valid_nexthops
)
2377 BGP_EVENT_ADD(peer
, BGP_Start
);
2380 if (!has_valid_nexthops
) {
2381 THREAD_OFF(peer
->t_connect
);
2382 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
2386 if (has_valid_nexthops
) {
2387 THREAD_OFF(peer
->t_connect
);
2388 BGP_EVENT_ADD(peer
, ConnectRetry_timer_expired
);
2394 if (!has_valid_nexthops
2395 && (peer
->gtsm_hops
== BGP_GTSM_HOPS_CONNECTED
2396 || peer
->bgp
->fast_convergence
))
2397 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
2405 /* Finite State Machine structure */
2406 static const struct {
2407 enum bgp_fsm_state_progress (*func
)(struct peer
*);
2408 enum bgp_fsm_status next_state
;
2409 } FSM
[BGP_STATUS_MAX
- 1][BGP_EVENTS_MAX
- 1] = {
2411 /* Idle state: In Idle state, all events other than BGP_Start is
2412 ignored. With BGP_Start event, finite state machine calls
2414 {bgp_start
, Connect
}, /* BGP_Start */
2415 {bgp_stop
, Idle
}, /* BGP_Stop */
2416 {bgp_stop
, Idle
}, /* TCP_connection_open */
2417 {bgp_stop
, Idle
}, /* TCP_connection_open_w_delay */
2418 {bgp_stop
, Idle
}, /* TCP_connection_closed */
2419 {bgp_ignore
, Idle
}, /* TCP_connection_open_failed */
2420 {bgp_stop
, Idle
}, /* TCP_fatal_error */
2421 {bgp_ignore
, Idle
}, /* ConnectRetry_timer_expired */
2422 {bgp_ignore
, Idle
}, /* Hold_Timer_expired */
2423 {bgp_ignore
, Idle
}, /* KeepAlive_timer_expired */
2424 {bgp_ignore
, Idle
}, /* DelayOpen_timer_expired */
2425 {bgp_ignore
, Idle
}, /* Receive_OPEN_message */
2426 {bgp_ignore
, Idle
}, /* Receive_KEEPALIVE_message */
2427 {bgp_ignore
, Idle
}, /* Receive_UPDATE_message */
2428 {bgp_ignore
, Idle
}, /* Receive_NOTIFICATION_message */
2429 {bgp_ignore
, Idle
}, /* Clearing_Completed */
2433 {bgp_ignore
, Connect
}, /* BGP_Start */
2434 {bgp_stop
, Idle
}, /* BGP_Stop */
2435 {bgp_connect_success
, OpenSent
}, /* TCP_connection_open */
2436 {bgp_connect_success_w_delayopen
,
2437 Connect
}, /* TCP_connection_open_w_delay */
2438 {bgp_stop
, Idle
}, /* TCP_connection_closed */
2439 {bgp_connect_fail
, Active
}, /* TCP_connection_open_failed */
2440 {bgp_connect_fail
, Idle
}, /* TCP_fatal_error */
2441 {bgp_reconnect
, Connect
}, /* ConnectRetry_timer_expired */
2442 {bgp_fsm_exception
, Idle
}, /* Hold_Timer_expired */
2443 {bgp_fsm_exception
, Idle
}, /* KeepAlive_timer_expired */
2444 {bgp_fsm_delayopen_timer_expire
,
2445 OpenSent
}, /* DelayOpen_timer_expired */
2446 {bgp_fsm_open
, OpenConfirm
}, /* Receive_OPEN_message */
2447 {bgp_fsm_exception
, Idle
}, /* Receive_KEEPALIVE_message */
2448 {bgp_fsm_exception
, Idle
}, /* Receive_UPDATE_message */
2449 {bgp_stop
, Idle
}, /* Receive_NOTIFICATION_message */
2450 {bgp_fsm_exception
, Idle
}, /* Clearing_Completed */
2454 {bgp_ignore
, Active
}, /* BGP_Start */
2455 {bgp_stop
, Idle
}, /* BGP_Stop */
2456 {bgp_connect_success
, OpenSent
}, /* TCP_connection_open */
2457 {bgp_connect_success_w_delayopen
,
2458 Active
}, /* TCP_connection_open_w_delay */
2459 {bgp_stop
, Idle
}, /* TCP_connection_closed */
2460 {bgp_ignore
, Active
}, /* TCP_connection_open_failed */
2461 {bgp_fsm_exception
, Idle
}, /* TCP_fatal_error */
2462 {bgp_start
, Connect
}, /* ConnectRetry_timer_expired */
2463 {bgp_fsm_exception
, Idle
}, /* Hold_Timer_expired */
2464 {bgp_fsm_exception
, Idle
}, /* KeepAlive_timer_expired */
2465 {bgp_fsm_delayopen_timer_expire
,
2466 OpenSent
}, /* DelayOpen_timer_expired */
2467 {bgp_fsm_open
, OpenConfirm
}, /* Receive_OPEN_message */
2468 {bgp_fsm_exception
, Idle
}, /* Receive_KEEPALIVE_message */
2469 {bgp_fsm_exception
, Idle
}, /* Receive_UPDATE_message */
2470 {bgp_fsm_exception
, Idle
}, /* Receive_NOTIFICATION_message */
2471 {bgp_fsm_exception
, Idle
}, /* Clearing_Completed */
2475 {bgp_ignore
, OpenSent
}, /* BGP_Start */
2476 {bgp_stop
, Idle
}, /* BGP_Stop */
2477 {bgp_stop
, Active
}, /* TCP_connection_open */
2478 {bgp_fsm_exception
, Idle
}, /* TCP_connection_open_w_delay */
2479 {bgp_stop
, Active
}, /* TCP_connection_closed */
2480 {bgp_stop
, Active
}, /* TCP_connection_open_failed */
2481 {bgp_stop
, Active
}, /* TCP_fatal_error */
2482 {bgp_fsm_exception
, Idle
}, /* ConnectRetry_timer_expired */
2483 {bgp_fsm_holdtime_expire
, Idle
}, /* Hold_Timer_expired */
2484 {bgp_fsm_exception
, Idle
}, /* KeepAlive_timer_expired */
2485 {bgp_fsm_exception
, Idle
}, /* DelayOpen_timer_expired */
2486 {bgp_fsm_open
, OpenConfirm
}, /* Receive_OPEN_message */
2487 {bgp_fsm_event_error
, Idle
}, /* Receive_KEEPALIVE_message */
2488 {bgp_fsm_event_error
, Idle
}, /* Receive_UPDATE_message */
2489 {bgp_fsm_event_error
, Idle
}, /* Receive_NOTIFICATION_message */
2490 {bgp_fsm_exception
, Idle
}, /* Clearing_Completed */
2494 {bgp_ignore
, OpenConfirm
}, /* BGP_Start */
2495 {bgp_stop
, Idle
}, /* BGP_Stop */
2496 {bgp_stop
, Idle
}, /* TCP_connection_open */
2497 {bgp_fsm_exception
, Idle
}, /* TCP_connection_open_w_delay */
2498 {bgp_stop
, Idle
}, /* TCP_connection_closed */
2499 {bgp_stop
, Idle
}, /* TCP_connection_open_failed */
2500 {bgp_stop
, Idle
}, /* TCP_fatal_error */
2501 {bgp_fsm_exception
, Idle
}, /* ConnectRetry_timer_expired */
2502 {bgp_fsm_holdtime_expire
, Idle
}, /* Hold_Timer_expired */
2503 {bgp_ignore
, OpenConfirm
}, /* KeepAlive_timer_expired */
2504 {bgp_fsm_exception
, Idle
}, /* DelayOpen_timer_expired */
2505 {bgp_fsm_exception
, Idle
}, /* Receive_OPEN_message */
2506 {bgp_establish
, Established
}, /* Receive_KEEPALIVE_message */
2507 {bgp_fsm_exception
, Idle
}, /* Receive_UPDATE_message */
2508 {bgp_stop_with_error
, Idle
}, /* Receive_NOTIFICATION_message */
2509 {bgp_fsm_exception
, Idle
}, /* Clearing_Completed */
2513 {bgp_ignore
, Established
}, /* BGP_Start */
2514 {bgp_stop
, Clearing
}, /* BGP_Stop */
2515 {bgp_stop
, Clearing
}, /* TCP_connection_open */
2516 {bgp_fsm_exception
, Idle
}, /* TCP_connection_open_w_delay */
2517 {bgp_stop
, Clearing
}, /* TCP_connection_closed */
2518 {bgp_stop
, Clearing
}, /* TCP_connection_open_failed */
2519 {bgp_stop
, Clearing
}, /* TCP_fatal_error */
2520 {bgp_stop
, Clearing
}, /* ConnectRetry_timer_expired */
2521 {bgp_fsm_holdtime_expire
, Clearing
}, /* Hold_Timer_expired */
2522 {bgp_ignore
, Established
}, /* KeepAlive_timer_expired */
2523 {bgp_fsm_exception
, Idle
}, /* DelayOpen_timer_expired */
2524 {bgp_stop
, Clearing
}, /* Receive_OPEN_message */
2526 Established
}, /* Receive_KEEPALIVE_message */
2527 {bgp_fsm_update
, Established
}, /* Receive_UPDATE_message */
2528 {bgp_stop_with_error
,
2529 Clearing
}, /* Receive_NOTIFICATION_message */
2530 {bgp_fsm_exception
, Idle
}, /* Clearing_Completed */
2534 {bgp_ignore
, Clearing
}, /* BGP_Start */
2535 {bgp_stop
, Clearing
}, /* BGP_Stop */
2536 {bgp_stop
, Clearing
}, /* TCP_connection_open */
2537 {bgp_stop
, Clearing
}, /* TCP_connection_open_w_delay */
2538 {bgp_stop
, Clearing
}, /* TCP_connection_closed */
2539 {bgp_stop
, Clearing
}, /* TCP_connection_open_failed */
2540 {bgp_stop
, Clearing
}, /* TCP_fatal_error */
2541 {bgp_stop
, Clearing
}, /* ConnectRetry_timer_expired */
2542 {bgp_stop
, Clearing
}, /* Hold_Timer_expired */
2543 {bgp_stop
, Clearing
}, /* KeepAlive_timer_expired */
2544 {bgp_stop
, Clearing
}, /* DelayOpen_timer_expired */
2545 {bgp_stop
, Clearing
}, /* Receive_OPEN_message */
2546 {bgp_stop
, Clearing
}, /* Receive_KEEPALIVE_message */
2547 {bgp_stop
, Clearing
}, /* Receive_UPDATE_message */
2548 {bgp_stop
, Clearing
}, /* Receive_NOTIFICATION_message */
2549 {bgp_clearing_completed
, Idle
}, /* Clearing_Completed */
2553 {bgp_ignore
, Deleted
}, /* BGP_Start */
2554 {bgp_ignore
, Deleted
}, /* BGP_Stop */
2555 {bgp_ignore
, Deleted
}, /* TCP_connection_open */
2556 {bgp_ignore
, Deleted
}, /* TCP_connection_open_w_delay */
2557 {bgp_ignore
, Deleted
}, /* TCP_connection_closed */
2558 {bgp_ignore
, Deleted
}, /* TCP_connection_open_failed */
2559 {bgp_ignore
, Deleted
}, /* TCP_fatal_error */
2560 {bgp_ignore
, Deleted
}, /* ConnectRetry_timer_expired */
2561 {bgp_ignore
, Deleted
}, /* Hold_Timer_expired */
2562 {bgp_ignore
, Deleted
}, /* KeepAlive_timer_expired */
2563 {bgp_ignore
, Deleted
}, /* DelayOpen_timer_expired */
2564 {bgp_ignore
, Deleted
}, /* Receive_OPEN_message */
2565 {bgp_ignore
, Deleted
}, /* Receive_KEEPALIVE_message */
2566 {bgp_ignore
, Deleted
}, /* Receive_UPDATE_message */
2567 {bgp_ignore
, Deleted
}, /* Receive_NOTIFICATION_message */
2568 {bgp_ignore
, Deleted
}, /* Clearing_Completed */
2572 /* Execute event process. */
2573 void bgp_event(struct thread
*thread
)
2575 enum bgp_fsm_events event
;
2578 peer
= THREAD_ARG(thread
);
2579 event
= THREAD_VAL(thread
);
2582 bgp_event_update(peer
, event
);
2586 int bgp_event_update(struct peer
*peer
, enum bgp_fsm_events event
)
2588 enum bgp_fsm_status next
;
2589 enum bgp_fsm_state_progress ret
= 0;
2591 int passive_conn
= 0;
2594 /* default return code */
2595 ret
= FSM_PEER_NOOP
;
2597 other
= peer
->doppelganger
;
2599 (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)) ? 1 : 0;
2600 dyn_nbr
= peer_dynamic_neighbor(peer
);
2602 /* Logging this event. */
2603 next
= FSM
[peer
->status
- 1][event
- 1].next_state
;
2605 if (bgp_debug_neighbor_events(peer
) && peer
->status
!= next
)
2606 zlog_debug("%s [FSM] %s (%s->%s), fd %d", peer
->host
,
2607 bgp_event_str
[event
],
2608 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
2609 lookup_msg(bgp_status_msg
, next
, NULL
), peer
->fd
);
2611 peer
->last_event
= peer
->cur_event
;
2612 peer
->cur_event
= event
;
2614 /* Call function. */
2615 if (FSM
[peer
->status
- 1][event
- 1].func
)
2616 ret
= (*(FSM
[peer
->status
- 1][event
- 1].func
))(peer
);
2618 if (ret
>= BGP_FSM_SUCCESS
) {
2619 if (ret
== BGP_FSM_SUCCESS_STATE_TRANSFER
&&
2620 next
== Established
) {
2621 /* The case when doppelganger swap accurred in
2623 Update the peer pointer accordingly */
2624 ret
= FSM_PEER_TRANSFERRED
;
2628 /* If status is changed. */
2629 if (next
!= peer
->status
) {
2630 bgp_fsm_change_status(peer
, next
);
2633 * If we're going to ESTABLISHED then we executed a
2634 * peer transfer. In this case we can either return
2635 * FSM_PEER_TRANSITIONED or FSM_PEER_TRANSFERRED.
2636 * Opting for TRANSFERRED since transfer implies
2637 * session establishment.
2639 if (ret
!= FSM_PEER_TRANSFERRED
)
2640 ret
= FSM_PEER_TRANSITIONED
;
2643 /* Make sure timer is set. */
2644 bgp_timer_set(peer
);
2648 * If we got a return value of -1, that means there was an
2649 * error, restart the FSM. Since bgp_stop() was called on the
2650 * peer. only a few fields are safe to access here. In any case
2651 * we need to indicate that the peer was stopped in the return
2654 if (!dyn_nbr
&& !passive_conn
&& peer
->bgp
&&
2655 ret
!= BGP_FSM_FAILURE_AND_DELETE
) {
2658 "%s [FSM] Failure handling event %s in state %s, prior events %s, %s, fd %d",
2659 peer
->host
, bgp_event_str
[peer
->cur_event
],
2660 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
2661 bgp_event_str
[peer
->last_event
],
2662 bgp_event_str
[peer
->last_major_event
],
2665 bgp_fsm_change_status(peer
, Idle
);
2666 bgp_timer_set(peer
);
2668 ret
= FSM_PEER_STOPPED
;
2675 int bgp_gr_lookup_n_update_all_peer(struct bgp
*bgp
,
2676 enum global_mode global_new_state
,
2677 enum global_mode global_old_state
)
2679 struct peer
*peer
= {0};
2680 struct listnode
*node
= {0};
2681 struct listnode
*nnode
= {0};
2682 enum peer_mode peer_old_state
= PEER_INVALID
;
2684 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
2686 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2687 zlog_debug("%s [BGP_GR] Peer: (%s) :", __func__
,
2690 peer_old_state
= bgp_peer_gr_mode_get(peer
);
2692 if (peer_old_state
== PEER_GLOBAL_INHERIT
) {
2695 *Reset only these peers and send a
2696 *new open message with the change capabilities.
2697 *Considering the mode to be "global_new_state" and
2698 *do all operation accordingly
2701 switch (global_new_state
) {
2703 BGP_PEER_GR_HELPER_ENABLE(peer
);
2706 BGP_PEER_GR_ENABLE(peer
);
2708 case GLOBAL_DISABLE
:
2709 BGP_PEER_GR_DISABLE(peer
);
2711 case GLOBAL_INVALID
:
2712 zlog_debug("%s [BGP_GR] GLOBAL_INVALID",
2714 return BGP_ERR_GR_OPERATION_FAILED
;
2719 bgp
->global_gr_present_state
= global_new_state
;
2721 return BGP_GR_SUCCESS
;
2724 int bgp_gr_update_all(struct bgp
*bgp
, int global_gr_cmd
)
2726 enum global_mode global_new_state
= GLOBAL_INVALID
;
2727 enum global_mode global_old_state
= GLOBAL_INVALID
;
2729 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2730 zlog_debug("%s [BGP_GR]START: global_gr_cmd :%s:", __func__
,
2731 print_global_gr_cmd(global_gr_cmd
));
2733 global_old_state
= bgp_global_gr_mode_get(bgp
);
2735 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2736 zlog_debug("[BGP_GR] global_old_gr_state :%s:",
2737 print_global_gr_mode(global_old_state
));
2739 if (global_old_state
!= GLOBAL_INVALID
) {
2741 bgp
->GLOBAL_GR_FSM
[global_old_state
][global_gr_cmd
];
2743 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2744 zlog_debug("[BGP_GR] global_new_gr_state :%s:",
2745 print_global_gr_mode(global_new_state
));
2747 zlog_err("%s [BGP_GR] global_old_state == GLOBAL_INVALID",
2749 return BGP_ERR_GR_OPERATION_FAILED
;
2752 if (global_new_state
== GLOBAL_INVALID
) {
2753 zlog_err("%s [BGP_GR] global_new_state == GLOBAL_INVALID",
2755 return BGP_ERR_GR_INVALID_CMD
;
2757 if (global_new_state
== global_old_state
) {
2759 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2761 "%s [BGP_GR] global_new_state == global_old_state :%s",
2763 print_global_gr_mode(global_new_state
));
2764 return BGP_GR_NO_OPERATION
;
2767 return bgp_gr_lookup_n_update_all_peer(bgp
, global_new_state
,
2771 const char *print_peer_gr_mode(enum peer_mode pr_mode
)
2773 const char *peer_gr_mode
= NULL
;
2777 peer_gr_mode
= "PEER_HELPER";
2780 peer_gr_mode
= "PEER_GR";
2783 peer_gr_mode
= "PEER_DISABLE";
2786 peer_gr_mode
= "PEER_INVALID";
2788 case PEER_GLOBAL_INHERIT
:
2789 peer_gr_mode
= "PEER_GLOBAL_INHERIT";
2793 return peer_gr_mode
;
2796 const char *print_peer_gr_cmd(enum peer_gr_command pr_gr_cmd
)
2798 const char *peer_gr_cmd
= NULL
;
2800 switch (pr_gr_cmd
) {
2802 peer_gr_cmd
= "PEER_GR_CMD";
2804 case NO_PEER_GR_CMD
:
2805 peer_gr_cmd
= "NO_PEER_GR_CMD";
2807 case PEER_DISABLE_CMD
:
2808 peer_gr_cmd
= "PEER_DISABLE_GR_CMD";
2810 case NO_PEER_DISABLE_CMD
:
2811 peer_gr_cmd
= "NO_PEER_DISABLE_GR_CMD";
2813 case PEER_HELPER_CMD
:
2814 peer_gr_cmd
= "PEER_HELPER_CMD";
2816 case NO_PEER_HELPER_CMD
:
2817 peer_gr_cmd
= "NO_PEER_HELPER_CMD";
2824 const char *print_global_gr_mode(enum global_mode gl_mode
)
2826 const char *global_gr_mode
= NULL
;
2830 global_gr_mode
= "GLOBAL_HELPER";
2833 global_gr_mode
= "GLOBAL_GR";
2835 case GLOBAL_DISABLE
:
2836 global_gr_mode
= "GLOBAL_DISABLE";
2838 case GLOBAL_INVALID
:
2839 global_gr_mode
= "GLOBAL_INVALID";
2843 return global_gr_mode
;
2846 const char *print_global_gr_cmd(enum global_gr_command gl_gr_cmd
)
2848 const char *global_gr_cmd
= NULL
;
2850 switch (gl_gr_cmd
) {
2852 global_gr_cmd
= "GLOBAL_GR_CMD";
2854 case NO_GLOBAL_GR_CMD
:
2855 global_gr_cmd
= "NO_GLOBAL_GR_CMD";
2857 case GLOBAL_DISABLE_CMD
:
2858 global_gr_cmd
= "GLOBAL_DISABLE_CMD";
2860 case NO_GLOBAL_DISABLE_CMD
:
2861 global_gr_cmd
= "NO_GLOBAL_DISABLE_CMD";
2865 return global_gr_cmd
;
2868 enum global_mode
bgp_global_gr_mode_get(struct bgp
*bgp
)
2870 return bgp
->global_gr_present_state
;
2873 enum peer_mode
bgp_peer_gr_mode_get(struct peer
*peer
)
2875 return peer
->peer_gr_present_state
;
2878 int bgp_neighbor_graceful_restart(struct peer
*peer
, int peer_gr_cmd
)
2880 enum peer_mode peer_new_state
= PEER_INVALID
;
2881 enum peer_mode peer_old_state
= PEER_INVALID
;
2882 struct bgp_peer_gr peer_state
;
2883 int result
= BGP_GR_FAILURE
;
2886 * fetch peer_old_state from peer structure also
2887 * fetch global_old_state from bgp structure,
2888 * peer had a back pointer to bgpo struct ;
2891 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2892 zlog_debug("%s [BGP_GR] START:Peer: (%s) : peer_gr_cmd :%s:",
2893 __func__
, peer
->host
,
2894 print_peer_gr_cmd(peer_gr_cmd
));
2896 peer_old_state
= bgp_peer_gr_mode_get(peer
);
2898 if (peer_old_state
== PEER_INVALID
) {
2899 zlog_debug("[BGP_GR] peer_old_state == Invalid state !");
2900 return BGP_ERR_GR_OPERATION_FAILED
;
2903 peer_state
= peer
->PEER_GR_FSM
[peer_old_state
][peer_gr_cmd
];
2904 peer_new_state
= peer_state
.next_state
;
2906 if (peer_new_state
== PEER_INVALID
) {
2908 "[BGP_GR] Invalid bgp graceful restart command used !");
2909 return BGP_ERR_GR_INVALID_CMD
;
2912 if (peer_new_state
!= peer_old_state
) {
2913 result
= peer_state
.action_fun(peer
, peer_old_state
,
2916 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2918 "[BGP_GR] peer_old_state == peer_new_state !");
2919 return BGP_GR_NO_OPERATION
;
2922 if (result
== BGP_GR_SUCCESS
) {
2924 /* Update the mode i.e peer_new_state into the peer structure */
2925 peer
->peer_gr_present_state
= peer_new_state
;
2926 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2928 "[BGP_GR] Successfully change the state of the peer to : %s : !",
2929 print_peer_gr_mode(peer_new_state
));
2931 return BGP_GR_SUCCESS
;
2937 unsigned int bgp_peer_gr_action(struct peer
*peer
, int old_peer_state
,
2940 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2942 "%s [BGP_GR] Move peer from old_peer_state :%s: to new_peer_state :%s: !!!!",
2943 __func__
, print_peer_gr_mode(old_peer_state
),
2944 print_peer_gr_mode(new_peer_state
));
2946 int bgp_gr_global_mode
= GLOBAL_INVALID
;
2947 unsigned int ret
= BGP_GR_FAILURE
;
2949 if (old_peer_state
== new_peer_state
) {
2950 /* Nothing to do over here as the present and old state is the
2952 return BGP_GR_NO_OPERATION
;
2954 if ((old_peer_state
== PEER_INVALID
)
2955 || (new_peer_state
== PEER_INVALID
)) {
2956 /* something bad happend , print error message */
2957 return BGP_ERR_GR_INVALID_CMD
;
2960 bgp_gr_global_mode
= bgp_global_gr_mode_get(peer
->bgp
);
2962 if ((old_peer_state
== PEER_GLOBAL_INHERIT
)
2963 && (new_peer_state
!= PEER_GLOBAL_INHERIT
)) {
2965 /* fetch the Mode running in the Global state machine
2966 *from the bgp structure into a variable called
2970 /* Here we are checking if the
2971 *1. peer_new_state == global_mode == helper_mode
2972 *2. peer_new_state == global_mode == GR_mode
2973 *3. peer_new_state == global_mode == disabled_mode
2976 BGP_PEER_GR_GLOBAL_INHERIT_UNSET(peer
);
2978 if (new_peer_state
== bgp_gr_global_mode
) {
2979 /*This is incremental updates i.e no tear down
2980 *of the existing session
2981 *as the peer is already working in the same mode.
2983 ret
= BGP_GR_SUCCESS
;
2985 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2987 "[BGP_GR] Peer state changed from :%s ",
2988 print_peer_gr_mode(old_peer_state
));
2990 bgp_peer_move_to_gr_mode(peer
, new_peer_state
);
2992 ret
= BGP_GR_SUCCESS
;
2995 /* In the case below peer is going into Global inherit mode i.e.
2996 * the peer would work as the mode configured at the global level
2998 else if ((new_peer_state
== PEER_GLOBAL_INHERIT
)
2999 && (old_peer_state
!= PEER_GLOBAL_INHERIT
)) {
3000 /* Here in this case it would be destructive
3001 * in all the cases except one case when,
3002 * Global GR is configured Disabled
3003 * and present_peer_state is not disable
3006 BGP_PEER_GR_GLOBAL_INHERIT_SET(peer
);
3008 if (old_peer_state
== bgp_gr_global_mode
) {
3010 /* This is incremental updates
3011 *i.e no tear down of the existing session
3012 *as the peer is already working in the same mode.
3014 ret
= BGP_GR_SUCCESS
;
3016 /* Destructive always */
3017 /* Tear down the old session
3018 * and send the new capability
3019 * as per the bgp_gr_global_mode
3022 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
3024 "[BGP_GR] Peer state changed from :%s",
3025 print_peer_gr_mode(old_peer_state
));
3027 bgp_peer_move_to_gr_mode(peer
, bgp_gr_global_mode
);
3029 ret
= BGP_GR_SUCCESS
;
3033 *This else case, it include all the cases except -->
3034 *(new_peer_state != Peer_Global) &&
3035 *( old_peer_state != Peer_Global )
3037 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
3038 zlog_debug("[BGP_GR] Peer state changed from :%s",
3039 print_peer_gr_mode(old_peer_state
));
3041 bgp_peer_move_to_gr_mode(peer
, new_peer_state
);
3043 ret
= BGP_GR_SUCCESS
;
3049 inline void bgp_peer_move_to_gr_mode(struct peer
*peer
, int new_state
)
3052 int bgp_global_gr_mode
= bgp_global_gr_mode_get(peer
->bgp
);
3054 switch (new_state
) {
3056 BGP_PEER_GR_HELPER_ENABLE(peer
);
3059 BGP_PEER_GR_ENABLE(peer
);
3062 BGP_PEER_GR_DISABLE(peer
);
3064 case PEER_GLOBAL_INHERIT
:
3065 BGP_PEER_GR_GLOBAL_INHERIT_SET(peer
);
3067 if (bgp_global_gr_mode
== GLOBAL_HELPER
) {
3068 BGP_PEER_GR_HELPER_ENABLE(peer
);
3069 } else if (bgp_global_gr_mode
== GLOBAL_GR
) {
3070 BGP_PEER_GR_ENABLE(peer
);
3071 } else if (bgp_global_gr_mode
== GLOBAL_DISABLE
) {
3072 BGP_PEER_GR_DISABLE(peer
);
3075 "[BGP_GR] Default switch inherit mode ::: SOMETHING IS WRONG !!!");
3080 "[BGP_GR] Default switch mode ::: SOMETHING IS WRONG !!!");
3083 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
3084 zlog_debug("[BGP_GR] Peer state changed --to--> : %d : !",
3088 void bgp_peer_gr_flags_update(struct peer
*peer
)
3090 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
3091 zlog_debug("%s [BGP_GR] called !", __func__
);
3092 if (CHECK_FLAG(peer
->peer_gr_new_status_flag
,
3093 PEER_GRACEFUL_RESTART_NEW_STATE_HELPER
))
3094 SET_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART_HELPER
);
3096 UNSET_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART_HELPER
);
3097 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
3099 "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_HELPER : %s : !",
3101 (CHECK_FLAG(peer
->flags
,
3102 PEER_FLAG_GRACEFUL_RESTART_HELPER
)
3105 if (CHECK_FLAG(peer
->peer_gr_new_status_flag
,
3106 PEER_GRACEFUL_RESTART_NEW_STATE_RESTART
))
3107 SET_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
);
3109 UNSET_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
);
3110 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
3112 "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !",
3114 (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)
3117 if (CHECK_FLAG(peer
->peer_gr_new_status_flag
,
3118 PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT
))
3119 SET_FLAG(peer
->flags
,
3120 PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT
);
3122 UNSET_FLAG(peer
->flags
,
3123 PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT
);
3124 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
3126 "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT : %s : !",
3128 (CHECK_FLAG(peer
->flags
,
3129 PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT
)
3133 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)
3134 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART_HELPER
)) {
3135 zlog_debug("[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_MODE!",
3138 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
3140 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
3142 peer_nsf_stop(peer
);
3144 "[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_WAIT!",