]> git.proxmox.com Git - mirror_frr.git/blob - bgpd/bgp_fsm.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #2810 from chiragshah6/evpn_dev1
[mirror_frr.git] / bgpd / bgp_fsm.c
1 /* BGP-4 Finite State Machine
2 * From RFC1771 [A Border Gateway Protocol 4 (BGP-4)]
3 * Copyright (C) 1996, 97, 98 Kunihiro Ishiguro
4 *
5 * This file is part of GNU Zebra.
6 *
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
10 * later version.
11 *
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.
16 *
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
20 */
21
22 #include <zebra.h>
23
24 #include "linklist.h"
25 #include "prefix.h"
26 #include "sockunion.h"
27 #include "thread.h"
28 #include "log.h"
29 #include "stream.h"
30 #include "ringbuf.h"
31 #include "memory.h"
32 #include "plist.h"
33 #include "workqueue.h"
34 #include "queue.h"
35 #include "filter.h"
36 #include "command.h"
37 #include "lib_errors.h"
38
39 #include "lib/json.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"
58
59 DEFINE_HOOK(peer_backward_transition, (struct peer * peer), (peer))
60 DEFINE_HOOK(peer_established, (struct peer * peer), (peer))
61
62 /* Definition of display strings corresponding to FSM events. This should be
63 * kept consistent with the events defined in bgpd.h
64 */
65 static const char *bgp_event_str[] = {
66 NULL,
67 "BGP_Start",
68 "BGP_Stop",
69 "TCP_connection_open",
70 "TCP_connection_closed",
71 "TCP_connection_open_failed",
72 "TCP_fatal_error",
73 "ConnectRetry_timer_expired",
74 "Hold_Timer_expired",
75 "KeepAlive_timer_expired",
76 "Receive_OPEN_message",
77 "Receive_KEEPALIVE_message",
78 "Receive_UPDATE_message",
79 "Receive_NOTIFICATION_message",
80 "Clearing_Completed",
81 };
82
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
86 function. */
87
88 /* BGP event function. */
89 int bgp_event(struct thread *);
90
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 *);
95
96 /* BGP FSM functions. */
97 static int bgp_start(struct peer *);
98
99 static void peer_xfer_stats(struct peer *peer_dst, struct peer *peer_src)
100 {
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;
110 }
111
112 static struct peer *peer_xfer_conn(struct peer *from_peer)
113 {
114 struct peer *peer;
115 afi_t afi;
116 safi_t safi;
117 int fd;
118 int status, pstatus;
119 unsigned char last_evt, last_maj_evt;
120
121 assert(from_peer != NULL);
122
123 peer = from_peer->doppelganger;
124
125 if (!peer || !CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
126 return from_peer;
127
128 if (bgp_debug_neighbor_events(peer))
129 zlog_debug("%s: peer transfer %p fd %d -> %p fd %d)",
130 from_peer->host, from_peer, from_peer->fd, peer,
131 peer->fd);
132
133 bgp_writes_off(peer);
134 bgp_reads_off(peer);
135 bgp_writes_off(from_peer);
136 bgp_reads_off(from_peer);
137
138 BGP_TIMER_OFF(peer->t_routeadv);
139 BGP_TIMER_OFF(peer->t_connect);
140 BGP_TIMER_OFF(peer->t_connect_check_r);
141 BGP_TIMER_OFF(peer->t_connect_check_w);
142 BGP_TIMER_OFF(from_peer->t_routeadv);
143 BGP_TIMER_OFF(from_peer->t_connect);
144 BGP_TIMER_OFF(from_peer->t_connect_check_r);
145 BGP_TIMER_OFF(from_peer->t_connect_check_w);
146 BGP_TIMER_OFF(from_peer->t_process_packet);
147
148 /*
149 * At this point in time, it is possible that there are packets pending
150 * on various buffers. Those need to be transferred or dropped,
151 * otherwise we'll get spurious failures during session establishment.
152 */
153 pthread_mutex_lock(&peer->io_mtx);
154 pthread_mutex_lock(&from_peer->io_mtx);
155 {
156 fd = peer->fd;
157 peer->fd = from_peer->fd;
158 from_peer->fd = fd;
159
160 stream_fifo_clean(peer->ibuf);
161 stream_fifo_clean(peer->obuf);
162
163 /*
164 * this should never happen, since bgp_process_packet() is the
165 * only task that sets and unsets the current packet and it
166 * runs in our pthread.
167 */
168 if (peer->curr) {
169 flog_err(
170 BGP_ERR_PKT_PROCESS,
171 "[%s] Dropping pending packet on connection transfer:",
172 peer->host);
173 uint16_t type = stream_getc_from(peer->curr,
174 BGP_MARKER_SIZE + 2);
175 bgp_dump_packet(peer, type, peer->curr);
176 stream_free(peer->curr);
177 peer->curr = NULL;
178 }
179
180 // copy each packet from old peer's output queue to new peer
181 while (from_peer->obuf->head)
182 stream_fifo_push(peer->obuf,
183 stream_fifo_pop(from_peer->obuf));
184
185 // copy each packet from old peer's input queue to new peer
186 while (from_peer->ibuf->head)
187 stream_fifo_push(peer->ibuf,
188 stream_fifo_pop(from_peer->ibuf));
189
190 ringbuf_wipe(peer->ibuf_work);
191 ringbuf_copy(peer->ibuf_work, from_peer->ibuf_work,
192 ringbuf_remain(from_peer->ibuf_work));
193 }
194 pthread_mutex_unlock(&from_peer->io_mtx);
195 pthread_mutex_unlock(&peer->io_mtx);
196
197 peer->as = from_peer->as;
198 peer->v_holdtime = from_peer->v_holdtime;
199 peer->v_keepalive = from_peer->v_keepalive;
200 peer->v_routeadv = from_peer->v_routeadv;
201 peer->v_gr_restart = from_peer->v_gr_restart;
202 peer->cap = from_peer->cap;
203 status = peer->status;
204 pstatus = peer->ostatus;
205 last_evt = peer->last_event;
206 last_maj_evt = peer->last_major_event;
207 peer->status = from_peer->status;
208 peer->ostatus = from_peer->ostatus;
209 peer->last_event = from_peer->last_event;
210 peer->last_major_event = from_peer->last_major_event;
211 from_peer->status = status;
212 from_peer->ostatus = pstatus;
213 from_peer->last_event = last_evt;
214 from_peer->last_major_event = last_maj_evt;
215 peer->remote_id = from_peer->remote_id;
216
217 if (from_peer->hostname != NULL) {
218 if (peer->hostname) {
219 XFREE(MTYPE_BGP_PEER_HOST, peer->hostname);
220 peer->hostname = NULL;
221 }
222
223 peer->hostname = from_peer->hostname;
224 from_peer->hostname = NULL;
225 }
226
227 if (from_peer->domainname != NULL) {
228 if (peer->domainname) {
229 XFREE(MTYPE_BGP_PEER_HOST, peer->domainname);
230 peer->domainname = NULL;
231 }
232
233 peer->domainname = from_peer->domainname;
234 from_peer->domainname = NULL;
235 }
236
237 FOREACH_AFI_SAFI (afi, safi) {
238 peer->af_flags[afi][safi] = from_peer->af_flags[afi][safi];
239 peer->af_sflags[afi][safi] = from_peer->af_sflags[afi][safi];
240 peer->af_cap[afi][safi] = from_peer->af_cap[afi][safi];
241 peer->afc_nego[afi][safi] = from_peer->afc_nego[afi][safi];
242 peer->afc_adv[afi][safi] = from_peer->afc_adv[afi][safi];
243 peer->afc_recv[afi][safi] = from_peer->afc_recv[afi][safi];
244 peer->orf_plist[afi][safi] = from_peer->orf_plist[afi][safi];
245 }
246
247 if (bgp_getsockname(peer) < 0) {
248 flog_err(
249 LIB_ERR_SOCKET,
250 "%%bgp_getsockname() failed for %s peer %s fd %d (from_peer fd %d)",
251 (CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER)
252 ? "accept"
253 : ""),
254 peer->host, peer->fd, from_peer->fd);
255 bgp_stop(peer);
256 bgp_stop(from_peer);
257 return NULL;
258 }
259 if (from_peer->status > Active) {
260 if (bgp_getsockname(from_peer) < 0) {
261 flog_err(
262 LIB_ERR_SOCKET,
263 "%%bgp_getsockname() failed for %s from_peer %s fd %d (peer fd %d)",
264
265 (CHECK_FLAG(from_peer->sflags,
266 PEER_STATUS_ACCEPT_PEER)
267 ? "accept"
268 : ""),
269 from_peer->host, from_peer->fd, peer->fd);
270 bgp_stop(from_peer);
271 from_peer = NULL;
272 }
273 }
274
275
276 // Note: peer_xfer_stats() must be called with I/O turned OFF
277 if (from_peer)
278 peer_xfer_stats(peer, from_peer);
279
280 bgp_reads_on(peer);
281 bgp_writes_on(peer);
282 thread_add_timer_msec(bm->master, bgp_process_packet, peer, 0,
283 &peer->t_process_packet);
284
285 return (peer);
286 }
287
288 /* Hook function called after bgp event is occered. And vty's
289 neighbor command invoke this function after making neighbor
290 structure. */
291 void bgp_timer_set(struct peer *peer)
292 {
293 switch (peer->status) {
294 case Idle:
295 /* First entry point of peer's finite state machine. In Idle
296 status start timer is on unless peer is shutdown or peer is
297 inactive. All other timer must be turned off */
298 if (BGP_PEER_START_SUPPRESSED(peer) || !peer_active(peer)
299 || peer->bgp->vrf_id == VRF_UNKNOWN) {
300 BGP_TIMER_OFF(peer->t_start);
301 } else {
302 BGP_TIMER_ON(peer->t_start, bgp_start_timer,
303 peer->v_start);
304 }
305 BGP_TIMER_OFF(peer->t_connect);
306 BGP_TIMER_OFF(peer->t_holdtime);
307 bgp_keepalives_off(peer);
308 BGP_TIMER_OFF(peer->t_routeadv);
309 break;
310
311 case Connect:
312 /* After start timer is expired, the peer moves to Connect
313 status. Make sure start timer is off and connect timer is
314 on. */
315 BGP_TIMER_OFF(peer->t_start);
316 BGP_TIMER_ON(peer->t_connect, bgp_connect_timer,
317 peer->v_connect);
318 BGP_TIMER_OFF(peer->t_holdtime);
319 bgp_keepalives_off(peer);
320 BGP_TIMER_OFF(peer->t_routeadv);
321 break;
322
323 case Active:
324 /* Active is waiting connection from remote peer. And if
325 connect timer is expired, change status to Connect. */
326 BGP_TIMER_OFF(peer->t_start);
327 /* If peer is passive mode, do not set connect timer. */
328 if (CHECK_FLAG(peer->flags, PEER_FLAG_PASSIVE)
329 || CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)) {
330 BGP_TIMER_OFF(peer->t_connect);
331 } else {
332 BGP_TIMER_ON(peer->t_connect, bgp_connect_timer,
333 peer->v_connect);
334 }
335 BGP_TIMER_OFF(peer->t_holdtime);
336 bgp_keepalives_off(peer);
337 BGP_TIMER_OFF(peer->t_routeadv);
338 break;
339
340 case OpenSent:
341 /* OpenSent status. */
342 BGP_TIMER_OFF(peer->t_start);
343 BGP_TIMER_OFF(peer->t_connect);
344 if (peer->v_holdtime != 0) {
345 BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer,
346 peer->v_holdtime);
347 } else {
348 BGP_TIMER_OFF(peer->t_holdtime);
349 }
350 bgp_keepalives_off(peer);
351 BGP_TIMER_OFF(peer->t_routeadv);
352 break;
353
354 case OpenConfirm:
355 /* OpenConfirm status. */
356 BGP_TIMER_OFF(peer->t_start);
357 BGP_TIMER_OFF(peer->t_connect);
358
359 /* If the negotiated Hold Time value is zero, then the Hold Time
360 timer and KeepAlive timers are not started. */
361 if (peer->v_holdtime == 0) {
362 BGP_TIMER_OFF(peer->t_holdtime);
363 bgp_keepalives_off(peer);
364 } else {
365 BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer,
366 peer->v_holdtime);
367 bgp_keepalives_on(peer);
368 }
369 BGP_TIMER_OFF(peer->t_routeadv);
370 break;
371
372 case Established:
373 /* In Established status start and connect timer is turned
374 off. */
375 BGP_TIMER_OFF(peer->t_start);
376 BGP_TIMER_OFF(peer->t_connect);
377
378 /* Same as OpenConfirm, if holdtime is zero then both holdtime
379 and keepalive must be turned off. */
380 if (peer->v_holdtime == 0) {
381 BGP_TIMER_OFF(peer->t_holdtime);
382 bgp_keepalives_off(peer);
383 } else {
384 BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer,
385 peer->v_holdtime);
386 bgp_keepalives_on(peer);
387 }
388 break;
389 case Deleted:
390 BGP_TIMER_OFF(peer->t_gr_restart);
391 BGP_TIMER_OFF(peer->t_gr_stale);
392 BGP_TIMER_OFF(peer->t_pmax_restart);
393 /* fallthru */
394 case Clearing:
395 BGP_TIMER_OFF(peer->t_start);
396 BGP_TIMER_OFF(peer->t_connect);
397 BGP_TIMER_OFF(peer->t_holdtime);
398 bgp_keepalives_off(peer);
399 BGP_TIMER_OFF(peer->t_routeadv);
400 break;
401 }
402 }
403
404 /* BGP start timer. This function set BGP_Start event to thread value
405 and process event. */
406 static int bgp_start_timer(struct thread *thread)
407 {
408 struct peer *peer;
409
410 peer = THREAD_ARG(thread);
411 peer->t_start = NULL;
412
413 if (bgp_debug_neighbor_events(peer))
414 zlog_debug("%s [FSM] Timer (start timer expire).", peer->host);
415
416 THREAD_VAL(thread) = BGP_Start;
417 bgp_event(thread); /* bgp_event unlocks peer */
418
419 return 0;
420 }
421
422 /* BGP connect retry timer. */
423 static int bgp_connect_timer(struct thread *thread)
424 {
425 struct peer *peer;
426 int ret;
427
428 peer = THREAD_ARG(thread);
429
430 assert(!peer->t_write);
431 assert(!peer->t_read);
432
433 peer->t_connect = NULL;
434
435 if (bgp_debug_neighbor_events(peer))
436 zlog_debug("%s [FSM] Timer (connect timer expire)", peer->host);
437
438 if (CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER)) {
439 bgp_stop(peer);
440 ret = -1;
441 } else {
442 THREAD_VAL(thread) = ConnectRetry_timer_expired;
443 bgp_event(thread); /* bgp_event unlocks peer */
444 ret = 0;
445 }
446
447 return ret;
448 }
449
450 /* BGP holdtime timer. */
451 static int bgp_holdtime_timer(struct thread *thread)
452 {
453 struct peer *peer;
454
455 peer = THREAD_ARG(thread);
456 peer->t_holdtime = NULL;
457
458 if (bgp_debug_neighbor_events(peer))
459 zlog_debug("%s [FSM] Timer (holdtime timer expire)",
460 peer->host);
461
462 THREAD_VAL(thread) = Hold_Timer_expired;
463 bgp_event(thread); /* bgp_event unlocks peer */
464
465 return 0;
466 }
467
468 int bgp_routeadv_timer(struct thread *thread)
469 {
470 struct peer *peer;
471
472 peer = THREAD_ARG(thread);
473 peer->t_routeadv = NULL;
474
475 if (bgp_debug_neighbor_events(peer))
476 zlog_debug("%s [FSM] Timer (routeadv timer expire)",
477 peer->host);
478
479 peer->synctime = bgp_clock();
480
481 thread_add_timer_msec(bm->master, bgp_generate_updgrp_packets, peer, 0,
482 &peer->t_generate_updgrp_packets);
483
484 /* MRAI timer will be started again when FIFO is built, no need to
485 * do it here.
486 */
487 return 0;
488 }
489
490 /* BGP Peer Down Cause */
491 const char *peer_down_str[] = {"",
492 "Router ID changed",
493 "Remote AS changed",
494 "Local AS change",
495 "Cluster ID changed",
496 "Confederation identifier changed",
497 "Confederation peer changed",
498 "RR client config change",
499 "RS client config change",
500 "Update source change",
501 "Address family activated",
502 "Admin. shutdown",
503 "User reset",
504 "BGP Notification received",
505 "BGP Notification send",
506 "Peer closed the session",
507 "Neighbor deleted",
508 "Peer-group add member",
509 "Peer-group delete member",
510 "Capability changed",
511 "Passive config change",
512 "Multihop config change",
513 "NSF peer closed the session",
514 "Intf peering v6only config change",
515 "BFD down received",
516 "Interface down",
517 "Neighbor address lost"};
518
519 static int bgp_graceful_restart_timer_expire(struct thread *thread)
520 {
521 struct peer *peer;
522 afi_t afi;
523 safi_t safi;
524
525 peer = THREAD_ARG(thread);
526 peer->t_gr_restart = NULL;
527
528 /* NSF delete stale route */
529 for (afi = AFI_IP; afi < AFI_MAX; afi++)
530 for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN; safi++)
531 if (peer->nsf[afi][safi])
532 bgp_clear_stale_route(peer, afi, safi);
533
534 UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT);
535 BGP_TIMER_OFF(peer->t_gr_stale);
536
537 if (bgp_debug_neighbor_events(peer)) {
538 zlog_debug("%s graceful restart timer expired", peer->host);
539 zlog_debug("%s graceful restart stalepath timer stopped",
540 peer->host);
541 }
542
543 bgp_timer_set(peer);
544
545 return 0;
546 }
547
548 static int bgp_graceful_stale_timer_expire(struct thread *thread)
549 {
550 struct peer *peer;
551 afi_t afi;
552 safi_t safi;
553
554 peer = THREAD_ARG(thread);
555 peer->t_gr_stale = NULL;
556
557 if (bgp_debug_neighbor_events(peer))
558 zlog_debug("%s graceful restart stalepath timer expired",
559 peer->host);
560
561 /* NSF delete stale route */
562 for (afi = AFI_IP; afi < AFI_MAX; afi++)
563 for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN; safi++)
564 if (peer->nsf[afi][safi])
565 bgp_clear_stale_route(peer, afi, safi);
566
567 return 0;
568 }
569
570 static int bgp_update_delay_applicable(struct bgp *bgp)
571 {
572 /* update_delay_over flag should be reset (set to 0) for any new
573 applicability of the update-delay during BGP process lifetime.
574 And it should be set after an occurence of the update-delay is
575 over)*/
576 if (!bgp->update_delay_over)
577 return 1;
578
579 return 0;
580 }
581
582 int bgp_update_delay_active(struct bgp *bgp)
583 {
584 if (bgp->t_update_delay)
585 return 1;
586
587 return 0;
588 }
589
590 int bgp_update_delay_configured(struct bgp *bgp)
591 {
592 if (bgp->v_update_delay)
593 return 1;
594
595 return 0;
596 }
597
598 /* Do the post-processing needed when bgp comes out of the read-only mode
599 on ending the update delay. */
600 void bgp_update_delay_end(struct bgp *bgp)
601 {
602 THREAD_TIMER_OFF(bgp->t_update_delay);
603 THREAD_TIMER_OFF(bgp->t_establish_wait);
604
605 /* Reset update-delay related state */
606 bgp->update_delay_over = 1;
607 bgp->established = 0;
608 bgp->restarted_peers = 0;
609 bgp->implicit_eors = 0;
610 bgp->explicit_eors = 0;
611
612 quagga_timestamp(3, bgp->update_delay_end_time,
613 sizeof(bgp->update_delay_end_time));
614
615 /*
616 * Add an end-of-initial-update marker to the main process queues so
617 * that
618 * the route advertisement timer for the peers can be started. Also set
619 * the zebra and peer update hold flags. These flags are used to achieve
620 * three stages in the update-delay post processing:
621 * 1. Finish best-path selection for all the prefixes held on the
622 * queues.
623 * (routes in BGP are updated, and peers sync queues are populated
624 * too)
625 * 2. As the eoiu mark is reached in the bgp process routine, ship all
626 * the
627 * routes to zebra. With that zebra should see updates from BGP
628 * close
629 * to each other.
630 * 3. Unblock the peer update writes. With that peer update packing
631 * with
632 * the prefixes should be at its maximum.
633 */
634 bgp_add_eoiu_mark(bgp);
635 bgp->main_zebra_update_hold = 1;
636 bgp->main_peers_update_hold = 1;
637
638 /* Resume the queue processing. This should trigger the event that would
639 take
640 care of processing any work that was queued during the read-only
641 mode. */
642 work_queue_unplug(bm->process_main_queue);
643 }
644
645 /**
646 * see bgp_fsm.h
647 */
648 void bgp_start_routeadv(struct bgp *bgp)
649 {
650 struct listnode *node, *nnode;
651 struct peer *peer;
652
653 zlog_info("bgp_start_routeadv(), update hold status %d",
654 bgp->main_peers_update_hold);
655
656 if (bgp->main_peers_update_hold)
657 return;
658
659 quagga_timestamp(3, bgp->update_delay_peers_resume_time,
660 sizeof(bgp->update_delay_peers_resume_time));
661
662 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
663 if (peer->status != Established)
664 continue;
665 BGP_TIMER_OFF(peer->t_routeadv);
666 BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
667 }
668 }
669
670 /**
671 * see bgp_fsm.h
672 */
673 void bgp_adjust_routeadv(struct peer *peer)
674 {
675 time_t nowtime = bgp_clock();
676 double diff;
677 unsigned long remain;
678
679 /* Bypass checks for special case of MRAI being 0 */
680 if (peer->v_routeadv == 0) {
681 /* Stop existing timer, just in case it is running for a
682 * different
683 * duration and schedule write thread immediately.
684 */
685 if (peer->t_routeadv)
686 BGP_TIMER_OFF(peer->t_routeadv);
687
688 peer->synctime = bgp_clock();
689 thread_add_timer_msec(bm->master, bgp_generate_updgrp_packets,
690 peer, 0,
691 &peer->t_generate_updgrp_packets);
692 return;
693 }
694
695
696 /*
697 * CASE I:
698 * If the last update was written more than MRAI back, expire the timer
699 * instantly so that we can send the update out sooner.
700 *
701 * <------- MRAI --------->
702 * |-----------------|-----------------------|
703 * <------------- m ------------>
704 * ^ ^ ^
705 * | | |
706 * | | current time
707 * | timer start
708 * last write
709 *
710 * m > MRAI
711 */
712 diff = difftime(nowtime, peer->last_update);
713 if (diff > (double)peer->v_routeadv) {
714 BGP_TIMER_OFF(peer->t_routeadv);
715 BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
716 return;
717 }
718
719 /*
720 * CASE II:
721 * - Find when to expire the MRAI timer.
722 * If MRAI timer is not active, assume we can start it now.
723 *
724 * <------- MRAI --------->
725 * |------------|-----------------------|
726 * <-------- m ----------><----- r ----->
727 * ^ ^ ^
728 * | | |
729 * | | current time
730 * | timer start
731 * last write
732 *
733 * (MRAI - m) < r
734 */
735 if (peer->t_routeadv)
736 remain = thread_timer_remain_second(peer->t_routeadv);
737 else
738 remain = peer->v_routeadv;
739 diff = peer->v_routeadv - diff;
740 if (diff <= (double)remain) {
741 BGP_TIMER_OFF(peer->t_routeadv);
742 BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, diff);
743 }
744 }
745
746 static int bgp_maxmed_onstartup_applicable(struct bgp *bgp)
747 {
748 if (!bgp->maxmed_onstartup_over)
749 return 1;
750
751 return 0;
752 }
753
754 int bgp_maxmed_onstartup_configured(struct bgp *bgp)
755 {
756 if (bgp->v_maxmed_onstartup != BGP_MAXMED_ONSTARTUP_UNCONFIGURED)
757 return 1;
758
759 return 0;
760 }
761
762 int bgp_maxmed_onstartup_active(struct bgp *bgp)
763 {
764 if (bgp->t_maxmed_onstartup)
765 return 1;
766
767 return 0;
768 }
769
770 void bgp_maxmed_update(struct bgp *bgp)
771 {
772 uint8_t maxmed_active;
773 uint32_t maxmed_value;
774
775 if (bgp->v_maxmed_admin) {
776 maxmed_active = 1;
777 maxmed_value = bgp->maxmed_admin_value;
778 } else if (bgp->t_maxmed_onstartup) {
779 maxmed_active = 1;
780 maxmed_value = bgp->maxmed_onstartup_value;
781 } else {
782 maxmed_active = 0;
783 maxmed_value = BGP_MAXMED_VALUE_DEFAULT;
784 }
785
786 if (bgp->maxmed_active != maxmed_active
787 || bgp->maxmed_value != maxmed_value) {
788 bgp->maxmed_active = maxmed_active;
789 bgp->maxmed_value = maxmed_value;
790
791 update_group_announce(bgp);
792 }
793 }
794
795 /* The maxmed onstartup timer expiry callback. */
796 static int bgp_maxmed_onstartup_timer(struct thread *thread)
797 {
798 struct bgp *bgp;
799
800 zlog_info("Max med on startup ended - timer expired.");
801
802 bgp = THREAD_ARG(thread);
803 THREAD_TIMER_OFF(bgp->t_maxmed_onstartup);
804 bgp->maxmed_onstartup_over = 1;
805
806 bgp_maxmed_update(bgp);
807
808 return 0;
809 }
810
811 static void bgp_maxmed_onstartup_begin(struct bgp *bgp)
812 {
813 /* Applicable only once in the process lifetime on the startup */
814 if (bgp->maxmed_onstartup_over)
815 return;
816
817 zlog_info("Begin maxmed onstartup mode - timer %d seconds",
818 bgp->v_maxmed_onstartup);
819
820 thread_add_timer(bm->master, bgp_maxmed_onstartup_timer, bgp,
821 bgp->v_maxmed_onstartup, &bgp->t_maxmed_onstartup);
822
823 if (!bgp->v_maxmed_admin) {
824 bgp->maxmed_active = 1;
825 bgp->maxmed_value = bgp->maxmed_onstartup_value;
826 }
827
828 /* Route announce to all peers should happen after this in
829 * bgp_establish() */
830 }
831
832 static void bgp_maxmed_onstartup_process_status_change(struct peer *peer)
833 {
834 if (peer->status == Established && !peer->bgp->established) {
835 bgp_maxmed_onstartup_begin(peer->bgp);
836 }
837 }
838
839 /* The update delay timer expiry callback. */
840 static int bgp_update_delay_timer(struct thread *thread)
841 {
842 struct bgp *bgp;
843
844 zlog_info("Update delay ended - timer expired.");
845
846 bgp = THREAD_ARG(thread);
847 THREAD_TIMER_OFF(bgp->t_update_delay);
848 bgp_update_delay_end(bgp);
849
850 return 0;
851 }
852
853 /* The establish wait timer expiry callback. */
854 static int bgp_establish_wait_timer(struct thread *thread)
855 {
856 struct bgp *bgp;
857
858 zlog_info("Establish wait - timer expired.");
859
860 bgp = THREAD_ARG(thread);
861 THREAD_TIMER_OFF(bgp->t_establish_wait);
862 bgp_check_update_delay(bgp);
863
864 return 0;
865 }
866
867 /* Steps to begin the update delay:
868 - initialize queues if needed
869 - stop the queue processing
870 - start the timer */
871 static void bgp_update_delay_begin(struct bgp *bgp)
872 {
873 struct listnode *node, *nnode;
874 struct peer *peer;
875
876 /* Stop the processing of queued work. Enqueue shall continue */
877 work_queue_plug(bm->process_main_queue);
878
879 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer))
880 peer->update_delay_over = 0;
881
882 /* Start the update-delay timer */
883 thread_add_timer(bm->master, bgp_update_delay_timer, bgp,
884 bgp->v_update_delay, &bgp->t_update_delay);
885
886 if (bgp->v_establish_wait != bgp->v_update_delay)
887 thread_add_timer(bm->master, bgp_establish_wait_timer, bgp,
888 bgp->v_establish_wait, &bgp->t_establish_wait);
889
890 quagga_timestamp(3, bgp->update_delay_begin_time,
891 sizeof(bgp->update_delay_begin_time));
892 }
893
894 static void bgp_update_delay_process_status_change(struct peer *peer)
895 {
896 if (peer->status == Established) {
897 if (!peer->bgp->established++) {
898 bgp_update_delay_begin(peer->bgp);
899 zlog_info(
900 "Begin read-only mode - update-delay timer %d seconds",
901 peer->bgp->v_update_delay);
902 }
903 if (CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_RCV))
904 bgp_update_restarted_peers(peer);
905 }
906 if (peer->ostatus == Established
907 && bgp_update_delay_active(peer->bgp)) {
908 /* Adjust the update-delay state to account for this flap.
909 NOTE: Intentionally skipping adjusting implicit_eors or
910 explicit_eors
911 counters. Extra sanity check in bgp_check_update_delay()
912 should
913 be enough to take care of any additive discrepancy in bgp eor
914 counters */
915 peer->bgp->established--;
916 peer->update_delay_over = 0;
917 }
918 }
919
920 /* Called after event occured, this function change status and reset
921 read/write and timer thread. */
922 void bgp_fsm_change_status(struct peer *peer, int status)
923 {
924
925 bgp_dump_state(peer, peer->status, status);
926
927 /* Transition into Clearing or Deleted must /always/ clear all routes..
928 * (and must do so before actually changing into Deleted..
929 */
930 if (status >= Clearing) {
931 bgp_clear_route_all(peer);
932
933 /* If no route was queued for the clear-node processing,
934 * generate the
935 * completion event here. This is needed because if there are no
936 * routes
937 * to trigger the background clear-node thread, the event won't
938 * get
939 * generated and the peer would be stuck in Clearing. Note that
940 * this
941 * event is for the peer and helps the peer transition out of
942 * Clearing
943 * state; it should not be generated per (AFI,SAFI). The event
944 * is
945 * directly posted here without calling clear_node_complete() as
946 * we
947 * shouldn't do an extra unlock. This event will get processed
948 * after
949 * the state change that happens below, so peer will be in
950 * Clearing
951 * (or Deleted).
952 */
953 if (!work_queue_is_scheduled(peer->clear_node_queue))
954 BGP_EVENT_ADD(peer, Clearing_Completed);
955 }
956
957 /* Preserve old status and change into new status. */
958 peer->ostatus = peer->status;
959 peer->status = status;
960
961 /* Save event that caused status change. */
962 peer->last_major_event = peer->cur_event;
963
964 if (status == Established)
965 UNSET_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER);
966
967 /* If max-med processing is applicable, do the necessary. */
968 if (status == Established) {
969 if (bgp_maxmed_onstartup_configured(peer->bgp)
970 && bgp_maxmed_onstartup_applicable(peer->bgp))
971 bgp_maxmed_onstartup_process_status_change(peer);
972 else
973 peer->bgp->maxmed_onstartup_over = 1;
974 }
975
976 /* If update-delay processing is applicable, do the necessary. */
977 if (bgp_update_delay_configured(peer->bgp)
978 && bgp_update_delay_applicable(peer->bgp))
979 bgp_update_delay_process_status_change(peer);
980
981 if (bgp_debug_neighbor_events(peer))
982 zlog_debug("%s went from %s to %s", peer->host,
983 lookup_msg(bgp_status_msg, peer->ostatus, NULL),
984 lookup_msg(bgp_status_msg, peer->status, NULL));
985 }
986
987 /* Flush the event queue and ensure the peer is shut down */
988 static int bgp_clearing_completed(struct peer *peer)
989 {
990 int rc = bgp_stop(peer);
991
992 if (rc >= 0)
993 BGP_EVENT_FLUSH(peer);
994
995 return rc;
996 }
997
998 /* Administrative BGP peer stop event. */
999 /* May be called multiple times for the same peer */
1000 int bgp_stop(struct peer *peer)
1001 {
1002 afi_t afi;
1003 safi_t safi;
1004 char orf_name[BUFSIZ];
1005 int ret = 0;
1006
1007 if (peer_dynamic_neighbor(peer)
1008 && !(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) {
1009 if (bgp_debug_neighbor_events(peer))
1010 zlog_debug("%s (dynamic neighbor) deleted", peer->host);
1011 peer_delete(peer);
1012 return -1;
1013 }
1014
1015 /* Can't do this in Clearing; events are used for state transitions */
1016 if (peer->status != Clearing) {
1017 /* Delete all existing events of the peer */
1018 BGP_EVENT_FLUSH(peer);
1019 }
1020
1021 /* Increment Dropped count. */
1022 if (peer->status == Established) {
1023 peer->dropped++;
1024
1025 /* bgp log-neighbor-changes of neighbor Down */
1026 if (bgp_flag_check(peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES)) {
1027 struct vrf *vrf = vrf_lookup_by_id(peer->bgp->vrf_id);
1028 zlog_info(
1029 "%%ADJCHANGE: neighbor %s(%s) in vrf %s Down %s",
1030 peer->host,
1031 (peer->hostname) ? peer->hostname : "Unknown",
1032 vrf ? ((vrf->vrf_id != VRF_DEFAULT) ? vrf->name
1033 : "Default")
1034 : "",
1035 peer_down_str[(int)peer->last_reset]);
1036 }
1037
1038 /* graceful restart */
1039 if (peer->t_gr_stale) {
1040 BGP_TIMER_OFF(peer->t_gr_stale);
1041 if (bgp_debug_neighbor_events(peer))
1042 zlog_debug(
1043 "%s graceful restart stalepath timer stopped",
1044 peer->host);
1045 }
1046 if (CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)) {
1047 if (bgp_debug_neighbor_events(peer)) {
1048 zlog_debug(
1049 "%s graceful restart timer started for %d sec",
1050 peer->host, peer->v_gr_restart);
1051 zlog_debug(
1052 "%s graceful restart stalepath timer started for %d sec",
1053 peer->host, peer->bgp->stalepath_time);
1054 }
1055 BGP_TIMER_ON(peer->t_gr_restart,
1056 bgp_graceful_restart_timer_expire,
1057 peer->v_gr_restart);
1058 BGP_TIMER_ON(peer->t_gr_stale,
1059 bgp_graceful_stale_timer_expire,
1060 peer->bgp->stalepath_time);
1061 } else {
1062 UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
1063
1064 for (afi = AFI_IP; afi < AFI_MAX; afi++)
1065 for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN;
1066 safi++)
1067 peer->nsf[afi][safi] = 0;
1068 }
1069
1070 /* set last reset time */
1071 peer->resettime = peer->uptime = bgp_clock();
1072
1073 if (BGP_DEBUG(update_groups, UPDATE_GROUPS))
1074 zlog_debug("%s remove from all update group",
1075 peer->host);
1076 update_group_remove_peer_afs(peer);
1077
1078 hook_call(peer_backward_transition, peer);
1079
1080 /* Reset peer synctime */
1081 peer->synctime = 0;
1082
1083 bgp_bfd_deregister_peer(peer);
1084 }
1085
1086 /* stop keepalives */
1087 bgp_keepalives_off(peer);
1088
1089 /* Stop read and write threads. */
1090 bgp_writes_off(peer);
1091 bgp_reads_off(peer);
1092
1093 THREAD_OFF(peer->t_connect_check_r);
1094 THREAD_OFF(peer->t_connect_check_w);
1095
1096 /* Stop all timers. */
1097 BGP_TIMER_OFF(peer->t_start);
1098 BGP_TIMER_OFF(peer->t_connect);
1099 BGP_TIMER_OFF(peer->t_holdtime);
1100 BGP_TIMER_OFF(peer->t_routeadv);
1101
1102 /* Clear input and output buffer. */
1103 pthread_mutex_lock(&peer->io_mtx);
1104 {
1105 if (peer->ibuf)
1106 stream_fifo_clean(peer->ibuf);
1107 if (peer->obuf)
1108 stream_fifo_clean(peer->obuf);
1109
1110 if (peer->ibuf_work)
1111 ringbuf_wipe(peer->ibuf_work);
1112 if (peer->obuf_work)
1113 stream_reset(peer->obuf_work);
1114
1115 if (peer->curr) {
1116 stream_free(peer->curr);
1117 peer->curr = NULL;
1118 }
1119 }
1120 pthread_mutex_unlock(&peer->io_mtx);
1121
1122 /* Close of file descriptor. */
1123 if (peer->fd >= 0) {
1124 close(peer->fd);
1125 peer->fd = -1;
1126 }
1127
1128 FOREACH_AFI_SAFI (afi, safi) {
1129 /* Reset all negotiated variables */
1130 peer->afc_nego[afi][safi] = 0;
1131 peer->afc_adv[afi][safi] = 0;
1132 peer->afc_recv[afi][safi] = 0;
1133
1134 /* peer address family capability flags*/
1135 peer->af_cap[afi][safi] = 0;
1136
1137 /* peer address family status flags*/
1138 peer->af_sflags[afi][safi] = 0;
1139
1140 /* Received ORF prefix-filter */
1141 peer->orf_plist[afi][safi] = NULL;
1142
1143 if ((peer->status == OpenConfirm)
1144 || (peer->status == Established)) {
1145 /* ORF received prefix-filter pnt */
1146 sprintf(orf_name, "%s.%d.%d", peer->host, afi, safi);
1147 prefix_bgp_orf_remove_all(afi, orf_name);
1148 }
1149 }
1150
1151 /* Reset keepalive and holdtime */
1152 if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER)) {
1153 peer->v_keepalive = peer->keepalive;
1154 peer->v_holdtime = peer->holdtime;
1155 } else {
1156 peer->v_keepalive = peer->bgp->default_keepalive;
1157 peer->v_holdtime = peer->bgp->default_holdtime;
1158 }
1159
1160 peer->update_time = 0;
1161
1162 /* Until we are sure that there is no problem about prefix count
1163 this should be commented out.*/
1164 #if 0
1165 /* Reset prefix count */
1166 peer->pcount[AFI_IP][SAFI_UNICAST] = 0;
1167 peer->pcount[AFI_IP][SAFI_MULTICAST] = 0;
1168 peer->pcount[AFI_IP][SAFI_LABELED_UNICAST] = 0;
1169 peer->pcount[AFI_IP][SAFI_MPLS_VPN] = 0;
1170 peer->pcount[AFI_IP6][SAFI_UNICAST] = 0;
1171 peer->pcount[AFI_IP6][SAFI_MULTICAST] = 0;
1172 peer->pcount[AFI_IP6][SAFI_LABELED_UNICAST] = 0;
1173 #endif /* 0 */
1174
1175 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE)
1176 && !(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) {
1177 peer_delete(peer);
1178 ret = -1;
1179 } else {
1180 bgp_peer_conf_if_to_su_update(peer);
1181 }
1182
1183 return ret;
1184 }
1185
1186 /* BGP peer is stoped by the error. */
1187 static int bgp_stop_with_error(struct peer *peer)
1188 {
1189 /* Double start timer. */
1190 peer->v_start *= 2;
1191
1192 /* Overflow check. */
1193 if (peer->v_start >= (60 * 2))
1194 peer->v_start = (60 * 2);
1195
1196 if (peer_dynamic_neighbor(peer)) {
1197 if (bgp_debug_neighbor_events(peer))
1198 zlog_debug("%s (dynamic neighbor) deleted", peer->host);
1199 peer_delete(peer);
1200 return -1;
1201 }
1202
1203 return (bgp_stop(peer));
1204 }
1205
1206
1207 /* something went wrong, send notify and tear down */
1208 static int bgp_stop_with_notify(struct peer *peer, uint8_t code,
1209 uint8_t sub_code)
1210 {
1211 /* Send notify to remote peer */
1212 bgp_notify_send(peer, code, sub_code);
1213
1214 if (peer_dynamic_neighbor(peer)) {
1215 if (bgp_debug_neighbor_events(peer))
1216 zlog_debug("%s (dynamic neighbor) deleted", peer->host);
1217 peer_delete(peer);
1218 return -1;
1219 }
1220
1221 /* Clear start timer value to default. */
1222 peer->v_start = BGP_INIT_START_TIMER;
1223
1224 return (bgp_stop(peer));
1225 }
1226
1227 /**
1228 * Determines whether a TCP session has successfully established for a peer and
1229 * events as appropriate.
1230 *
1231 * This function is called when setting up a new session. After connect() is
1232 * called on the peer's socket (in bgp_start()), the fd is passed to poll()
1233 * to wait for connection success or failure. When poll() returns, this
1234 * function is called to evaluate the result.
1235 *
1236 * Due to differences in behavior of poll() on Linux and BSD - specifically,
1237 * the value of .revents in the case of a closed connection - this function is
1238 * scheduled both for a read and a write event. The write event is triggered
1239 * when the connection is established. A read event is triggered when the
1240 * connection is closed. Thus we need to cancel whichever one did not occur.
1241 */
1242 static int bgp_connect_check(struct thread *thread)
1243 {
1244 int status;
1245 socklen_t slen;
1246 int ret;
1247 struct peer *peer;
1248
1249 peer = THREAD_ARG(thread);
1250 assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_READS_ON));
1251 assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON));
1252 assert(!peer->t_read);
1253 assert(!peer->t_write);
1254
1255 THREAD_OFF(peer->t_connect_check_r);
1256 THREAD_OFF(peer->t_connect_check_w);
1257
1258 /* Check file descriptor. */
1259 slen = sizeof(status);
1260 ret = getsockopt(peer->fd, SOL_SOCKET, SO_ERROR, (void *)&status,
1261 &slen);
1262
1263 /* If getsockopt is fail, this is fatal error. */
1264 if (ret < 0) {
1265 zlog_info("can't get sockopt for nonblocking connect: %d(%s)",
1266 errno, safe_strerror(errno));
1267 BGP_EVENT_ADD(peer, TCP_fatal_error);
1268 return -1;
1269 }
1270
1271 /* When status is 0 then TCP connection is established. */
1272 if (status == 0) {
1273 BGP_EVENT_ADD(peer, TCP_connection_open);
1274 return 1;
1275 } else {
1276 if (bgp_debug_neighbor_events(peer))
1277 zlog_debug("%s [Event] Connect failed %d(%s)",
1278 peer->host, status, safe_strerror(status));
1279 BGP_EVENT_ADD(peer, TCP_connection_open_failed);
1280 return 0;
1281 }
1282 }
1283
1284 /* TCP connection open. Next we send open message to remote peer. And
1285 add read thread for reading open message. */
1286 static int bgp_connect_success(struct peer *peer)
1287 {
1288 if (peer->fd < 0) {
1289 flog_err(BGP_ERR_CONNECT,
1290 "bgp_connect_success peer's fd is negative value %d",
1291 peer->fd);
1292 bgp_stop(peer);
1293 return -1;
1294 }
1295
1296 if (bgp_getsockname(peer) < 0) {
1297 flog_err_sys(LIB_ERR_SOCKET,
1298 "%s: bgp_getsockname(): failed for peer %s, fd %d",
1299 __FUNCTION__, peer->host, peer->fd);
1300 bgp_notify_send(peer, BGP_NOTIFY_FSM_ERR,
1301 0); /* internal error */
1302 bgp_writes_on(peer);
1303 return -1;
1304 }
1305
1306 bgp_reads_on(peer);
1307
1308 if (bgp_debug_neighbor_events(peer)) {
1309 char buf1[SU_ADDRSTRLEN];
1310
1311 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER))
1312 zlog_debug("%s open active, local address %s",
1313 peer->host,
1314 sockunion2str(peer->su_local, buf1,
1315 SU_ADDRSTRLEN));
1316 else
1317 zlog_debug("%s passive open", peer->host);
1318 }
1319
1320 bgp_open_send(peer);
1321
1322 return 0;
1323 }
1324
1325 /* TCP connect fail */
1326 static int bgp_connect_fail(struct peer *peer)
1327 {
1328 if (peer_dynamic_neighbor(peer)) {
1329 if (bgp_debug_neighbor_events(peer))
1330 zlog_debug("%s (dynamic neighbor) deleted", peer->host);
1331 peer_delete(peer);
1332 return -1;
1333 }
1334
1335 return (bgp_stop(peer));
1336 }
1337
1338 /* This function is the first starting point of all BGP connection. It
1339 try to connect to remote peer with non-blocking IO. */
1340 int bgp_start(struct peer *peer)
1341 {
1342 int status;
1343 int connected = 0;
1344
1345 bgp_peer_conf_if_to_su_update(peer);
1346
1347 if (peer->su.sa.sa_family == AF_UNSPEC) {
1348 if (bgp_debug_neighbor_events(peer))
1349 zlog_debug(
1350 "%s [FSM] Unable to get neighbor's IP address, waiting...",
1351 peer->host);
1352 return -1;
1353 }
1354
1355 if (BGP_PEER_START_SUPPRESSED(peer)) {
1356 if (bgp_debug_neighbor_events(peer))
1357 flog_err(BGP_ERR_FSM,
1358 "%s [FSM] Trying to start suppressed peer"
1359 " - this is never supposed to happen!",
1360 peer->host);
1361 return -1;
1362 }
1363
1364 /* Scrub some information that might be left over from a previous,
1365 * session
1366 */
1367 /* Connection information. */
1368 if (peer->su_local) {
1369 sockunion_free(peer->su_local);
1370 peer->su_local = NULL;
1371 }
1372
1373 if (peer->su_remote) {
1374 sockunion_free(peer->su_remote);
1375 peer->su_remote = NULL;
1376 }
1377
1378 /* Clear remote router-id. */
1379 peer->remote_id.s_addr = 0;
1380
1381 /* Clear peer capability flag. */
1382 peer->cap = 0;
1383
1384 /* If the peer is passive mode, force to move to Active mode. */
1385 if (CHECK_FLAG(peer->flags, PEER_FLAG_PASSIVE)) {
1386 BGP_EVENT_ADD(peer, TCP_connection_open_failed);
1387 return 0;
1388 }
1389
1390 if (peer->bgp->vrf_id == VRF_UNKNOWN) {
1391 if (bgp_debug_neighbor_events(peer))
1392 flog_err(
1393 BGP_ERR_FSM,
1394 "%s [FSM] In a VRF that is not initialised yet",
1395 peer->host);
1396 return -1;
1397 }
1398
1399 /* Register to be notified on peer up */
1400 if (peer->sort == BGP_PEER_EBGP && peer->ttl == 1
1401 && !CHECK_FLAG(peer->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK)
1402 && !bgp_flag_check(peer->bgp, BGP_FLAG_DISABLE_NH_CONNECTED_CHK))
1403 connected = 1;
1404 else
1405 connected = 0;
1406
1407 if (!bgp_find_or_add_nexthop(peer->bgp, peer->bgp,
1408 family2afi(peer->su.sa.sa_family), NULL,
1409 peer, connected)) {
1410 if (bgp_zebra_num_connects()) {
1411 if (bgp_debug_neighbor_events(peer))
1412 zlog_debug("%s [FSM] Waiting for NHT",
1413 peer->host);
1414
1415 BGP_EVENT_ADD(peer, TCP_connection_open_failed);
1416 return 0;
1417 }
1418 }
1419
1420 assert(!peer->t_write);
1421 assert(!peer->t_read);
1422 assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON));
1423 assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_READS_ON));
1424 status = bgp_connect(peer);
1425
1426 switch (status) {
1427 case connect_error:
1428 if (bgp_debug_neighbor_events(peer))
1429 zlog_debug("%s [FSM] Connect error", peer->host);
1430 BGP_EVENT_ADD(peer, TCP_connection_open_failed);
1431 break;
1432 case connect_success:
1433 if (bgp_debug_neighbor_events(peer))
1434 zlog_debug(
1435 "%s [FSM] Connect immediately success, fd %d",
1436 peer->host, peer->fd);
1437 BGP_EVENT_ADD(peer, TCP_connection_open);
1438 break;
1439 case connect_in_progress:
1440 /* To check nonblocking connect, we wait until socket is
1441 readable or writable. */
1442 if (bgp_debug_neighbor_events(peer))
1443 zlog_debug(
1444 "%s [FSM] Non blocking connect waiting result, fd %d",
1445 peer->host, peer->fd);
1446 if (peer->fd < 0) {
1447 flog_err(BGP_ERR_FSM,
1448 "bgp_start peer's fd is negative value %d",
1449 peer->fd);
1450 return -1;
1451 }
1452 /*
1453 * - when the socket becomes ready, poll() will signify POLLOUT
1454 * - if it fails to connect, poll() will signify POLLHUP
1455 * - POLLHUP is handled as a 'read' event by thread.c
1456 *
1457 * therefore, we schedule both a read and a write event with
1458 * bgp_connect_check() as the handler for each and cancel the
1459 * unused event in that function.
1460 */
1461 thread_add_read(bm->master, bgp_connect_check, peer, peer->fd,
1462 &peer->t_connect_check_r);
1463 thread_add_write(bm->master, bgp_connect_check, peer, peer->fd,
1464 &peer->t_connect_check_w);
1465 break;
1466 }
1467 return 0;
1468 }
1469
1470 /* Connect retry timer is expired when the peer status is Connect. */
1471 static int bgp_reconnect(struct peer *peer)
1472 {
1473 if (bgp_stop(peer) < 0)
1474 return -1;
1475
1476 bgp_start(peer);
1477 return 0;
1478 }
1479
1480 static int bgp_fsm_open(struct peer *peer)
1481 {
1482 /* Send keepalive and make keepalive timer */
1483 bgp_keepalive_send(peer);
1484
1485 /* Reset holdtimer value. */
1486 BGP_TIMER_OFF(peer->t_holdtime);
1487
1488 return 0;
1489 }
1490
1491 /* FSM error, unexpected event. This is error of BGP connection. So cut the
1492 peer and change to Idle status. */
1493 static int bgp_fsm_event_error(struct peer *peer)
1494 {
1495 flog_err(BGP_ERR_FSM,
1496 "%s [FSM] unexpected packet received in state %s", peer->host,
1497 lookup_msg(bgp_status_msg, peer->status, NULL));
1498
1499 return bgp_stop_with_notify(peer, BGP_NOTIFY_FSM_ERR, 0);
1500 }
1501
1502 /* Hold timer expire. This is error of BGP connection. So cut the
1503 peer and change to Idle status. */
1504 static int bgp_fsm_holdtime_expire(struct peer *peer)
1505 {
1506 if (bgp_debug_neighbor_events(peer))
1507 zlog_debug("%s [FSM] Hold timer expire", peer->host);
1508
1509 return bgp_stop_with_notify(peer, BGP_NOTIFY_HOLD_ERR, 0);
1510 }
1511
1512 /**
1513 * Transition to Established state.
1514 *
1515 * Convert peer from stub to full fledged peer, set some timers, and generate
1516 * initial updates.
1517 */
1518 static int bgp_establish(struct peer *peer)
1519 {
1520 afi_t afi;
1521 safi_t safi;
1522 int nsf_af_count = 0;
1523 int ret = 0;
1524 struct peer *other;
1525
1526 other = peer->doppelganger;
1527 peer = peer_xfer_conn(peer);
1528 if (!peer) {
1529 flog_err(BGP_ERR_CONNECT, "%%Neighbor failed in xfer_conn");
1530 return -1;
1531 }
1532
1533 if (other == peer)
1534 ret = 1; /* bgp_establish specific code when xfer_conn
1535 happens. */
1536
1537 /* Reset capability open status flag. */
1538 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_CAPABILITY_OPEN))
1539 SET_FLAG(peer->sflags, PEER_STATUS_CAPABILITY_OPEN);
1540
1541 /* Clear start timer value to default. */
1542 peer->v_start = BGP_INIT_START_TIMER;
1543
1544 /* Increment established count. */
1545 peer->established++;
1546 bgp_fsm_change_status(peer, Established);
1547
1548 /* bgp log-neighbor-changes of neighbor Up */
1549 if (bgp_flag_check(peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES)) {
1550 struct vrf *vrf = vrf_lookup_by_id(peer->bgp->vrf_id);
1551 zlog_info("%%ADJCHANGE: neighbor %s(%s) in vrf %s Up",
1552 peer->host,
1553 (peer->hostname) ? peer->hostname : "Unknown",
1554 vrf ? ((vrf->vrf_id != VRF_DEFAULT) ? vrf->name
1555 : "Default")
1556 : "");
1557 }
1558 /* assign update-group/subgroup */
1559 update_group_adjust_peer_afs(peer);
1560
1561 /* graceful restart */
1562 UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT);
1563 for (afi = AFI_IP; afi < AFI_MAX; afi++)
1564 for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN; safi++) {
1565 if (peer->afc_nego[afi][safi]
1566 && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_ADV)
1567 && CHECK_FLAG(peer->af_cap[afi][safi],
1568 PEER_CAP_RESTART_AF_RCV)) {
1569 if (peer->nsf[afi][safi]
1570 && !CHECK_FLAG(
1571 peer->af_cap[afi][safi],
1572 PEER_CAP_RESTART_AF_PRESERVE_RCV))
1573 bgp_clear_stale_route(peer, afi, safi);
1574
1575 peer->nsf[afi][safi] = 1;
1576 nsf_af_count++;
1577 } else {
1578 if (peer->nsf[afi][safi])
1579 bgp_clear_stale_route(peer, afi, safi);
1580 peer->nsf[afi][safi] = 0;
1581 }
1582 }
1583
1584 if (nsf_af_count)
1585 SET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
1586 else {
1587 UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
1588 if (peer->t_gr_stale) {
1589 BGP_TIMER_OFF(peer->t_gr_stale);
1590 if (bgp_debug_neighbor_events(peer))
1591 zlog_debug(
1592 "%s graceful restart stalepath timer stopped",
1593 peer->host);
1594 }
1595 }
1596
1597 if (peer->t_gr_restart) {
1598 BGP_TIMER_OFF(peer->t_gr_restart);
1599 if (bgp_debug_neighbor_events(peer))
1600 zlog_debug("%s graceful restart timer stopped",
1601 peer->host);
1602 }
1603
1604 hook_call(peer_established, peer);
1605
1606 /* Reset uptime, turn on keepalives, send current table. */
1607 if (!peer->v_holdtime)
1608 bgp_keepalives_on(peer);
1609
1610 peer->uptime = bgp_clock();
1611
1612 /* Send route-refresh when ORF is enabled */
1613 FOREACH_AFI_SAFI (afi, safi) {
1614 if (CHECK_FLAG(peer->af_cap[afi][safi],
1615 PEER_CAP_ORF_PREFIX_SM_ADV)) {
1616 if (CHECK_FLAG(peer->af_cap[afi][safi],
1617 PEER_CAP_ORF_PREFIX_RM_RCV))
1618 bgp_route_refresh_send(peer, afi, safi,
1619 ORF_TYPE_PREFIX,
1620 REFRESH_IMMEDIATE, 0);
1621 else if (CHECK_FLAG(peer->af_cap[afi][safi],
1622 PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
1623 bgp_route_refresh_send(peer, afi, safi,
1624 ORF_TYPE_PREFIX_OLD,
1625 REFRESH_IMMEDIATE, 0);
1626 }
1627 }
1628
1629 /* First update is deferred until ORF or ROUTE-REFRESH is received */
1630 FOREACH_AFI_SAFI (afi, safi) {
1631 if (CHECK_FLAG(peer->af_cap[afi][safi],
1632 PEER_CAP_ORF_PREFIX_RM_ADV))
1633 if (CHECK_FLAG(peer->af_cap[afi][safi],
1634 PEER_CAP_ORF_PREFIX_SM_RCV)
1635 || CHECK_FLAG(peer->af_cap[afi][safi],
1636 PEER_CAP_ORF_PREFIX_SM_OLD_RCV))
1637 SET_FLAG(peer->af_sflags[afi][safi],
1638 PEER_STATUS_ORF_WAIT_REFRESH);
1639 }
1640
1641 bgp_announce_peer(peer);
1642
1643 /* Start the route advertisement timer to send updates to the peer - if
1644 * BGP
1645 * is not in read-only mode. If it is, the timer will be started at the
1646 * end
1647 * of read-only mode.
1648 */
1649 if (!bgp_update_delay_active(peer->bgp)) {
1650 BGP_TIMER_OFF(peer->t_routeadv);
1651 BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
1652 }
1653
1654 if (peer->doppelganger && (peer->doppelganger->status != Deleted)) {
1655 if (bgp_debug_neighbor_events(peer))
1656 zlog_debug(
1657 "[Event] Deleting stub connection for peer %s",
1658 peer->host);
1659
1660 if (peer->doppelganger->status > Active)
1661 bgp_notify_send(peer->doppelganger, BGP_NOTIFY_CEASE,
1662 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION);
1663 else
1664 peer_delete(peer->doppelganger);
1665 }
1666
1667 bgp_bfd_register_peer(peer);
1668 return ret;
1669 }
1670
1671 /* Keepalive packet is received. */
1672 static int bgp_fsm_keepalive(struct peer *peer)
1673 {
1674 BGP_TIMER_OFF(peer->t_holdtime);
1675 return 0;
1676 }
1677
1678 /* Update packet is received. */
1679 static int bgp_fsm_update(struct peer *peer)
1680 {
1681 BGP_TIMER_OFF(peer->t_holdtime);
1682 return 0;
1683 }
1684
1685 /* This is empty event. */
1686 static int bgp_ignore(struct peer *peer)
1687 {
1688 flog_err(
1689 BGP_ERR_FSM,
1690 "%s [FSM] Ignoring event %s in state %s, prior events %s, %s, fd %d",
1691 peer->host, bgp_event_str[peer->cur_event],
1692 lookup_msg(bgp_status_msg, peer->status, NULL),
1693 bgp_event_str[peer->last_event],
1694 bgp_event_str[peer->last_major_event], peer->fd);
1695 return 0;
1696 }
1697
1698 /* This is to handle unexpected events.. */
1699 static int bgp_fsm_exeption(struct peer *peer)
1700 {
1701 flog_err(
1702 BGP_ERR_FSM,
1703 "%s [FSM] Unexpected event %s in state %s, prior events %s, %s, fd %d",
1704 peer->host, bgp_event_str[peer->cur_event],
1705 lookup_msg(bgp_status_msg, peer->status, NULL),
1706 bgp_event_str[peer->last_event],
1707 bgp_event_str[peer->last_major_event], peer->fd);
1708 return (bgp_stop(peer));
1709 }
1710
1711 void bgp_fsm_nht_update(struct peer *peer, int valid)
1712 {
1713 if (!peer)
1714 return;
1715
1716 switch (peer->status) {
1717 case Idle:
1718 if (valid)
1719 BGP_EVENT_ADD(peer, BGP_Start);
1720 break;
1721 case Connect:
1722 if (!valid) {
1723 BGP_TIMER_OFF(peer->t_connect);
1724 BGP_EVENT_ADD(peer, TCP_fatal_error);
1725 }
1726 break;
1727 case Active:
1728 if (valid) {
1729 BGP_TIMER_OFF(peer->t_connect);
1730 BGP_EVENT_ADD(peer, ConnectRetry_timer_expired);
1731 }
1732 break;
1733 case OpenSent:
1734 case OpenConfirm:
1735 case Established:
1736 if (!valid && (peer->gtsm_hops == 1))
1737 BGP_EVENT_ADD(peer, TCP_fatal_error);
1738 case Clearing:
1739 case Deleted:
1740 default:
1741 break;
1742 }
1743 }
1744
1745
1746 /* Finite State Machine structure */
1747 static const struct {
1748 int (*func)(struct peer *);
1749 int next_state;
1750 } FSM[BGP_STATUS_MAX - 1][BGP_EVENTS_MAX - 1] = {
1751 {
1752 /* Idle state: In Idle state, all events other than BGP_Start is
1753 ignored. With BGP_Start event, finite state machine calls
1754 bgp_start(). */
1755 {bgp_start, Connect}, /* BGP_Start */
1756 {bgp_stop, Idle}, /* BGP_Stop */
1757 {bgp_stop, Idle}, /* TCP_connection_open */
1758 {bgp_stop, Idle}, /* TCP_connection_closed */
1759 {bgp_ignore, Idle}, /* TCP_connection_open_failed */
1760 {bgp_stop, Idle}, /* TCP_fatal_error */
1761 {bgp_ignore, Idle}, /* ConnectRetry_timer_expired */
1762 {bgp_ignore, Idle}, /* Hold_Timer_expired */
1763 {bgp_ignore, Idle}, /* KeepAlive_timer_expired */
1764 {bgp_ignore, Idle}, /* Receive_OPEN_message */
1765 {bgp_ignore, Idle}, /* Receive_KEEPALIVE_message */
1766 {bgp_ignore, Idle}, /* Receive_UPDATE_message */
1767 {bgp_ignore, Idle}, /* Receive_NOTIFICATION_message */
1768 {bgp_ignore, Idle}, /* Clearing_Completed */
1769 },
1770 {
1771 /* Connect */
1772 {bgp_ignore, Connect}, /* BGP_Start */
1773 {bgp_stop, Idle}, /* BGP_Stop */
1774 {bgp_connect_success, OpenSent}, /* TCP_connection_open */
1775 {bgp_stop, Idle}, /* TCP_connection_closed */
1776 {bgp_connect_fail, Active}, /* TCP_connection_open_failed */
1777 {bgp_connect_fail, Idle}, /* TCP_fatal_error */
1778 {bgp_reconnect, Connect}, /* ConnectRetry_timer_expired */
1779 {bgp_fsm_exeption, Idle}, /* Hold_Timer_expired */
1780 {bgp_fsm_exeption, Idle}, /* KeepAlive_timer_expired */
1781 {bgp_fsm_exeption, Idle}, /* Receive_OPEN_message */
1782 {bgp_fsm_exeption, Idle}, /* Receive_KEEPALIVE_message */
1783 {bgp_fsm_exeption, Idle}, /* Receive_UPDATE_message */
1784 {bgp_stop, Idle}, /* Receive_NOTIFICATION_message */
1785 {bgp_fsm_exeption, Idle}, /* Clearing_Completed */
1786 },
1787 {
1788 /* Active, */
1789 {bgp_ignore, Active}, /* BGP_Start */
1790 {bgp_stop, Idle}, /* BGP_Stop */
1791 {bgp_connect_success, OpenSent}, /* TCP_connection_open */
1792 {bgp_stop, Idle}, /* TCP_connection_closed */
1793 {bgp_ignore, Active}, /* TCP_connection_open_failed */
1794 {bgp_fsm_exeption, Idle}, /* TCP_fatal_error */
1795 {bgp_start, Connect}, /* ConnectRetry_timer_expired */
1796 {bgp_fsm_exeption, Idle}, /* Hold_Timer_expired */
1797 {bgp_fsm_exeption, Idle}, /* KeepAlive_timer_expired */
1798 {bgp_fsm_exeption, Idle}, /* Receive_OPEN_message */
1799 {bgp_fsm_exeption, Idle}, /* Receive_KEEPALIVE_message */
1800 {bgp_fsm_exeption, Idle}, /* Receive_UPDATE_message */
1801 {bgp_fsm_exeption, Idle}, /* Receive_NOTIFICATION_message */
1802 {bgp_fsm_exeption, Idle}, /* Clearing_Completed */
1803 },
1804 {
1805 /* OpenSent, */
1806 {bgp_ignore, OpenSent}, /* BGP_Start */
1807 {bgp_stop, Idle}, /* BGP_Stop */
1808 {bgp_stop, Active}, /* TCP_connection_open */
1809 {bgp_stop, Active}, /* TCP_connection_closed */
1810 {bgp_stop, Active}, /* TCP_connection_open_failed */
1811 {bgp_stop, Active}, /* TCP_fatal_error */
1812 {bgp_fsm_exeption, Idle}, /* ConnectRetry_timer_expired */
1813 {bgp_fsm_holdtime_expire, Idle}, /* Hold_Timer_expired */
1814 {bgp_fsm_exeption, Idle}, /* KeepAlive_timer_expired */
1815 {bgp_fsm_open, OpenConfirm}, /* Receive_OPEN_message */
1816 {bgp_fsm_event_error, Idle}, /* Receive_KEEPALIVE_message */
1817 {bgp_fsm_event_error, Idle}, /* Receive_UPDATE_message */
1818 {bgp_stop_with_error, Idle}, /* Receive_NOTIFICATION_message */
1819 {bgp_fsm_exeption, Idle}, /* Clearing_Completed */
1820 },
1821 {
1822 /* OpenConfirm, */
1823 {bgp_ignore, OpenConfirm}, /* BGP_Start */
1824 {bgp_stop, Idle}, /* BGP_Stop */
1825 {bgp_stop, Idle}, /* TCP_connection_open */
1826 {bgp_stop, Idle}, /* TCP_connection_closed */
1827 {bgp_stop, Idle}, /* TCP_connection_open_failed */
1828 {bgp_stop, Idle}, /* TCP_fatal_error */
1829 {bgp_fsm_exeption, Idle}, /* ConnectRetry_timer_expired */
1830 {bgp_fsm_holdtime_expire, Idle}, /* Hold_Timer_expired */
1831 {bgp_ignore, OpenConfirm}, /* KeepAlive_timer_expired */
1832 {bgp_fsm_exeption, Idle}, /* Receive_OPEN_message */
1833 {bgp_establish, Established}, /* Receive_KEEPALIVE_message */
1834 {bgp_fsm_exeption, Idle}, /* Receive_UPDATE_message */
1835 {bgp_stop_with_error, Idle}, /* Receive_NOTIFICATION_message */
1836 {bgp_fsm_exeption, Idle}, /* Clearing_Completed */
1837 },
1838 {
1839 /* Established, */
1840 {bgp_ignore, Established}, /* BGP_Start */
1841 {bgp_stop, Clearing}, /* BGP_Stop */
1842 {bgp_stop, Clearing}, /* TCP_connection_open */
1843 {bgp_stop, Clearing}, /* TCP_connection_closed */
1844 {bgp_stop, Clearing}, /* TCP_connection_open_failed */
1845 {bgp_stop, Clearing}, /* TCP_fatal_error */
1846 {bgp_stop, Clearing}, /* ConnectRetry_timer_expired */
1847 {bgp_fsm_holdtime_expire, Clearing}, /* Hold_Timer_expired */
1848 {bgp_ignore, Established}, /* KeepAlive_timer_expired */
1849 {bgp_stop, Clearing}, /* Receive_OPEN_message */
1850 {bgp_fsm_keepalive,
1851 Established}, /* Receive_KEEPALIVE_message */
1852 {bgp_fsm_update, Established}, /* Receive_UPDATE_message */
1853 {bgp_stop_with_error,
1854 Clearing}, /* Receive_NOTIFICATION_message */
1855 {bgp_fsm_exeption, Idle}, /* Clearing_Completed */
1856 },
1857 {
1858 /* Clearing, */
1859 {bgp_ignore, Clearing}, /* BGP_Start */
1860 {bgp_stop, Clearing}, /* BGP_Stop */
1861 {bgp_stop, Clearing}, /* TCP_connection_open */
1862 {bgp_stop, Clearing}, /* TCP_connection_closed */
1863 {bgp_stop, Clearing}, /* TCP_connection_open_failed */
1864 {bgp_stop, Clearing}, /* TCP_fatal_error */
1865 {bgp_stop, Clearing}, /* ConnectRetry_timer_expired */
1866 {bgp_stop, Clearing}, /* Hold_Timer_expired */
1867 {bgp_stop, Clearing}, /* KeepAlive_timer_expired */
1868 {bgp_stop, Clearing}, /* Receive_OPEN_message */
1869 {bgp_stop, Clearing}, /* Receive_KEEPALIVE_message */
1870 {bgp_stop, Clearing}, /* Receive_UPDATE_message */
1871 {bgp_stop, Clearing}, /* Receive_NOTIFICATION_message */
1872 {bgp_clearing_completed, Idle}, /* Clearing_Completed */
1873 },
1874 {
1875 /* Deleted, */
1876 {bgp_ignore, Deleted}, /* BGP_Start */
1877 {bgp_ignore, Deleted}, /* BGP_Stop */
1878 {bgp_ignore, Deleted}, /* TCP_connection_open */
1879 {bgp_ignore, Deleted}, /* TCP_connection_closed */
1880 {bgp_ignore, Deleted}, /* TCP_connection_open_failed */
1881 {bgp_ignore, Deleted}, /* TCP_fatal_error */
1882 {bgp_ignore, Deleted}, /* ConnectRetry_timer_expired */
1883 {bgp_ignore, Deleted}, /* Hold_Timer_expired */
1884 {bgp_ignore, Deleted}, /* KeepAlive_timer_expired */
1885 {bgp_ignore, Deleted}, /* Receive_OPEN_message */
1886 {bgp_ignore, Deleted}, /* Receive_KEEPALIVE_message */
1887 {bgp_ignore, Deleted}, /* Receive_UPDATE_message */
1888 {bgp_ignore, Deleted}, /* Receive_NOTIFICATION_message */
1889 {bgp_ignore, Deleted}, /* Clearing_Completed */
1890 },
1891 };
1892
1893 /* Execute event process. */
1894 int bgp_event(struct thread *thread)
1895 {
1896 int event;
1897 struct peer *peer;
1898 int ret;
1899
1900 peer = THREAD_ARG(thread);
1901 event = THREAD_VAL(thread);
1902
1903 ret = bgp_event_update(peer, event);
1904
1905 return (ret);
1906 }
1907
1908 int bgp_event_update(struct peer *peer, int event)
1909 {
1910 int next;
1911 int ret = 0;
1912 struct peer *other;
1913 int passive_conn = 0;
1914 int dyn_nbr;
1915
1916 /* default return code */
1917 ret = FSM_PEER_NOOP;
1918
1919 other = peer->doppelganger;
1920 passive_conn =
1921 (CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER)) ? 1 : 0;
1922 dyn_nbr = peer_dynamic_neighbor(peer);
1923
1924 /* Logging this event. */
1925 next = FSM[peer->status - 1][event - 1].next_state;
1926
1927 if (bgp_debug_neighbor_events(peer) && peer->status != next)
1928 zlog_debug("%s [FSM] %s (%s->%s), fd %d", peer->host,
1929 bgp_event_str[event],
1930 lookup_msg(bgp_status_msg, peer->status, NULL),
1931 lookup_msg(bgp_status_msg, next, NULL), peer->fd);
1932
1933 peer->last_event = peer->cur_event;
1934 peer->cur_event = event;
1935
1936 /* Call function. */
1937 if (FSM[peer->status - 1][event - 1].func)
1938 ret = (*(FSM[peer->status - 1][event - 1].func))(peer);
1939
1940 if (ret >= 0) {
1941 if (ret == 1 && next == Established) {
1942 /* The case when doppelganger swap accurred in
1943 bgp_establish.
1944 Update the peer pointer accordingly */
1945 ret = FSM_PEER_TRANSFERRED;
1946 peer = other;
1947 }
1948
1949 /* If status is changed. */
1950 if (next != peer->status) {
1951 bgp_fsm_change_status(peer, next);
1952
1953 /*
1954 * If we're going to ESTABLISHED then we executed a
1955 * peer transfer. In this case we can either return
1956 * FSM_PEER_TRANSITIONED or FSM_PEER_TRANSFERRED.
1957 * Opting for TRANSFERRED since transfer implies
1958 * session establishment.
1959 */
1960 if (ret != FSM_PEER_TRANSFERRED)
1961 ret = FSM_PEER_TRANSITIONED;
1962 }
1963
1964 /* Make sure timer is set. */
1965 bgp_timer_set(peer);
1966
1967 } else {
1968 /*
1969 * If we got a return value of -1, that means there was an
1970 * error, restart the FSM. Since bgp_stop() was called on the
1971 * peer. only a few fields are safe to access here. In any case
1972 * we need to indicate that the peer was stopped in the return
1973 * code.
1974 */
1975 if (!dyn_nbr && !passive_conn && peer->bgp) {
1976 flog_err(
1977 BGP_ERR_FSM,
1978 "%s [FSM] Failure handling event %s in state %s, "
1979 "prior events %s, %s, fd %d",
1980 peer->host, bgp_event_str[peer->cur_event],
1981 lookup_msg(bgp_status_msg, peer->status, NULL),
1982 bgp_event_str[peer->last_event],
1983 bgp_event_str[peer->last_major_event],
1984 peer->fd);
1985 bgp_stop(peer);
1986 bgp_fsm_change_status(peer, Idle);
1987 bgp_timer_set(peer);
1988 }
1989 ret = FSM_PEER_STOPPED;
1990 }
1991
1992 return ret;
1993 }
FRRouting mirror