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