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"
39 #include "bgpd/bgpd.h"
40 #include "bgpd/bgp_attr.h"
41 #include "bgpd/bgp_debug.h"
42 #include "bgpd/bgp_fsm.h"
43 #include "bgpd/bgp_packet.h"
44 #include "bgpd/bgp_network.h"
45 #include "bgpd/bgp_route.h"
46 #include "bgpd/bgp_dump.h"
47 #include "bgpd/bgp_open.h"
48 #include "bgpd/bgp_advertise.h"
49 #include "bgpd/bgp_updgrp.h"
50 #include "bgpd/bgp_nht.h"
51 #include "bgpd/bgp_bfd.h"
52 #include "bgpd/bgp_memory.h"
53 #include "bgpd/bgp_keepalives.h"
54 #include "bgpd/bgp_io.h"
55 #include "bgpd/bgp_zebra.h"
57 DEFINE_HOOK(peer_backward_transition
, (struct peer
* peer
), (peer
))
58 DEFINE_HOOK(peer_established
, (struct peer
* peer
), (peer
))
60 /* Definition of display strings corresponding to FSM events. This should be
61 * kept consistent with the events defined in bgpd.h
63 static const char *bgp_event_str
[] = {
67 "TCP_connection_open",
68 "TCP_connection_closed",
69 "TCP_connection_open_failed",
71 "ConnectRetry_timer_expired",
73 "KeepAlive_timer_expired",
74 "Receive_OPEN_message",
75 "Receive_KEEPALIVE_message",
76 "Receive_UPDATE_message",
77 "Receive_NOTIFICATION_message",
81 /* BGP FSM (finite state machine) has three types of functions. Type
82 one is thread functions. Type two is event functions. Type three
83 is FSM functions. Timer functions are set by bgp_timer_set
86 /* BGP event function. */
87 int bgp_event(struct thread
*);
89 /* BGP thread functions. */
90 static int bgp_start_timer(struct thread
*);
91 static int bgp_connect_timer(struct thread
*);
92 static int bgp_holdtime_timer(struct thread
*);
94 /* BGP FSM functions. */
95 static int bgp_start(struct peer
*);
97 static void peer_xfer_stats(struct peer
*peer_dst
, struct peer
*peer_src
)
99 /* Copy stats over. These are only the pre-established state stats */
100 peer_dst
->open_in
+= peer_src
->open_in
;
101 peer_dst
->open_out
+= peer_src
->open_out
;
102 peer_dst
->keepalive_in
+= peer_src
->keepalive_in
;
103 peer_dst
->keepalive_out
+= peer_src
->keepalive_out
;
104 peer_dst
->notify_in
+= peer_src
->notify_in
;
105 peer_dst
->notify_out
+= peer_src
->notify_out
;
106 peer_dst
->dynamic_cap_in
+= peer_src
->dynamic_cap_in
;
107 peer_dst
->dynamic_cap_out
+= peer_src
->dynamic_cap_out
;
110 static struct peer
*peer_xfer_conn(struct peer
*from_peer
)
117 unsigned char last_evt
, last_maj_evt
;
119 assert(from_peer
!= NULL
);
121 peer
= from_peer
->doppelganger
;
123 if (!peer
|| !CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
126 if (bgp_debug_neighbor_events(peer
))
127 zlog_debug("%s: peer transfer %p fd %d -> %p fd %d)",
128 from_peer
->host
, from_peer
, from_peer
->fd
, peer
,
131 bgp_writes_off(peer
);
133 bgp_writes_off(from_peer
);
134 bgp_reads_off(from_peer
);
136 BGP_TIMER_OFF(peer
->t_routeadv
);
137 BGP_TIMER_OFF(peer
->t_connect
);
138 BGP_TIMER_OFF(peer
->t_connect_check_r
);
139 BGP_TIMER_OFF(peer
->t_connect_check_w
);
140 BGP_TIMER_OFF(from_peer
->t_routeadv
);
141 BGP_TIMER_OFF(from_peer
->t_connect
);
142 BGP_TIMER_OFF(from_peer
->t_connect_check_r
);
143 BGP_TIMER_OFF(from_peer
->t_connect_check_w
);
144 BGP_TIMER_OFF(from_peer
->t_process_packet
);
147 * At this point in time, it is possible that there are packets pending
148 * on various buffers. Those need to be transferred or dropped,
149 * otherwise we'll get spurious failures during session establishment.
151 pthread_mutex_lock(&peer
->io_mtx
);
152 pthread_mutex_lock(&from_peer
->io_mtx
);
155 peer
->fd
= from_peer
->fd
;
158 stream_fifo_clean(peer
->ibuf
);
159 stream_fifo_clean(peer
->obuf
);
162 * this should never happen, since bgp_process_packet() is the
163 * only task that sets and unsets the current packet and it
164 * runs in our pthread.
168 "[%s] Dropping pending packet on connection transfer:",
170 uint16_t type
= stream_getc_from(peer
->curr
,
171 BGP_MARKER_SIZE
+ 2);
172 bgp_dump_packet(peer
, type
, peer
->curr
);
173 stream_free(peer
->curr
);
177 // copy each packet from old peer's output queue to new peer
178 while (from_peer
->obuf
->head
)
179 stream_fifo_push(peer
->obuf
,
180 stream_fifo_pop(from_peer
->obuf
));
182 // copy each packet from old peer's input queue to new peer
183 while (from_peer
->ibuf
->head
)
184 stream_fifo_push(peer
->ibuf
,
185 stream_fifo_pop(from_peer
->ibuf
));
187 ringbuf_wipe(peer
->ibuf_work
);
188 ringbuf_copy(peer
->ibuf_work
, from_peer
->ibuf_work
,
189 ringbuf_remain(from_peer
->ibuf_work
));
191 pthread_mutex_unlock(&from_peer
->io_mtx
);
192 pthread_mutex_unlock(&peer
->io_mtx
);
194 peer
->as
= from_peer
->as
;
195 peer
->v_holdtime
= from_peer
->v_holdtime
;
196 peer
->v_keepalive
= from_peer
->v_keepalive
;
197 peer
->routeadv
= from_peer
->routeadv
;
198 peer
->v_routeadv
= from_peer
->v_routeadv
;
199 peer
->v_gr_restart
= from_peer
->v_gr_restart
;
200 peer
->cap
= from_peer
->cap
;
201 status
= peer
->status
;
202 pstatus
= peer
->ostatus
;
203 last_evt
= peer
->last_event
;
204 last_maj_evt
= peer
->last_major_event
;
205 peer
->status
= from_peer
->status
;
206 peer
->ostatus
= from_peer
->ostatus
;
207 peer
->last_event
= from_peer
->last_event
;
208 peer
->last_major_event
= from_peer
->last_major_event
;
209 from_peer
->status
= status
;
210 from_peer
->ostatus
= pstatus
;
211 from_peer
->last_event
= last_evt
;
212 from_peer
->last_major_event
= last_maj_evt
;
213 peer
->remote_id
= from_peer
->remote_id
;
215 if (from_peer
->hostname
!= NULL
) {
216 if (peer
->hostname
) {
217 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
218 peer
->hostname
= NULL
;
221 peer
->hostname
= from_peer
->hostname
;
222 from_peer
->hostname
= NULL
;
225 if (from_peer
->domainname
!= NULL
) {
226 if (peer
->domainname
) {
227 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
228 peer
->domainname
= NULL
;
231 peer
->domainname
= from_peer
->domainname
;
232 from_peer
->domainname
= NULL
;
235 FOREACH_AFI_SAFI (afi
, safi
) {
236 peer
->af_flags
[afi
][safi
] = from_peer
->af_flags
[afi
][safi
];
237 peer
->af_sflags
[afi
][safi
] = from_peer
->af_sflags
[afi
][safi
];
238 peer
->af_cap
[afi
][safi
] = from_peer
->af_cap
[afi
][safi
];
239 peer
->afc_nego
[afi
][safi
] = from_peer
->afc_nego
[afi
][safi
];
240 peer
->afc_adv
[afi
][safi
] = from_peer
->afc_adv
[afi
][safi
];
241 peer
->afc_recv
[afi
][safi
] = from_peer
->afc_recv
[afi
][safi
];
242 peer
->orf_plist
[afi
][safi
] = from_peer
->orf_plist
[afi
][safi
];
245 if (bgp_getsockname(peer
) < 0) {
247 "%%bgp_getsockname() failed for %s peer %s fd %d (from_peer fd %d)",
248 (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)
251 peer
->host
, peer
->fd
, from_peer
->fd
);
256 if (from_peer
->status
> Active
) {
257 if (bgp_getsockname(from_peer
) < 0) {
259 "%%bgp_getsockname() failed for %s from_peer %s fd %d (peer fd %d)",
260 (CHECK_FLAG(from_peer
->sflags
,
261 PEER_STATUS_ACCEPT_PEER
)
264 from_peer
->host
, from_peer
->fd
, peer
->fd
);
271 // Note: peer_xfer_stats() must be called with I/O turned OFF
273 peer_xfer_stats(peer
, from_peer
);
277 thread_add_timer_msec(bm
->master
, bgp_process_packet
, peer
, 0,
278 &peer
->t_process_packet
);
283 /* Hook function called after bgp event is occered. And vty's
284 neighbor command invoke this function after making neighbor
286 void bgp_timer_set(struct peer
*peer
)
288 switch (peer
->status
) {
290 /* First entry point of peer's finite state machine. In Idle
291 status start timer is on unless peer is shutdown or peer is
292 inactive. All other timer must be turned off */
293 if (BGP_PEER_START_SUPPRESSED(peer
) || !peer_active(peer
)
294 || peer
->bgp
->vrf_id
== VRF_UNKNOWN
) {
295 BGP_TIMER_OFF(peer
->t_start
);
297 BGP_TIMER_ON(peer
->t_start
, bgp_start_timer
,
300 BGP_TIMER_OFF(peer
->t_connect
);
301 BGP_TIMER_OFF(peer
->t_holdtime
);
302 bgp_keepalives_off(peer
);
303 BGP_TIMER_OFF(peer
->t_routeadv
);
307 /* After start timer is expired, the peer moves to Connect
308 status. Make sure start timer is off and connect timer is
310 BGP_TIMER_OFF(peer
->t_start
);
311 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
313 BGP_TIMER_OFF(peer
->t_holdtime
);
314 bgp_keepalives_off(peer
);
315 BGP_TIMER_OFF(peer
->t_routeadv
);
319 /* Active is waiting connection from remote peer. And if
320 connect timer is expired, change status to Connect. */
321 BGP_TIMER_OFF(peer
->t_start
);
322 /* If peer is passive mode, do not set connect timer. */
323 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)
324 || CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
325 BGP_TIMER_OFF(peer
->t_connect
);
327 BGP_TIMER_ON(peer
->t_connect
, bgp_connect_timer
,
330 BGP_TIMER_OFF(peer
->t_holdtime
);
331 bgp_keepalives_off(peer
);
332 BGP_TIMER_OFF(peer
->t_routeadv
);
336 /* OpenSent status. */
337 BGP_TIMER_OFF(peer
->t_start
);
338 BGP_TIMER_OFF(peer
->t_connect
);
339 if (peer
->v_holdtime
!= 0) {
340 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
343 BGP_TIMER_OFF(peer
->t_holdtime
);
345 bgp_keepalives_off(peer
);
346 BGP_TIMER_OFF(peer
->t_routeadv
);
350 /* OpenConfirm status. */
351 BGP_TIMER_OFF(peer
->t_start
);
352 BGP_TIMER_OFF(peer
->t_connect
);
354 /* If the negotiated Hold Time value is zero, then the Hold Time
355 timer and KeepAlive timers are not started. */
356 if (peer
->v_holdtime
== 0) {
357 BGP_TIMER_OFF(peer
->t_holdtime
);
358 bgp_keepalives_off(peer
);
360 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
362 bgp_keepalives_on(peer
);
364 BGP_TIMER_OFF(peer
->t_routeadv
);
368 /* In Established status start and connect timer is turned
370 BGP_TIMER_OFF(peer
->t_start
);
371 BGP_TIMER_OFF(peer
->t_connect
);
373 /* Same as OpenConfirm, if holdtime is zero then both holdtime
374 and keepalive must be turned off. */
375 if (peer
->v_holdtime
== 0) {
376 BGP_TIMER_OFF(peer
->t_holdtime
);
377 bgp_keepalives_off(peer
);
379 BGP_TIMER_ON(peer
->t_holdtime
, bgp_holdtime_timer
,
381 bgp_keepalives_on(peer
);
385 BGP_TIMER_OFF(peer
->t_gr_restart
);
386 BGP_TIMER_OFF(peer
->t_gr_stale
);
387 BGP_TIMER_OFF(peer
->t_pmax_restart
);
390 BGP_TIMER_OFF(peer
->t_start
);
391 BGP_TIMER_OFF(peer
->t_connect
);
392 BGP_TIMER_OFF(peer
->t_holdtime
);
393 bgp_keepalives_off(peer
);
394 BGP_TIMER_OFF(peer
->t_routeadv
);
399 /* BGP start timer. This function set BGP_Start event to thread value
400 and process event. */
401 static int bgp_start_timer(struct thread
*thread
)
405 peer
= THREAD_ARG(thread
);
406 peer
->t_start
= NULL
;
408 if (bgp_debug_neighbor_events(peer
))
409 zlog_debug("%s [FSM] Timer (start timer expire).", peer
->host
);
411 THREAD_VAL(thread
) = BGP_Start
;
412 bgp_event(thread
); /* bgp_event unlocks peer */
417 /* BGP connect retry timer. */
418 static int bgp_connect_timer(struct thread
*thread
)
423 peer
= THREAD_ARG(thread
);
425 assert(!peer
->t_write
);
426 assert(!peer
->t_read
);
428 peer
->t_connect
= NULL
;
430 if (bgp_debug_neighbor_events(peer
))
431 zlog_debug("%s [FSM] Timer (connect timer expire)", peer
->host
);
433 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)) {
437 THREAD_VAL(thread
) = ConnectRetry_timer_expired
;
438 bgp_event(thread
); /* bgp_event unlocks peer */
445 /* BGP holdtime timer. */
446 static int bgp_holdtime_timer(struct thread
*thread
)
450 peer
= THREAD_ARG(thread
);
451 peer
->t_holdtime
= NULL
;
453 if (bgp_debug_neighbor_events(peer
))
454 zlog_debug("%s [FSM] Timer (holdtime timer expire)",
457 THREAD_VAL(thread
) = Hold_Timer_expired
;
458 bgp_event(thread
); /* bgp_event unlocks peer */
463 int bgp_routeadv_timer(struct thread
*thread
)
467 peer
= THREAD_ARG(thread
);
468 peer
->t_routeadv
= NULL
;
470 if (bgp_debug_neighbor_events(peer
))
471 zlog_debug("%s [FSM] Timer (routeadv timer expire)",
474 peer
->synctime
= bgp_clock();
476 thread_add_timer_msec(bm
->master
, bgp_generate_updgrp_packets
, peer
, 0,
477 &peer
->t_generate_updgrp_packets
);
479 /* MRAI timer will be started again when FIFO is built, no need to
485 /* BGP Peer Down Cause */
486 const char *peer_down_str
[] = {"",
490 "Cluster ID changed",
491 "Confederation identifier changed",
492 "Confederation peer changed",
493 "RR client config change",
494 "RS client config change",
495 "Update source change",
496 "Address family activated",
499 "BGP Notification received",
500 "BGP Notification send",
501 "Peer closed the session",
503 "Peer-group add member",
504 "Peer-group delete member",
505 "Capability changed",
506 "Passive config change",
507 "Multihop config change",
508 "NSF peer closed the session",
509 "Intf peering v6only config change",
512 "Neighbor address lost"};
514 static int bgp_graceful_restart_timer_expire(struct thread
*thread
)
520 peer
= THREAD_ARG(thread
);
521 peer
->t_gr_restart
= NULL
;
523 /* NSF delete stale route */
524 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
525 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
526 if (peer
->nsf
[afi
][safi
])
527 bgp_clear_stale_route(peer
, afi
, safi
);
529 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
530 BGP_TIMER_OFF(peer
->t_gr_stale
);
532 if (bgp_debug_neighbor_events(peer
)) {
533 zlog_debug("%s graceful restart timer expired", peer
->host
);
534 zlog_debug("%s graceful restart stalepath timer stopped",
543 static int bgp_graceful_stale_timer_expire(struct thread
*thread
)
549 peer
= THREAD_ARG(thread
);
550 peer
->t_gr_stale
= NULL
;
552 if (bgp_debug_neighbor_events(peer
))
553 zlog_debug("%s graceful restart stalepath timer expired",
556 /* NSF delete stale route */
557 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
558 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
559 if (peer
->nsf
[afi
][safi
])
560 bgp_clear_stale_route(peer
, afi
, safi
);
565 static int bgp_update_delay_applicable(struct bgp
*bgp
)
567 /* update_delay_over flag should be reset (set to 0) for any new
568 applicability of the update-delay during BGP process lifetime.
569 And it should be set after an occurence of the update-delay is
571 if (!bgp
->update_delay_over
)
577 int bgp_update_delay_active(struct bgp
*bgp
)
579 if (bgp
->t_update_delay
)
585 int bgp_update_delay_configured(struct bgp
*bgp
)
587 if (bgp
->v_update_delay
)
593 /* Do the post-processing needed when bgp comes out of the read-only mode
594 on ending the update delay. */
595 void bgp_update_delay_end(struct bgp
*bgp
)
597 THREAD_TIMER_OFF(bgp
->t_update_delay
);
598 THREAD_TIMER_OFF(bgp
->t_establish_wait
);
600 /* Reset update-delay related state */
601 bgp
->update_delay_over
= 1;
602 bgp
->established
= 0;
603 bgp
->restarted_peers
= 0;
604 bgp
->implicit_eors
= 0;
605 bgp
->explicit_eors
= 0;
607 quagga_timestamp(3, bgp
->update_delay_end_time
,
608 sizeof(bgp
->update_delay_end_time
));
611 * Add an end-of-initial-update marker to the main process queues so
613 * the route advertisement timer for the peers can be started. Also set
614 * the zebra and peer update hold flags. These flags are used to achieve
615 * three stages in the update-delay post processing:
616 * 1. Finish best-path selection for all the prefixes held on the
618 * (routes in BGP are updated, and peers sync queues are populated
620 * 2. As the eoiu mark is reached in the bgp process routine, ship all
622 * routes to zebra. With that zebra should see updates from BGP
625 * 3. Unblock the peer update writes. With that peer update packing
627 * the prefixes should be at its maximum.
629 bgp_add_eoiu_mark(bgp
);
630 bgp
->main_zebra_update_hold
= 1;
631 bgp
->main_peers_update_hold
= 1;
633 /* Resume the queue processing. This should trigger the event that would
635 care of processing any work that was queued during the read-only
637 work_queue_unplug(bm
->process_main_queue
);
643 void bgp_start_routeadv(struct bgp
*bgp
)
645 struct listnode
*node
, *nnode
;
648 zlog_info("bgp_start_routeadv(), update hold status %d",
649 bgp
->main_peers_update_hold
);
651 if (bgp
->main_peers_update_hold
)
654 quagga_timestamp(3, bgp
->update_delay_peers_resume_time
,
655 sizeof(bgp
->update_delay_peers_resume_time
));
657 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
658 if (peer
->status
!= Established
)
660 BGP_TIMER_OFF(peer
->t_routeadv
);
661 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
668 void bgp_adjust_routeadv(struct peer
*peer
)
670 time_t nowtime
= bgp_clock();
672 unsigned long remain
;
674 /* Bypass checks for special case of MRAI being 0 */
675 if (peer
->v_routeadv
== 0) {
676 /* Stop existing timer, just in case it is running for a
678 * duration and schedule write thread immediately.
680 if (peer
->t_routeadv
)
681 BGP_TIMER_OFF(peer
->t_routeadv
);
683 peer
->synctime
= bgp_clock();
684 thread_add_timer_msec(bm
->master
, bgp_generate_updgrp_packets
,
686 &peer
->t_generate_updgrp_packets
);
693 * If the last update was written more than MRAI back, expire the timer
694 * instantly so that we can send the update out sooner.
696 * <------- MRAI --------->
697 * |-----------------|-----------------------|
698 * <------------- m ------------>
707 diff
= difftime(nowtime
, peer
->last_update
);
708 if (diff
> (double)peer
->v_routeadv
) {
709 BGP_TIMER_OFF(peer
->t_routeadv
);
710 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
716 * - Find when to expire the MRAI timer.
717 * If MRAI timer is not active, assume we can start it now.
719 * <------- MRAI --------->
720 * |------------|-----------------------|
721 * <-------- m ----------><----- r ----->
730 if (peer
->t_routeadv
)
731 remain
= thread_timer_remain_second(peer
->t_routeadv
);
733 remain
= peer
->v_routeadv
;
734 diff
= peer
->v_routeadv
- diff
;
735 if (diff
<= (double)remain
) {
736 BGP_TIMER_OFF(peer
->t_routeadv
);
737 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, diff
);
741 static int bgp_maxmed_onstartup_applicable(struct bgp
*bgp
)
743 if (!bgp
->maxmed_onstartup_over
)
749 int bgp_maxmed_onstartup_configured(struct bgp
*bgp
)
751 if (bgp
->v_maxmed_onstartup
!= BGP_MAXMED_ONSTARTUP_UNCONFIGURED
)
757 int bgp_maxmed_onstartup_active(struct bgp
*bgp
)
759 if (bgp
->t_maxmed_onstartup
)
765 void bgp_maxmed_update(struct bgp
*bgp
)
767 uint8_t maxmed_active
;
768 uint32_t maxmed_value
;
770 if (bgp
->v_maxmed_admin
) {
772 maxmed_value
= bgp
->maxmed_admin_value
;
773 } else if (bgp
->t_maxmed_onstartup
) {
775 maxmed_value
= bgp
->maxmed_onstartup_value
;
778 maxmed_value
= BGP_MAXMED_VALUE_DEFAULT
;
781 if (bgp
->maxmed_active
!= maxmed_active
782 || bgp
->maxmed_value
!= maxmed_value
) {
783 bgp
->maxmed_active
= maxmed_active
;
784 bgp
->maxmed_value
= maxmed_value
;
786 update_group_announce(bgp
);
790 /* The maxmed onstartup timer expiry callback. */
791 static int bgp_maxmed_onstartup_timer(struct thread
*thread
)
795 zlog_info("Max med on startup ended - timer expired.");
797 bgp
= THREAD_ARG(thread
);
798 THREAD_TIMER_OFF(bgp
->t_maxmed_onstartup
);
799 bgp
->maxmed_onstartup_over
= 1;
801 bgp_maxmed_update(bgp
);
806 static void bgp_maxmed_onstartup_begin(struct bgp
*bgp
)
808 /* Applicable only once in the process lifetime on the startup */
809 if (bgp
->maxmed_onstartup_over
)
812 zlog_info("Begin maxmed onstartup mode - timer %d seconds",
813 bgp
->v_maxmed_onstartup
);
815 thread_add_timer(bm
->master
, bgp_maxmed_onstartup_timer
, bgp
,
816 bgp
->v_maxmed_onstartup
, &bgp
->t_maxmed_onstartup
);
818 if (!bgp
->v_maxmed_admin
) {
819 bgp
->maxmed_active
= 1;
820 bgp
->maxmed_value
= bgp
->maxmed_onstartup_value
;
823 /* Route announce to all peers should happen after this in
827 static void bgp_maxmed_onstartup_process_status_change(struct peer
*peer
)
829 if (peer
->status
== Established
&& !peer
->bgp
->established
) {
830 bgp_maxmed_onstartup_begin(peer
->bgp
);
834 /* The update delay timer expiry callback. */
835 static int bgp_update_delay_timer(struct thread
*thread
)
839 zlog_info("Update delay ended - timer expired.");
841 bgp
= THREAD_ARG(thread
);
842 THREAD_TIMER_OFF(bgp
->t_update_delay
);
843 bgp_update_delay_end(bgp
);
848 /* The establish wait timer expiry callback. */
849 static int bgp_establish_wait_timer(struct thread
*thread
)
853 zlog_info("Establish wait - timer expired.");
855 bgp
= THREAD_ARG(thread
);
856 THREAD_TIMER_OFF(bgp
->t_establish_wait
);
857 bgp_check_update_delay(bgp
);
862 /* Steps to begin the update delay:
863 - initialize queues if needed
864 - stop the queue processing
866 static void bgp_update_delay_begin(struct bgp
*bgp
)
868 struct listnode
*node
, *nnode
;
871 /* Stop the processing of queued work. Enqueue shall continue */
872 work_queue_plug(bm
->process_main_queue
);
874 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
875 peer
->update_delay_over
= 0;
877 /* Start the update-delay timer */
878 thread_add_timer(bm
->master
, bgp_update_delay_timer
, bgp
,
879 bgp
->v_update_delay
, &bgp
->t_update_delay
);
881 if (bgp
->v_establish_wait
!= bgp
->v_update_delay
)
882 thread_add_timer(bm
->master
, bgp_establish_wait_timer
, bgp
,
883 bgp
->v_establish_wait
, &bgp
->t_establish_wait
);
885 quagga_timestamp(3, bgp
->update_delay_begin_time
,
886 sizeof(bgp
->update_delay_begin_time
));
889 static void bgp_update_delay_process_status_change(struct peer
*peer
)
891 if (peer
->status
== Established
) {
892 if (!peer
->bgp
->established
++) {
893 bgp_update_delay_begin(peer
->bgp
);
895 "Begin read-only mode - update-delay timer %d seconds",
896 peer
->bgp
->v_update_delay
);
898 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
))
899 bgp_update_restarted_peers(peer
);
901 if (peer
->ostatus
== Established
902 && bgp_update_delay_active(peer
->bgp
)) {
903 /* Adjust the update-delay state to account for this flap.
904 NOTE: Intentionally skipping adjusting implicit_eors or
906 counters. Extra sanity check in bgp_check_update_delay()
908 be enough to take care of any additive discrepancy in bgp eor
910 peer
->bgp
->established
--;
911 peer
->update_delay_over
= 0;
915 /* Called after event occured, this function change status and reset
916 read/write and timer thread. */
917 void bgp_fsm_change_status(struct peer
*peer
, int status
)
920 bgp_dump_state(peer
, peer
->status
, status
);
922 /* Transition into Clearing or Deleted must /always/ clear all routes..
923 * (and must do so before actually changing into Deleted..
925 if (status
>= Clearing
) {
926 bgp_clear_route_all(peer
);
928 /* If no route was queued for the clear-node processing,
930 * completion event here. This is needed because if there are no
932 * to trigger the background clear-node thread, the event won't
934 * generated and the peer would be stuck in Clearing. Note that
936 * event is for the peer and helps the peer transition out of
938 * state; it should not be generated per (AFI,SAFI). The event
940 * directly posted here without calling clear_node_complete() as
942 * shouldn't do an extra unlock. This event will get processed
944 * the state change that happens below, so peer will be in
948 if (!work_queue_is_scheduled(peer
->clear_node_queue
))
949 BGP_EVENT_ADD(peer
, Clearing_Completed
);
952 /* Preserve old status and change into new status. */
953 peer
->ostatus
= peer
->status
;
954 peer
->status
= status
;
956 /* Save event that caused status change. */
957 peer
->last_major_event
= peer
->cur_event
;
959 if (status
== Established
)
960 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
962 /* If max-med processing is applicable, do the necessary. */
963 if (status
== Established
) {
964 if (bgp_maxmed_onstartup_configured(peer
->bgp
)
965 && bgp_maxmed_onstartup_applicable(peer
->bgp
))
966 bgp_maxmed_onstartup_process_status_change(peer
);
968 peer
->bgp
->maxmed_onstartup_over
= 1;
971 /* If update-delay processing is applicable, do the necessary. */
972 if (bgp_update_delay_configured(peer
->bgp
)
973 && bgp_update_delay_applicable(peer
->bgp
))
974 bgp_update_delay_process_status_change(peer
);
976 if (bgp_debug_neighbor_events(peer
))
977 zlog_debug("%s went from %s to %s", peer
->host
,
978 lookup_msg(bgp_status_msg
, peer
->ostatus
, NULL
),
979 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
982 /* Flush the event queue and ensure the peer is shut down */
983 static int bgp_clearing_completed(struct peer
*peer
)
985 int rc
= bgp_stop(peer
);
988 BGP_EVENT_FLUSH(peer
);
993 /* Administrative BGP peer stop event. */
994 /* May be called multiple times for the same peer */
995 int bgp_stop(struct peer
*peer
)
999 char orf_name
[BUFSIZ
];
1002 if (peer_dynamic_neighbor(peer
)
1003 && !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
1004 if (bgp_debug_neighbor_events(peer
))
1005 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1010 /* Can't do this in Clearing; events are used for state transitions */
1011 if (peer
->status
!= Clearing
) {
1012 /* Delete all existing events of the peer */
1013 BGP_EVENT_FLUSH(peer
);
1016 /* Increment Dropped count. */
1017 if (peer
->status
== Established
) {
1020 /* bgp log-neighbor-changes of neighbor Down */
1021 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)) {
1022 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1024 "%%ADJCHANGE: neighbor %s(%s) in vrf %s Down %s",
1026 (peer
->hostname
) ? peer
->hostname
: "Unknown",
1027 vrf
? ((vrf
->vrf_id
!= VRF_DEFAULT
) ? vrf
->name
1030 peer_down_str
[(int)peer
->last_reset
]);
1033 /* graceful restart */
1034 if (peer
->t_gr_stale
) {
1035 BGP_TIMER_OFF(peer
->t_gr_stale
);
1036 if (bgp_debug_neighbor_events(peer
))
1038 "%s graceful restart stalepath timer stopped",
1041 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)) {
1042 if (bgp_debug_neighbor_events(peer
)) {
1044 "%s graceful restart timer started for %d sec",
1045 peer
->host
, peer
->v_gr_restart
);
1047 "%s graceful restart stalepath timer started for %d sec",
1048 peer
->host
, peer
->bgp
->stalepath_time
);
1050 BGP_TIMER_ON(peer
->t_gr_restart
,
1051 bgp_graceful_restart_timer_expire
,
1052 peer
->v_gr_restart
);
1053 BGP_TIMER_ON(peer
->t_gr_stale
,
1054 bgp_graceful_stale_timer_expire
,
1055 peer
->bgp
->stalepath_time
);
1057 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1059 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1060 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
;
1062 peer
->nsf
[afi
][safi
] = 0;
1065 /* set last reset time */
1066 peer
->resettime
= peer
->uptime
= bgp_clock();
1068 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1069 zlog_debug("%s remove from all update group",
1071 update_group_remove_peer_afs(peer
);
1073 hook_call(peer_backward_transition
, peer
);
1075 /* Reset peer synctime */
1078 bgp_bfd_deregister_peer(peer
);
1081 /* stop keepalives */
1082 bgp_keepalives_off(peer
);
1084 /* Stop read and write threads. */
1085 bgp_writes_off(peer
);
1086 bgp_reads_off(peer
);
1088 THREAD_OFF(peer
->t_connect_check_r
);
1089 THREAD_OFF(peer
->t_connect_check_w
);
1091 /* Stop all timers. */
1092 BGP_TIMER_OFF(peer
->t_start
);
1093 BGP_TIMER_OFF(peer
->t_connect
);
1094 BGP_TIMER_OFF(peer
->t_holdtime
);
1095 BGP_TIMER_OFF(peer
->t_routeadv
);
1097 /* Clear input and output buffer. */
1098 pthread_mutex_lock(&peer
->io_mtx
);
1101 stream_fifo_clean(peer
->ibuf
);
1103 stream_fifo_clean(peer
->obuf
);
1105 if (peer
->ibuf_work
)
1106 ringbuf_wipe(peer
->ibuf_work
);
1107 if (peer
->obuf_work
)
1108 stream_reset(peer
->obuf_work
);
1111 stream_free(peer
->curr
);
1115 pthread_mutex_unlock(&peer
->io_mtx
);
1117 /* Close of file descriptor. */
1118 if (peer
->fd
>= 0) {
1123 FOREACH_AFI_SAFI (afi
, safi
) {
1124 /* Reset all negotiated variables */
1125 peer
->afc_nego
[afi
][safi
] = 0;
1126 peer
->afc_adv
[afi
][safi
] = 0;
1127 peer
->afc_recv
[afi
][safi
] = 0;
1129 /* peer address family capability flags*/
1130 peer
->af_cap
[afi
][safi
] = 0;
1132 /* peer address family status flags*/
1133 peer
->af_sflags
[afi
][safi
] = 0;
1135 /* Received ORF prefix-filter */
1136 peer
->orf_plist
[afi
][safi
] = NULL
;
1138 if ((peer
->status
== OpenConfirm
)
1139 || (peer
->status
== Established
)) {
1140 /* ORF received prefix-filter pnt */
1141 sprintf(orf_name
, "%s.%d.%d", peer
->host
, afi
, safi
);
1142 prefix_bgp_orf_remove_all(afi
, orf_name
);
1146 /* Reset keepalive and holdtime */
1147 if (PEER_OR_GROUP_TIMER_SET(peer
)) {
1148 peer
->v_keepalive
= peer
->keepalive
;
1149 peer
->v_holdtime
= peer
->holdtime
;
1151 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
1152 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
1155 peer
->update_time
= 0;
1157 /* Until we are sure that there is no problem about prefix count
1158 this should be commented out.*/
1160 /* Reset prefix count */
1161 peer
->pcount
[AFI_IP
][SAFI_UNICAST
] = 0;
1162 peer
->pcount
[AFI_IP
][SAFI_MULTICAST
] = 0;
1163 peer
->pcount
[AFI_IP
][SAFI_LABELED_UNICAST
] = 0;
1164 peer
->pcount
[AFI_IP
][SAFI_MPLS_VPN
] = 0;
1165 peer
->pcount
[AFI_IP6
][SAFI_UNICAST
] = 0;
1166 peer
->pcount
[AFI_IP6
][SAFI_MULTICAST
] = 0;
1167 peer
->pcount
[AFI_IP6
][SAFI_LABELED_UNICAST
] = 0;
1170 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1171 && !(CHECK_FLAG(peer
->flags
, PEER_FLAG_DELETE
))) {
1175 bgp_peer_conf_if_to_su_update(peer
);
1181 /* BGP peer is stoped by the error. */
1182 static int bgp_stop_with_error(struct peer
*peer
)
1184 /* Double start timer. */
1187 /* Overflow check. */
1188 if (peer
->v_start
>= (60 * 2))
1189 peer
->v_start
= (60 * 2);
1191 if (peer_dynamic_neighbor(peer
)) {
1192 if (bgp_debug_neighbor_events(peer
))
1193 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1198 return (bgp_stop(peer
));
1202 /* something went wrong, send notify and tear down */
1203 static int bgp_stop_with_notify(struct peer
*peer
, uint8_t code
,
1206 /* Send notify to remote peer */
1207 bgp_notify_send(peer
, code
, sub_code
);
1209 if (peer_dynamic_neighbor(peer
)) {
1210 if (bgp_debug_neighbor_events(peer
))
1211 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1216 /* Clear start timer value to default. */
1217 peer
->v_start
= BGP_INIT_START_TIMER
;
1219 return (bgp_stop(peer
));
1223 * Determines whether a TCP session has successfully established for a peer and
1224 * events as appropriate.
1226 * This function is called when setting up a new session. After connect() is
1227 * called on the peer's socket (in bgp_start()), the fd is passed to poll()
1228 * to wait for connection success or failure. When poll() returns, this
1229 * function is called to evaluate the result.
1231 * Due to differences in behavior of poll() on Linux and BSD - specifically,
1232 * the value of .revents in the case of a closed connection - this function is
1233 * scheduled both for a read and a write event. The write event is triggered
1234 * when the connection is established. A read event is triggered when the
1235 * connection is closed. Thus we need to cancel whichever one did not occur.
1237 static int bgp_connect_check(struct thread
*thread
)
1244 peer
= THREAD_ARG(thread
);
1245 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
1246 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
1247 assert(!peer
->t_read
);
1248 assert(!peer
->t_write
);
1250 THREAD_OFF(peer
->t_connect_check_r
);
1251 THREAD_OFF(peer
->t_connect_check_w
);
1253 /* Check file descriptor. */
1254 slen
= sizeof(status
);
1255 ret
= getsockopt(peer
->fd
, SOL_SOCKET
, SO_ERROR
, (void *)&status
,
1258 /* If getsockopt is fail, this is fatal error. */
1260 zlog_info("can't get sockopt for nonblocking connect: %d(%s)",
1261 errno
, safe_strerror(errno
));
1262 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1266 /* When status is 0 then TCP connection is established. */
1268 BGP_EVENT_ADD(peer
, TCP_connection_open
);
1271 if (bgp_debug_neighbor_events(peer
))
1272 zlog_debug("%s [Event] Connect failed %d(%s)",
1273 peer
->host
, status
, safe_strerror(status
));
1274 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1279 /* TCP connection open. Next we send open message to remote peer. And
1280 add read thread for reading open message. */
1281 static int bgp_connect_success(struct peer
*peer
)
1284 zlog_err("bgp_connect_success peer's fd is negative value %d",
1290 if (bgp_getsockname(peer
) < 0) {
1291 zlog_err("%s: bgp_getsockname(): failed for peer %s, fd %d",
1292 __FUNCTION__
, peer
->host
, peer
->fd
);
1293 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
1294 0); /* internal error */
1295 bgp_writes_on(peer
);
1301 if (bgp_debug_neighbor_events(peer
)) {
1302 char buf1
[SU_ADDRSTRLEN
];
1304 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
1305 zlog_debug("%s open active, local address %s",
1307 sockunion2str(peer
->su_local
, buf1
,
1310 zlog_debug("%s passive open", peer
->host
);
1313 bgp_open_send(peer
);
1318 /* TCP connect fail */
1319 static int bgp_connect_fail(struct peer
*peer
)
1321 if (peer_dynamic_neighbor(peer
)) {
1322 if (bgp_debug_neighbor_events(peer
))
1323 zlog_debug("%s (dynamic neighbor) deleted", peer
->host
);
1328 return (bgp_stop(peer
));
1331 /* This function is the first starting point of all BGP connection. It
1332 try to connect to remote peer with non-blocking IO. */
1333 int bgp_start(struct peer
*peer
)
1338 bgp_peer_conf_if_to_su_update(peer
);
1340 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
) {
1341 if (bgp_debug_neighbor_events(peer
))
1343 "%s [FSM] Unable to get neighbor's IP address, waiting...",
1348 if (BGP_PEER_START_SUPPRESSED(peer
)) {
1349 if (bgp_debug_neighbor_events(peer
))
1351 "%s [FSM] Trying to start suppressed peer"
1352 " - this is never supposed to happen!",
1357 /* Scrub some information that might be left over from a previous,
1360 /* Connection information. */
1361 if (peer
->su_local
) {
1362 sockunion_free(peer
->su_local
);
1363 peer
->su_local
= NULL
;
1366 if (peer
->su_remote
) {
1367 sockunion_free(peer
->su_remote
);
1368 peer
->su_remote
= NULL
;
1371 /* Clear remote router-id. */
1372 peer
->remote_id
.s_addr
= 0;
1374 /* Clear peer capability flag. */
1377 /* If the peer is passive mode, force to move to Active mode. */
1378 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)) {
1379 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1383 if (peer
->bgp
->vrf_id
== VRF_UNKNOWN
) {
1384 if (bgp_debug_neighbor_events(peer
))
1386 "%s [FSM] In a VRF that is not initialised yet",
1391 /* Register to be notified on peer up */
1392 if (peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
== 1
1393 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)
1394 && !bgp_flag_check(peer
->bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
1399 if (!bgp_find_or_add_nexthop(peer
->bgp
, peer
->bgp
,
1400 family2afi(peer
->su
.sa
.sa_family
), NULL
,
1402 if (bgp_zebra_num_connects()) {
1403 if (bgp_debug_neighbor_events(peer
))
1404 zlog_debug("%s [FSM] Waiting for NHT",
1407 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1412 assert(!peer
->t_write
);
1413 assert(!peer
->t_read
);
1414 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
1415 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
1416 status
= bgp_connect(peer
);
1420 if (bgp_debug_neighbor_events(peer
))
1421 zlog_debug("%s [FSM] Connect error", peer
->host
);
1422 BGP_EVENT_ADD(peer
, TCP_connection_open_failed
);
1424 case connect_success
:
1425 if (bgp_debug_neighbor_events(peer
))
1427 "%s [FSM] Connect immediately success, fd %d",
1428 peer
->host
, peer
->fd
);
1429 BGP_EVENT_ADD(peer
, TCP_connection_open
);
1431 case connect_in_progress
:
1432 /* To check nonblocking connect, we wait until socket is
1433 readable or writable. */
1434 if (bgp_debug_neighbor_events(peer
))
1436 "%s [FSM] Non blocking connect waiting result, fd %d",
1437 peer
->host
, peer
->fd
);
1439 zlog_err("bgp_start peer's fd is negative value %d",
1444 * - when the socket becomes ready, poll() will signify POLLOUT
1445 * - if it fails to connect, poll() will signify POLLHUP
1446 * - POLLHUP is handled as a 'read' event by thread.c
1448 * therefore, we schedule both a read and a write event with
1449 * bgp_connect_check() as the handler for each and cancel the
1450 * unused event in that function.
1452 thread_add_read(bm
->master
, bgp_connect_check
, peer
, peer
->fd
,
1453 &peer
->t_connect_check_r
);
1454 thread_add_write(bm
->master
, bgp_connect_check
, peer
, peer
->fd
,
1455 &peer
->t_connect_check_w
);
1461 /* Connect retry timer is expired when the peer status is Connect. */
1462 static int bgp_reconnect(struct peer
*peer
)
1464 if (bgp_stop(peer
) < 0)
1471 static int bgp_fsm_open(struct peer
*peer
)
1473 /* Send keepalive and make keepalive timer */
1474 bgp_keepalive_send(peer
);
1476 /* Reset holdtimer value. */
1477 BGP_TIMER_OFF(peer
->t_holdtime
);
1482 /* FSM error, unexpected event. This is error of BGP connection. So cut the
1483 peer and change to Idle status. */
1484 static int bgp_fsm_event_error(struct peer
*peer
)
1486 zlog_err("%s [FSM] unexpected packet received in state %s", peer
->host
,
1487 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1489 return bgp_stop_with_notify(peer
, BGP_NOTIFY_FSM_ERR
, 0);
1492 /* Hold timer expire. This is error of BGP connection. So cut the
1493 peer and change to Idle status. */
1494 static int bgp_fsm_holdtime_expire(struct peer
*peer
)
1496 if (bgp_debug_neighbor_events(peer
))
1497 zlog_debug("%s [FSM] Hold timer expire", peer
->host
);
1499 return bgp_stop_with_notify(peer
, BGP_NOTIFY_HOLD_ERR
, 0);
1503 * Transition to Established state.
1505 * Convert peer from stub to full fledged peer, set some timers, and generate
1508 static int bgp_establish(struct peer
*peer
)
1512 int nsf_af_count
= 0;
1516 other
= peer
->doppelganger
;
1517 peer
= peer_xfer_conn(peer
);
1519 zlog_err("%%Neighbor failed in xfer_conn");
1524 ret
= 1; /* bgp_establish specific code when xfer_conn
1527 /* Reset capability open status flag. */
1528 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
))
1529 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1531 /* Clear start timer value to default. */
1532 peer
->v_start
= BGP_INIT_START_TIMER
;
1534 /* Increment established count. */
1535 peer
->established
++;
1536 bgp_fsm_change_status(peer
, Established
);
1538 /* bgp log-neighbor-changes of neighbor Up */
1539 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)) {
1540 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1541 zlog_info("%%ADJCHANGE: neighbor %s(%s) in vrf %s Up",
1543 (peer
->hostname
) ? peer
->hostname
: "Unknown",
1544 vrf
? ((vrf
->vrf_id
!= VRF_DEFAULT
) ? vrf
->name
1548 /* assign update-group/subgroup */
1549 update_group_adjust_peer_afs(peer
);
1551 /* graceful restart */
1552 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
1553 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1554 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++) {
1555 if (peer
->afc_nego
[afi
][safi
]
1556 && CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
)
1557 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1558 PEER_CAP_RESTART_AF_RCV
)) {
1559 if (peer
->nsf
[afi
][safi
]
1561 peer
->af_cap
[afi
][safi
],
1562 PEER_CAP_RESTART_AF_PRESERVE_RCV
))
1563 bgp_clear_stale_route(peer
, afi
, safi
);
1565 peer
->nsf
[afi
][safi
] = 1;
1568 if (peer
->nsf
[afi
][safi
])
1569 bgp_clear_stale_route(peer
, afi
, safi
);
1570 peer
->nsf
[afi
][safi
] = 0;
1575 SET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1577 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
1578 if (peer
->t_gr_stale
) {
1579 BGP_TIMER_OFF(peer
->t_gr_stale
);
1580 if (bgp_debug_neighbor_events(peer
))
1582 "%s graceful restart stalepath timer stopped",
1587 if (peer
->t_gr_restart
) {
1588 BGP_TIMER_OFF(peer
->t_gr_restart
);
1589 if (bgp_debug_neighbor_events(peer
))
1590 zlog_debug("%s graceful restart timer stopped",
1594 hook_call(peer_established
, peer
);
1596 /* Reset uptime, turn on keepalives, send current table. */
1597 if (!peer
->v_holdtime
)
1598 bgp_keepalives_on(peer
);
1600 peer
->uptime
= bgp_clock();
1602 /* Send route-refresh when ORF is enabled */
1603 FOREACH_AFI_SAFI (afi
, safi
) {
1604 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1605 PEER_CAP_ORF_PREFIX_SM_ADV
)) {
1606 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1607 PEER_CAP_ORF_PREFIX_RM_RCV
))
1608 bgp_route_refresh_send(peer
, afi
, safi
,
1610 REFRESH_IMMEDIATE
, 0);
1611 else if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1612 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))
1613 bgp_route_refresh_send(peer
, afi
, safi
,
1614 ORF_TYPE_PREFIX_OLD
,
1615 REFRESH_IMMEDIATE
, 0);
1619 /* First update is deferred until ORF or ROUTE-REFRESH is received */
1620 FOREACH_AFI_SAFI (afi
, safi
) {
1621 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1622 PEER_CAP_ORF_PREFIX_RM_ADV
))
1623 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1624 PEER_CAP_ORF_PREFIX_SM_RCV
)
1625 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1626 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
))
1627 SET_FLAG(peer
->af_sflags
[afi
][safi
],
1628 PEER_STATUS_ORF_WAIT_REFRESH
);
1631 bgp_announce_peer(peer
);
1633 /* Start the route advertisement timer to send updates to the peer - if
1635 * is not in read-only mode. If it is, the timer will be started at the
1637 * of read-only mode.
1639 if (!bgp_update_delay_active(peer
->bgp
)) {
1640 BGP_TIMER_OFF(peer
->t_routeadv
);
1641 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
1644 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)) {
1645 if (bgp_debug_neighbor_events(peer
))
1647 "[Event] Deleting stub connection for peer %s",
1650 if (peer
->doppelganger
->status
> Active
)
1651 bgp_notify_send(peer
->doppelganger
, BGP_NOTIFY_CEASE
,
1652 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1654 peer_delete(peer
->doppelganger
);
1657 bgp_bfd_register_peer(peer
);
1661 /* Keepalive packet is received. */
1662 static int bgp_fsm_keepalive(struct peer
*peer
)
1664 BGP_TIMER_OFF(peer
->t_holdtime
);
1668 /* Update packet is received. */
1669 static int bgp_fsm_update(struct peer
*peer
)
1671 BGP_TIMER_OFF(peer
->t_holdtime
);
1675 /* This is empty event. */
1676 static int bgp_ignore(struct peer
*peer
)
1679 "%s [FSM] Ignoring event %s in state %s, prior events %s, %s, fd %d",
1680 peer
->host
, bgp_event_str
[peer
->cur_event
],
1681 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1682 bgp_event_str
[peer
->last_event
],
1683 bgp_event_str
[peer
->last_major_event
], peer
->fd
);
1687 /* This is to handle unexpected events.. */
1688 static int bgp_fsm_exeption(struct peer
*peer
)
1691 "%s [FSM] Unexpected event %s in state %s, prior events %s, %s, fd %d",
1692 peer
->host
, bgp_event_str
[peer
->cur_event
],
1693 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1694 bgp_event_str
[peer
->last_event
],
1695 bgp_event_str
[peer
->last_major_event
], peer
->fd
);
1696 return (bgp_stop(peer
));
1699 void bgp_fsm_nht_update(struct peer
*peer
, int valid
)
1704 switch (peer
->status
) {
1707 BGP_EVENT_ADD(peer
, BGP_Start
);
1711 BGP_TIMER_OFF(peer
->t_connect
);
1712 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1717 BGP_TIMER_OFF(peer
->t_connect
);
1718 BGP_EVENT_ADD(peer
, ConnectRetry_timer_expired
);
1724 if (!valid
&& (peer
->gtsm_hops
== 1))
1725 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
1734 /* Finite State Machine structure */
1735 static const struct {
1736 int (*func
)(struct peer
*);
1738 } FSM
[BGP_STATUS_MAX
- 1][BGP_EVENTS_MAX
- 1] = {
1740 /* Idle state: In Idle state, all events other than BGP_Start is
1741 ignored. With BGP_Start event, finite state machine calls
1743 {bgp_start
, Connect
}, /* BGP_Start */
1744 {bgp_stop
, Idle
}, /* BGP_Stop */
1745 {bgp_stop
, Idle
}, /* TCP_connection_open */
1746 {bgp_stop
, Idle
}, /* TCP_connection_closed */
1747 {bgp_ignore
, Idle
}, /* TCP_connection_open_failed */
1748 {bgp_stop
, Idle
}, /* TCP_fatal_error */
1749 {bgp_ignore
, Idle
}, /* ConnectRetry_timer_expired */
1750 {bgp_ignore
, Idle
}, /* Hold_Timer_expired */
1751 {bgp_ignore
, Idle
}, /* KeepAlive_timer_expired */
1752 {bgp_ignore
, Idle
}, /* Receive_OPEN_message */
1753 {bgp_ignore
, Idle
}, /* Receive_KEEPALIVE_message */
1754 {bgp_ignore
, Idle
}, /* Receive_UPDATE_message */
1755 {bgp_ignore
, Idle
}, /* Receive_NOTIFICATION_message */
1756 {bgp_ignore
, Idle
}, /* Clearing_Completed */
1760 {bgp_ignore
, Connect
}, /* BGP_Start */
1761 {bgp_stop
, Idle
}, /* BGP_Stop */
1762 {bgp_connect_success
, OpenSent
}, /* TCP_connection_open */
1763 {bgp_stop
, Idle
}, /* TCP_connection_closed */
1764 {bgp_connect_fail
, Active
}, /* TCP_connection_open_failed */
1765 {bgp_connect_fail
, Idle
}, /* TCP_fatal_error */
1766 {bgp_reconnect
, Connect
}, /* ConnectRetry_timer_expired */
1767 {bgp_fsm_exeption
, Idle
}, /* Hold_Timer_expired */
1768 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
1769 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
1770 {bgp_fsm_exeption
, Idle
}, /* Receive_KEEPALIVE_message */
1771 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
1772 {bgp_stop
, Idle
}, /* Receive_NOTIFICATION_message */
1773 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1777 {bgp_ignore
, Active
}, /* BGP_Start */
1778 {bgp_stop
, Idle
}, /* BGP_Stop */
1779 {bgp_connect_success
, OpenSent
}, /* TCP_connection_open */
1780 {bgp_stop
, Idle
}, /* TCP_connection_closed */
1781 {bgp_ignore
, Active
}, /* TCP_connection_open_failed */
1782 {bgp_fsm_exeption
, Idle
}, /* TCP_fatal_error */
1783 {bgp_start
, Connect
}, /* ConnectRetry_timer_expired */
1784 {bgp_fsm_exeption
, Idle
}, /* Hold_Timer_expired */
1785 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
1786 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
1787 {bgp_fsm_exeption
, Idle
}, /* Receive_KEEPALIVE_message */
1788 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
1789 {bgp_fsm_exeption
, Idle
}, /* Receive_NOTIFICATION_message */
1790 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1794 {bgp_ignore
, OpenSent
}, /* BGP_Start */
1795 {bgp_stop
, Idle
}, /* BGP_Stop */
1796 {bgp_stop
, Active
}, /* TCP_connection_open */
1797 {bgp_stop
, Active
}, /* TCP_connection_closed */
1798 {bgp_stop
, Active
}, /* TCP_connection_open_failed */
1799 {bgp_stop
, Active
}, /* TCP_fatal_error */
1800 {bgp_fsm_exeption
, Idle
}, /* ConnectRetry_timer_expired */
1801 {bgp_fsm_holdtime_expire
, Idle
}, /* Hold_Timer_expired */
1802 {bgp_fsm_exeption
, Idle
}, /* KeepAlive_timer_expired */
1803 {bgp_fsm_open
, OpenConfirm
}, /* Receive_OPEN_message */
1804 {bgp_fsm_event_error
, Idle
}, /* Receive_KEEPALIVE_message */
1805 {bgp_fsm_event_error
, Idle
}, /* Receive_UPDATE_message */
1806 {bgp_stop_with_error
, Idle
}, /* Receive_NOTIFICATION_message */
1807 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1811 {bgp_ignore
, OpenConfirm
}, /* BGP_Start */
1812 {bgp_stop
, Idle
}, /* BGP_Stop */
1813 {bgp_stop
, Idle
}, /* TCP_connection_open */
1814 {bgp_stop
, Idle
}, /* TCP_connection_closed */
1815 {bgp_stop
, Idle
}, /* TCP_connection_open_failed */
1816 {bgp_stop
, Idle
}, /* TCP_fatal_error */
1817 {bgp_fsm_exeption
, Idle
}, /* ConnectRetry_timer_expired */
1818 {bgp_fsm_holdtime_expire
, Idle
}, /* Hold_Timer_expired */
1819 {bgp_ignore
, OpenConfirm
}, /* KeepAlive_timer_expired */
1820 {bgp_fsm_exeption
, Idle
}, /* Receive_OPEN_message */
1821 {bgp_establish
, Established
}, /* Receive_KEEPALIVE_message */
1822 {bgp_fsm_exeption
, Idle
}, /* Receive_UPDATE_message */
1823 {bgp_stop_with_error
, Idle
}, /* Receive_NOTIFICATION_message */
1824 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1828 {bgp_ignore
, Established
}, /* BGP_Start */
1829 {bgp_stop
, Clearing
}, /* BGP_Stop */
1830 {bgp_stop
, Clearing
}, /* TCP_connection_open */
1831 {bgp_stop
, Clearing
}, /* TCP_connection_closed */
1832 {bgp_stop
, Clearing
}, /* TCP_connection_open_failed */
1833 {bgp_stop
, Clearing
}, /* TCP_fatal_error */
1834 {bgp_stop
, Clearing
}, /* ConnectRetry_timer_expired */
1835 {bgp_fsm_holdtime_expire
, Clearing
}, /* Hold_Timer_expired */
1836 {bgp_ignore
, Established
}, /* KeepAlive_timer_expired */
1837 {bgp_stop
, Clearing
}, /* Receive_OPEN_message */
1839 Established
}, /* Receive_KEEPALIVE_message */
1840 {bgp_fsm_update
, Established
}, /* Receive_UPDATE_message */
1841 {bgp_stop_with_error
,
1842 Clearing
}, /* Receive_NOTIFICATION_message */
1843 {bgp_fsm_exeption
, Idle
}, /* Clearing_Completed */
1847 {bgp_ignore
, Clearing
}, /* BGP_Start */
1848 {bgp_stop
, Clearing
}, /* BGP_Stop */
1849 {bgp_stop
, Clearing
}, /* TCP_connection_open */
1850 {bgp_stop
, Clearing
}, /* TCP_connection_closed */
1851 {bgp_stop
, Clearing
}, /* TCP_connection_open_failed */
1852 {bgp_stop
, Clearing
}, /* TCP_fatal_error */
1853 {bgp_stop
, Clearing
}, /* ConnectRetry_timer_expired */
1854 {bgp_stop
, Clearing
}, /* Hold_Timer_expired */
1855 {bgp_stop
, Clearing
}, /* KeepAlive_timer_expired */
1856 {bgp_stop
, Clearing
}, /* Receive_OPEN_message */
1857 {bgp_stop
, Clearing
}, /* Receive_KEEPALIVE_message */
1858 {bgp_stop
, Clearing
}, /* Receive_UPDATE_message */
1859 {bgp_stop
, Clearing
}, /* Receive_NOTIFICATION_message */
1860 {bgp_clearing_completed
, Idle
}, /* Clearing_Completed */
1864 {bgp_ignore
, Deleted
}, /* BGP_Start */
1865 {bgp_ignore
, Deleted
}, /* BGP_Stop */
1866 {bgp_ignore
, Deleted
}, /* TCP_connection_open */
1867 {bgp_ignore
, Deleted
}, /* TCP_connection_closed */
1868 {bgp_ignore
, Deleted
}, /* TCP_connection_open_failed */
1869 {bgp_ignore
, Deleted
}, /* TCP_fatal_error */
1870 {bgp_ignore
, Deleted
}, /* ConnectRetry_timer_expired */
1871 {bgp_ignore
, Deleted
}, /* Hold_Timer_expired */
1872 {bgp_ignore
, Deleted
}, /* KeepAlive_timer_expired */
1873 {bgp_ignore
, Deleted
}, /* Receive_OPEN_message */
1874 {bgp_ignore
, Deleted
}, /* Receive_KEEPALIVE_message */
1875 {bgp_ignore
, Deleted
}, /* Receive_UPDATE_message */
1876 {bgp_ignore
, Deleted
}, /* Receive_NOTIFICATION_message */
1877 {bgp_ignore
, Deleted
}, /* Clearing_Completed */
1881 /* Execute event process. */
1882 int bgp_event(struct thread
*thread
)
1888 peer
= THREAD_ARG(thread
);
1889 event
= THREAD_VAL(thread
);
1891 ret
= bgp_event_update(peer
, event
);
1896 int bgp_event_update(struct peer
*peer
, int event
)
1901 int passive_conn
= 0;
1904 /* default return code */
1905 ret
= FSM_PEER_NOOP
;
1907 other
= peer
->doppelganger
;
1909 (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
)) ? 1 : 0;
1910 dyn_nbr
= peer_dynamic_neighbor(peer
);
1912 /* Logging this event. */
1913 next
= FSM
[peer
->status
- 1][event
- 1].next_state
;
1915 if (bgp_debug_neighbor_events(peer
) && peer
->status
!= next
)
1916 zlog_debug("%s [FSM] %s (%s->%s), fd %d", peer
->host
,
1917 bgp_event_str
[event
],
1918 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1919 lookup_msg(bgp_status_msg
, next
, NULL
), peer
->fd
);
1921 peer
->last_event
= peer
->cur_event
;
1922 peer
->cur_event
= event
;
1924 /* Call function. */
1925 if (FSM
[peer
->status
- 1][event
- 1].func
)
1926 ret
= (*(FSM
[peer
->status
- 1][event
- 1].func
))(peer
);
1929 if (ret
== 1 && next
== Established
) {
1930 /* The case when doppelganger swap accurred in
1932 Update the peer pointer accordingly */
1933 ret
= FSM_PEER_TRANSFERRED
;
1937 /* If status is changed. */
1938 if (next
!= peer
->status
) {
1939 bgp_fsm_change_status(peer
, next
);
1942 * If we're going to ESTABLISHED then we executed a
1943 * peer transfer. In this case we can either return
1944 * FSM_PEER_TRANSITIONED or FSM_PEER_TRANSFERRED.
1945 * Opting for TRANSFERRED since transfer implies
1946 * session establishment.
1948 if (ret
!= FSM_PEER_TRANSFERRED
)
1949 ret
= FSM_PEER_TRANSITIONED
;
1952 /* Make sure timer is set. */
1953 bgp_timer_set(peer
);
1957 * If we got a return value of -1, that means there was an
1958 * error, restart the FSM. Since bgp_stop() was called on the
1959 * peer. only a few fields are safe to access here. In any case
1960 * we need to indicate that the peer was stopped in the return
1963 if (!dyn_nbr
&& !passive_conn
&& peer
->bgp
) {
1965 "%s [FSM] Failure handling event %s in state %s, "
1966 "prior events %s, %s, fd %d",
1967 peer
->host
, bgp_event_str
[peer
->cur_event
],
1968 lookup_msg(bgp_status_msg
, peer
->status
, NULL
),
1969 bgp_event_str
[peer
->last_event
],
1970 bgp_event_str
[peer
->last_major_event
],
1973 bgp_fsm_change_status(peer
, Idle
);
1974 bgp_timer_set(peer
);
1976 ret
= FSM_PEER_STOPPED
;