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_established
, (struct peer
* peer
), (peer
))
62 /* Definition of display strings corresponding to FSM events. This should be
63 * kept consistent with the events defined in bgpd.h
65 static const char *bgp_event_str
[] = {
69 "TCP_connection_open",
70 "TCP_connection_closed",
71 "TCP_connection_open_failed",
73 "ConnectRetry_timer_expired",
75 "KeepAlive_timer_expired",
76 "Receive_OPEN_message",
77 "Receive_KEEPALIVE_message",
78 "Receive_UPDATE_message",
79 "Receive_NOTIFICATION_message",
83 /* BGP FSM (finite state machine) has three types of functions. Type
84 one is thread functions. Type two is event functions. Type three
85 is FSM functions. Timer functions are set by bgp_timer_set
88 /* BGP event function. */
89 int bgp_event(struct thread
*);
91 /* BGP thread functions. */
92 static int bgp_start_timer(struct thread
*);
93 static int bgp_connect_timer(struct thread
*);
94 static int bgp_holdtime_timer(struct thread
*);
96 /* BGP FSM functions. */
97 static int bgp_start(struct peer
*);
99 static void peer_xfer_stats(struct peer
*peer_dst
, struct peer
*peer_src
)
101 /* Copy stats over. These are only the pre-established state stats */
102 peer_dst
->open_in
+= peer_src
->open_in
;
103 peer_dst
->open_out
+= peer_src
->open_out
;
104 peer_dst
->keepalive_in
+= peer_src
->keepalive_in
;
105 peer_dst
->keepalive_out
+= peer_src
->keepalive_out
;
106 peer_dst
->notify_in
+= peer_src
->notify_in
;
107 peer_dst
->notify_out
+= peer_src
->notify_out
;
108 peer_dst
->dynamic_cap_in
+= peer_src
->dynamic_cap_in
;
109 peer_dst
->dynamic_cap_out
+= peer_src
->dynamic_cap_out
;
112 static struct peer
*peer_xfer_conn(struct peer
*from_peer
)
119 unsigned char last_evt
, last_maj_evt
;
121 assert(from_peer
!= NULL
);
123 peer
= from_peer
->doppelganger
;
125 if (!peer
|| !CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
129 * Let's check that we are not going to loose known configuration
130 * state based upon doppelganger rules.
132 FOREACH_AFI_SAFI (afi
, safi
) {
133 if (from_peer
->afc
[afi
][safi
] != peer
->afc
[afi
][safi
]) {
135 EC_BGP_DOPPELGANGER_CONFIG
,
136 "from_peer->afc[%d][%d] is not the same as what we are overwriting",
142 if (bgp_debug_neighbor_events(peer
))
143 zlog_debug("%s: peer transfer %p fd %d -> %p fd %d)",
144 from_peer
->host
, from_peer
, from_peer
->fd
, peer
,
147 bgp_writes_off(peer
);
149 bgp_writes_off(from_peer
);
150 bgp_reads_off(from_peer
);
152 BGP_TIMER_OFF(peer
->t_routeadv
);
153 BGP_TIMER_OFF(peer
->t_connect
);
154 BGP_TIMER_OFF(peer
->t_connect_check_r
);
155 BGP_TIMER_OFF(peer
->t_connect_check_w
);
156 BGP_TIMER_OFF(from_peer
->t_routeadv
);
157 BGP_TIMER_OFF(from_peer
->t_connect
);
158 BGP_TIMER_OFF(from_peer
->t_connect_check_r
);
159 BGP_TIMER_OFF(from_peer
->t_connect_check_w
);
160 BGP_TIMER_OFF(from_peer
->t_process_packet
);
163 * At this point in time, it is possible that there are packets pending
164 * on various buffers. Those need to be transferred or dropped,
165 * otherwise we'll get spurious failures during session establishment.
167 pthread_mutex_lock(&peer
->io_mtx
);
168 pthread_mutex_lock(&from_peer
->io_mtx
);
171 peer
->fd
= from_peer
->fd
;
174 stream_fifo_clean(peer
->ibuf
);
175 stream_fifo_clean(peer
->obuf
);
178 * this should never happen, since bgp_process_packet() is the
179 * only task that sets and unsets the current packet and it
180 * runs in our pthread.
185 "[%s] Dropping pending packet on connection transfer:",
187 uint16_t type
= stream_getc_from(peer
->curr
,
188 BGP_MARKER_SIZE
+ 2);
189 bgp_dump_packet(peer
, type
, peer
->curr
);
190 stream_free(peer
->curr
);
194 // copy each packet from old peer's output queue to new peer
195 while (from_peer
->obuf
->head
)
196 stream_fifo_push(peer
->obuf
,
197 stream_fifo_pop(from_peer
->obuf
));
199 // copy each packet from old peer's input queue to new peer
200 while (from_peer
->ibuf
->head
)
201 stream_fifo_push(peer
->ibuf
,
202 stream_fifo_pop(from_peer
->ibuf
));
204 ringbuf_wipe(peer
->ibuf_work
);
205 ringbuf_copy(peer
->ibuf_work
, from_peer
->ibuf_work
,
206 ringbuf_remain(from_peer
->ibuf_work
));
208 pthread_mutex_unlock(&from_peer
->io_mtx
);
209 pthread_mutex_unlock(&peer
->io_mtx
);
211 peer
->as
= from_peer
->as
;
212 peer
->v_holdtime
= from_peer
->v_holdtime
;
213 peer
->v_keepalive
= from_peer
->v_keepalive
;
214 peer
->v_routeadv
= from_peer
->v_routeadv
;
215 peer
->v_gr_restart
= from_peer
->v_gr_restart
;
216 peer
->cap
= from_peer
->cap
;
217 status
= peer
->status
;
218 pstatus
= peer
->ostatus
;
219 last_evt
= peer
->last_event
;
220 last_maj_evt
= peer
->last_major_event
;
221 peer
->status
= from_peer
->status
;
222 peer
->ostatus
= from_peer
->ostatus
;
223 peer
->last_event
= from_peer
->last_event
;
224 peer
->last_major_event
= from_peer
->last_major_event
;
225 from_peer
->status
= status
;
226 from_peer
->ostatus
= pstatus
;
227 from_peer
->last_event
= last_evt
;
228 from_peer
->last_major_event
= last_maj_evt
;
229 peer
->remote_id
= from_peer
->remote_id
;
231 if (from_peer
->hostname
!= NULL
) {
232 if (peer
->hostname
) {
233 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
234 peer
->hostname
= NULL
;
237 peer
->hostname
= from_peer
->hostname
;
238 from_peer
->hostname
= NULL
;
241 if (from_peer
->domainname
!= NULL
) {
242 if (peer
->domainname
) {
243 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
244 peer
->domainname
= NULL
;
247 peer
->domainname
= from_peer
->domainname
;
248 from_peer
->domainname
= NULL
;
251 FOREACH_AFI_SAFI (afi
, safi
) {
252 peer
->af_flags
[afi
][safi
] = from_peer
->af_flags
[afi
][safi
];
253 peer
->af_sflags
[afi
][safi
] = from_peer
->af_sflags
[afi
][safi
];
254 peer
->af_cap
[afi
][safi
] = from_peer
->af_cap
[afi
][safi
];
255 peer
->afc_nego
[afi
][safi
] = from_peer
->afc_nego
[afi
][safi
];
256 peer
->afc_adv
[afi
][safi
] = from_peer
->afc_adv
[afi
][safi
];
257 peer
->afc_recv
[afi
][safi
] = from_peer
->afc_recv
[afi
][safi
];
258 peer
->orf_plist
[afi
][safi
] = from_peer
->orf_plist
[afi
][safi
];
261 if (bgp_getsockname(peer
) < 0) {
264 "%%bgp_getsockname() failed for %s peer %s fd %d (from_peer fd %d)",
265 (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)
268 peer
->host
, peer
->fd
, from_peer
->fd
);
273 if (from_peer
->status
> Active
) {
274 if (bgp_getsockname(from_peer
) < 0) {
277 "%%bgp_getsockname() failed for %s from_peer %s fd %d (peer fd %d)",
279 (CHECK_FLAG(from_peer
->sflags
,
280 PEER_STATUS_ACCEPT_PEER
)
283 from_peer
->host
, from_peer
->fd
, peer
->fd
);
290 // Note: peer_xfer_stats() must be called with I/O turned OFF
292 peer_xfer_stats(peer
, from_peer
);
296 thread_add_timer_msec(bm
->master
, bgp_process_packet
, peer
, 0,
297 &peer
->t_process_packet
);
302 /* Hook function called after bgp event is occered. And vty's
303 neighbor command invoke this function after making neighbor
305 void bgp_timer_set(struct peer
*peer
)
307 switch (peer
->status
) {
309 /* First entry point of peer's finite state machine. In Idle
310 status start timer is on unless peer is shutdown or peer is
311 inactive. All other timer must be turned off */
312 if (BGP_PEER_START_SUPPRESSED(peer
) || !peer_active(peer
)
313 || (peer
->bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
&&
314 peer
->bgp
->vrf_id
== VRF_UNKNOWN
)) {
315 BGP_TIMER_OFF(peer
->t_start
);
317 BGP_TIMER_ON(peer
->t_start
, bgp_start_timer
,
320 BGP_TIMER_OFF(peer
->t_connect
);
321 BGP_TIMER_OFF(peer
->t_holdtime
);
322 bgp_keepalives_off(peer
);
323 BGP_TIMER_OFF(peer
->t_routeadv
);
327 /* After start timer is expired, the peer moves to Connect
328 status. Make sure start timer is off and connect timer is
330 BGP_TIMER_OFF(peer
->t_start
);
331 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
333 BGP_TIMER_OFF(peer
->t_holdtime
);
334 bgp_keepalives_off(peer
);
335 BGP_TIMER_OFF(peer
->t_routeadv
);
339 /* Active is waiting connection from remote peer. And if
340 connect timer is expired, change status to Connect. */
341 BGP_TIMER_OFF(peer
->t_start
);
342 /* If peer is passive mode, do not set connect timer. */
343 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)
344 || CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
345 BGP_TIMER_OFF(peer
->t_connect
);
347 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
350 BGP_TIMER_OFF(peer
->t_holdtime
);
351 bgp_keepalives_off(peer
);
352 BGP_TIMER_OFF(peer
->t_routeadv
);
356 /* OpenSent status. */
357 BGP_TIMER_OFF(peer
->t_start
);
358 BGP_TIMER_OFF(peer
->t_connect
);
359 if (peer
->v_holdtime
!= 0) {
360 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
363 BGP_TIMER_OFF(peer
->t_holdtime
);
365 bgp_keepalives_off(peer
);
366 BGP_TIMER_OFF(peer
->t_routeadv
);
370 /* OpenConfirm status. */
371 BGP_TIMER_OFF(peer
->t_start
);
372 BGP_TIMER_OFF(peer
->t_connect
);
374 /* If the negotiated Hold Time value is zero, then the Hold Time
375 timer and KeepAlive timers are not started. */
376 if (peer
->v_holdtime
== 0) {
377 BGP_TIMER_OFF(peer
->t_holdtime
);
378 bgp_keepalives_off(peer
);
380 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
382 bgp_keepalives_on(peer
);
384 BGP_TIMER_OFF(peer
->t_routeadv
);
388 /* In Established status start and connect timer is turned
390 BGP_TIMER_OFF(peer
->t_start
);
391 BGP_TIMER_OFF(peer
->t_connect
);
393 /* Same as OpenConfirm, if holdtime is zero then both holdtime
394 and keepalive must be turned off. */
395 if (peer
->v_holdtime
== 0) {
396 BGP_TIMER_OFF(peer
->t_holdtime
);
397 bgp_keepalives_off(peer
);
399 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
401 bgp_keepalives_on(peer
);
405 BGP_TIMER_OFF(peer
->t_gr_restart
);
406 BGP_TIMER_OFF(peer
->t_gr_stale
);
407 BGP_TIMER_OFF(peer
->t_pmax_restart
);
410 BGP_TIMER_OFF(peer
->t_start
);
411 BGP_TIMER_OFF(peer
->t_connect
);
412 BGP_TIMER_OFF(peer
->t_holdtime
);
413 bgp_keepalives_off(peer
);
414 BGP_TIMER_OFF(peer
->t_routeadv
);
419 /* BGP start timer. This function set BGP_Start event to thread value
420 and process event. */
421 static int bgp_start_timer(struct thread
*thread
)
425 peer
= THREAD_ARG(thread
);
426 peer
->t_start
= NULL
;
428 if (bgp_debug_neighbor_events(peer
))
429 zlog_debug("%s [FSM] Timer (start timer expire).", peer
->host
);
431 THREAD_VAL(thread
) = BGP_Start
;
432 bgp_event(thread
); /* bgp_event unlocks peer */
437 /* BGP connect retry timer. */
438 static int bgp_connect_timer(struct thread
*thread
)
443 peer
= THREAD_ARG(thread
);
445 assert(!peer
->t_write
);
446 assert(!peer
->t_read
);
448 peer
->t_connect
= NULL
;
450 if (bgp_debug_neighbor_events(peer
))
451 zlog_debug("%s [FSM] Timer (connect timer expire)", peer
->host
);
453 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)) {
457 THREAD_VAL(thread
) = ConnectRetry_timer_expired
;
458 bgp_event(thread
); /* bgp_event unlocks peer */
465 /* BGP holdtime timer. */
466 static int bgp_holdtime_timer(struct thread
*thread
)
470 peer
= THREAD_ARG(thread
);
471 peer
->t_holdtime
= NULL
;
473 if (bgp_debug_neighbor_events(peer
))
474 zlog_debug("%s [FSM] Timer (holdtime timer expire)",
477 THREAD_VAL(thread
) = Hold_Timer_expired
;
478 bgp_event(thread
); /* bgp_event unlocks peer */
483 int bgp_routeadv_timer(struct thread
*thread
)
487 peer
= THREAD_ARG(thread
);
488 peer
->t_routeadv
= NULL
;
490 if (bgp_debug_neighbor_events(peer
))
491 zlog_debug("%s [FSM] Timer (routeadv timer expire)",
494 peer
->synctime
= bgp_clock();
496 thread_add_timer_msec(bm
->master
, bgp_generate_updgrp_packets
, peer
, 0,
497 &peer
->t_generate_updgrp_packets
);
499 /* MRAI timer will be started again when FIFO is built, no need to
505 /* BGP Peer Down Cause */
506 const char *peer_down_str
[] = {"",
510 "Cluster ID changed",
511 "Confederation identifier changed",
512 "Confederation peer changed",
513 "RR client config change",
514 "RS client config change",
515 "Update source change",
516 "Address family activated",
519 "BGP Notification received",
520 "BGP Notification send",
521 "Peer closed the session",
523 "Peer-group add member",
524 "Peer-group delete member",
525 "Capability changed",
526 "Passive config change",
527 "Multihop config change",
528 "NSF peer closed the session",
529 "Intf peering v6only config change",
532 "Neighbor address lost"};
534 static int bgp_graceful_restart_timer_expire(struct thread
*thread
)
540 peer
= THREAD_ARG(thread
);
541 peer
->t_gr_restart
= NULL
;
543 /* NSF delete stale route */
544 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
545 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
546 if (peer
->nsf
[afi
][safi
])
547 bgp_clear_stale_route(peer
, afi
, safi
);
549 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
550 BGP_TIMER_OFF(peer
->t_gr_stale
);
552 if (bgp_debug_neighbor_events(peer
)) {
553 zlog_debug("%s graceful restart timer expired", peer
->host
);
554 zlog_debug("%s graceful restart stalepath timer stopped",
563 static int bgp_graceful_stale_timer_expire(struct thread
*thread
)
569 peer
= THREAD_ARG(thread
);
570 peer
->t_gr_stale
= NULL
;
572 if (bgp_debug_neighbor_events(peer
))
573 zlog_debug("%s graceful restart stalepath timer expired",
576 /* NSF delete stale route */
577 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
578 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
579 if (peer
->nsf
[afi
][safi
])
580 bgp_clear_stale_route(peer
, afi
, safi
);
585 static int bgp_update_delay_applicable(struct bgp
*bgp
)
587 /* update_delay_over flag should be reset (set to 0) for any new
588 applicability of the update-delay during BGP process lifetime.
589 And it should be set after an occurence of the update-delay is
591 if (!bgp
->update_delay_over
)
597 int bgp_update_delay_active(struct bgp
*bgp
)
599 if (bgp
->t_update_delay
)
605 int bgp_update_delay_configured(struct bgp
*bgp
)
607 if (bgp
->v_update_delay
)
613 /* Do the post-processing needed when bgp comes out of the read-only mode
614 on ending the update delay. */
615 void bgp_update_delay_end(struct bgp
*bgp
)
617 THREAD_TIMER_OFF(bgp
->t_update_delay
);
618 THREAD_TIMER_OFF(bgp
->t_establish_wait
);
620 /* Reset update-delay related state */
621 bgp
->update_delay_over
= 1;
622 bgp
->established
= 0;
623 bgp
->restarted_peers
= 0;
624 bgp
->implicit_eors
= 0;
625 bgp
->explicit_eors
= 0;
627 quagga_timestamp(3, bgp
->update_delay_end_time
,
628 sizeof(bgp
->update_delay_end_time
));
631 * Add an end-of-initial-update marker to the main process queues so
633 * the route advertisement timer for the peers can be started. Also set
634 * the zebra and peer update hold flags. These flags are used to achieve
635 * three stages in the update-delay post processing:
636 * 1. Finish best-path selection for all the prefixes held on the
638 * (routes in BGP are updated, and peers sync queues are populated
640 * 2. As the eoiu mark is reached in the bgp process routine, ship all
642 * routes to zebra. With that zebra should see updates from BGP
645 * 3. Unblock the peer update writes. With that peer update packing
647 * the prefixes should be at its maximum.
649 bgp_add_eoiu_mark(bgp
);
650 bgp
->main_zebra_update_hold
= 1;
651 bgp
->main_peers_update_hold
= 1;
653 /* Resume the queue processing. This should trigger the event that would
655 care of processing any work that was queued during the read-only
657 work_queue_unplug(bm
->process_main_queue
);
663 void bgp_start_routeadv(struct bgp
*bgp
)
665 struct listnode
*node
, *nnode
;
668 zlog_info("bgp_start_routeadv(), update hold status %d",
669 bgp
->main_peers_update_hold
);
671 if (bgp
->main_peers_update_hold
)
674 quagga_timestamp(3, bgp
->update_delay_peers_resume_time
,
675 sizeof(bgp
->update_delay_peers_resume_time
));
677 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
678 if (peer
->status
!= Established
)
680 BGP_TIMER_OFF(peer
->t_routeadv
);
681 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
688 void bgp_adjust_routeadv(struct peer
*peer
)
690 time_t nowtime
= bgp_clock();
692 unsigned long remain
;
694 /* Bypass checks for special case of MRAI being 0 */
695 if (peer
->v_routeadv
== 0) {
696 /* Stop existing timer, just in case it is running for a
698 * duration and schedule write thread immediately.
700 if (peer
->t_routeadv
)
701 BGP_TIMER_OFF(peer
->t_routeadv
);
703 peer
->synctime
= bgp_clock();
704 thread_add_timer_msec(bm
->master
, bgp_generate_updgrp_packets
,
706 &peer
->t_generate_updgrp_packets
);
713 * If the last update was written more than MRAI back, expire the timer
714 * instantly so that we can send the update out sooner.
716 * <------- MRAI --------->
717 * |-----------------|-----------------------|
718 * <------------- m ------------>
727 diff
= difftime(nowtime
, peer
->last_update
);
728 if (diff
> (double)peer
->v_routeadv
) {
729 BGP_TIMER_OFF(peer
->t_routeadv
);
730 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
736 * - Find when to expire the MRAI timer.
737 * If MRAI timer is not active, assume we can start it now.
739 * <------- MRAI --------->
740 * |------------|-----------------------|
741 * <-------- m ----------><----- r ----->
750 if (peer
->t_routeadv
)
751 remain
= thread_timer_remain_second(peer
->t_routeadv
);
753 remain
= peer
->v_routeadv
;
754 diff
= peer
->v_routeadv
- diff
;
755 if (diff
<= (double)remain
) {
756 BGP_TIMER_OFF(peer
->t_routeadv
);
757 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, diff
);
761 static int bgp_maxmed_onstartup_applicable(struct bgp
*bgp
)
763 if (!bgp
->maxmed_onstartup_over
)
769 int bgp_maxmed_onstartup_configured(struct bgp
*bgp
)
771 if (bgp
->v_maxmed_onstartup
!= BGP_MAXMED_ONSTARTUP_UNCONFIGURED
)
777 int bgp_maxmed_onstartup_active(struct bgp
*bgp
)
779 if (bgp
->t_maxmed_onstartup
)
785 void bgp_maxmed_update(struct bgp
*bgp
)
787 uint8_t maxmed_active
;
788 uint32_t maxmed_value
;
790 if (bgp
->v_maxmed_admin
) {
792 maxmed_value
= bgp
->maxmed_admin_value
;
793 } else if (bgp
->t_maxmed_onstartup
) {
795 maxmed_value
= bgp
->maxmed_onstartup_value
;
798 maxmed_value
= BGP_MAXMED_VALUE_DEFAULT
;
801 if (bgp
->maxmed_active
!= maxmed_active
802 || bgp
->maxmed_value
!= maxmed_value
) {
803 bgp
->maxmed_active
= maxmed_active
;
804 bgp
->maxmed_value
= maxmed_value
;
806 update_group_announce(bgp
);
810 /* The maxmed onstartup timer expiry callback. */
811 static int bgp_maxmed_onstartup_timer(struct thread
*thread
)
815 zlog_info("Max med on startup ended - timer expired.");
817 bgp
= THREAD_ARG(thread
);
818 THREAD_TIMER_OFF(bgp
->t_maxmed_onstartup
);
819 bgp
->maxmed_onstartup_over
= 1;
821 bgp_maxmed_update(bgp
);
826 static void bgp_maxmed_onstartup_begin(struct bgp
*bgp
)
828 /* Applicable only once in the process lifetime on the startup */
829 if (bgp
->maxmed_onstartup_over
)
832 zlog_info("Begin maxmed onstartup mode - timer %d seconds",
833 bgp
->v_maxmed_onstartup
);
835 thread_add_timer(bm
->master
, bgp_maxmed_onstartup_timer
, bgp
,
836 bgp
->v_maxmed_onstartup
, &bgp
->t_maxmed_onstartup
);
838 if (!bgp
->v_maxmed_admin
) {
839 bgp
->maxmed_active
= 1;
840 bgp
->maxmed_value
= bgp
->maxmed_onstartup_value
;
843 /* Route announce to all peers should happen after this in
847 static void bgp_maxmed_onstartup_process_status_change(struct peer
*peer
)
849 if (peer
->status
== Established
&& !peer
->bgp
->established
) {
850 bgp_maxmed_onstartup_begin(peer
->bgp
);
854 /* The update delay timer expiry callback. */
855 static int bgp_update_delay_timer(struct thread
*thread
)
859 zlog_info("Update delay ended - timer expired.");
861 bgp
= THREAD_ARG(thread
);
862 THREAD_TIMER_OFF(bgp
->t_update_delay
);
863 bgp_update_delay_end(bgp
);
868 /* The establish wait timer expiry callback. */
869 static int bgp_establish_wait_timer(struct thread
*thread
)
873 zlog_info("Establish wait - timer expired.");
875 bgp
= THREAD_ARG(thread
);
876 THREAD_TIMER_OFF(bgp
->t_establish_wait
);
877 bgp_check_update_delay(bgp
);
882 /* Steps to begin the update delay:
883 - initialize queues if needed
884 - stop the queue processing
886 static void bgp_update_delay_begin(struct bgp
*bgp
)
888 struct listnode
*node
, *nnode
;
891 /* Stop the processing of queued work. Enqueue shall continue */
892 work_queue_plug(bm
->process_main_queue
);
894 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
895 peer
->update_delay_over
= 0;
897 /* Start the update-delay timer */
898 thread_add_timer(bm
->master
, bgp_update_delay_timer
, bgp
,
899 bgp
->v_update_delay
, &bgp
->t_update_delay
);
901 if (bgp
->v_establish_wait
!= bgp
->v_update_delay
)
902 thread_add_timer(bm
->master
, bgp_establish_wait_timer
, bgp
,
903 bgp
->v_establish_wait
, &bgp
->t_establish_wait
);
905 quagga_timestamp(3, bgp
->update_delay_begin_time
,
906 sizeof(bgp
->update_delay_begin_time
));
909 static void bgp_update_delay_process_status_change(struct peer
*peer
)
911 if (peer
->status
== Established
) {
912 if (!peer
->bgp
->established
++) {
913 bgp_update_delay_begin(peer
->bgp
);
915 "Begin read-only mode - update-delay timer %d seconds",
916 peer
->bgp
->v_update_delay
);
918 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
))
919 bgp_update_restarted_peers(peer
);
921 if (peer
->ostatus
== Established
922 && bgp_update_delay_active(peer
->bgp
)) {
923 /* Adjust the update-delay state to account for this flap.
924 NOTE: Intentionally skipping adjusting implicit_eors or
926 counters. Extra sanity check in bgp_check_update_delay()
928 be enough to take care of any additive discrepancy in bgp eor
930 peer
->bgp
->established
--;
931 peer
->update_delay_over
= 0;
935 /* Called after event occurred, this function change status and reset
936 read/write and timer thread. */
937 void bgp_fsm_change_status(struct peer
*peer
, int status
)
942 bgp_dump_state(peer
, peer
->status
, status
);
945 peer_count
= bgp
->established_peers
;
947 if (status
== Established
)
948 bgp
->established_peers
++;
949 else if ((peer
->status
== Established
) && (status
!= Established
))
950 bgp
->established_peers
--;
952 if (BGP_DEBUG(neighbor_events
, NEIGHBOR_EVENTS
))
953 zlog_debug("%s : vrf %u, established_peers %u", __func__
,
954 bgp
->vrf_id
, bgp
->established_peers
);
955 /* Set to router ID to the value provided by RIB if there are no peers
956 * in the established state and peer count did not change
958 if ((peer_count
!= bgp
->established_peers
) &&
959 (bgp
->established_peers
== 0))
960 bgp_router_id_zebra_bump(bgp
->vrf_id
, NULL
);
962 /* Transition into Clearing or Deleted must /always/ clear all routes..
963 * (and must do so before actually changing into Deleted..
965 if (status
>= Clearing
) {
966 bgp_clear_route_all(peer
);
968 /* If no route was queued for the clear-node processing,
970 * completion event here. This is needed because if there are no
972 * to trigger the background clear-node thread, the event won't
974 * generated and the peer would be stuck in Clearing. Note that
976 * event is for the peer and helps the peer transition out of
978 * state; it should not be generated per (AFI,SAFI). The event
980 * directly posted here without calling clear_node_complete() as
982 * shouldn't do an extra unlock. This event will get processed
984 * the state change that happens below, so peer will be in
988 if (!work_queue_is_scheduled(peer
->clear_node_queue
))
989 BGP_EVENT_ADD(peer
, Clearing_Completed
);
992 /* Preserve old status and change into new status. */
993 peer
->ostatus
= peer
->status
;
994 peer
->status
= status
;
996 /* Save event that caused status change. */
997 peer
->last_major_event
= peer
->cur_event
;
999 if (status
== Established
)
1000 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
1002 /* If max-med processing is applicable, do the necessary. */
1003 if (status
== Established
) {
1004 if (bgp_maxmed_onstartup_configured(peer
->bgp
)
1005 && bgp_maxmed_onstartup_applicable(peer
->bgp
))
1006 bgp_maxmed_onstartup_process_status_change(peer
);
1008 peer
->bgp
->maxmed_onstartup_over
= 1;
1011 /* If update-delay processing is applicable, do the necessary. */
1012 if (bgp_update_delay_configured(peer
->bgp
)
1013 && bgp_update_delay_applicable(peer
->bgp
))
1014 bgp_update_delay_process_status_change(peer
);
1016 if (bgp_debug_neighbor_events(peer
))
1017 zlog_debug("%s went from %s to %s", peer
->host
,
1018 lookup_msg(bgp_status_msg
, peer
->ostatus
, NULL
),
1019 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1022 /* Flush the event queue and ensure the peer is shut down */
1023 static int bgp_clearing_completed(struct peer
*peer
)
1025 int rc
= bgp_stop(peer
);
1028 BGP_EVENT_FLUSH(peer
);
1033 /* Administrative BGP peer stop event. */
1034 /* May be called multiple times for the same peer */
1035 int bgp_stop(struct peer
*peer
)
1039 char orf_name
[BUFSIZ
];
1042 if (peer_dynamic_neighbor(peer
)
1043 && !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
1044 if (bgp_debug_neighbor_events(peer
))
1045 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1050 /* Can't do this in Clearing; events are used for state transitions */
1051 if (peer
->status
!= Clearing
) {
1052 /* Delete all existing events of the peer */
1053 BGP_EVENT_FLUSH(peer
);
1056 /* Increment Dropped count. */
1057 if (peer
->status
== Established
) {
1060 /* bgp log-neighbor-changes of neighbor Down */
1061 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)) {
1062 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1064 "%%ADJCHANGE: neighbor %s(%s) in vrf %s Down %s",
1066 (peer
->hostname
) ? peer
->hostname
: "Unknown",
1067 vrf
? ((vrf
->vrf_id
!= VRF_DEFAULT
)
1071 peer_down_str
[(int)peer
->last_reset
]);
1074 /* graceful restart */
1075 if (peer
->t_gr_stale
) {
1076 BGP_TIMER_OFF(peer
->t_gr_stale
);
1077 if (bgp_debug_neighbor_events(peer
))
1079 "%s graceful restart stalepath timer stopped",
1082 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
1083 if (bgp_debug_neighbor_events(peer
)) {
1085 "%s graceful restart timer started for %d sec",
1086 peer
->host
, peer
->v_gr_restart
);
1088 "%s graceful restart stalepath timer started for %d sec",
1089 peer
->host
, peer
->bgp
->stalepath_time
);
1091 BGP_TIMER_ON(peer
->t_gr_restart
,
1092 bgp_graceful_restart_timer_expire
,
1093 peer
->v_gr_restart
);
1094 BGP_TIMER_ON(peer
->t_gr_stale
,
1095 bgp_graceful_stale_timer_expire
,
1096 peer
->bgp
->stalepath_time
);
1098 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1100 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1101 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
;
1103 peer
->nsf
[afi
][safi
] = 0;
1106 /* set last reset time */
1107 peer
->resettime
= peer
->uptime
= bgp_clock();
1109 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1110 zlog_debug("%s remove from all update group",
1112 update_group_remove_peer_afs(peer
);
1114 hook_call(peer_backward_transition
, peer
);
1116 /* Reset peer synctime */
1120 /* stop keepalives */
1121 bgp_keepalives_off(peer
);
1123 /* Stop read and write threads. */
1124 bgp_writes_off(peer
);
1125 bgp_reads_off(peer
);
1127 THREAD_OFF(peer
->t_connect_check_r
);
1128 THREAD_OFF(peer
->t_connect_check_w
);
1130 /* Stop all timers. */
1131 BGP_TIMER_OFF(peer
->t_start
);
1132 BGP_TIMER_OFF(peer
->t_connect
);
1133 BGP_TIMER_OFF(peer
->t_holdtime
);
1134 BGP_TIMER_OFF(peer
->t_routeadv
);
1136 /* Clear input and output buffer. */
1137 pthread_mutex_lock(&peer
->io_mtx
);
1140 stream_fifo_clean(peer
->ibuf
);
1142 stream_fifo_clean(peer
->obuf
);
1144 if (peer
->ibuf_work
)
1145 ringbuf_wipe(peer
->ibuf_work
);
1146 if (peer
->obuf_work
)
1147 stream_reset(peer
->obuf_work
);
1150 stream_free(peer
->curr
);
1154 pthread_mutex_unlock(&peer
->io_mtx
);
1156 /* Close of file descriptor. */
1157 if (peer
->fd
>= 0) {
1162 FOREACH_AFI_SAFI (afi
, safi
) {
1163 /* Reset all negotiated variables */
1164 peer
->afc_nego
[afi
][safi
] = 0;
1165 peer
->afc_adv
[afi
][safi
] = 0;
1166 peer
->afc_recv
[afi
][safi
] = 0;
1168 /* peer address family capability flags*/
1169 peer
->af_cap
[afi
][safi
] = 0;
1171 /* peer address family status flags*/
1172 peer
->af_sflags
[afi
][safi
] = 0;
1174 /* Received ORF prefix-filter */
1175 peer
->orf_plist
[afi
][safi
] = NULL
;
1177 if ((peer
->status
== OpenConfirm
)
1178 || (peer
->status
== Established
)) {
1179 /* ORF received prefix-filter pnt */
1180 sprintf(orf_name
, "%s.%d.%d", peer
->host
, afi
, safi
);
1181 prefix_bgp_orf_remove_all(afi
, orf_name
);
1185 /* Reset keepalive and holdtime */
1186 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER
)) {
1187 peer
->v_keepalive
= peer
->keepalive
;
1188 peer
->v_holdtime
= peer
->holdtime
;
1190 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
1191 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
1194 peer
->update_time
= 0;
1196 /* Until we are sure that there is no problem about prefix count
1197 this should be commented out.*/
1199 /* Reset prefix count */
1200 peer
->pcount
[AFI_IP
][SAFI_UNICAST
] = 0;
1201 peer
->pcount
[AFI_IP
][SAFI_MULTICAST
] = 0;
1202 peer
->pcount
[AFI_IP
][SAFI_LABELED_UNICAST
] = 0;
1203 peer
->pcount
[AFI_IP
][SAFI_MPLS_VPN
] = 0;
1204 peer
->pcount
[AFI_IP6
][SAFI_UNICAST
] = 0;
1205 peer
->pcount
[AFI_IP6
][SAFI_MULTICAST
] = 0;
1206 peer
->pcount
[AFI_IP6
][SAFI_LABELED_UNICAST
] = 0;
1209 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1210 && !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
1214 bgp_peer_conf_if_to_su_update(peer
);
1220 /* BGP peer is stoped by the error. */
1221 static int bgp_stop_with_error(struct peer
*peer
)
1223 /* Double start timer. */
1226 /* Overflow check. */
1227 if (peer
->v_start
>= (60 * 2))
1228 peer
->v_start
= (60 * 2);
1230 if (peer_dynamic_neighbor(peer
)) {
1231 if (bgp_debug_neighbor_events(peer
))
1232 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1237 return (bgp_stop(peer
));
1241 /* something went wrong, send notify and tear down */
1242 static int bgp_stop_with_notify(struct peer
*peer
, uint8_t code
,
1245 /* Send notify to remote peer */
1246 bgp_notify_send(peer
, code
, sub_code
);
1248 if (peer_dynamic_neighbor(peer
)) {
1249 if (bgp_debug_neighbor_events(peer
))
1250 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1255 /* Clear start timer value to default. */
1256 peer
->v_start
= BGP_INIT_START_TIMER
;
1258 return (bgp_stop(peer
));
1262 * Determines whether a TCP session has successfully established for a peer and
1263 * events as appropriate.
1265 * This function is called when setting up a new session. After connect() is
1266 * called on the peer's socket (in bgp_start()), the fd is passed to poll()
1267 * to wait for connection success or failure. When poll() returns, this
1268 * function is called to evaluate the result.
1270 * Due to differences in behavior of poll() on Linux and BSD - specifically,
1271 * the value of .revents in the case of a closed connection - this function is
1272 * scheduled both for a read and a write event. The write event is triggered
1273 * when the connection is established. A read event is triggered when the
1274 * connection is closed. Thus we need to cancel whichever one did not occur.
1276 static int bgp_connect_check(struct thread
*thread
)
1283 peer
= THREAD_ARG(thread
);
1284 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
1285 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
1286 assert(!peer
->t_read
);
1287 assert(!peer
->t_write
);
1289 THREAD_OFF(peer
->t_connect_check_r
);
1290 THREAD_OFF(peer
->t_connect_check_w
);
1292 /* Check file descriptor. */
1293 slen
= sizeof(status
);
1294 ret
= getsockopt(peer
->fd
, SOL_SOCKET
, SO_ERROR
, (void *)&status
,
1297 /* If getsockopt is fail, this is fatal error. */
1299 zlog_info("can't get sockopt for nonblocking connect: %d(%s)",
1300 errno
, safe_strerror(errno
));
1301 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1305 /* When status is 0 then TCP connection is established. */
1307 BGP_EVENT_ADD(peer
, TCP_connection_open
);
1310 if (bgp_debug_neighbor_events(peer
))
1311 zlog_debug("%s [Event] Connect failed %d(%s)",
1312 peer
->host
, status
, safe_strerror(status
));
1313 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1318 /* TCP connection open. Next we send open message to remote peer. And
1319 add read thread for reading open message. */
1320 static int bgp_connect_success(struct peer
*peer
)
1323 flog_err(EC_BGP_CONNECT
,
1324 "bgp_connect_success peer's fd is negative value %d",
1330 if (bgp_getsockname(peer
) < 0) {
1331 flog_err_sys(EC_LIB_SOCKET
,
1332 "%s: bgp_getsockname(): failed for peer %s, fd %d",
1333 __FUNCTION__
, peer
->host
, peer
->fd
);
1334 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
1335 0); /* internal error */
1336 bgp_writes_on(peer
);
1342 if (bgp_debug_neighbor_events(peer
)) {
1343 char buf1
[SU_ADDRSTRLEN
];
1345 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
1346 zlog_debug("%s open active, local address %s",
1348 sockunion2str(peer
->su_local
, buf1
,
1351 zlog_debug("%s passive open", peer
->host
);
1354 bgp_open_send(peer
);
1359 /* TCP connect fail */
1360 static int bgp_connect_fail(struct peer
*peer
)
1362 if (peer_dynamic_neighbor(peer
)) {
1363 if (bgp_debug_neighbor_events(peer
))
1364 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1369 return (bgp_stop(peer
));
1372 /* This function is the first starting point of all BGP connection. It
1373 try to connect to remote peer with non-blocking IO. */
1374 int bgp_start(struct peer
*peer
)
1379 bgp_peer_conf_if_to_su_update(peer
);
1381 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
) {
1382 if (bgp_debug_neighbor_events(peer
))
1384 "%s [FSM] Unable to get neighbor's IP address, waiting...",
1389 if (BGP_PEER_START_SUPPRESSED(peer
)) {
1390 if (bgp_debug_neighbor_events(peer
))
1391 flog_err(EC_BGP_FSM
,
1392 "%s [FSM] Trying to start suppressed peer"
1393 " - this is never supposed to happen!",
1398 /* Scrub some information that might be left over from a previous,
1401 /* Connection information. */
1402 if (peer
->su_local
) {
1403 sockunion_free(peer
->su_local
);
1404 peer
->su_local
= NULL
;
1407 if (peer
->su_remote
) {
1408 sockunion_free(peer
->su_remote
);
1409 peer
->su_remote
= NULL
;
1412 /* Clear remote router-id. */
1413 peer
->remote_id
.s_addr
= 0;
1415 /* Clear peer capability flag. */
1418 /* If the peer is passive mode, force to move to Active mode. */
1419 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)) {
1420 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1424 if (peer
->bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
&&
1425 peer
->bgp
->vrf_id
== VRF_UNKNOWN
) {
1426 if (bgp_debug_neighbor_events(peer
))
1429 "%s [FSM] In a VRF that is not initialised yet",
1434 /* Register to be notified on peer up */
1435 if (peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
== 1
1436 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)
1437 && !bgp_flag_check(peer
->bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
1442 if (!bgp_find_or_add_nexthop(peer
->bgp
, peer
->bgp
,
1443 family2afi(peer
->su
.sa
.sa_family
), NULL
,
1445 if (bgp_zebra_num_connects()) {
1446 if (bgp_debug_neighbor_events(peer
))
1447 zlog_debug("%s [FSM] Waiting for NHT",
1450 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1455 assert(!peer
->t_write
);
1456 assert(!peer
->t_read
);
1457 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
1458 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
1459 status
= bgp_connect(peer
);
1463 if (bgp_debug_neighbor_events(peer
))
1464 zlog_debug("%s [FSM] Connect error", peer
->host
);
1465 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1467 case connect_success
:
1468 if (bgp_debug_neighbor_events(peer
))
1470 "%s [FSM] Connect immediately success, fd %d",
1471 peer
->host
, peer
->fd
);
1472 BGP_EVENT_ADD(peer
, TCP_connection_open
);
1474 case connect_in_progress
:
1475 /* To check nonblocking connect, we wait until socket is
1476 readable or writable. */
1477 if (bgp_debug_neighbor_events(peer
))
1479 "%s [FSM] Non blocking connect waiting result, fd %d",
1480 peer
->host
, peer
->fd
);
1482 flog_err(EC_BGP_FSM
,
1483 "bgp_start peer's fd is negative value %d",
1488 * - when the socket becomes ready, poll() will signify POLLOUT
1489 * - if it fails to connect, poll() will signify POLLHUP
1490 * - POLLHUP is handled as a 'read' event by thread.c
1492 * therefore, we schedule both a read and a write event with
1493 * bgp_connect_check() as the handler for each and cancel the
1494 * unused event in that function.
1496 thread_add_read(bm
->master
, bgp_connect_check
, peer
, peer
->fd
,
1497 &peer
->t_connect_check_r
);
1498 thread_add_write(bm
->master
, bgp_connect_check
, peer
, peer
->fd
,
1499 &peer
->t_connect_check_w
);
1505 /* Connect retry timer is expired when the peer status is Connect. */
1506 static int bgp_reconnect(struct peer
*peer
)
1508 if (bgp_stop(peer
) < 0)
1515 static int bgp_fsm_open(struct peer
*peer
)
1517 /* Send keepalive and make keepalive timer */
1518 bgp_keepalive_send(peer
);
1520 /* Reset holdtimer value. */
1521 BGP_TIMER_OFF(peer
->t_holdtime
);
1526 /* FSM error, unexpected event. This is error of BGP connection. So cut the
1527 peer and change to Idle status. */
1528 static int bgp_fsm_event_error(struct peer
*peer
)
1530 flog_err(EC_BGP_FSM
, "%s [FSM] unexpected packet received in state %s",
1531 peer
->host
, lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1533 return bgp_stop_with_notify(peer
, BGP_NOTIFY_FSM_ERR
, 0);
1536 /* Hold timer expire. This is error of BGP connection. So cut the
1537 peer and change to Idle status. */
1538 static int bgp_fsm_holdtime_expire(struct peer
*peer
)
1540 if (bgp_debug_neighbor_events(peer
))
1541 zlog_debug("%s [FSM] Hold timer expire", peer
->host
);
1543 return bgp_stop_with_notify(peer
, BGP_NOTIFY_HOLD_ERR
, 0);
1547 * Transition to Established state.
1549 * Convert peer from stub to full fledged peer, set some timers, and generate
1552 static int bgp_establish(struct peer
*peer
)
1556 int nsf_af_count
= 0;
1560 other
= peer
->doppelganger
;
1561 peer
= peer_xfer_conn(peer
);
1563 flog_err(EC_BGP_CONNECT
, "%%Neighbor failed in xfer_conn");
1568 ret
= 1; /* bgp_establish specific code when xfer_conn
1571 /* Reset capability open status flag. */
1572 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
))
1573 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1575 /* Clear start timer value to default. */
1576 peer
->v_start
= BGP_INIT_START_TIMER
;
1578 /* Increment established count. */
1579 peer
->established
++;
1580 bgp_fsm_change_status(peer
, Established
);
1582 /* bgp log-neighbor-changes of neighbor Up */
1583 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)) {
1584 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1585 zlog_info("%%ADJCHANGE: neighbor %s(%s) in vrf %s Up",
1587 (peer
->hostname
) ? peer
->hostname
: "Unknown",
1588 vrf
? ((vrf
->vrf_id
!= VRF_DEFAULT
)
1593 /* assign update-group/subgroup */
1594 update_group_adjust_peer_afs(peer
);
1596 /* graceful restart */
1597 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
1598 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1599 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++) {
1600 if (peer
->afc_nego
[afi
][safi
]
1601 && CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
)
1602 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1603 PEER_CAP_RESTART_AF_RCV
)) {
1604 if (peer
->nsf
[afi
][safi
]
1606 peer
->af_cap
[afi
][safi
],
1607 PEER_CAP_RESTART_AF_PRESERVE_RCV
))
1608 bgp_clear_stale_route(peer
, afi
, safi
);
1610 peer
->nsf
[afi
][safi
] = 1;
1613 if (peer
->nsf
[afi
][safi
])
1614 bgp_clear_stale_route(peer
, afi
, safi
);
1615 peer
->nsf
[afi
][safi
] = 0;
1620 SET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1622 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1623 if (peer
->t_gr_stale
) {
1624 BGP_TIMER_OFF(peer
->t_gr_stale
);
1625 if (bgp_debug_neighbor_events(peer
))
1627 "%s graceful restart stalepath timer stopped",
1632 if (peer
->t_gr_restart
) {
1633 BGP_TIMER_OFF(peer
->t_gr_restart
);
1634 if (bgp_debug_neighbor_events(peer
))
1635 zlog_debug("%s graceful restart timer stopped",
1639 hook_call(peer_established
, peer
);
1641 /* Reset uptime, turn on keepalives, send current table. */
1642 if (!peer
->v_holdtime
)
1643 bgp_keepalives_on(peer
);
1645 peer
->uptime
= bgp_clock();
1647 /* Send route-refresh when ORF is enabled */
1648 FOREACH_AFI_SAFI (afi
, safi
) {
1649 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1650 PEER_CAP_ORF_PREFIX_SM_ADV
)) {
1651 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1652 PEER_CAP_ORF_PREFIX_RM_RCV
))
1653 bgp_route_refresh_send(peer
, afi
, safi
,
1655 REFRESH_IMMEDIATE
, 0);
1656 else if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1657 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))
1658 bgp_route_refresh_send(peer
, afi
, safi
,
1659 ORF_TYPE_PREFIX_OLD
,
1660 REFRESH_IMMEDIATE
, 0);
1664 /* First update is deferred until ORF or ROUTE-REFRESH is received */
1665 FOREACH_AFI_SAFI (afi
, safi
) {
1666 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1667 PEER_CAP_ORF_PREFIX_RM_ADV
))
1668 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1669 PEER_CAP_ORF_PREFIX_SM_RCV
)
1670 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1671 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
))
1672 SET_FLAG(peer
->af_sflags
[afi
][safi
],
1673 PEER_STATUS_ORF_WAIT_REFRESH
);
1676 bgp_announce_peer(peer
);
1678 /* Start the route advertisement timer to send updates to the peer - if
1680 * is not in read-only mode. If it is, the timer will be started at the
1682 * of read-only mode.
1684 if (!bgp_update_delay_active(peer
->bgp
)) {
1685 BGP_TIMER_OFF(peer
->t_routeadv
);
1686 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
1689 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)) {
1690 if (bgp_debug_neighbor_events(peer
))
1692 "[Event] Deleting stub connection for peer %s",
1695 if (peer
->doppelganger
->status
> Active
)
1696 bgp_notify_send(peer
->doppelganger
, BGP_NOTIFY_CEASE
,
1697 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1699 peer_delete(peer
->doppelganger
);
1703 * If we are replacing the old peer for a doppelganger
1704 * then switch it around in the bgp->peerhash
1705 * the doppelgangers su and this peer's su are the same
1706 * so the hash_release is the same for either.
1708 hash_release(peer
->bgp
->peerhash
, peer
);
1709 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1711 bgp_bfd_register_peer(peer
);
1715 /* Keepalive packet is received. */
1716 static int bgp_fsm_keepalive(struct peer
*peer
)
1718 BGP_TIMER_OFF(peer
->t_holdtime
);
1722 /* Update packet is received. */
1723 static int bgp_fsm_update(struct peer
*peer
)
1725 BGP_TIMER_OFF(peer
->t_holdtime
);
1729 /* This is empty event. */
1730 static int bgp_ignore(struct peer
*peer
)
1734 "%s [FSM] Ignoring event %s in state %s, prior events %s, %s, fd %d",
1735 peer
->host
, bgp_event_str
[peer
->cur_event
],
1736 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1737 bgp_event_str
[peer
->last_event
],
1738 bgp_event_str
[peer
->last_major_event
], peer
->fd
);
1742 /* This is to handle unexpected events.. */
1743 static int bgp_fsm_exeption(struct peer
*peer
)
1747 "%s [FSM] Unexpected event %s in state %s, prior events %s, %s, fd %d",
1748 peer
->host
, bgp_event_str
[peer
->cur_event
],
1749 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1750 bgp_event_str
[peer
->last_event
],
1751 bgp_event_str
[peer
->last_major_event
], peer
->fd
);
1752 return (bgp_stop(peer
));
1755 void bgp_fsm_event_update(struct peer
*peer
, int valid
)
1760 switch (peer
->status
) {
1763 BGP_EVENT_ADD(peer
, BGP_Start
);
1767 BGP_TIMER_OFF(peer
->t_connect
);
1768 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1773 BGP_TIMER_OFF(peer
->t_connect
);
1774 BGP_EVENT_ADD(peer
, ConnectRetry_timer_expired
);
1780 if (!valid
&& (peer
->gtsm_hops
== 1))
1781 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1789 /* Finite State Machine structure */
1790 static const struct {
1791 int (*func
)(struct peer
*);
1793 } FSM
[BGP_STATUS_MAX
- 1][BGP_EVENTS_MAX
- 1] = {
1795 /* Idle state: In Idle state, all events other than BGP_Start is
1796 ignored. With BGP_Start event, finite state machine calls
1798 {bgp_start
, Connect
}, /* BGP_Start */
1799 {bgp_stop
, Idle
}, /* BGP_Stop */
1800 {bgp_stop
, Idle
}, /* TCP_connection_open */
1801 {bgp_stop
, Idle
}, /* TCP_connection_closed */
1802 {bgp_ignore
, Idle
}, /* TCP_connection_open_failed */
1803 {bgp_stop
, Idle
}, /* TCP_fatal_error */
1804 {bgp_ignore
, Idle
}, /* ConnectRetry_timer_expired */
1805 {bgp_ignore
, Idle
}, /* Hold_Timer_expired */
1806 {bgp_ignore
, Idle
}, /* KeepAlive_timer_expired */
1807 {bgp_ignore
, Idle
}, /* Receive_OPEN_message */
1808 {bgp_ignore
, Idle
}, /* Receive_KEEPALIVE_message */
1809 {bgp_ignore
, Idle
}, /* Receive_UPDATE_message */
1810 {bgp_ignore
, Idle
}, /* Receive_NOTIFICATION_message */
1811 {bgp_ignore
, Idle
}, /* Clearing_Completed */
1815 {bgp_ignore
, Connect
}, /* BGP_Start */
1816 {bgp_stop
, Idle
}, /* BGP_Stop */
1817 {bgp_connect_success
, OpenSent
}, /* TCP_connection_open */
1818 {bgp_stop
, Idle
}, /* TCP_connection_closed */
1819 {bgp_connect_fail
, Active
}, /* TCP_connection_open_failed */
1820 {bgp_connect_fail
, Idle
}, /* TCP_fatal_error */
1821 {bgp_reconnect
, Connect
}, /* ConnectRetry_timer_expired */
1822 {bgp_fsm_exeption
, Idle
}, /* Hold_Timer_expired */
1823 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
1824 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
1825 {bgp_fsm_exeption
, Idle
}, /* Receive_KEEPALIVE_message */
1826 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
1827 {bgp_stop
, Idle
}, /* Receive_NOTIFICATION_message */
1828 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1832 {bgp_ignore
, Active
}, /* BGP_Start */
1833 {bgp_stop
, Idle
}, /* BGP_Stop */
1834 {bgp_connect_success
, OpenSent
}, /* TCP_connection_open */
1835 {bgp_stop
, Idle
}, /* TCP_connection_closed */
1836 {bgp_ignore
, Active
}, /* TCP_connection_open_failed */
1837 {bgp_fsm_exeption
, Idle
}, /* TCP_fatal_error */
1838 {bgp_start
, Connect
}, /* ConnectRetry_timer_expired */
1839 {bgp_fsm_exeption
, Idle
}, /* Hold_Timer_expired */
1840 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
1841 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
1842 {bgp_fsm_exeption
, Idle
}, /* Receive_KEEPALIVE_message */
1843 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
1844 {bgp_fsm_exeption
, Idle
}, /* Receive_NOTIFICATION_message */
1845 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1849 {bgp_ignore
, OpenSent
}, /* BGP_Start */
1850 {bgp_stop
, Idle
}, /* BGP_Stop */
1851 {bgp_stop
, Active
}, /* TCP_connection_open */
1852 {bgp_stop
, Active
}, /* TCP_connection_closed */
1853 {bgp_stop
, Active
}, /* TCP_connection_open_failed */
1854 {bgp_stop
, Active
}, /* TCP_fatal_error */
1855 {bgp_fsm_exeption
, Idle
}, /* ConnectRetry_timer_expired */
1856 {bgp_fsm_holdtime_expire
, Idle
}, /* Hold_Timer_expired */
1857 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
1858 {bgp_fsm_open
, OpenConfirm
}, /* Receive_OPEN_message */
1859 {bgp_fsm_event_error
, Idle
}, /* Receive_KEEPALIVE_message */
1860 {bgp_fsm_event_error
, Idle
}, /* Receive_UPDATE_message */
1861 {bgp_stop_with_error
, Idle
}, /* Receive_NOTIFICATION_message */
1862 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1866 {bgp_ignore
, OpenConfirm
}, /* BGP_Start */
1867 {bgp_stop
, Idle
}, /* BGP_Stop */
1868 {bgp_stop
, Idle
}, /* TCP_connection_open */
1869 {bgp_stop
, Idle
}, /* TCP_connection_closed */
1870 {bgp_stop
, Idle
}, /* TCP_connection_open_failed */
1871 {bgp_stop
, Idle
}, /* TCP_fatal_error */
1872 {bgp_fsm_exeption
, Idle
}, /* ConnectRetry_timer_expired */
1873 {bgp_fsm_holdtime_expire
, Idle
}, /* Hold_Timer_expired */
1874 {bgp_ignore
, OpenConfirm
}, /* KeepAlive_timer_expired */
1875 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
1876 {bgp_establish
, Established
}, /* Receive_KEEPALIVE_message */
1877 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
1878 {bgp_stop_with_error
, Idle
}, /* Receive_NOTIFICATION_message */
1879 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1883 {bgp_ignore
, Established
}, /* BGP_Start */
1884 {bgp_stop
, Clearing
}, /* BGP_Stop */
1885 {bgp_stop
, Clearing
}, /* TCP_connection_open */
1886 {bgp_stop
, Clearing
}, /* TCP_connection_closed */
1887 {bgp_stop
, Clearing
}, /* TCP_connection_open_failed */
1888 {bgp_stop
, Clearing
}, /* TCP_fatal_error */
1889 {bgp_stop
, Clearing
}, /* ConnectRetry_timer_expired */
1890 {bgp_fsm_holdtime_expire
, Clearing
}, /* Hold_Timer_expired */
1891 {bgp_ignore
, Established
}, /* KeepAlive_timer_expired */
1892 {bgp_stop
, Clearing
}, /* Receive_OPEN_message */
1894 Established
}, /* Receive_KEEPALIVE_message */
1895 {bgp_fsm_update
, Established
}, /* Receive_UPDATE_message */
1896 {bgp_stop_with_error
,
1897 Clearing
}, /* Receive_NOTIFICATION_message */
1898 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1902 {bgp_ignore
, Clearing
}, /* BGP_Start */
1903 {bgp_stop
, Clearing
}, /* BGP_Stop */
1904 {bgp_stop
, Clearing
}, /* TCP_connection_open */
1905 {bgp_stop
, Clearing
}, /* TCP_connection_closed */
1906 {bgp_stop
, Clearing
}, /* TCP_connection_open_failed */
1907 {bgp_stop
, Clearing
}, /* TCP_fatal_error */
1908 {bgp_stop
, Clearing
}, /* ConnectRetry_timer_expired */
1909 {bgp_stop
, Clearing
}, /* Hold_Timer_expired */
1910 {bgp_stop
, Clearing
}, /* KeepAlive_timer_expired */
1911 {bgp_stop
, Clearing
}, /* Receive_OPEN_message */
1912 {bgp_stop
, Clearing
}, /* Receive_KEEPALIVE_message */
1913 {bgp_stop
, Clearing
}, /* Receive_UPDATE_message */
1914 {bgp_stop
, Clearing
}, /* Receive_NOTIFICATION_message */
1915 {bgp_clearing_completed
, Idle
}, /* Clearing_Completed */
1919 {bgp_ignore
, Deleted
}, /* BGP_Start */
1920 {bgp_ignore
, Deleted
}, /* BGP_Stop */
1921 {bgp_ignore
, Deleted
}, /* TCP_connection_open */
1922 {bgp_ignore
, Deleted
}, /* TCP_connection_closed */
1923 {bgp_ignore
, Deleted
}, /* TCP_connection_open_failed */
1924 {bgp_ignore
, Deleted
}, /* TCP_fatal_error */
1925 {bgp_ignore
, Deleted
}, /* ConnectRetry_timer_expired */
1926 {bgp_ignore
, Deleted
}, /* Hold_Timer_expired */
1927 {bgp_ignore
, Deleted
}, /* KeepAlive_timer_expired */
1928 {bgp_ignore
, Deleted
}, /* Receive_OPEN_message */
1929 {bgp_ignore
, Deleted
}, /* Receive_KEEPALIVE_message */
1930 {bgp_ignore
, Deleted
}, /* Receive_UPDATE_message */
1931 {bgp_ignore
, Deleted
}, /* Receive_NOTIFICATION_message */
1932 {bgp_ignore
, Deleted
}, /* Clearing_Completed */
1936 /* Execute event process. */
1937 int bgp_event(struct thread
*thread
)
1943 peer
= THREAD_ARG(thread
);
1944 event
= THREAD_VAL(thread
);
1946 ret
= bgp_event_update(peer
, event
);
1951 int bgp_event_update(struct peer
*peer
, int event
)
1956 int passive_conn
= 0;
1959 /* default return code */
1960 ret
= FSM_PEER_NOOP
;
1962 other
= peer
->doppelganger
;
1964 (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)) ? 1 : 0;
1965 dyn_nbr
= peer_dynamic_neighbor(peer
);
1967 /* Logging this event. */
1968 next
= FSM
[peer
->status
- 1][event
- 1].next_state
;
1970 if (bgp_debug_neighbor_events(peer
) && peer
->status
!= next
)
1971 zlog_debug("%s [FSM] %s (%s->%s), fd %d", peer
->host
,
1972 bgp_event_str
[event
],
1973 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1974 lookup_msg(bgp_status_msg
, next
, NULL
), peer
->fd
);
1976 peer
->last_event
= peer
->cur_event
;
1977 peer
->cur_event
= event
;
1979 /* Call function. */
1980 if (FSM
[peer
->status
- 1][event
- 1].func
)
1981 ret
= (*(FSM
[peer
->status
- 1][event
- 1].func
))(peer
);
1984 if (ret
== 1 && next
== Established
) {
1985 /* The case when doppelganger swap accurred in
1987 Update the peer pointer accordingly */
1988 ret
= FSM_PEER_TRANSFERRED
;
1992 /* If status is changed. */
1993 if (next
!= peer
->status
) {
1994 bgp_fsm_change_status(peer
, next
);
1997 * If we're going to ESTABLISHED then we executed a
1998 * peer transfer. In this case we can either return
1999 * FSM_PEER_TRANSITIONED or FSM_PEER_TRANSFERRED.
2000 * Opting for TRANSFERRED since transfer implies
2001 * session establishment.
2003 if (ret
!= FSM_PEER_TRANSFERRED
)
2004 ret
= FSM_PEER_TRANSITIONED
;
2007 /* Make sure timer is set. */
2008 bgp_timer_set(peer
);
2012 * If we got a return value of -1, that means there was an
2013 * error, restart the FSM. Since bgp_stop() was called on the
2014 * peer. only a few fields are safe to access here. In any case
2015 * we need to indicate that the peer was stopped in the return
2018 if (!dyn_nbr
&& !passive_conn
&& peer
->bgp
) {
2021 "%s [FSM] Failure handling event %s in state %s, "
2022 "prior events %s, %s, fd %d",
2023 peer
->host
, bgp_event_str
[peer
->cur_event
],
2024 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
2025 bgp_event_str
[peer
->last_event
],
2026 bgp_event_str
[peer
->last_major_event
],
2029 bgp_fsm_change_status(peer
, Idle
);
2030 bgp_timer_set(peer
);
2032 ret
= FSM_PEER_STOPPED
;