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_updgrp.h"
52 #include "bgpd/bgp_nht.h"
53 #include "bgpd/bgp_bfd.h"
54 #include "bgpd/bgp_memory.h"
55 #include "bgpd/bgp_keepalives.h"
56 #include "bgpd/bgp_io.h"
57 #include "bgpd/bgp_zebra.h"
59 DEFINE_HOOK(peer_backward_transition
, (struct peer
* peer
), (peer
))
60 DEFINE_HOOK(peer_status_changed
, (struct peer
* peer
), (peer
))
61 extern const char *get_afi_safi_str(afi_t afi
,
62 safi_t safi
, bool for_json
);
63 /* Definition of display strings corresponding to FSM events. This should be
64 * kept consistent with the events defined in bgpd.h
66 static const char *const bgp_event_str
[] = {
70 "TCP_connection_open",
71 "TCP_connection_closed",
72 "TCP_connection_open_failed",
74 "ConnectRetry_timer_expired",
76 "KeepAlive_timer_expired",
77 "Receive_OPEN_message",
78 "Receive_KEEPALIVE_message",
79 "Receive_UPDATE_message",
80 "Receive_NOTIFICATION_message",
84 /* BGP FSM (finite state machine) has three types of functions. Type
85 one is thread functions. Type two is event functions. Type three
86 is FSM functions. Timer functions are set by bgp_timer_set
89 /* BGP event function. */
90 int bgp_event(struct thread
*);
92 /* BGP thread functions. */
93 static int bgp_start_timer(struct thread
*);
94 static int bgp_connect_timer(struct thread
*);
95 static int bgp_holdtime_timer(struct thread
*);
97 /* BGP FSM functions. */
98 static int bgp_start(struct peer
*);
100 /* Register peer with NHT */
101 static int bgp_peer_reg_with_nht(struct peer
*peer
)
105 if (peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
== BGP_DEFAULT_TTL
106 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)
107 && !bgp_flag_check(peer
->bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
110 return bgp_find_or_add_nexthop(
111 peer
->bgp
, peer
->bgp
, family2afi(peer
->su
.sa
.sa_family
),
112 NULL
, peer
, connected
);
115 static void peer_xfer_stats(struct peer
*peer_dst
, struct peer
*peer_src
)
117 /* Copy stats over. These are only the pre-established state stats */
118 peer_dst
->open_in
+= peer_src
->open_in
;
119 peer_dst
->open_out
+= peer_src
->open_out
;
120 peer_dst
->keepalive_in
+= peer_src
->keepalive_in
;
121 peer_dst
->keepalive_out
+= peer_src
->keepalive_out
;
122 peer_dst
->notify_in
+= peer_src
->notify_in
;
123 peer_dst
->notify_out
+= peer_src
->notify_out
;
124 peer_dst
->dynamic_cap_in
+= peer_src
->dynamic_cap_in
;
125 peer_dst
->dynamic_cap_out
+= peer_src
->dynamic_cap_out
;
128 static struct peer
*peer_xfer_conn(struct peer
*from_peer
)
135 unsigned char last_evt
, last_maj_evt
;
137 assert(from_peer
!= NULL
);
139 peer
= from_peer
->doppelganger
;
141 if (!peer
|| !CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
145 * Let's check that we are not going to loose known configuration
146 * state based upon doppelganger rules.
148 FOREACH_AFI_SAFI (afi
, safi
) {
149 if (from_peer
->afc
[afi
][safi
] != peer
->afc
[afi
][safi
]) {
151 EC_BGP_DOPPELGANGER_CONFIG
,
152 "from_peer->afc[%d][%d] is not the same as what we are overwriting",
158 if (bgp_debug_neighbor_events(peer
))
159 zlog_debug("%s: peer transfer %p fd %d -> %p fd %d)",
160 from_peer
->host
, from_peer
, from_peer
->fd
, peer
,
163 bgp_writes_off(peer
);
165 bgp_writes_off(from_peer
);
166 bgp_reads_off(from_peer
);
169 * Before exchanging FD remove doppelganger from
170 * keepalive peer hash. It could be possible conf peer
171 * fd is set to -1. If blocked on lock then keepalive
172 * thread can access peer pointer with fd -1.
174 bgp_keepalives_off(from_peer
);
176 BGP_TIMER_OFF(peer
->t_routeadv
);
177 BGP_TIMER_OFF(peer
->t_connect
);
178 BGP_TIMER_OFF(peer
->t_connect_check_r
);
179 BGP_TIMER_OFF(peer
->t_connect_check_w
);
180 BGP_TIMER_OFF(from_peer
->t_routeadv
);
181 BGP_TIMER_OFF(from_peer
->t_connect
);
182 BGP_TIMER_OFF(from_peer
->t_connect_check_r
);
183 BGP_TIMER_OFF(from_peer
->t_connect_check_w
);
184 BGP_TIMER_OFF(from_peer
->t_process_packet
);
187 * At this point in time, it is possible that there are packets pending
188 * on various buffers. Those need to be transferred or dropped,
189 * otherwise we'll get spurious failures during session establishment.
191 frr_with_mutex(&peer
->io_mtx
, &from_peer
->io_mtx
) {
193 peer
->fd
= from_peer
->fd
;
196 stream_fifo_clean(peer
->ibuf
);
197 stream_fifo_clean(peer
->obuf
);
200 * this should never happen, since bgp_process_packet() is the
201 * only task that sets and unsets the current packet and it
202 * runs in our pthread.
207 "[%s] Dropping pending packet on connection transfer:",
209 /* there used to be a bgp_packet_dump call here, but
210 * that's extremely confusing since there's no way to
211 * identify the packet in MRT dumps or BMP as dropped
212 * due to connection transfer.
214 stream_free(peer
->curr
);
218 // copy each packet from old peer's output queue to new peer
219 while (from_peer
->obuf
->head
)
220 stream_fifo_push(peer
->obuf
,
221 stream_fifo_pop(from_peer
->obuf
));
223 // copy each packet from old peer's input queue to new peer
224 while (from_peer
->ibuf
->head
)
225 stream_fifo_push(peer
->ibuf
,
226 stream_fifo_pop(from_peer
->ibuf
));
228 ringbuf_wipe(peer
->ibuf_work
);
229 ringbuf_copy(peer
->ibuf_work
, from_peer
->ibuf_work
,
230 ringbuf_remain(from_peer
->ibuf_work
));
233 peer
->as
= from_peer
->as
;
234 peer
->v_holdtime
= from_peer
->v_holdtime
;
235 peer
->v_keepalive
= from_peer
->v_keepalive
;
236 peer
->v_routeadv
= from_peer
->v_routeadv
;
237 peer
->v_gr_restart
= from_peer
->v_gr_restart
;
238 peer
->cap
= from_peer
->cap
;
239 status
= peer
->status
;
240 pstatus
= peer
->ostatus
;
241 last_evt
= peer
->last_event
;
242 last_maj_evt
= peer
->last_major_event
;
243 peer
->status
= from_peer
->status
;
244 peer
->ostatus
= from_peer
->ostatus
;
245 peer
->last_event
= from_peer
->last_event
;
246 peer
->last_major_event
= from_peer
->last_major_event
;
247 from_peer
->status
= status
;
248 from_peer
->ostatus
= pstatus
;
249 from_peer
->last_event
= last_evt
;
250 from_peer
->last_major_event
= last_maj_evt
;
251 peer
->remote_id
= from_peer
->remote_id
;
252 peer
->last_reset
= from_peer
->last_reset
;
254 peer
->peer_gr_present_state
= from_peer
->peer_gr_present_state
;
255 peer
->peer_gr_new_status_flag
= from_peer
->peer_gr_new_status_flag
;
256 bgp_peer_gr_flags_update(peer
);
258 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(
262 if (bgp_peer_gr_mode_get(peer
) == PEER_DISABLE
) {
264 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
266 if (CHECK_FLAG(peer
->sflags
,
267 PEER_STATUS_NSF_WAIT
)) {
272 if (from_peer
->hostname
!= NULL
) {
273 if (peer
->hostname
) {
274 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
275 peer
->hostname
= NULL
;
278 peer
->hostname
= from_peer
->hostname
;
279 from_peer
->hostname
= NULL
;
282 if (from_peer
->domainname
!= NULL
) {
283 if (peer
->domainname
) {
284 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
285 peer
->domainname
= NULL
;
288 peer
->domainname
= from_peer
->domainname
;
289 from_peer
->domainname
= NULL
;
292 FOREACH_AFI_SAFI (afi
, safi
) {
293 peer
->af_flags
[afi
][safi
] = from_peer
->af_flags
[afi
][safi
];
294 peer
->af_sflags
[afi
][safi
] = from_peer
->af_sflags
[afi
][safi
];
295 peer
->af_cap
[afi
][safi
] = from_peer
->af_cap
[afi
][safi
];
296 peer
->afc_nego
[afi
][safi
] = from_peer
->afc_nego
[afi
][safi
];
297 peer
->afc_adv
[afi
][safi
] = from_peer
->afc_adv
[afi
][safi
];
298 peer
->afc_recv
[afi
][safi
] = from_peer
->afc_recv
[afi
][safi
];
299 peer
->orf_plist
[afi
][safi
] = from_peer
->orf_plist
[afi
][safi
];
302 if (bgp_getsockname(peer
) < 0) {
305 "%%bgp_getsockname() failed for %s peer %s fd %d (from_peer fd %d)",
306 (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)
309 peer
->host
, peer
->fd
, from_peer
->fd
);
314 if (from_peer
->status
> Active
) {
315 if (bgp_getsockname(from_peer
) < 0) {
318 "%%bgp_getsockname() failed for %s from_peer %s fd %d (peer fd %d)",
320 (CHECK_FLAG(from_peer
->sflags
,
321 PEER_STATUS_ACCEPT_PEER
)
324 from_peer
->host
, from_peer
->fd
, peer
->fd
);
331 // Note: peer_xfer_stats() must be called with I/O turned OFF
333 peer_xfer_stats(peer
, from_peer
);
335 /* Register peer for NHT. This is to allow RAs to be enabled when
336 * needed, even on a passive connection.
338 bgp_peer_reg_with_nht(peer
);
342 thread_add_timer_msec(bm
->master
, bgp_process_packet
, peer
, 0,
343 &peer
->t_process_packet
);
348 /* Hook function called after bgp event is occered. And vty's
349 neighbor command invoke this function after making neighbor
351 void bgp_timer_set(struct peer
*peer
)
353 switch (peer
->status
) {
355 /* First entry point of peer's finite state machine. In Idle
356 status start timer is on unless peer is shutdown or peer is
357 inactive. All other timer must be turned off */
358 if (BGP_PEER_START_SUPPRESSED(peer
) || !peer_active(peer
)
359 || (peer
->bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
&&
360 peer
->bgp
->vrf_id
== VRF_UNKNOWN
)) {
361 BGP_TIMER_OFF(peer
->t_start
);
363 BGP_TIMER_ON(peer
->t_start
, bgp_start_timer
,
366 BGP_TIMER_OFF(peer
->t_connect
);
367 BGP_TIMER_OFF(peer
->t_holdtime
);
368 bgp_keepalives_off(peer
);
369 BGP_TIMER_OFF(peer
->t_routeadv
);
373 /* After start timer is expired, the peer moves to Connect
374 status. Make sure start timer is off and connect timer is
376 BGP_TIMER_OFF(peer
->t_start
);
377 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
379 BGP_TIMER_OFF(peer
->t_holdtime
);
380 bgp_keepalives_off(peer
);
381 BGP_TIMER_OFF(peer
->t_routeadv
);
385 /* Active is waiting connection from remote peer. And if
386 connect timer is expired, change status to Connect. */
387 BGP_TIMER_OFF(peer
->t_start
);
388 /* If peer is passive mode, do not set connect timer. */
389 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)
390 || CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
391 BGP_TIMER_OFF(peer
->t_connect
);
393 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
396 BGP_TIMER_OFF(peer
->t_holdtime
);
397 bgp_keepalives_off(peer
);
398 BGP_TIMER_OFF(peer
->t_routeadv
);
402 /* OpenSent status. */
403 BGP_TIMER_OFF(peer
->t_start
);
404 BGP_TIMER_OFF(peer
->t_connect
);
405 if (peer
->v_holdtime
!= 0) {
406 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
409 BGP_TIMER_OFF(peer
->t_holdtime
);
411 bgp_keepalives_off(peer
);
412 BGP_TIMER_OFF(peer
->t_routeadv
);
416 /* OpenConfirm status. */
417 BGP_TIMER_OFF(peer
->t_start
);
418 BGP_TIMER_OFF(peer
->t_connect
);
420 /* If the negotiated Hold Time value is zero, then the Hold Time
421 timer and KeepAlive timers are not started. */
422 if (peer
->v_holdtime
== 0) {
423 BGP_TIMER_OFF(peer
->t_holdtime
);
424 bgp_keepalives_off(peer
);
426 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
428 bgp_keepalives_on(peer
);
430 BGP_TIMER_OFF(peer
->t_routeadv
);
434 /* In Established status start and connect timer is turned
436 BGP_TIMER_OFF(peer
->t_start
);
437 BGP_TIMER_OFF(peer
->t_connect
);
439 /* Same as OpenConfirm, if holdtime is zero then both holdtime
440 and keepalive must be turned off. */
441 if (peer
->v_holdtime
== 0) {
442 BGP_TIMER_OFF(peer
->t_holdtime
);
443 bgp_keepalives_off(peer
);
445 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
447 bgp_keepalives_on(peer
);
451 BGP_TIMER_OFF(peer
->t_gr_restart
);
452 BGP_TIMER_OFF(peer
->t_gr_stale
);
453 BGP_TIMER_OFF(peer
->t_pmax_restart
);
456 BGP_TIMER_OFF(peer
->t_start
);
457 BGP_TIMER_OFF(peer
->t_connect
);
458 BGP_TIMER_OFF(peer
->t_holdtime
);
459 bgp_keepalives_off(peer
);
460 BGP_TIMER_OFF(peer
->t_routeadv
);
465 /* BGP start timer. This function set BGP_Start event to thread value
466 and process event. */
467 static int bgp_start_timer(struct thread
*thread
)
471 peer
= THREAD_ARG(thread
);
472 peer
->t_start
= NULL
;
474 if (bgp_debug_neighbor_events(peer
))
475 zlog_debug("%s [FSM] Timer (start timer expire).", peer
->host
);
477 THREAD_VAL(thread
) = BGP_Start
;
478 bgp_event(thread
); /* bgp_event unlocks peer */
483 /* BGP connect retry timer. */
484 static int bgp_connect_timer(struct thread
*thread
)
489 peer
= THREAD_ARG(thread
);
491 assert(!peer
->t_write
);
492 assert(!peer
->t_read
);
494 peer
->t_connect
= NULL
;
496 if (bgp_debug_neighbor_events(peer
))
497 zlog_debug("%s [FSM] Timer (connect timer expire)", peer
->host
);
499 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)) {
503 THREAD_VAL(thread
) = ConnectRetry_timer_expired
;
504 bgp_event(thread
); /* bgp_event unlocks peer */
511 /* BGP holdtime timer. */
512 static int bgp_holdtime_timer(struct thread
*thread
)
516 peer
= THREAD_ARG(thread
);
517 peer
->t_holdtime
= NULL
;
519 if (bgp_debug_neighbor_events(peer
))
520 zlog_debug("%s [FSM] Timer (holdtime timer expire)",
523 THREAD_VAL(thread
) = Hold_Timer_expired
;
524 bgp_event(thread
); /* bgp_event unlocks peer */
529 int bgp_routeadv_timer(struct thread
*thread
)
533 peer
= THREAD_ARG(thread
);
534 peer
->t_routeadv
= NULL
;
536 if (bgp_debug_neighbor_events(peer
))
537 zlog_debug("%s [FSM] Timer (routeadv timer expire)",
540 peer
->synctime
= bgp_clock();
542 thread_add_timer_msec(bm
->master
, bgp_generate_updgrp_packets
, peer
, 0,
543 &peer
->t_generate_updgrp_packets
);
545 /* MRAI timer will be started again when FIFO is built, no need to
551 /* BGP Peer Down Cause */
552 const char *const peer_down_str
[] = {"",
556 "Cluster ID changed",
557 "Confederation identifier changed",
558 "Confederation peer changed",
559 "RR client config change",
560 "RS client config change",
561 "Update source change",
562 "Address family activated",
565 "BGP Notification received",
566 "BGP Notification send",
567 "Peer closed the session",
569 "Peer-group add member",
570 "Peer-group delete member",
571 "Capability changed",
572 "Passive config change",
573 "Multihop config change",
574 "NSF peer closed the session",
575 "Intf peering v6only config change",
578 "Neighbor address lost",
580 "Waiting for Peer IPv6 LLA",
581 "Waiting for VRF to be initialized",
582 "No AFI/SAFI activated for peer"};
584 static int bgp_graceful_restart_timer_expire(struct thread
*thread
)
590 peer
= THREAD_ARG(thread
);
591 peer
->t_gr_restart
= NULL
;
593 /* NSF delete stale route */
594 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
595 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
596 if (peer
->nsf
[afi
][safi
])
597 bgp_clear_stale_route(peer
, afi
, safi
);
599 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
600 BGP_TIMER_OFF(peer
->t_gr_stale
);
602 if (bgp_debug_neighbor_events(peer
)) {
603 zlog_debug("%s graceful restart timer expired", peer
->host
);
604 zlog_debug("%s graceful restart stalepath timer stopped",
613 static int bgp_graceful_stale_timer_expire(struct thread
*thread
)
619 peer
= THREAD_ARG(thread
);
620 peer
->t_gr_stale
= NULL
;
622 if (bgp_debug_neighbor_events(peer
))
623 zlog_debug("%s graceful restart stalepath timer expired",
626 /* NSF delete stale route */
627 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
628 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
629 if (peer
->nsf
[afi
][safi
])
630 bgp_clear_stale_route(peer
, afi
, safi
);
635 /* Selection deferral timer processing function */
636 static int bgp_graceful_deferral_timer_expire(struct thread
*thread
)
638 struct afi_safi_info
*info
;
643 info
= THREAD_ARG(thread
);
648 if (BGP_DEBUG(update
, UPDATE_OUT
))
650 "afi %d, safi %d : graceful restart deferral timer expired",
653 bgp
->gr_info
[afi
][safi
].t_select_deferral
= NULL
;
655 bgp
->gr_info
[afi
][safi
].eor_required
= 0;
656 bgp
->gr_info
[afi
][safi
].eor_received
= 0;
657 XFREE(MTYPE_TMP
, info
);
659 /* Best path selection */
660 return bgp_best_path_select_defer(bgp
, afi
, safi
);
663 static int bgp_update_delay_applicable(struct bgp
*bgp
)
665 /* update_delay_over flag should be reset (set to 0) for any new
666 applicability of the update-delay during BGP process lifetime.
667 And it should be set after an occurence of the update-delay is
669 if (!bgp
->update_delay_over
)
675 int bgp_update_delay_active(struct bgp
*bgp
)
677 if (bgp
->t_update_delay
)
683 int bgp_update_delay_configured(struct bgp
*bgp
)
685 if (bgp
->v_update_delay
)
691 /* Do the post-processing needed when bgp comes out of the read-only mode
692 on ending the update delay. */
693 void bgp_update_delay_end(struct bgp
*bgp
)
695 THREAD_TIMER_OFF(bgp
->t_update_delay
);
696 THREAD_TIMER_OFF(bgp
->t_establish_wait
);
698 /* Reset update-delay related state */
699 bgp
->update_delay_over
= 1;
700 bgp
->established
= 0;
701 bgp
->restarted_peers
= 0;
702 bgp
->implicit_eors
= 0;
703 bgp
->explicit_eors
= 0;
705 quagga_timestamp(3, bgp
->update_delay_end_time
,
706 sizeof(bgp
->update_delay_end_time
));
709 * Add an end-of-initial-update marker to the main process queues so
711 * the route advertisement timer for the peers can be started. Also set
712 * the zebra and peer update hold flags. These flags are used to achieve
713 * three stages in the update-delay post processing:
714 * 1. Finish best-path selection for all the prefixes held on the
716 * (routes in BGP are updated, and peers sync queues are populated
718 * 2. As the eoiu mark is reached in the bgp process routine, ship all
720 * routes to zebra. With that zebra should see updates from BGP
723 * 3. Unblock the peer update writes. With that peer update packing
725 * the prefixes should be at its maximum.
727 bgp_add_eoiu_mark(bgp
);
728 bgp
->main_zebra_update_hold
= 1;
729 bgp
->main_peers_update_hold
= 1;
731 /* Resume the queue processing. This should trigger the event that would
733 care of processing any work that was queued during the read-only
735 work_queue_unplug(bm
->process_main_queue
);
741 void bgp_start_routeadv(struct bgp
*bgp
)
743 struct listnode
*node
, *nnode
;
746 zlog_info("bgp_start_routeadv(), update hold status %d",
747 bgp
->main_peers_update_hold
);
749 if (bgp
->main_peers_update_hold
)
752 quagga_timestamp(3, bgp
->update_delay_peers_resume_time
,
753 sizeof(bgp
->update_delay_peers_resume_time
));
755 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
756 if (peer
->status
!= Established
)
758 BGP_TIMER_OFF(peer
->t_routeadv
);
759 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
766 void bgp_adjust_routeadv(struct peer
*peer
)
768 time_t nowtime
= bgp_clock();
770 unsigned long remain
;
772 /* Bypass checks for special case of MRAI being 0 */
773 if (peer
->v_routeadv
== 0) {
774 /* Stop existing timer, just in case it is running for a
776 * duration and schedule write thread immediately.
778 if (peer
->t_routeadv
)
779 BGP_TIMER_OFF(peer
->t_routeadv
);
781 peer
->synctime
= bgp_clock();
782 thread_add_timer_msec(bm
->master
, bgp_generate_updgrp_packets
,
784 &peer
->t_generate_updgrp_packets
);
791 * If the last update was written more than MRAI back, expire the timer
792 * instantly so that we can send the update out sooner.
794 * <------- MRAI --------->
795 * |-----------------|-----------------------|
796 * <------------- m ------------>
805 diff
= difftime(nowtime
, peer
->last_update
);
806 if (diff
> (double)peer
->v_routeadv
) {
807 BGP_TIMER_OFF(peer
->t_routeadv
);
808 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
814 * - Find when to expire the MRAI timer.
815 * If MRAI timer is not active, assume we can start it now.
817 * <------- MRAI --------->
818 * |------------|-----------------------|
819 * <-------- m ----------><----- r ----->
828 if (peer
->t_routeadv
)
829 remain
= thread_timer_remain_second(peer
->t_routeadv
);
831 remain
= peer
->v_routeadv
;
832 diff
= peer
->v_routeadv
- diff
;
833 if (diff
<= (double)remain
) {
834 BGP_TIMER_OFF(peer
->t_routeadv
);
835 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, diff
);
839 static int bgp_maxmed_onstartup_applicable(struct bgp
*bgp
)
841 if (!bgp
->maxmed_onstartup_over
)
847 int bgp_maxmed_onstartup_configured(struct bgp
*bgp
)
849 if (bgp
->v_maxmed_onstartup
!= BGP_MAXMED_ONSTARTUP_UNCONFIGURED
)
855 int bgp_maxmed_onstartup_active(struct bgp
*bgp
)
857 if (bgp
->t_maxmed_onstartup
)
863 void bgp_maxmed_update(struct bgp
*bgp
)
865 uint8_t maxmed_active
;
866 uint32_t maxmed_value
;
868 if (bgp
->v_maxmed_admin
) {
870 maxmed_value
= bgp
->maxmed_admin_value
;
871 } else if (bgp
->t_maxmed_onstartup
) {
873 maxmed_value
= bgp
->maxmed_onstartup_value
;
876 maxmed_value
= BGP_MAXMED_VALUE_DEFAULT
;
879 if (bgp
->maxmed_active
!= maxmed_active
880 || bgp
->maxmed_value
!= maxmed_value
) {
881 bgp
->maxmed_active
= maxmed_active
;
882 bgp
->maxmed_value
= maxmed_value
;
884 update_group_announce(bgp
);
888 /* The maxmed onstartup timer expiry callback. */
889 static int bgp_maxmed_onstartup_timer(struct thread
*thread
)
893 zlog_info("Max med on startup ended - timer expired.");
895 bgp
= THREAD_ARG(thread
);
896 THREAD_TIMER_OFF(bgp
->t_maxmed_onstartup
);
897 bgp
->maxmed_onstartup_over
= 1;
899 bgp_maxmed_update(bgp
);
904 static void bgp_maxmed_onstartup_begin(struct bgp
*bgp
)
906 /* Applicable only once in the process lifetime on the startup */
907 if (bgp
->maxmed_onstartup_over
)
910 zlog_info("Begin maxmed onstartup mode - timer %d seconds",
911 bgp
->v_maxmed_onstartup
);
913 thread_add_timer(bm
->master
, bgp_maxmed_onstartup_timer
, bgp
,
914 bgp
->v_maxmed_onstartup
, &bgp
->t_maxmed_onstartup
);
916 if (!bgp
->v_maxmed_admin
) {
917 bgp
->maxmed_active
= 1;
918 bgp
->maxmed_value
= bgp
->maxmed_onstartup_value
;
921 /* Route announce to all peers should happen after this in
925 static void bgp_maxmed_onstartup_process_status_change(struct peer
*peer
)
927 if (peer
->status
== Established
&& !peer
->bgp
->established
) {
928 bgp_maxmed_onstartup_begin(peer
->bgp
);
932 /* The update delay timer expiry callback. */
933 static int bgp_update_delay_timer(struct thread
*thread
)
937 zlog_info("Update delay ended - timer expired.");
939 bgp
= THREAD_ARG(thread
);
940 THREAD_TIMER_OFF(bgp
->t_update_delay
);
941 bgp_update_delay_end(bgp
);
946 /* The establish wait timer expiry callback. */
947 static int bgp_establish_wait_timer(struct thread
*thread
)
951 zlog_info("Establish wait - timer expired.");
953 bgp
= THREAD_ARG(thread
);
954 THREAD_TIMER_OFF(bgp
->t_establish_wait
);
955 bgp_check_update_delay(bgp
);
960 /* Steps to begin the update delay:
961 - initialize queues if needed
962 - stop the queue processing
964 static void bgp_update_delay_begin(struct bgp
*bgp
)
966 struct listnode
*node
, *nnode
;
969 /* Stop the processing of queued work. Enqueue shall continue */
970 work_queue_plug(bm
->process_main_queue
);
972 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
973 peer
->update_delay_over
= 0;
975 /* Start the update-delay timer */
976 thread_add_timer(bm
->master
, bgp_update_delay_timer
, bgp
,
977 bgp
->v_update_delay
, &bgp
->t_update_delay
);
979 if (bgp
->v_establish_wait
!= bgp
->v_update_delay
)
980 thread_add_timer(bm
->master
, bgp_establish_wait_timer
, bgp
,
981 bgp
->v_establish_wait
, &bgp
->t_establish_wait
);
983 quagga_timestamp(3, bgp
->update_delay_begin_time
,
984 sizeof(bgp
->update_delay_begin_time
));
987 static void bgp_update_delay_process_status_change(struct peer
*peer
)
989 if (peer
->status
== Established
) {
990 if (!peer
->bgp
->established
++) {
991 bgp_update_delay_begin(peer
->bgp
);
993 "Begin read-only mode - update-delay timer %d seconds",
994 peer
->bgp
->v_update_delay
);
996 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
))
997 bgp_update_restarted_peers(peer
);
999 if (peer
->ostatus
== Established
1000 && bgp_update_delay_active(peer
->bgp
)) {
1001 /* Adjust the update-delay state to account for this flap.
1002 NOTE: Intentionally skipping adjusting implicit_eors or
1004 counters. Extra sanity check in bgp_check_update_delay()
1006 be enough to take care of any additive discrepancy in bgp eor
1008 peer
->bgp
->established
--;
1009 peer
->update_delay_over
= 0;
1013 /* Called after event occurred, this function change status and reset
1014 read/write and timer thread. */
1015 void bgp_fsm_change_status(struct peer
*peer
, int status
)
1018 uint32_t peer_count
;
1021 peer_count
= bgp
->established_peers
;
1023 if (status
== Established
)
1024 bgp
->established_peers
++;
1025 else if ((peer
->status
== Established
) && (status
!= Established
))
1026 bgp
->established_peers
--;
1028 if (bgp_debug_neighbor_events(peer
)) {
1029 struct vrf
*vrf
= vrf_lookup_by_id(bgp
->vrf_id
);
1031 zlog_debug("%s : vrf %s(%u), Status: %s established_peers %u", __func__
,
1032 vrf
? vrf
->name
: "Unknown", bgp
->vrf_id
,
1033 lookup_msg(bgp_status_msg
, status
, NULL
),
1034 bgp
->established_peers
);
1037 /* Set to router ID to the value provided by RIB if there are no peers
1038 * in the established state and peer count did not change
1040 if ((peer_count
!= bgp
->established_peers
) &&
1041 (bgp
->established_peers
== 0))
1042 bgp_router_id_zebra_bump(bgp
->vrf_id
, NULL
);
1044 /* Transition into Clearing or Deleted must /always/ clear all routes..
1045 * (and must do so before actually changing into Deleted..
1047 if (status
>= Clearing
) {
1048 bgp_clear_route_all(peer
);
1050 /* If no route was queued for the clear-node processing,
1052 * completion event here. This is needed because if there are no
1054 * to trigger the background clear-node thread, the event won't
1056 * generated and the peer would be stuck in Clearing. Note that
1058 * event is for the peer and helps the peer transition out of
1060 * state; it should not be generated per (AFI,SAFI). The event
1062 * directly posted here without calling clear_node_complete() as
1064 * shouldn't do an extra unlock. This event will get processed
1066 * the state change that happens below, so peer will be in
1070 if (!work_queue_is_scheduled(peer
->clear_node_queue
))
1071 BGP_EVENT_ADD(peer
, Clearing_Completed
);
1074 /* Preserve old status and change into new status. */
1075 peer
->ostatus
= peer
->status
;
1076 peer
->status
= status
;
1078 /* Save event that caused status change. */
1079 peer
->last_major_event
= peer
->cur_event
;
1081 /* Operations after status change */
1082 hook_call(peer_status_changed
, peer
);
1084 if (status
== Established
)
1085 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
1087 /* If max-med processing is applicable, do the necessary. */
1088 if (status
== Established
) {
1089 if (bgp_maxmed_onstartup_configured(peer
->bgp
)
1090 && bgp_maxmed_onstartup_applicable(peer
->bgp
))
1091 bgp_maxmed_onstartup_process_status_change(peer
);
1093 peer
->bgp
->maxmed_onstartup_over
= 1;
1096 /* If update-delay processing is applicable, do the necessary. */
1097 if (bgp_update_delay_configured(peer
->bgp
)
1098 && bgp_update_delay_applicable(peer
->bgp
))
1099 bgp_update_delay_process_status_change(peer
);
1101 if (bgp_debug_neighbor_events(peer
))
1102 zlog_debug("%s went from %s to %s", peer
->host
,
1103 lookup_msg(bgp_status_msg
, peer
->ostatus
, NULL
),
1104 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1107 /* Flush the event queue and ensure the peer is shut down */
1108 static int bgp_clearing_completed(struct peer
*peer
)
1110 int rc
= bgp_stop(peer
);
1113 BGP_EVENT_FLUSH(peer
);
1118 /* Administrative BGP peer stop event. */
1119 /* May be called multiple times for the same peer */
1120 int bgp_stop(struct peer
*peer
)
1124 char orf_name
[BUFSIZ
];
1126 struct bgp
*bgp
= peer
->bgp
;
1127 struct graceful_restart_info
*gr_info
= NULL
;
1129 peer
->nsf_af_count
= 0;
1131 if (peer_dynamic_neighbor(peer
)
1132 && !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
1133 if (bgp_debug_neighbor_events(peer
))
1134 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1139 /* Can't do this in Clearing; events are used for state transitions */
1140 if (peer
->status
!= Clearing
) {
1141 /* Delete all existing events of the peer */
1142 BGP_EVENT_FLUSH(peer
);
1145 /* Increment Dropped count. */
1146 if (peer
->status
== Established
) {
1149 /* bgp log-neighbor-changes of neighbor Down */
1150 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)) {
1151 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1154 "%%ADJCHANGE: neighbor %s(%s) in vrf %s Down %s",
1156 (peer
->hostname
) ? peer
->hostname
: "Unknown",
1157 vrf
? ((vrf
->vrf_id
!= VRF_DEFAULT
)
1161 peer_down_str
[(int)peer
->last_reset
]);
1164 /* graceful restart */
1165 if (peer
->t_gr_stale
) {
1166 BGP_TIMER_OFF(peer
->t_gr_stale
);
1167 if (bgp_debug_neighbor_events(peer
))
1169 "%s graceful restart stalepath timer stopped",
1172 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
1173 if (bgp_debug_neighbor_events(peer
)) {
1175 "%s graceful restart timer started for %d sec",
1176 peer
->host
, peer
->v_gr_restart
);
1178 "%s graceful restart stalepath timer started for %d sec",
1179 peer
->host
, peer
->bgp
->stalepath_time
);
1181 BGP_TIMER_ON(peer
->t_gr_restart
,
1182 bgp_graceful_restart_timer_expire
,
1183 peer
->v_gr_restart
);
1184 BGP_TIMER_ON(peer
->t_gr_stale
,
1185 bgp_graceful_stale_timer_expire
,
1186 peer
->bgp
->stalepath_time
);
1188 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1190 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1191 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
;
1193 peer
->nsf
[afi
][safi
] = 0;
1196 /* If peer reset before receiving EOR, decrement EOR count and
1197 * cancel the selection deferral timer if there are no
1198 * pending EOR messages to be received
1200 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)) {
1201 FOREACH_AFI_SAFI (afi
, safi
) {
1202 if (!peer
->afc_nego
[afi
][safi
]
1203 || CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
1204 PEER_STATUS_EOR_RECEIVED
))
1207 gr_info
= &bgp
->gr_info
[afi
][safi
];
1211 if (gr_info
->eor_required
)
1212 gr_info
->eor_required
--;
1214 if (BGP_DEBUG(update
, UPDATE_OUT
))
1215 zlog_debug("peer %s, EOR_required %d",
1217 gr_info
->eor_required
);
1219 /* There is no pending EOR message */
1220 if (gr_info
->eor_required
== 0) {
1222 gr_info
->t_select_deferral
);
1223 gr_info
->eor_received
= 0;
1228 /* set last reset time */
1229 peer
->resettime
= peer
->uptime
= bgp_clock();
1231 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1232 zlog_debug("%s remove from all update group",
1234 update_group_remove_peer_afs(peer
);
1236 hook_call(peer_backward_transition
, peer
);
1238 /* Reset peer synctime */
1242 /* stop keepalives */
1243 bgp_keepalives_off(peer
);
1245 /* Stop read and write threads. */
1246 bgp_writes_off(peer
);
1247 bgp_reads_off(peer
);
1249 THREAD_OFF(peer
->t_connect_check_r
);
1250 THREAD_OFF(peer
->t_connect_check_w
);
1252 /* Stop all timers. */
1253 BGP_TIMER_OFF(peer
->t_start
);
1254 BGP_TIMER_OFF(peer
->t_connect
);
1255 BGP_TIMER_OFF(peer
->t_holdtime
);
1256 BGP_TIMER_OFF(peer
->t_routeadv
);
1258 /* Clear input and output buffer. */
1259 frr_with_mutex(&peer
->io_mtx
) {
1261 stream_fifo_clean(peer
->ibuf
);
1263 stream_fifo_clean(peer
->obuf
);
1265 if (peer
->ibuf_work
)
1266 ringbuf_wipe(peer
->ibuf_work
);
1267 if (peer
->obuf_work
)
1268 stream_reset(peer
->obuf_work
);
1271 stream_free(peer
->curr
);
1276 /* Close of file descriptor. */
1277 if (peer
->fd
>= 0) {
1282 FOREACH_AFI_SAFI (afi
, safi
) {
1283 /* Reset all negotiated variables */
1284 peer
->afc_nego
[afi
][safi
] = 0;
1285 peer
->afc_adv
[afi
][safi
] = 0;
1286 peer
->afc_recv
[afi
][safi
] = 0;
1288 /* peer address family capability flags*/
1289 peer
->af_cap
[afi
][safi
] = 0;
1291 /* peer address family status flags*/
1292 peer
->af_sflags
[afi
][safi
] = 0;
1294 /* Received ORF prefix-filter */
1295 peer
->orf_plist
[afi
][safi
] = NULL
;
1297 if ((peer
->status
== OpenConfirm
)
1298 || (peer
->status
== Established
)) {
1299 /* ORF received prefix-filter pnt */
1300 sprintf(orf_name
, "%s.%d.%d", peer
->host
, afi
, safi
);
1301 prefix_bgp_orf_remove_all(afi
, orf_name
);
1305 /* Reset keepalive and holdtime */
1306 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER
)) {
1307 peer
->v_keepalive
= peer
->keepalive
;
1308 peer
->v_holdtime
= peer
->holdtime
;
1310 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
1311 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
1314 peer
->update_time
= 0;
1316 /* Until we are sure that there is no problem about prefix count
1317 this should be commented out.*/
1319 /* Reset prefix count */
1320 peer
->pcount
[AFI_IP
][SAFI_UNICAST
] = 0;
1321 peer
->pcount
[AFI_IP
][SAFI_MULTICAST
] = 0;
1322 peer
->pcount
[AFI_IP
][SAFI_LABELED_UNICAST
] = 0;
1323 peer
->pcount
[AFI_IP
][SAFI_MPLS_VPN
] = 0;
1324 peer
->pcount
[AFI_IP6
][SAFI_UNICAST
] = 0;
1325 peer
->pcount
[AFI_IP6
][SAFI_MULTICAST
] = 0;
1326 peer
->pcount
[AFI_IP6
][SAFI_LABELED_UNICAST
] = 0;
1329 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1330 && !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
1334 bgp_peer_conf_if_to_su_update(peer
);
1339 /* BGP peer is stoped by the error. */
1340 static int bgp_stop_with_error(struct peer
*peer
)
1342 /* Double start timer. */
1345 /* Overflow check. */
1346 if (peer
->v_start
>= (60 * 2))
1347 peer
->v_start
= (60 * 2);
1349 if (peer_dynamic_neighbor(peer
)) {
1350 if (bgp_debug_neighbor_events(peer
))
1351 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1356 return (bgp_stop(peer
));
1360 /* something went wrong, send notify and tear down */
1361 static int bgp_stop_with_notify(struct peer
*peer
, uint8_t code
,
1364 /* Send notify to remote peer */
1365 bgp_notify_send(peer
, code
, sub_code
);
1367 if (peer_dynamic_neighbor(peer
)) {
1368 if (bgp_debug_neighbor_events(peer
))
1369 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1374 /* Clear start timer value to default. */
1375 peer
->v_start
= BGP_INIT_START_TIMER
;
1377 return (bgp_stop(peer
));
1381 * Determines whether a TCP session has successfully established for a peer and
1382 * events as appropriate.
1384 * This function is called when setting up a new session. After connect() is
1385 * called on the peer's socket (in bgp_start()), the fd is passed to poll()
1386 * to wait for connection success or failure. When poll() returns, this
1387 * function is called to evaluate the result.
1389 * Due to differences in behavior of poll() on Linux and BSD - specifically,
1390 * the value of .revents in the case of a closed connection - this function is
1391 * scheduled both for a read and a write event. The write event is triggered
1392 * when the connection is established. A read event is triggered when the
1393 * connection is closed. Thus we need to cancel whichever one did not occur.
1395 static int bgp_connect_check(struct thread
*thread
)
1402 peer
= THREAD_ARG(thread
);
1403 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
1404 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
1405 assert(!peer
->t_read
);
1406 assert(!peer
->t_write
);
1408 THREAD_OFF(peer
->t_connect_check_r
);
1409 THREAD_OFF(peer
->t_connect_check_w
);
1411 /* Check file descriptor. */
1412 slen
= sizeof(status
);
1413 ret
= getsockopt(peer
->fd
, SOL_SOCKET
, SO_ERROR
, (void *)&status
,
1416 /* If getsockopt is fail, this is fatal error. */
1418 zlog_err("can't get sockopt for nonblocking connect: %d(%s)",
1419 errno
, safe_strerror(errno
));
1420 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1424 /* When status is 0 then TCP connection is established. */
1426 BGP_EVENT_ADD(peer
, TCP_connection_open
);
1429 if (bgp_debug_neighbor_events(peer
))
1430 zlog_debug("%s [Event] Connect failed %d(%s)",
1431 peer
->host
, status
, safe_strerror(status
));
1432 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1437 /* TCP connection open. Next we send open message to remote peer. And
1438 add read thread for reading open message. */
1439 static int bgp_connect_success(struct peer
*peer
)
1442 flog_err(EC_BGP_CONNECT
,
1443 "bgp_connect_success peer's fd is negative value %d",
1449 if (bgp_getsockname(peer
) < 0) {
1450 flog_err_sys(EC_LIB_SOCKET
,
1451 "%s: bgp_getsockname(): failed for peer %s, fd %d",
1452 __FUNCTION__
, peer
->host
, peer
->fd
);
1454 peer
, BGP_NOTIFY_FSM_ERR
,
1455 BGP_NOTIFY_SUBCODE_UNSPECIFIC
); /* internal error */
1456 bgp_writes_on(peer
);
1462 if (bgp_debug_neighbor_events(peer
)) {
1463 char buf1
[SU_ADDRSTRLEN
];
1465 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
1466 zlog_debug("%s open active, local address %s",
1468 sockunion2str(peer
->su_local
, buf1
,
1471 zlog_debug("%s passive open", peer
->host
);
1474 bgp_open_send(peer
);
1479 /* TCP connect fail */
1480 static int bgp_connect_fail(struct peer
*peer
)
1482 if (peer_dynamic_neighbor(peer
)) {
1483 if (bgp_debug_neighbor_events(peer
))
1484 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1489 return (bgp_stop(peer
));
1492 /* This function is the first starting point of all BGP connection. It
1493 try to connect to remote peer with non-blocking IO. */
1494 int bgp_start(struct peer
*peer
)
1498 bgp_peer_conf_if_to_su_update(peer
);
1500 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
) {
1501 if (bgp_debug_neighbor_events(peer
))
1503 "%s [FSM] Unable to get neighbor's IP address, waiting...",
1505 peer
->last_reset
= PEER_DOWN_NBR_ADDR
;
1509 if (BGP_PEER_START_SUPPRESSED(peer
)) {
1510 if (bgp_debug_neighbor_events(peer
))
1511 flog_err(EC_BGP_FSM
,
1512 "%s [FSM] Trying to start suppressed peer"
1513 " - this is never supposed to happen!",
1518 /* Scrub some information that might be left over from a previous,
1521 /* Connection information. */
1522 if (peer
->su_local
) {
1523 sockunion_free(peer
->su_local
);
1524 peer
->su_local
= NULL
;
1527 if (peer
->su_remote
) {
1528 sockunion_free(peer
->su_remote
);
1529 peer
->su_remote
= NULL
;
1532 /* Clear remote router-id. */
1533 peer
->remote_id
.s_addr
= 0;
1535 /* Clear peer capability flag. */
1538 /* If the peer is passive mode, force to move to Active mode. */
1539 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)) {
1540 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1544 if (peer
->bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
&&
1545 peer
->bgp
->vrf_id
== VRF_UNKNOWN
) {
1546 if (bgp_debug_neighbor_events(peer
))
1549 "%s [FSM] In a VRF that is not initialised yet",
1551 peer
->last_reset
= PEER_DOWN_VRF_UNINIT
;
1555 /* Register peer for NHT. If next hop is already resolved, proceed
1556 * with connection setup, else wait.
1558 if (!bgp_peer_reg_with_nht(peer
)) {
1559 if (bgp_zebra_num_connects()) {
1560 if (bgp_debug_neighbor_events(peer
))
1561 zlog_debug("%s [FSM] Waiting for NHT",
1563 peer
->last_reset
= PEER_DOWN_WAITING_NHT
;
1564 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1569 assert(!peer
->t_write
);
1570 assert(!peer
->t_read
);
1571 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
1572 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
1573 status
= bgp_connect(peer
);
1577 if (bgp_debug_neighbor_events(peer
))
1578 zlog_debug("%s [FSM] Connect error", peer
->host
);
1579 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1581 case connect_success
:
1582 if (bgp_debug_neighbor_events(peer
))
1584 "%s [FSM] Connect immediately success, fd %d",
1585 peer
->host
, peer
->fd
);
1586 BGP_EVENT_ADD(peer
, TCP_connection_open
);
1588 case connect_in_progress
:
1589 /* To check nonblocking connect, we wait until socket is
1590 readable or writable. */
1591 if (bgp_debug_neighbor_events(peer
))
1593 "%s [FSM] Non blocking connect waiting result, fd %d",
1594 peer
->host
, peer
->fd
);
1596 flog_err(EC_BGP_FSM
,
1597 "bgp_start peer's fd is negative value %d",
1602 * - when the socket becomes ready, poll() will signify POLLOUT
1603 * - if it fails to connect, poll() will signify POLLHUP
1604 * - POLLHUP is handled as a 'read' event by thread.c
1606 * therefore, we schedule both a read and a write event with
1607 * bgp_connect_check() as the handler for each and cancel the
1608 * unused event in that function.
1610 thread_add_read(bm
->master
, bgp_connect_check
, peer
, peer
->fd
,
1611 &peer
->t_connect_check_r
);
1612 thread_add_write(bm
->master
, bgp_connect_check
, peer
, peer
->fd
,
1613 &peer
->t_connect_check_w
);
1619 /* Connect retry timer is expired when the peer status is Connect. */
1620 static int bgp_reconnect(struct peer
*peer
)
1622 if (bgp_stop(peer
) < 0)
1625 /* Send graceful restart capabilty */
1626 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(
1627 peer
->bgp
, peer
->bgp
->peer
);
1633 static int bgp_fsm_open(struct peer
*peer
)
1635 /* Send keepalive and make keepalive timer */
1636 bgp_keepalive_send(peer
);
1638 /* Reset holdtimer value. */
1639 BGP_TIMER_OFF(peer
->t_holdtime
);
1644 /* FSM error, unexpected event. This is error of BGP connection. So cut the
1645 peer and change to Idle status. */
1646 static int bgp_fsm_event_error(struct peer
*peer
)
1648 flog_err(EC_BGP_FSM
, "%s [FSM] unexpected packet received in state %s",
1649 peer
->host
, lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1651 return bgp_stop_with_notify(peer
, BGP_NOTIFY_FSM_ERR
, 0);
1654 /* Hold timer expire. This is error of BGP connection. So cut the
1655 peer and change to Idle status. */
1656 static int bgp_fsm_holdtime_expire(struct peer
*peer
)
1658 if (bgp_debug_neighbor_events(peer
))
1659 zlog_debug("%s [FSM] Hold timer expire", peer
->host
);
1661 return bgp_stop_with_notify(peer
, BGP_NOTIFY_HOLD_ERR
, 0);
1664 /* Start the selection deferral timer thread for the specified AFI, SAFI */
1665 static int bgp_start_deferral_timer(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1666 struct graceful_restart_info
*gr_info
)
1668 struct afi_safi_info
*thread_info
;
1670 /* If the deferral timer is active, then increment eor count */
1671 if (gr_info
->t_select_deferral
) {
1672 gr_info
->eor_required
++;
1676 /* Start the deferral timer when the first peer enabled for the graceful
1677 * restart is established
1679 if (gr_info
->eor_required
== 0) {
1680 thread_info
= XMALLOC(MTYPE_TMP
, sizeof(struct afi_safi_info
));
1682 thread_info
->afi
= afi
;
1683 thread_info
->safi
= safi
;
1684 thread_info
->bgp
= bgp
;
1686 thread_add_timer(bm
->master
, bgp_graceful_deferral_timer_expire
,
1687 thread_info
, bgp
->select_defer_time
,
1688 &gr_info
->t_select_deferral
);
1690 gr_info
->eor_required
++;
1691 /* Send message to RIB indicating route update pending */
1692 if (gr_info
->af_enabled
[afi
][safi
] == false) {
1693 gr_info
->af_enabled
[afi
][safi
] = true;
1694 /* Send message to RIB */
1695 bgp_zebra_update(afi
, safi
, bgp
->vrf_id
,
1696 ZEBRA_CLIENT_ROUTE_UPDATE_PENDING
);
1698 if (BGP_DEBUG(update
, UPDATE_OUT
))
1699 zlog_debug("Started the deferral timer for %s eor_required %d",
1700 get_afi_safi_str(afi
, safi
, false),
1701 gr_info
->eor_required
);
1705 /* Update the graceful restart information for the specified AFI, SAFI */
1706 static int bgp_update_gr_info(struct peer
*peer
, afi_t afi
, safi_t safi
)
1708 struct graceful_restart_info
*gr_info
;
1709 struct bgp
*bgp
= peer
->bgp
;
1712 if ((afi
< AFI_IP
) || (afi
>= AFI_MAX
)) {
1713 if (BGP_DEBUG(update
, UPDATE_OUT
))
1714 zlog_debug("%s : invalid afi %d", __func__
, afi
);
1718 if ((safi
< SAFI_UNICAST
) || (safi
> SAFI_MPLS_VPN
)) {
1719 if (BGP_DEBUG(update
, UPDATE_OUT
))
1720 zlog_debug("%s : invalid safi %d", __func__
, safi
);
1724 /* Restarting router */
1725 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
) &&
1726 BGP_PEER_RESTARTING_MODE(peer
)) {
1727 /* Check if the forwarding state is preserved */
1728 if (bgp_flag_check(bgp
, BGP_FLAG_GR_PRESERVE_FWD
)) {
1729 gr_info
= &(bgp
->gr_info
[afi
][safi
]);
1730 ret
= bgp_start_deferral_timer(bgp
, afi
, safi
, gr_info
);
1737 * Transition to Established state.
1739 * Convert peer from stub to full fledged peer, set some timers, and generate
1742 static int bgp_establish(struct peer
*peer
)
1746 int nsf_af_count
= 0;
1751 other
= peer
->doppelganger
;
1752 peer
= peer_xfer_conn(peer
);
1754 flog_err(EC_BGP_CONNECT
, "%%Neighbor failed in xfer_conn");
1759 ret
= 1; /* bgp_establish specific code when xfer_conn
1762 /* Reset capability open status flag. */
1763 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
))
1764 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1766 /* Clear start timer value to default. */
1767 peer
->v_start
= BGP_INIT_START_TIMER
;
1769 /* Increment established count. */
1770 peer
->established
++;
1771 bgp_fsm_change_status(peer
, Established
);
1773 /* bgp log-neighbor-changes of neighbor Up */
1774 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)) {
1775 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1776 zlog_info("%%ADJCHANGE: neighbor %s(%s) in vrf %s Up",
1778 (peer
->hostname
) ? peer
->hostname
: "Unknown",
1779 vrf
? ((vrf
->vrf_id
!= VRF_DEFAULT
)
1784 /* assign update-group/subgroup */
1785 update_group_adjust_peer_afs(peer
);
1787 /* graceful restart */
1788 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
1789 if (bgp_debug_neighbor_events(peer
)) {
1790 if (BGP_PEER_RESTARTING_MODE(peer
))
1791 zlog_debug("peer %s BGP_RESTARTING_MODE",
1793 else if (BGP_PEER_HELPER_MODE(peer
))
1794 zlog_debug("peer %s BGP_HELPER_MODE",
1797 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1798 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++) {
1799 if (peer
->afc_nego
[afi
][safi
]
1800 && CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
)
1801 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1802 PEER_CAP_RESTART_AF_RCV
)) {
1803 if (peer
->nsf
[afi
][safi
]
1805 peer
->af_cap
[afi
][safi
],
1806 PEER_CAP_RESTART_AF_PRESERVE_RCV
))
1807 bgp_clear_stale_route(peer
, afi
, safi
);
1809 peer
->nsf
[afi
][safi
] = 1;
1812 if (peer
->nsf
[afi
][safi
])
1813 bgp_clear_stale_route(peer
, afi
, safi
);
1814 peer
->nsf
[afi
][safi
] = 0;
1816 /* Update the graceful restart information */
1817 if (peer
->afc_nego
[afi
][safi
]) {
1818 if (!BGP_SELECT_DEFER_DISABLE(peer
->bgp
)) {
1819 status
= bgp_update_gr_info(peer
, afi
,
1822 zlog_err("Error in updating graceful restart for %s",
1823 get_afi_safi_str(afi
,
1826 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(
1828 BGP_PEER_RESTARTING_MODE(peer
)
1829 && bgp_flag_check(peer
->bgp
,
1830 BGP_FLAG_GR_PRESERVE_FWD
))
1831 peer
->bgp
->gr_info
[afi
][safi
]
1837 peer
->nsf_af_count
= nsf_af_count
;
1840 SET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1842 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1843 if (peer
->t_gr_stale
) {
1844 BGP_TIMER_OFF(peer
->t_gr_stale
);
1845 if (bgp_debug_neighbor_events(peer
))
1847 "%s graceful restart stalepath timer stopped",
1852 if (peer
->t_gr_restart
) {
1853 BGP_TIMER_OFF(peer
->t_gr_restart
);
1854 if (bgp_debug_neighbor_events(peer
))
1855 zlog_debug("%s graceful restart timer stopped",
1859 /* Reset uptime, turn on keepalives, send current table. */
1860 if (!peer
->v_holdtime
)
1861 bgp_keepalives_on(peer
);
1863 peer
->uptime
= bgp_clock();
1865 /* Send route-refresh when ORF is enabled */
1866 FOREACH_AFI_SAFI (afi
, safi
) {
1867 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1868 PEER_CAP_ORF_PREFIX_SM_ADV
)) {
1869 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1870 PEER_CAP_ORF_PREFIX_RM_RCV
))
1871 bgp_route_refresh_send(peer
, afi
, safi
,
1873 REFRESH_IMMEDIATE
, 0);
1874 else if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1875 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))
1876 bgp_route_refresh_send(peer
, afi
, safi
,
1877 ORF_TYPE_PREFIX_OLD
,
1878 REFRESH_IMMEDIATE
, 0);
1882 /* First update is deferred until ORF or ROUTE-REFRESH is received */
1883 FOREACH_AFI_SAFI (afi
, safi
) {
1884 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1885 PEER_CAP_ORF_PREFIX_RM_ADV
))
1886 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1887 PEER_CAP_ORF_PREFIX_SM_RCV
)
1888 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1889 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
))
1890 SET_FLAG(peer
->af_sflags
[afi
][safi
],
1891 PEER_STATUS_ORF_WAIT_REFRESH
);
1894 bgp_announce_peer(peer
);
1896 /* Start the route advertisement timer to send updates to the peer - if
1898 * is not in read-only mode. If it is, the timer will be started at the
1900 * of read-only mode.
1902 if (!bgp_update_delay_active(peer
->bgp
)) {
1903 BGP_TIMER_OFF(peer
->t_routeadv
);
1904 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
1907 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)) {
1908 if (bgp_debug_neighbor_events(peer
))
1910 "[Event] Deleting stub connection for peer %s",
1913 if (peer
->doppelganger
->status
> Active
)
1914 bgp_notify_send(peer
->doppelganger
, BGP_NOTIFY_CEASE
,
1915 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1917 peer_delete(peer
->doppelganger
);
1921 * If we are replacing the old peer for a doppelganger
1922 * then switch it around in the bgp->peerhash
1923 * the doppelgangers su and this peer's su are the same
1924 * so the hash_release is the same for either.
1926 hash_release(peer
->bgp
->peerhash
, peer
);
1927 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1929 bgp_bfd_register_peer(peer
);
1933 /* Keepalive packet is received. */
1934 static int bgp_fsm_keepalive(struct peer
*peer
)
1936 BGP_TIMER_OFF(peer
->t_holdtime
);
1940 /* Update packet is received. */
1941 static int bgp_fsm_update(struct peer
*peer
)
1943 BGP_TIMER_OFF(peer
->t_holdtime
);
1947 /* This is empty event. */
1948 static int bgp_ignore(struct peer
*peer
)
1952 "%s [FSM] Ignoring event %s in state %s, prior events %s, %s, fd %d",
1953 peer
->host
, bgp_event_str
[peer
->cur_event
],
1954 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1955 bgp_event_str
[peer
->last_event
],
1956 bgp_event_str
[peer
->last_major_event
], peer
->fd
);
1960 /* This is to handle unexpected events.. */
1961 static int bgp_fsm_exeption(struct peer
*peer
)
1965 "%s [FSM] Unexpected event %s in state %s, prior events %s, %s, fd %d",
1966 peer
->host
, bgp_event_str
[peer
->cur_event
],
1967 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1968 bgp_event_str
[peer
->last_event
],
1969 bgp_event_str
[peer
->last_major_event
], peer
->fd
);
1970 return (bgp_stop(peer
));
1973 void bgp_fsm_event_update(struct peer
*peer
, int valid
)
1978 switch (peer
->status
) {
1981 BGP_EVENT_ADD(peer
, BGP_Start
);
1985 BGP_TIMER_OFF(peer
->t_connect
);
1986 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1991 BGP_TIMER_OFF(peer
->t_connect
);
1992 BGP_EVENT_ADD(peer
, ConnectRetry_timer_expired
);
1998 if (!valid
&& (peer
->gtsm_hops
== 1))
1999 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
2007 /* Finite State Machine structure */
2008 static const struct {
2009 int (*func
)(struct peer
*);
2011 } FSM
[BGP_STATUS_MAX
- 1][BGP_EVENTS_MAX
- 1] = {
2013 /* Idle state: In Idle state, all events other than BGP_Start is
2014 ignored. With BGP_Start event, finite state machine calls
2016 {bgp_start
, Connect
}, /* BGP_Start */
2017 {bgp_stop
, Idle
}, /* BGP_Stop */
2018 {bgp_stop
, Idle
}, /* TCP_connection_open */
2019 {bgp_stop
, Idle
}, /* TCP_connection_closed */
2020 {bgp_ignore
, Idle
}, /* TCP_connection_open_failed */
2021 {bgp_stop
, Idle
}, /* TCP_fatal_error */
2022 {bgp_ignore
, Idle
}, /* ConnectRetry_timer_expired */
2023 {bgp_ignore
, Idle
}, /* Hold_Timer_expired */
2024 {bgp_ignore
, Idle
}, /* KeepAlive_timer_expired */
2025 {bgp_ignore
, Idle
}, /* Receive_OPEN_message */
2026 {bgp_ignore
, Idle
}, /* Receive_KEEPALIVE_message */
2027 {bgp_ignore
, Idle
}, /* Receive_UPDATE_message */
2028 {bgp_ignore
, Idle
}, /* Receive_NOTIFICATION_message */
2029 {bgp_ignore
, Idle
}, /* Clearing_Completed */
2033 {bgp_ignore
, Connect
}, /* BGP_Start */
2034 {bgp_stop
, Idle
}, /* BGP_Stop */
2035 {bgp_connect_success
, OpenSent
}, /* TCP_connection_open */
2036 {bgp_stop
, Idle
}, /* TCP_connection_closed */
2037 {bgp_connect_fail
, Active
}, /* TCP_connection_open_failed */
2038 {bgp_connect_fail
, Idle
}, /* TCP_fatal_error */
2039 {bgp_reconnect
, Connect
}, /* ConnectRetry_timer_expired */
2040 {bgp_fsm_exeption
, Idle
}, /* Hold_Timer_expired */
2041 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
2042 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
2043 {bgp_fsm_exeption
, Idle
}, /* Receive_KEEPALIVE_message */
2044 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
2045 {bgp_stop
, Idle
}, /* Receive_NOTIFICATION_message */
2046 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
2050 {bgp_ignore
, Active
}, /* BGP_Start */
2051 {bgp_stop
, Idle
}, /* BGP_Stop */
2052 {bgp_connect_success
, OpenSent
}, /* TCP_connection_open */
2053 {bgp_stop
, Idle
}, /* TCP_connection_closed */
2054 {bgp_ignore
, Active
}, /* TCP_connection_open_failed */
2055 {bgp_fsm_exeption
, Idle
}, /* TCP_fatal_error */
2056 {bgp_start
, Connect
}, /* ConnectRetry_timer_expired */
2057 {bgp_fsm_exeption
, Idle
}, /* Hold_Timer_expired */
2058 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
2059 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
2060 {bgp_fsm_exeption
, Idle
}, /* Receive_KEEPALIVE_message */
2061 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
2062 {bgp_fsm_exeption
, Idle
}, /* Receive_NOTIFICATION_message */
2063 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
2067 {bgp_ignore
, OpenSent
}, /* BGP_Start */
2068 {bgp_stop
, Idle
}, /* BGP_Stop */
2069 {bgp_stop
, Active
}, /* TCP_connection_open */
2070 {bgp_stop
, Active
}, /* TCP_connection_closed */
2071 {bgp_stop
, Active
}, /* TCP_connection_open_failed */
2072 {bgp_stop
, Active
}, /* TCP_fatal_error */
2073 {bgp_fsm_exeption
, Idle
}, /* ConnectRetry_timer_expired */
2074 {bgp_fsm_holdtime_expire
, Idle
}, /* Hold_Timer_expired */
2075 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
2076 {bgp_fsm_open
, OpenConfirm
}, /* Receive_OPEN_message */
2077 {bgp_fsm_event_error
, Idle
}, /* Receive_KEEPALIVE_message */
2078 {bgp_fsm_event_error
, Idle
}, /* Receive_UPDATE_message */
2079 {bgp_fsm_event_error
, Idle
}, /* Receive_NOTIFICATION_message */
2080 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
2084 {bgp_ignore
, OpenConfirm
}, /* BGP_Start */
2085 {bgp_stop
, Idle
}, /* BGP_Stop */
2086 {bgp_stop
, Idle
}, /* TCP_connection_open */
2087 {bgp_stop
, Idle
}, /* TCP_connection_closed */
2088 {bgp_stop
, Idle
}, /* TCP_connection_open_failed */
2089 {bgp_stop
, Idle
}, /* TCP_fatal_error */
2090 {bgp_fsm_exeption
, Idle
}, /* ConnectRetry_timer_expired */
2091 {bgp_fsm_holdtime_expire
, Idle
}, /* Hold_Timer_expired */
2092 {bgp_ignore
, OpenConfirm
}, /* KeepAlive_timer_expired */
2093 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
2094 {bgp_establish
, Established
}, /* Receive_KEEPALIVE_message */
2095 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
2096 {bgp_stop_with_error
, Idle
}, /* Receive_NOTIFICATION_message */
2097 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
2101 {bgp_ignore
, Established
}, /* BGP_Start */
2102 {bgp_stop
, Clearing
}, /* BGP_Stop */
2103 {bgp_stop
, Clearing
}, /* TCP_connection_open */
2104 {bgp_stop
, Clearing
}, /* TCP_connection_closed */
2105 {bgp_stop
, Clearing
}, /* TCP_connection_open_failed */
2106 {bgp_stop
, Clearing
}, /* TCP_fatal_error */
2107 {bgp_stop
, Clearing
}, /* ConnectRetry_timer_expired */
2108 {bgp_fsm_holdtime_expire
, Clearing
}, /* Hold_Timer_expired */
2109 {bgp_ignore
, Established
}, /* KeepAlive_timer_expired */
2110 {bgp_stop
, Clearing
}, /* Receive_OPEN_message */
2112 Established
}, /* Receive_KEEPALIVE_message */
2113 {bgp_fsm_update
, Established
}, /* Receive_UPDATE_message */
2114 {bgp_stop_with_error
,
2115 Clearing
}, /* Receive_NOTIFICATION_message */
2116 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
2120 {bgp_ignore
, Clearing
}, /* BGP_Start */
2121 {bgp_stop
, Clearing
}, /* BGP_Stop */
2122 {bgp_stop
, Clearing
}, /* TCP_connection_open */
2123 {bgp_stop
, Clearing
}, /* TCP_connection_closed */
2124 {bgp_stop
, Clearing
}, /* TCP_connection_open_failed */
2125 {bgp_stop
, Clearing
}, /* TCP_fatal_error */
2126 {bgp_stop
, Clearing
}, /* ConnectRetry_timer_expired */
2127 {bgp_stop
, Clearing
}, /* Hold_Timer_expired */
2128 {bgp_stop
, Clearing
}, /* KeepAlive_timer_expired */
2129 {bgp_stop
, Clearing
}, /* Receive_OPEN_message */
2130 {bgp_stop
, Clearing
}, /* Receive_KEEPALIVE_message */
2131 {bgp_stop
, Clearing
}, /* Receive_UPDATE_message */
2132 {bgp_stop
, Clearing
}, /* Receive_NOTIFICATION_message */
2133 {bgp_clearing_completed
, Idle
}, /* Clearing_Completed */
2137 {bgp_ignore
, Deleted
}, /* BGP_Start */
2138 {bgp_ignore
, Deleted
}, /* BGP_Stop */
2139 {bgp_ignore
, Deleted
}, /* TCP_connection_open */
2140 {bgp_ignore
, Deleted
}, /* TCP_connection_closed */
2141 {bgp_ignore
, Deleted
}, /* TCP_connection_open_failed */
2142 {bgp_ignore
, Deleted
}, /* TCP_fatal_error */
2143 {bgp_ignore
, Deleted
}, /* ConnectRetry_timer_expired */
2144 {bgp_ignore
, Deleted
}, /* Hold_Timer_expired */
2145 {bgp_ignore
, Deleted
}, /* KeepAlive_timer_expired */
2146 {bgp_ignore
, Deleted
}, /* Receive_OPEN_message */
2147 {bgp_ignore
, Deleted
}, /* Receive_KEEPALIVE_message */
2148 {bgp_ignore
, Deleted
}, /* Receive_UPDATE_message */
2149 {bgp_ignore
, Deleted
}, /* Receive_NOTIFICATION_message */
2150 {bgp_ignore
, Deleted
}, /* Clearing_Completed */
2154 /* Execute event process. */
2155 int bgp_event(struct thread
*thread
)
2161 peer
= THREAD_ARG(thread
);
2162 event
= THREAD_VAL(thread
);
2164 ret
= bgp_event_update(peer
, event
);
2169 int bgp_event_update(struct peer
*peer
, int event
)
2174 int passive_conn
= 0;
2177 /* default return code */
2178 ret
= FSM_PEER_NOOP
;
2180 other
= peer
->doppelganger
;
2182 (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)) ? 1 : 0;
2183 dyn_nbr
= peer_dynamic_neighbor(peer
);
2185 /* Logging this event. */
2186 next
= FSM
[peer
->status
- 1][event
- 1].next_state
;
2188 if (bgp_debug_neighbor_events(peer
) && peer
->status
!= next
)
2189 zlog_debug("%s [FSM] %s (%s->%s), fd %d", peer
->host
,
2190 bgp_event_str
[event
],
2191 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
2192 lookup_msg(bgp_status_msg
, next
, NULL
), peer
->fd
);
2194 peer
->last_event
= peer
->cur_event
;
2195 peer
->cur_event
= event
;
2197 /* Call function. */
2198 if (FSM
[peer
->status
- 1][event
- 1].func
)
2199 ret
= (*(FSM
[peer
->status
- 1][event
- 1].func
))(peer
);
2202 if (ret
== 1 && next
== Established
) {
2203 /* The case when doppelganger swap accurred in
2205 Update the peer pointer accordingly */
2206 ret
= FSM_PEER_TRANSFERRED
;
2210 /* If status is changed. */
2211 if (next
!= peer
->status
) {
2212 bgp_fsm_change_status(peer
, next
);
2215 * If we're going to ESTABLISHED then we executed a
2216 * peer transfer. In this case we can either return
2217 * FSM_PEER_TRANSITIONED or FSM_PEER_TRANSFERRED.
2218 * Opting for TRANSFERRED since transfer implies
2219 * session establishment.
2221 if (ret
!= FSM_PEER_TRANSFERRED
)
2222 ret
= FSM_PEER_TRANSITIONED
;
2225 /* Make sure timer is set. */
2226 bgp_timer_set(peer
);
2230 * If we got a return value of -1, that means there was an
2231 * error, restart the FSM. Since bgp_stop() was called on the
2232 * peer. only a few fields are safe to access here. In any case
2233 * we need to indicate that the peer was stopped in the return
2236 if (!dyn_nbr
&& !passive_conn
&& peer
->bgp
) {
2239 "%s [FSM] Failure handling event %s in state %s, "
2240 "prior events %s, %s, fd %d",
2241 peer
->host
, bgp_event_str
[peer
->cur_event
],
2242 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
2243 bgp_event_str
[peer
->last_event
],
2244 bgp_event_str
[peer
->last_major_event
],
2247 bgp_fsm_change_status(peer
, Idle
);
2248 bgp_timer_set(peer
);
2250 ret
= FSM_PEER_STOPPED
;
2257 int bgp_gr_lookup_n_update_all_peer(struct bgp
*bgp
,
2258 enum global_mode global_new_state
,
2259 enum global_mode global_old_state
)
2261 struct peer
*peer
= {0};
2262 struct listnode
*node
= {0};
2263 struct listnode
*nnode
= {0};
2264 enum peer_mode peer_old_state
= PEER_INVALID
;
2266 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
2268 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2270 "%s [BGP_GR] Peer: (%s) :",
2271 __func__
, peer
->host
);
2273 peer_old_state
= bgp_peer_gr_mode_get(peer
);
2275 if (peer_old_state
== PEER_GLOBAL_INHERIT
) {
2278 *Reset only these peers and send a
2279 *new open message with the change capabilities.
2280 *Considering the mode to be "global_new_state" and
2281 *do all operation accordingly
2284 switch (global_new_state
) {
2286 BGP_PEER_GR_HELPER_ENABLE(peer
);
2289 BGP_PEER_GR_ENABLE(peer
);
2291 case GLOBAL_DISABLE
:
2292 BGP_PEER_GR_DISABLE(peer
);
2294 case GLOBAL_INVALID
:
2296 "%s [BGP_GR] GLOBAL_INVALID",
2298 return BGP_ERR_GR_OPERATION_FAILED
;
2303 bgp
->global_gr_present_state
= global_new_state
;
2305 return BGP_GR_SUCCESS
;
2308 int bgp_gr_update_all(struct bgp
*bgp
, int global_gr_cmd
)
2310 enum global_mode global_new_state
= GLOBAL_INVALID
;
2311 enum global_mode global_old_state
= GLOBAL_INVALID
;
2313 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2315 "%s [BGP_GR]START: global_gr_cmd :%s:",
2316 __func__
, print_global_gr_cmd(global_gr_cmd
));
2318 global_old_state
= bgp_global_gr_mode_get(bgp
);
2320 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2322 "[BGP_GR] global_old_gr_state :%s:",
2323 print_global_gr_mode(global_old_state
));
2325 if (global_old_state
!= GLOBAL_INVALID
) {
2327 bgp
->GLOBAL_GR_FSM
[global_old_state
][global_gr_cmd
];
2329 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2331 "[BGP_GR] global_new_gr_state :%s:",
2332 print_global_gr_mode(global_new_state
));
2335 "%s [BGP_GR] global_old_state == GLOBAL_INVALID",
2337 return BGP_ERR_GR_OPERATION_FAILED
;
2340 if (global_new_state
== GLOBAL_INVALID
) {
2342 "%s [BGP_GR] global_new_state == GLOBAL_INVALID",
2344 return BGP_ERR_GR_INVALID_CMD
;
2346 if (global_new_state
== global_old_state
) {
2348 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2350 "%s [BGP_GR] global_new_state == global_old_state :%s",
2351 __func__
, print_global_gr_mode(global_new_state
));
2352 return BGP_GR_NO_OPERATION
;
2355 return bgp_gr_lookup_n_update_all_peer(bgp
,
2360 const char *print_peer_gr_mode(enum peer_mode pr_mode
)
2362 const char *peer_gr_mode
= NULL
;
2366 peer_gr_mode
= "PEER_HELPER";
2369 peer_gr_mode
= "PEER_GR";
2372 peer_gr_mode
= "PEER_DISABLE";
2375 peer_gr_mode
= "PEER_INVALID";
2377 case PEER_GLOBAL_INHERIT
:
2378 peer_gr_mode
= "PEER_GLOBAL_INHERIT";
2382 return peer_gr_mode
;
2385 const char *print_peer_gr_cmd(enum peer_gr_command pr_gr_cmd
)
2387 const char *peer_gr_cmd
= NULL
;
2389 switch (pr_gr_cmd
) {
2391 peer_gr_cmd
= "PEER_GR_CMD";
2393 case NO_PEER_GR_CMD
:
2394 peer_gr_cmd
= "NO_PEER_GR_CMD";
2396 case PEER_DISABLE_CMD
:
2397 peer_gr_cmd
= "PEER_GR_CMD";
2399 case NO_PEER_DISABLE_CMD
:
2400 peer_gr_cmd
= "NO_PEER_GR_CMD";
2402 case PEER_HELPER_CMD
:
2403 peer_gr_cmd
= "PEER_HELPER_CMD";
2405 case NO_PEER_HELPER_CMD
:
2406 peer_gr_cmd
= "NO_PEER_HELPER_CMD";
2413 const char *print_global_gr_mode(enum global_mode gl_mode
)
2415 const char *global_gr_mode
= NULL
;
2419 global_gr_mode
= "GLOBAL_HELPER";
2422 global_gr_mode
= "GLOBAL_GR";
2424 case GLOBAL_DISABLE
:
2425 global_gr_mode
= "GLOBAL_DISABLE";
2427 case GLOBAL_INVALID
:
2428 global_gr_mode
= "GLOBAL_INVALID";
2432 return global_gr_mode
;
2435 const char *print_global_gr_cmd(enum global_gr_command gl_gr_cmd
)
2437 const char *global_gr_cmd
= NULL
;
2439 switch (gl_gr_cmd
) {
2441 global_gr_cmd
= "GLOBAL_GR_CMD";
2443 case NO_GLOBAL_GR_CMD
:
2444 global_gr_cmd
= "NO_GLOBAL_GR_CMD";
2446 case GLOBAL_DISABLE_CMD
:
2447 global_gr_cmd
= "GLOBAL_DISABLE_CMD";
2449 case NO_GLOBAL_DISABLE_CMD
:
2450 global_gr_cmd
= "NO_GLOBAL_DISABLE_CMD";
2454 return global_gr_cmd
;
2457 enum global_mode
bgp_global_gr_mode_get(struct bgp
*bgp
)
2459 return bgp
->global_gr_present_state
;
2462 enum peer_mode
bgp_peer_gr_mode_get(struct peer
*peer
)
2464 return peer
->peer_gr_present_state
;
2467 int bgp_neighbor_graceful_restart(struct peer
*peer
,
2470 enum peer_mode peer_new_state
= PEER_INVALID
;
2471 enum peer_mode peer_old_state
= PEER_INVALID
;
2472 struct bgp_peer_gr peer_state
;
2473 int result
= BGP_GR_FAILURE
;
2476 * fetch peer_old_state from peer structure also
2477 * fetch global_old_state from bgp structure,
2478 * peer had a back pointer to bgpo struct ;
2481 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2483 "%s [BGP_GR] START:Peer: (%s) : peer_gr_cmd :%s:",
2484 __func__
, peer
->host
, print_peer_gr_cmd(peer_gr_cmd
));
2486 peer_old_state
= bgp_peer_gr_mode_get(peer
);
2488 if (peer_old_state
== PEER_INVALID
) {
2490 "[BGP_GR] peer_old_state == Invalid state !");
2491 return BGP_ERR_GR_OPERATION_FAILED
;
2494 peer_state
= peer
->PEER_GR_FSM
[peer_old_state
][peer_gr_cmd
];
2495 peer_new_state
= peer_state
.next_state
;
2497 if (peer_new_state
== PEER_INVALID
) {
2499 "[BGP_GR] Invalid bgp graceful restart command used !");
2500 return BGP_ERR_GR_INVALID_CMD
;
2503 if (peer_new_state
!= peer_old_state
) {
2504 result
= peer_state
.action_fun(peer
,
2508 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2510 "[BGP_GR] peer_old_state == peer_new_state !");
2511 return BGP_GR_NO_OPERATION
;
2514 if (result
== BGP_GR_SUCCESS
) {
2516 /* Update the mode i.e peer_new_state into the peer structure */
2517 peer
->peer_gr_present_state
= peer_new_state
;
2518 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2519 zlog_debug("[BGP_GR] Succesfully change the state of the peer to : %s : !",
2520 print_peer_gr_mode(peer_new_state
));
2522 return BGP_GR_SUCCESS
;
2528 unsigned int bgp_peer_gr_action(struct peer
*peer
,
2529 int old_peer_state
, int new_peer_state
)
2531 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2533 "%s [BGP_GR] Move peer from old_peer_state :%s: to new_peer_state :%s: !!!!",
2534 __func__
, print_peer_gr_mode(old_peer_state
),
2535 print_peer_gr_mode(new_peer_state
));
2537 int bgp_gr_global_mode
= GLOBAL_INVALID
;
2538 unsigned int ret
= BGP_GR_FAILURE
;
2540 if (old_peer_state
== new_peer_state
) {
2541 /* Nothing to do over here as the present and old state is the same */
2542 return BGP_GR_NO_OPERATION
;
2544 if ((old_peer_state
== PEER_INVALID
) ||
2545 (new_peer_state
== PEER_INVALID
)) {
2546 /* something bad happend , print error message */
2547 return BGP_ERR_GR_INVALID_CMD
;
2550 bgp_gr_global_mode
= bgp_global_gr_mode_get(peer
->bgp
);
2552 if ((old_peer_state
== PEER_GLOBAL_INHERIT
) &&
2553 (new_peer_state
!= PEER_GLOBAL_INHERIT
)) {
2555 /* fetch the Mode running in the Global state machine
2556 *from the bgp structure into a variable called
2560 /* Here we are checking if the
2561 *1. peer_new_state == global_mode == helper_mode
2562 *2. peer_new_state == global_mode == GR_mode
2563 *3. peer_new_state == global_mode == disabled_mode
2566 BGP_PEER_GR_GLOBAL_INHERIT_UNSET(peer
);
2568 if (new_peer_state
== bgp_gr_global_mode
) {
2569 /*This is incremental updates i.e no tear down
2570 *of the existing session
2571 *as the peer is already working in the same mode.
2573 ret
= BGP_GR_SUCCESS
;
2575 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2577 "[BGP_GR] Peer state changed from :%s ",
2578 print_peer_gr_mode(old_peer_state
));
2580 bgp_peer_move_to_gr_mode(peer
, new_peer_state
);
2582 ret
= BGP_GR_SUCCESS
;
2585 /* In the case below peer is going into Global inherit mode i.e.
2586 * the peer would work as the mode configured at the global level
2588 else if ((new_peer_state
== PEER_GLOBAL_INHERIT
) &&
2589 (old_peer_state
!= PEER_GLOBAL_INHERIT
)) {
2590 /* Here in this case it would be destructive
2591 * in all the cases except one case when,
2592 * Global GR is configured Disabled
2593 * and present_peer_state is not disable
2596 BGP_PEER_GR_GLOBAL_INHERIT_SET(peer
);
2598 if (old_peer_state
== bgp_gr_global_mode
) {
2600 /* This is incremental updates
2601 *i.e no tear down of the existing session
2602 *as the peer is already working in the same mode.
2604 ret
= BGP_GR_SUCCESS
;
2606 /* Destructive always */
2607 /* Tear down the old session
2608 * and send the new capability
2609 * as per the bgp_gr_global_mode
2612 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2613 zlog_debug("[BGP_GR] Peer state changed from :%s",
2614 print_peer_gr_mode(old_peer_state
));
2616 bgp_peer_move_to_gr_mode(peer
, bgp_gr_global_mode
);
2618 ret
= BGP_GR_SUCCESS
;
2622 *This else case, it include all the cases except -->
2623 *(new_peer_state != Peer_Global) &&
2624 *( old_peer_state != Peer_Global )
2626 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2627 zlog_debug("[BGP_GR] Peer state changed from :%s",
2628 print_peer_gr_mode(old_peer_state
));
2630 bgp_peer_move_to_gr_mode(peer
, new_peer_state
);
2632 ret
= BGP_GR_SUCCESS
;
2638 inline void bgp_peer_move_to_gr_mode(struct peer
*peer
, int new_state
)
2641 int bgp_global_gr_mode
= bgp_global_gr_mode_get(peer
->bgp
);
2643 switch (new_state
) {
2645 BGP_PEER_GR_HELPER_ENABLE(peer
);
2648 BGP_PEER_GR_ENABLE(peer
);
2651 BGP_PEER_GR_DISABLE(peer
);
2653 case PEER_GLOBAL_INHERIT
:
2654 BGP_PEER_GR_GLOBAL_INHERIT_SET(peer
);
2656 if (bgp_global_gr_mode
== GLOBAL_HELPER
) {
2657 BGP_PEER_GR_HELPER_ENABLE(peer
);
2658 } else if (bgp_global_gr_mode
== GLOBAL_GR
) {
2659 BGP_PEER_GR_ENABLE(peer
);
2660 } else if (bgp_global_gr_mode
== GLOBAL_DISABLE
) {
2661 BGP_PEER_GR_DISABLE(peer
);
2664 "[BGP_GR] Default switch inherit mode ::: SOMETHING IS WRONG !!!");
2668 zlog_err("[BGP_GR] Default switch mode ::: SOMETHING IS WRONG !!!");
2671 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2672 zlog_debug("[BGP_GR] Peer state changed --to--> : %d : !",
2676 void bgp_peer_gr_flags_update(struct peer
*peer
)
2678 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2680 "%s [BGP_GR] called !",
2682 if (CHECK_FLAG(peer
->peer_gr_new_status_flag
,
2683 PEER_GRACEFUL_RESTART_NEW_STATE_HELPER
))
2684 SET_FLAG(peer
->flags
,
2685 PEER_FLAG_GRACEFUL_RESTART_HELPER
);
2687 UNSET_FLAG(peer
->flags
,
2688 PEER_FLAG_GRACEFUL_RESTART_HELPER
);
2689 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2691 "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_HELPER : %s : !",
2693 (CHECK_FLAG(peer
->flags
,
2694 PEER_FLAG_GRACEFUL_RESTART_HELPER
) ?
2696 if (CHECK_FLAG(peer
->peer_gr_new_status_flag
,
2697 PEER_GRACEFUL_RESTART_NEW_STATE_RESTART
))
2698 SET_FLAG(peer
->flags
,
2699 PEER_FLAG_GRACEFUL_RESTART
);
2701 UNSET_FLAG(peer
->flags
,
2702 PEER_FLAG_GRACEFUL_RESTART
);
2703 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2705 "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !",
2707 (CHECK_FLAG(peer
->flags
,
2708 PEER_FLAG_GRACEFUL_RESTART
) ?
2710 if (CHECK_FLAG(peer
->peer_gr_new_status_flag
,
2711 PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT
))
2712 SET_FLAG(peer
->flags
,
2713 PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT
);
2715 UNSET_FLAG(peer
->flags
,
2716 PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT
);
2717 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
2719 "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT : %s : !",
2721 (CHECK_FLAG(peer
->flags
,
2722 PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT
) ?
2725 if (!CHECK_FLAG(peer
->flags
,
2726 PEER_FLAG_GRACEFUL_RESTART
) &&
2727 !CHECK_FLAG(peer
->flags
,
2728 PEER_FLAG_GRACEFUL_RESTART_HELPER
)){
2730 "[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_MODE!",
2733 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2735 if (CHECK_FLAG(peer
->sflags
,
2736 PEER_STATUS_NSF_WAIT
)) {
2738 peer_nsf_stop(peer
);
2740 "[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_WAIT!",