Annotation of embedaddon/quagga/bgpd/bgp_fsm.c, revision 1.1
1.1 ! misho 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
! 18: along with GNU Zebra; see the file COPYING. If not, write to the Free
! 19: Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 20: 02111-1307, USA. */
! 21:
! 22: #include <zebra.h>
! 23:
! 24: #include "linklist.h"
! 25: #include "prefix.h"
! 26: #include "vty.h"
! 27: #include "sockunion.h"
! 28: #include "thread.h"
! 29: #include "log.h"
! 30: #include "stream.h"
! 31: #include "memory.h"
! 32: #include "plist.h"
! 33:
! 34: #include "bgpd/bgpd.h"
! 35: #include "bgpd/bgp_attr.h"
! 36: #include "bgpd/bgp_debug.h"
! 37: #include "bgpd/bgp_fsm.h"
! 38: #include "bgpd/bgp_packet.h"
! 39: #include "bgpd/bgp_network.h"
! 40: #include "bgpd/bgp_route.h"
! 41: #include "bgpd/bgp_dump.h"
! 42: #include "bgpd/bgp_open.h"
! 43: #ifdef HAVE_SNMP
! 44: #include "bgpd/bgp_snmp.h"
! 45: #endif /* HAVE_SNMP */
! 46:
! 47: /* BGP FSM (finite state machine) has three types of functions. Type
! 48: one is thread functions. Type two is event functions. Type three
! 49: is FSM functions. Timer functions are set by bgp_timer_set
! 50: function. */
! 51:
! 52: /* BGP event function. */
! 53: int bgp_event (struct thread *);
! 54:
! 55: /* BGP thread functions. */
! 56: static int bgp_start_timer (struct thread *);
! 57: static int bgp_connect_timer (struct thread *);
! 58: static int bgp_holdtime_timer (struct thread *);
! 59: static int bgp_keepalive_timer (struct thread *);
! 60:
! 61: /* BGP FSM functions. */
! 62: static int bgp_start (struct peer *);
! 63:
! 64: /* BGP start timer jitter. */
! 65: static int
! 66: bgp_start_jitter (int time)
! 67: {
! 68: return ((rand () % (time + 1)) - (time / 2));
! 69: }
! 70:
! 71: /* Check if suppress start/restart of sessions to peer. */
! 72: #define BGP_PEER_START_SUPPRESSED(P) \
! 73: (CHECK_FLAG ((P)->flags, PEER_FLAG_SHUTDOWN) \
! 74: || CHECK_FLAG ((P)->sflags, PEER_STATUS_PREFIX_OVERFLOW))
! 75:
! 76: /* Hook function called after bgp event is occered. And vty's
! 77: neighbor command invoke this function after making neighbor
! 78: structure. */
! 79: void
! 80: bgp_timer_set (struct peer *peer)
! 81: {
! 82: int jitter = 0;
! 83:
! 84: switch (peer->status)
! 85: {
! 86: case Idle:
! 87: /* First entry point of peer's finite state machine. In Idle
! 88: status start timer is on unless peer is shutdown or peer is
! 89: inactive. All other timer must be turned off */
! 90: if (BGP_PEER_START_SUPPRESSED (peer) || ! peer_active (peer))
! 91: {
! 92: BGP_TIMER_OFF (peer->t_start);
! 93: }
! 94: else
! 95: {
! 96: jitter = bgp_start_jitter (peer->v_start);
! 97: BGP_TIMER_ON (peer->t_start, bgp_start_timer,
! 98: peer->v_start + jitter);
! 99: }
! 100: BGP_TIMER_OFF (peer->t_connect);
! 101: BGP_TIMER_OFF (peer->t_holdtime);
! 102: BGP_TIMER_OFF (peer->t_keepalive);
! 103: BGP_TIMER_OFF (peer->t_asorig);
! 104: BGP_TIMER_OFF (peer->t_routeadv);
! 105: break;
! 106:
! 107: case Connect:
! 108: /* After start timer is expired, the peer moves to Connnect
! 109: status. Make sure start timer is off and connect timer is
! 110: on. */
! 111: BGP_TIMER_OFF (peer->t_start);
! 112: BGP_TIMER_ON (peer->t_connect, bgp_connect_timer, peer->v_connect);
! 113: BGP_TIMER_OFF (peer->t_holdtime);
! 114: BGP_TIMER_OFF (peer->t_keepalive);
! 115: BGP_TIMER_OFF (peer->t_asorig);
! 116: BGP_TIMER_OFF (peer->t_routeadv);
! 117: break;
! 118:
! 119: case Active:
! 120: /* Active is waiting connection from remote peer. And if
! 121: connect timer is expired, change status to Connect. */
! 122: BGP_TIMER_OFF (peer->t_start);
! 123: /* If peer is passive mode, do not set connect timer. */
! 124: if (CHECK_FLAG (peer->flags, PEER_FLAG_PASSIVE)
! 125: || CHECK_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT))
! 126: {
! 127: BGP_TIMER_OFF (peer->t_connect);
! 128: }
! 129: else
! 130: {
! 131: BGP_TIMER_ON (peer->t_connect, bgp_connect_timer, peer->v_connect);
! 132: }
! 133: BGP_TIMER_OFF (peer->t_holdtime);
! 134: BGP_TIMER_OFF (peer->t_keepalive);
! 135: BGP_TIMER_OFF (peer->t_asorig);
! 136: BGP_TIMER_OFF (peer->t_routeadv);
! 137: break;
! 138:
! 139: case OpenSent:
! 140: /* OpenSent status. */
! 141: BGP_TIMER_OFF (peer->t_start);
! 142: BGP_TIMER_OFF (peer->t_connect);
! 143: if (peer->v_holdtime != 0)
! 144: {
! 145: BGP_TIMER_ON (peer->t_holdtime, bgp_holdtime_timer,
! 146: peer->v_holdtime);
! 147: }
! 148: else
! 149: {
! 150: BGP_TIMER_OFF (peer->t_holdtime);
! 151: }
! 152: BGP_TIMER_OFF (peer->t_keepalive);
! 153: BGP_TIMER_OFF (peer->t_asorig);
! 154: BGP_TIMER_OFF (peer->t_routeadv);
! 155: break;
! 156:
! 157: case OpenConfirm:
! 158: /* OpenConfirm status. */
! 159: BGP_TIMER_OFF (peer->t_start);
! 160: BGP_TIMER_OFF (peer->t_connect);
! 161:
! 162: /* If the negotiated Hold Time value is zero, then the Hold Time
! 163: timer and KeepAlive timers are not started. */
! 164: if (peer->v_holdtime == 0)
! 165: {
! 166: BGP_TIMER_OFF (peer->t_holdtime);
! 167: BGP_TIMER_OFF (peer->t_keepalive);
! 168: }
! 169: else
! 170: {
! 171: BGP_TIMER_ON (peer->t_holdtime, bgp_holdtime_timer,
! 172: peer->v_holdtime);
! 173: BGP_TIMER_ON (peer->t_keepalive, bgp_keepalive_timer,
! 174: peer->v_keepalive);
! 175: }
! 176: BGP_TIMER_OFF (peer->t_asorig);
! 177: BGP_TIMER_OFF (peer->t_routeadv);
! 178: break;
! 179:
! 180: case Established:
! 181: /* In Established status start and connect timer is turned
! 182: off. */
! 183: BGP_TIMER_OFF (peer->t_start);
! 184: BGP_TIMER_OFF (peer->t_connect);
! 185:
! 186: /* Same as OpenConfirm, if holdtime is zero then both holdtime
! 187: and keepalive must be turned off. */
! 188: if (peer->v_holdtime == 0)
! 189: {
! 190: BGP_TIMER_OFF (peer->t_holdtime);
! 191: BGP_TIMER_OFF (peer->t_keepalive);
! 192: }
! 193: else
! 194: {
! 195: BGP_TIMER_ON (peer->t_holdtime, bgp_holdtime_timer,
! 196: peer->v_holdtime);
! 197: BGP_TIMER_ON (peer->t_keepalive, bgp_keepalive_timer,
! 198: peer->v_keepalive);
! 199: }
! 200: BGP_TIMER_OFF (peer->t_asorig);
! 201: break;
! 202: case Deleted:
! 203: BGP_TIMER_OFF (peer->t_gr_restart);
! 204: BGP_TIMER_OFF (peer->t_gr_stale);
! 205: BGP_TIMER_OFF (peer->t_pmax_restart);
! 206: case Clearing:
! 207: BGP_TIMER_OFF (peer->t_start);
! 208: BGP_TIMER_OFF (peer->t_connect);
! 209: BGP_TIMER_OFF (peer->t_holdtime);
! 210: BGP_TIMER_OFF (peer->t_keepalive);
! 211: BGP_TIMER_OFF (peer->t_asorig);
! 212: BGP_TIMER_OFF (peer->t_routeadv);
! 213: }
! 214: }
! 215:
! 216: /* BGP start timer. This function set BGP_Start event to thread value
! 217: and process event. */
! 218: static int
! 219: bgp_start_timer (struct thread *thread)
! 220: {
! 221: struct peer *peer;
! 222:
! 223: peer = THREAD_ARG (thread);
! 224: peer->t_start = NULL;
! 225:
! 226: if (BGP_DEBUG (fsm, FSM))
! 227: zlog (peer->log, LOG_DEBUG,
! 228: "%s [FSM] Timer (start timer expire).", peer->host);
! 229:
! 230: THREAD_VAL (thread) = BGP_Start;
! 231: bgp_event (thread); /* bgp_event unlocks peer */
! 232:
! 233: return 0;
! 234: }
! 235:
! 236: /* BGP connect retry timer. */
! 237: static int
! 238: bgp_connect_timer (struct thread *thread)
! 239: {
! 240: struct peer *peer;
! 241:
! 242: peer = THREAD_ARG (thread);
! 243: peer->t_connect = NULL;
! 244:
! 245: if (BGP_DEBUG (fsm, FSM))
! 246: zlog (peer->log, LOG_DEBUG, "%s [FSM] Timer (connect timer expire)",
! 247: peer->host);
! 248:
! 249: THREAD_VAL (thread) = ConnectRetry_timer_expired;
! 250: bgp_event (thread); /* bgp_event unlocks peer */
! 251:
! 252: return 0;
! 253: }
! 254:
! 255: /* BGP holdtime timer. */
! 256: static int
! 257: bgp_holdtime_timer (struct thread *thread)
! 258: {
! 259: struct peer *peer;
! 260:
! 261: peer = THREAD_ARG (thread);
! 262: peer->t_holdtime = NULL;
! 263:
! 264: if (BGP_DEBUG (fsm, FSM))
! 265: zlog (peer->log, LOG_DEBUG,
! 266: "%s [FSM] Timer (holdtime timer expire)",
! 267: peer->host);
! 268:
! 269: THREAD_VAL (thread) = Hold_Timer_expired;
! 270: bgp_event (thread); /* bgp_event unlocks peer */
! 271:
! 272: return 0;
! 273: }
! 274:
! 275: /* BGP keepalive fire ! */
! 276: static int
! 277: bgp_keepalive_timer (struct thread *thread)
! 278: {
! 279: struct peer *peer;
! 280:
! 281: peer = THREAD_ARG (thread);
! 282: peer->t_keepalive = NULL;
! 283:
! 284: if (BGP_DEBUG (fsm, FSM))
! 285: zlog (peer->log, LOG_DEBUG,
! 286: "%s [FSM] Timer (keepalive timer expire)",
! 287: peer->host);
! 288:
! 289: THREAD_VAL (thread) = KeepAlive_timer_expired;
! 290: bgp_event (thread); /* bgp_event unlocks peer */
! 291:
! 292: return 0;
! 293: }
! 294:
! 295: static int
! 296: bgp_routeadv_timer (struct thread *thread)
! 297: {
! 298: struct peer *peer;
! 299:
! 300: peer = THREAD_ARG (thread);
! 301: peer->t_routeadv = NULL;
! 302:
! 303: if (BGP_DEBUG (fsm, FSM))
! 304: zlog (peer->log, LOG_DEBUG,
! 305: "%s [FSM] Timer (routeadv timer expire)",
! 306: peer->host);
! 307:
! 308: peer->synctime = bgp_clock ();
! 309:
! 310: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
! 311:
! 312: BGP_TIMER_ON (peer->t_routeadv, bgp_routeadv_timer,
! 313: peer->v_routeadv);
! 314:
! 315: return 0;
! 316: }
! 317:
! 318: /* BGP Peer Down Cause */
! 319: const char *peer_down_str[] =
! 320: {
! 321: "",
! 322: "Router ID changed",
! 323: "Remote AS changed",
! 324: "Local AS change",
! 325: "Cluster ID changed",
! 326: "Confederation identifier changed",
! 327: "Confederation peer changed",
! 328: "RR client config change",
! 329: "RS client config change",
! 330: "Update source change",
! 331: "Address family activated",
! 332: "Admin. shutdown",
! 333: "User reset",
! 334: "BGP Notification received",
! 335: "BGP Notification send",
! 336: "Peer closed the session",
! 337: "Neighbor deleted",
! 338: "Peer-group add member",
! 339: "Peer-group delete member",
! 340: "Capability changed",
! 341: "Passive config change",
! 342: "Multihop config change",
! 343: "NSF peer closed the session"
! 344: };
! 345:
! 346: static int
! 347: bgp_graceful_restart_timer_expire (struct thread *thread)
! 348: {
! 349: struct peer *peer;
! 350: afi_t afi;
! 351: safi_t safi;
! 352:
! 353: peer = THREAD_ARG (thread);
! 354: peer->t_gr_restart = NULL;
! 355:
! 356: /* NSF delete stale route */
! 357: for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
! 358: for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
! 359: if (peer->nsf[afi][safi])
! 360: bgp_clear_stale_route (peer, afi, safi);
! 361:
! 362: UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT);
! 363: BGP_TIMER_OFF (peer->t_gr_stale);
! 364:
! 365: if (BGP_DEBUG (events, EVENTS))
! 366: {
! 367: zlog_debug ("%s graceful restart timer expired", peer->host);
! 368: zlog_debug ("%s graceful restart stalepath timer stopped", peer->host);
! 369: }
! 370:
! 371: bgp_timer_set (peer);
! 372:
! 373: return 0;
! 374: }
! 375:
! 376: static int
! 377: bgp_graceful_stale_timer_expire (struct thread *thread)
! 378: {
! 379: struct peer *peer;
! 380: afi_t afi;
! 381: safi_t safi;
! 382:
! 383: peer = THREAD_ARG (thread);
! 384: peer->t_gr_stale = NULL;
! 385:
! 386: if (BGP_DEBUG (events, EVENTS))
! 387: zlog_debug ("%s graceful restart stalepath timer expired", peer->host);
! 388:
! 389: /* NSF delete stale route */
! 390: for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
! 391: for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
! 392: if (peer->nsf[afi][safi])
! 393: bgp_clear_stale_route (peer, afi, safi);
! 394:
! 395: return 0;
! 396: }
! 397:
! 398: /* Called after event occured, this function change status and reset
! 399: read/write and timer thread. */
! 400: void
! 401: bgp_fsm_change_status (struct peer *peer, int status)
! 402: {
! 403: bgp_dump_state (peer, peer->status, status);
! 404:
! 405: /* Transition into Clearing or Deleted must /always/ clear all routes..
! 406: * (and must do so before actually changing into Deleted..
! 407: */
! 408: if (status >= Clearing)
! 409: bgp_clear_route_all (peer);
! 410:
! 411: /* Preserve old status and change into new status. */
! 412: peer->ostatus = peer->status;
! 413: peer->status = status;
! 414:
! 415: if (BGP_DEBUG (normal, NORMAL))
! 416: zlog_debug ("%s went from %s to %s",
! 417: peer->host,
! 418: LOOKUP (bgp_status_msg, peer->ostatus),
! 419: LOOKUP (bgp_status_msg, peer->status));
! 420: }
! 421:
! 422: /* Flush the event queue and ensure the peer is shut down */
! 423: static int
! 424: bgp_clearing_completed (struct peer *peer)
! 425: {
! 426: int rc = bgp_stop(peer);
! 427: BGP_EVENT_FLUSH (peer);
! 428:
! 429: return rc;
! 430: }
! 431:
! 432: /* Administrative BGP peer stop event. */
! 433: /* May be called multiple times for the same peer */
! 434: int
! 435: bgp_stop (struct peer *peer)
! 436: {
! 437: afi_t afi;
! 438: safi_t safi;
! 439: char orf_name[BUFSIZ];
! 440:
! 441: /* Can't do this in Clearing; events are used for state transitions */
! 442: if (peer->status != Clearing)
! 443: {
! 444: /* Delete all existing events of the peer */
! 445: BGP_EVENT_FLUSH (peer);
! 446: }
! 447:
! 448: /* Increment Dropped count. */
! 449: if (peer->status == Established)
! 450: {
! 451: peer->dropped++;
! 452:
! 453: /* bgp log-neighbor-changes of neighbor Down */
! 454: if (bgp_flag_check (peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES))
! 455: zlog_info ("%%ADJCHANGE: neighbor %s Down %s", peer->host,
! 456: peer_down_str [(int) peer->last_reset]);
! 457:
! 458: /* graceful restart */
! 459: if (peer->t_gr_stale)
! 460: {
! 461: BGP_TIMER_OFF (peer->t_gr_stale);
! 462: if (BGP_DEBUG (events, EVENTS))
! 463: zlog_debug ("%s graceful restart stalepath timer stopped", peer->host);
! 464: }
! 465: if (CHECK_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT))
! 466: {
! 467: if (BGP_DEBUG (events, EVENTS))
! 468: {
! 469: zlog_debug ("%s graceful restart timer started for %d sec",
! 470: peer->host, peer->v_gr_restart);
! 471: zlog_debug ("%s graceful restart stalepath timer started for %d sec",
! 472: peer->host, peer->bgp->stalepath_time);
! 473: }
! 474: BGP_TIMER_ON (peer->t_gr_restart, bgp_graceful_restart_timer_expire,
! 475: peer->v_gr_restart);
! 476: BGP_TIMER_ON (peer->t_gr_stale, bgp_graceful_stale_timer_expire,
! 477: peer->bgp->stalepath_time);
! 478: }
! 479: else
! 480: {
! 481: UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_MODE);
! 482:
! 483: for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
! 484: for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
! 485: peer->nsf[afi][safi] = 0;
! 486: }
! 487:
! 488: /* set last reset time */
! 489: peer->resettime = peer->uptime = bgp_clock ();
! 490:
! 491: #ifdef HAVE_SNMP
! 492: bgpTrapBackwardTransition (peer);
! 493: #endif /* HAVE_SNMP */
! 494:
! 495: /* Reset peer synctime */
! 496: peer->synctime = 0;
! 497: }
! 498:
! 499: /* Stop read and write threads when exists. */
! 500: BGP_READ_OFF (peer->t_read);
! 501: BGP_WRITE_OFF (peer->t_write);
! 502:
! 503: /* Stop all timers. */
! 504: BGP_TIMER_OFF (peer->t_start);
! 505: BGP_TIMER_OFF (peer->t_connect);
! 506: BGP_TIMER_OFF (peer->t_holdtime);
! 507: BGP_TIMER_OFF (peer->t_keepalive);
! 508: BGP_TIMER_OFF (peer->t_asorig);
! 509: BGP_TIMER_OFF (peer->t_routeadv);
! 510:
! 511: /* Stream reset. */
! 512: peer->packet_size = 0;
! 513:
! 514: /* Clear input and output buffer. */
! 515: if (peer->ibuf)
! 516: stream_reset (peer->ibuf);
! 517: if (peer->work)
! 518: stream_reset (peer->work);
! 519: if (peer->obuf)
! 520: stream_fifo_clean (peer->obuf);
! 521:
! 522: /* Close of file descriptor. */
! 523: if (peer->fd >= 0)
! 524: {
! 525: close (peer->fd);
! 526: peer->fd = -1;
! 527: }
! 528:
! 529: for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
! 530: for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
! 531: {
! 532: /* Reset all negotiated variables */
! 533: peer->afc_nego[afi][safi] = 0;
! 534: peer->afc_adv[afi][safi] = 0;
! 535: peer->afc_recv[afi][safi] = 0;
! 536:
! 537: /* peer address family capability flags*/
! 538: peer->af_cap[afi][safi] = 0;
! 539:
! 540: /* peer address family status flags*/
! 541: peer->af_sflags[afi][safi] = 0;
! 542:
! 543: /* Received ORF prefix-filter */
! 544: peer->orf_plist[afi][safi] = NULL;
! 545:
! 546: /* ORF received prefix-filter pnt */
! 547: sprintf (orf_name, "%s.%d.%d", peer->host, afi, safi);
! 548: prefix_bgp_orf_remove_all (orf_name);
! 549: }
! 550:
! 551: /* Reset keepalive and holdtime */
! 552: if (CHECK_FLAG (peer->config, PEER_CONFIG_TIMER))
! 553: {
! 554: peer->v_keepalive = peer->keepalive;
! 555: peer->v_holdtime = peer->holdtime;
! 556: }
! 557: else
! 558: {
! 559: peer->v_keepalive = peer->bgp->default_keepalive;
! 560: peer->v_holdtime = peer->bgp->default_holdtime;
! 561: }
! 562:
! 563: peer->update_time = 0;
! 564:
! 565: /* Until we are sure that there is no problem about prefix count
! 566: this should be commented out.*/
! 567: #if 0
! 568: /* Reset prefix count */
! 569: peer->pcount[AFI_IP][SAFI_UNICAST] = 0;
! 570: peer->pcount[AFI_IP][SAFI_MULTICAST] = 0;
! 571: peer->pcount[AFI_IP][SAFI_MPLS_VPN] = 0;
! 572: peer->pcount[AFI_IP6][SAFI_UNICAST] = 0;
! 573: peer->pcount[AFI_IP6][SAFI_MULTICAST] = 0;
! 574: #endif /* 0 */
! 575:
! 576: return 0;
! 577: }
! 578:
! 579: /* BGP peer is stoped by the error. */
! 580: static int
! 581: bgp_stop_with_error (struct peer *peer)
! 582: {
! 583: /* Double start timer. */
! 584: peer->v_start *= 2;
! 585:
! 586: /* Overflow check. */
! 587: if (peer->v_start >= (60 * 2))
! 588: peer->v_start = (60 * 2);
! 589:
! 590: bgp_stop (peer);
! 591:
! 592: return 0;
! 593: }
! 594:
! 595: /* TCP connection open. Next we send open message to remote peer. And
! 596: add read thread for reading open message. */
! 597: static int
! 598: bgp_connect_success (struct peer *peer)
! 599: {
! 600: char buf1[BUFSIZ];
! 601:
! 602: if (peer->fd < 0)
! 603: {
! 604: zlog_err ("bgp_connect_success peer's fd is negative value %d",
! 605: peer->fd);
! 606: return -1;
! 607: }
! 608: BGP_READ_ON (peer->t_read, bgp_read, peer->fd);
! 609:
! 610: if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
! 611: bgp_getsockname (peer);
! 612:
! 613: if (BGP_DEBUG (normal, NORMAL))
! 614: {
! 615: if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
! 616: zlog_debug ("%s open active, local address %s", peer->host,
! 617: sockunion2str (peer->su_local, buf1, SU_ADDRSTRLEN));
! 618: else
! 619: zlog_debug ("%s passive open", peer->host);
! 620: }
! 621:
! 622: if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
! 623: bgp_open_send (peer);
! 624:
! 625: return 0;
! 626: }
! 627:
! 628: /* TCP connect fail */
! 629: static int
! 630: bgp_connect_fail (struct peer *peer)
! 631: {
! 632: bgp_stop (peer);
! 633: return 0;
! 634: }
! 635:
! 636: /* This function is the first starting point of all BGP connection. It
! 637: try to connect to remote peer with non-blocking IO. */
! 638: int
! 639: bgp_start (struct peer *peer)
! 640: {
! 641: int status;
! 642:
! 643: if (BGP_PEER_START_SUPPRESSED (peer))
! 644: {
! 645: if (BGP_DEBUG (fsm, FSM))
! 646: plog_err (peer->log, "%s [FSM] Trying to start suppressed peer"
! 647: " - this is never supposed to happen!", peer->host);
! 648: return -1;
! 649: }
! 650:
! 651: /* Scrub some information that might be left over from a previous,
! 652: * session
! 653: */
! 654: /* Connection information. */
! 655: if (peer->su_local)
! 656: {
! 657: sockunion_free (peer->su_local);
! 658: peer->su_local = NULL;
! 659: }
! 660:
! 661: if (peer->su_remote)
! 662: {
! 663: sockunion_free (peer->su_remote);
! 664: peer->su_remote = NULL;
! 665: }
! 666:
! 667: /* Clear remote router-id. */
! 668: peer->remote_id.s_addr = 0;
! 669:
! 670: /* Clear peer capability flag. */
! 671: peer->cap = 0;
! 672:
! 673: /* If the peer is passive mode, force to move to Active mode. */
! 674: if (CHECK_FLAG (peer->flags, PEER_FLAG_PASSIVE))
! 675: {
! 676: BGP_EVENT_ADD (peer, TCP_connection_open_failed);
! 677: return 0;
! 678: }
! 679:
! 680: status = bgp_connect (peer);
! 681:
! 682: switch (status)
! 683: {
! 684: case connect_error:
! 685: if (BGP_DEBUG (fsm, FSM))
! 686: plog_debug (peer->log, "%s [FSM] Connect error", peer->host);
! 687: BGP_EVENT_ADD (peer, TCP_connection_open_failed);
! 688: break;
! 689: case connect_success:
! 690: if (BGP_DEBUG (fsm, FSM))
! 691: plog_debug (peer->log, "%s [FSM] Connect immediately success",
! 692: peer->host);
! 693: BGP_EVENT_ADD (peer, TCP_connection_open);
! 694: break;
! 695: case connect_in_progress:
! 696: /* To check nonblocking connect, we wait until socket is
! 697: readable or writable. */
! 698: if (BGP_DEBUG (fsm, FSM))
! 699: plog_debug (peer->log, "%s [FSM] Non blocking connect waiting result",
! 700: peer->host);
! 701: if (peer->fd < 0)
! 702: {
! 703: zlog_err ("bgp_start peer's fd is negative value %d",
! 704: peer->fd);
! 705: return -1;
! 706: }
! 707: BGP_READ_ON (peer->t_read, bgp_read, peer->fd);
! 708: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
! 709: break;
! 710: }
! 711: return 0;
! 712: }
! 713:
! 714: /* Connect retry timer is expired when the peer status is Connect. */
! 715: static int
! 716: bgp_reconnect (struct peer *peer)
! 717: {
! 718: bgp_stop (peer);
! 719: bgp_start (peer);
! 720: return 0;
! 721: }
! 722:
! 723: static int
! 724: bgp_fsm_open (struct peer *peer)
! 725: {
! 726: /* Send keepalive and make keepalive timer */
! 727: bgp_keepalive_send (peer);
! 728:
! 729: /* Reset holdtimer value. */
! 730: BGP_TIMER_OFF (peer->t_holdtime);
! 731:
! 732: return 0;
! 733: }
! 734:
! 735: /* Keepalive send to peer. */
! 736: static int
! 737: bgp_fsm_keepalive_expire (struct peer *peer)
! 738: {
! 739: bgp_keepalive_send (peer);
! 740: return 0;
! 741: }
! 742:
! 743: /* Hold timer expire. This is error of BGP connection. So cut the
! 744: peer and change to Idle status. */
! 745: static int
! 746: bgp_fsm_holdtime_expire (struct peer *peer)
! 747: {
! 748: if (BGP_DEBUG (fsm, FSM))
! 749: zlog (peer->log, LOG_DEBUG, "%s [FSM] Hold timer expire", peer->host);
! 750:
! 751: /* Send notify to remote peer. */
! 752: bgp_notify_send (peer, BGP_NOTIFY_HOLD_ERR, 0);
! 753:
! 754: /* Sweep if it is temporary peer. */
! 755: if (CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
! 756: {
! 757: zlog_info ("%s [Event] Accepting BGP peer is deleted", peer->host);
! 758: peer_delete (peer);
! 759: return -1;
! 760: }
! 761:
! 762: /* bgp_stop needs to be invoked while in Established state */
! 763: bgp_stop(peer);
! 764:
! 765: return 0;
! 766: }
! 767:
! 768: /* Status goes to Established. Send keepalive packet then make first
! 769: update information. */
! 770: static int
! 771: bgp_establish (struct peer *peer)
! 772: {
! 773: struct bgp_notify *notify;
! 774: afi_t afi;
! 775: safi_t safi;
! 776: int nsf_af_count = 0;
! 777:
! 778: /* Reset capability open status flag. */
! 779: if (! CHECK_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN))
! 780: SET_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN);
! 781:
! 782: /* Clear last notification data. */
! 783: notify = &peer->notify;
! 784: if (notify->data)
! 785: XFREE (MTYPE_TMP, notify->data);
! 786: memset (notify, 0, sizeof (struct bgp_notify));
! 787:
! 788: /* Clear start timer value to default. */
! 789: peer->v_start = BGP_INIT_START_TIMER;
! 790:
! 791: /* Increment established count. */
! 792: peer->established++;
! 793: bgp_fsm_change_status (peer, Established);
! 794:
! 795: /* bgp log-neighbor-changes of neighbor Up */
! 796: if (bgp_flag_check (peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES))
! 797: zlog_info ("%%ADJCHANGE: neighbor %s Up", peer->host);
! 798:
! 799: /* graceful restart */
! 800: UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT);
! 801: for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
! 802: for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
! 803: {
! 804: if (peer->afc_nego[afi][safi]
! 805: && CHECK_FLAG (peer->cap, PEER_CAP_RESTART_ADV)
! 806: && CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_RESTART_AF_RCV))
! 807: {
! 808: if (peer->nsf[afi][safi]
! 809: && ! CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_RESTART_AF_PRESERVE_RCV))
! 810: bgp_clear_stale_route (peer, afi, safi);
! 811:
! 812: peer->nsf[afi][safi] = 1;
! 813: nsf_af_count++;
! 814: }
! 815: else
! 816: {
! 817: if (peer->nsf[afi][safi])
! 818: bgp_clear_stale_route (peer, afi, safi);
! 819: peer->nsf[afi][safi] = 0;
! 820: }
! 821: }
! 822:
! 823: if (nsf_af_count)
! 824: SET_FLAG (peer->sflags, PEER_STATUS_NSF_MODE);
! 825: else
! 826: {
! 827: UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_MODE);
! 828: if (peer->t_gr_stale)
! 829: {
! 830: BGP_TIMER_OFF (peer->t_gr_stale);
! 831: if (BGP_DEBUG (events, EVENTS))
! 832: zlog_debug ("%s graceful restart stalepath timer stopped", peer->host);
! 833: }
! 834: }
! 835:
! 836: if (peer->t_gr_restart)
! 837: {
! 838: BGP_TIMER_OFF (peer->t_gr_restart);
! 839: if (BGP_DEBUG (events, EVENTS))
! 840: zlog_debug ("%s graceful restart timer stopped", peer->host);
! 841: }
! 842:
! 843: #ifdef HAVE_SNMP
! 844: bgpTrapEstablished (peer);
! 845: #endif /* HAVE_SNMP */
! 846:
! 847: /* Reset uptime, send keepalive, send current table. */
! 848: peer->uptime = bgp_clock ();
! 849:
! 850: /* Send route-refresh when ORF is enabled */
! 851: for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
! 852: for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
! 853: if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV))
! 854: {
! 855: if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV))
! 856: bgp_route_refresh_send (peer, afi, safi, ORF_TYPE_PREFIX,
! 857: REFRESH_IMMEDIATE, 0);
! 858: else if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
! 859: bgp_route_refresh_send (peer, afi, safi, ORF_TYPE_PREFIX_OLD,
! 860: REFRESH_IMMEDIATE, 0);
! 861: }
! 862:
! 863: if (peer->v_keepalive)
! 864: bgp_keepalive_send (peer);
! 865:
! 866: /* First update is deferred until ORF or ROUTE-REFRESH is received */
! 867: for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
! 868: for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
! 869: if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV))
! 870: if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_RCV)
! 871: || CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_OLD_RCV))
! 872: SET_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_WAIT_REFRESH);
! 873:
! 874: bgp_announce_route_all (peer);
! 875:
! 876: BGP_TIMER_ON (peer->t_routeadv, bgp_routeadv_timer, 1);
! 877:
! 878: return 0;
! 879: }
! 880:
! 881: /* Keepalive packet is received. */
! 882: static int
! 883: bgp_fsm_keepalive (struct peer *peer)
! 884: {
! 885: /* peer count update */
! 886: peer->keepalive_in++;
! 887:
! 888: BGP_TIMER_OFF (peer->t_holdtime);
! 889: return 0;
! 890: }
! 891:
! 892: /* Update packet is received. */
! 893: static int
! 894: bgp_fsm_update (struct peer *peer)
! 895: {
! 896: BGP_TIMER_OFF (peer->t_holdtime);
! 897: return 0;
! 898: }
! 899:
! 900: /* This is empty event. */
! 901: static int
! 902: bgp_ignore (struct peer *peer)
! 903: {
! 904: if (BGP_DEBUG (fsm, FSM))
! 905: zlog (peer->log, LOG_DEBUG, "%s [FSM] bgp_ignore called", peer->host);
! 906: return 0;
! 907: }
! 908:
! 909: /* Finite State Machine structure */
! 910: static const struct {
! 911: int (*func) (struct peer *);
! 912: int next_state;
! 913: } FSM [BGP_STATUS_MAX - 1][BGP_EVENTS_MAX - 1] =
! 914: {
! 915: {
! 916: /* Idle state: In Idle state, all events other than BGP_Start is
! 917: ignored. With BGP_Start event, finite state machine calls
! 918: bgp_start(). */
! 919: {bgp_start, Connect}, /* BGP_Start */
! 920: {bgp_stop, Idle}, /* BGP_Stop */
! 921: {bgp_stop, Idle}, /* TCP_connection_open */
! 922: {bgp_stop, Idle}, /* TCP_connection_closed */
! 923: {bgp_ignore, Idle}, /* TCP_connection_open_failed */
! 924: {bgp_stop, Idle}, /* TCP_fatal_error */
! 925: {bgp_ignore, Idle}, /* ConnectRetry_timer_expired */
! 926: {bgp_ignore, Idle}, /* Hold_Timer_expired */
! 927: {bgp_ignore, Idle}, /* KeepAlive_timer_expired */
! 928: {bgp_ignore, Idle}, /* Receive_OPEN_message */
! 929: {bgp_ignore, Idle}, /* Receive_KEEPALIVE_message */
! 930: {bgp_ignore, Idle}, /* Receive_UPDATE_message */
! 931: {bgp_ignore, Idle}, /* Receive_NOTIFICATION_message */
! 932: {bgp_ignore, Idle}, /* Clearing_Completed */
! 933: },
! 934: {
! 935: /* Connect */
! 936: {bgp_ignore, Connect}, /* BGP_Start */
! 937: {bgp_stop, Idle}, /* BGP_Stop */
! 938: {bgp_connect_success, OpenSent}, /* TCP_connection_open */
! 939: {bgp_stop, Idle}, /* TCP_connection_closed */
! 940: {bgp_connect_fail, Active}, /* TCP_connection_open_failed */
! 941: {bgp_connect_fail, Idle}, /* TCP_fatal_error */
! 942: {bgp_reconnect, Connect}, /* ConnectRetry_timer_expired */
! 943: {bgp_ignore, Idle}, /* Hold_Timer_expired */
! 944: {bgp_ignore, Idle}, /* KeepAlive_timer_expired */
! 945: {bgp_ignore, Idle}, /* Receive_OPEN_message */
! 946: {bgp_ignore, Idle}, /* Receive_KEEPALIVE_message */
! 947: {bgp_ignore, Idle}, /* Receive_UPDATE_message */
! 948: {bgp_stop, Idle}, /* Receive_NOTIFICATION_message */
! 949: {bgp_ignore, Idle}, /* Clearing_Completed */
! 950: },
! 951: {
! 952: /* Active, */
! 953: {bgp_ignore, Active}, /* BGP_Start */
! 954: {bgp_stop, Idle}, /* BGP_Stop */
! 955: {bgp_connect_success, OpenSent}, /* TCP_connection_open */
! 956: {bgp_stop, Idle}, /* TCP_connection_closed */
! 957: {bgp_ignore, Active}, /* TCP_connection_open_failed */
! 958: {bgp_ignore, Idle}, /* TCP_fatal_error */
! 959: {bgp_start, Connect}, /* ConnectRetry_timer_expired */
! 960: {bgp_ignore, Idle}, /* Hold_Timer_expired */
! 961: {bgp_ignore, Idle}, /* KeepAlive_timer_expired */
! 962: {bgp_ignore, Idle}, /* Receive_OPEN_message */
! 963: {bgp_ignore, Idle}, /* Receive_KEEPALIVE_message */
! 964: {bgp_ignore, Idle}, /* Receive_UPDATE_message */
! 965: {bgp_stop_with_error, Idle}, /* Receive_NOTIFICATION_message */
! 966: {bgp_ignore, Idle}, /* Clearing_Completed */
! 967: },
! 968: {
! 969: /* OpenSent, */
! 970: {bgp_ignore, OpenSent}, /* BGP_Start */
! 971: {bgp_stop, Idle}, /* BGP_Stop */
! 972: {bgp_stop, Active}, /* TCP_connection_open */
! 973: {bgp_stop, Active}, /* TCP_connection_closed */
! 974: {bgp_stop, Active}, /* TCP_connection_open_failed */
! 975: {bgp_stop, Active}, /* TCP_fatal_error */
! 976: {bgp_ignore, Idle}, /* ConnectRetry_timer_expired */
! 977: {bgp_fsm_holdtime_expire, Idle}, /* Hold_Timer_expired */
! 978: {bgp_ignore, Idle}, /* KeepAlive_timer_expired */
! 979: {bgp_fsm_open, OpenConfirm}, /* Receive_OPEN_message */
! 980: {bgp_ignore, Idle}, /* Receive_KEEPALIVE_message */
! 981: {bgp_ignore, Idle}, /* Receive_UPDATE_message */
! 982: {bgp_stop_with_error, Idle}, /* Receive_NOTIFICATION_message */
! 983: {bgp_ignore, Idle}, /* Clearing_Completed */
! 984: },
! 985: {
! 986: /* OpenConfirm, */
! 987: {bgp_ignore, OpenConfirm}, /* BGP_Start */
! 988: {bgp_stop, Idle}, /* BGP_Stop */
! 989: {bgp_stop, Idle}, /* TCP_connection_open */
! 990: {bgp_stop, Idle}, /* TCP_connection_closed */
! 991: {bgp_stop, Idle}, /* TCP_connection_open_failed */
! 992: {bgp_stop, Idle}, /* TCP_fatal_error */
! 993: {bgp_ignore, Idle}, /* ConnectRetry_timer_expired */
! 994: {bgp_fsm_holdtime_expire, Idle}, /* Hold_Timer_expired */
! 995: {bgp_ignore, OpenConfirm}, /* KeepAlive_timer_expired */
! 996: {bgp_ignore, Idle}, /* Receive_OPEN_message */
! 997: {bgp_establish, Established}, /* Receive_KEEPALIVE_message */
! 998: {bgp_ignore, Idle}, /* Receive_UPDATE_message */
! 999: {bgp_stop_with_error, Idle}, /* Receive_NOTIFICATION_message */
! 1000: {bgp_ignore, Idle}, /* Clearing_Completed */
! 1001: },
! 1002: {
! 1003: /* Established, */
! 1004: {bgp_ignore, Established}, /* BGP_Start */
! 1005: {bgp_stop, Clearing}, /* BGP_Stop */
! 1006: {bgp_stop, Clearing}, /* TCP_connection_open */
! 1007: {bgp_stop, Clearing}, /* TCP_connection_closed */
! 1008: {bgp_stop, Clearing}, /* TCP_connection_open_failed */
! 1009: {bgp_stop, Clearing}, /* TCP_fatal_error */
! 1010: {bgp_stop, Clearing}, /* ConnectRetry_timer_expired */
! 1011: {bgp_fsm_holdtime_expire, Clearing}, /* Hold_Timer_expired */
! 1012: {bgp_fsm_keepalive_expire, Established}, /* KeepAlive_timer_expired */
! 1013: {bgp_stop, Clearing}, /* Receive_OPEN_message */
! 1014: {bgp_fsm_keepalive, Established}, /* Receive_KEEPALIVE_message */
! 1015: {bgp_fsm_update, Established}, /* Receive_UPDATE_message */
! 1016: {bgp_stop_with_error, Clearing}, /* Receive_NOTIFICATION_message */
! 1017: {bgp_ignore, Idle}, /* Clearing_Completed */
! 1018: },
! 1019: {
! 1020: /* Clearing, */
! 1021: {bgp_ignore, Clearing}, /* BGP_Start */
! 1022: {bgp_stop, Clearing}, /* BGP_Stop */
! 1023: {bgp_stop, Clearing}, /* TCP_connection_open */
! 1024: {bgp_stop, Clearing}, /* TCP_connection_closed */
! 1025: {bgp_stop, Clearing}, /* TCP_connection_open_failed */
! 1026: {bgp_stop, Clearing}, /* TCP_fatal_error */
! 1027: {bgp_stop, Clearing}, /* ConnectRetry_timer_expired */
! 1028: {bgp_stop, Clearing}, /* Hold_Timer_expired */
! 1029: {bgp_stop, Clearing}, /* KeepAlive_timer_expired */
! 1030: {bgp_stop, Clearing}, /* Receive_OPEN_message */
! 1031: {bgp_stop, Clearing}, /* Receive_KEEPALIVE_message */
! 1032: {bgp_stop, Clearing}, /* Receive_UPDATE_message */
! 1033: {bgp_stop, Clearing}, /* Receive_NOTIFICATION_message */
! 1034: {bgp_clearing_completed, Idle}, /* Clearing_Completed */
! 1035: },
! 1036: {
! 1037: /* Deleted, */
! 1038: {bgp_ignore, Deleted}, /* BGP_Start */
! 1039: {bgp_ignore, Deleted}, /* BGP_Stop */
! 1040: {bgp_ignore, Deleted}, /* TCP_connection_open */
! 1041: {bgp_ignore, Deleted}, /* TCP_connection_closed */
! 1042: {bgp_ignore, Deleted}, /* TCP_connection_open_failed */
! 1043: {bgp_ignore, Deleted}, /* TCP_fatal_error */
! 1044: {bgp_ignore, Deleted}, /* ConnectRetry_timer_expired */
! 1045: {bgp_ignore, Deleted}, /* Hold_Timer_expired */
! 1046: {bgp_ignore, Deleted}, /* KeepAlive_timer_expired */
! 1047: {bgp_ignore, Deleted}, /* Receive_OPEN_message */
! 1048: {bgp_ignore, Deleted}, /* Receive_KEEPALIVE_message */
! 1049: {bgp_ignore, Deleted}, /* Receive_UPDATE_message */
! 1050: {bgp_ignore, Deleted}, /* Receive_NOTIFICATION_message */
! 1051: {bgp_ignore, Deleted}, /* Clearing_Completed */
! 1052: },
! 1053: };
! 1054:
! 1055: static const char *bgp_event_str[] =
! 1056: {
! 1057: NULL,
! 1058: "BGP_Start",
! 1059: "BGP_Stop",
! 1060: "TCP_connection_open",
! 1061: "TCP_connection_closed",
! 1062: "TCP_connection_open_failed",
! 1063: "TCP_fatal_error",
! 1064: "ConnectRetry_timer_expired",
! 1065: "Hold_Timer_expired",
! 1066: "KeepAlive_timer_expired",
! 1067: "Receive_OPEN_message",
! 1068: "Receive_KEEPALIVE_message",
! 1069: "Receive_UPDATE_message",
! 1070: "Receive_NOTIFICATION_message",
! 1071: "Clearing_Completed",
! 1072: };
! 1073:
! 1074: /* Execute event process. */
! 1075: int
! 1076: bgp_event (struct thread *thread)
! 1077: {
! 1078: int ret = 0;
! 1079: int event;
! 1080: int next;
! 1081: struct peer *peer;
! 1082:
! 1083: peer = THREAD_ARG (thread);
! 1084: event = THREAD_VAL (thread);
! 1085:
! 1086: /* Logging this event. */
! 1087: next = FSM [peer->status -1][event - 1].next_state;
! 1088:
! 1089: if (BGP_DEBUG (fsm, FSM) && peer->status != next)
! 1090: plog_debug (peer->log, "%s [FSM] %s (%s->%s)", peer->host,
! 1091: bgp_event_str[event],
! 1092: LOOKUP (bgp_status_msg, peer->status),
! 1093: LOOKUP (bgp_status_msg, next));
! 1094:
! 1095: /* Call function. */
! 1096: if (FSM [peer->status -1][event - 1].func)
! 1097: ret = (*(FSM [peer->status - 1][event - 1].func))(peer);
! 1098:
! 1099: /* When function do not want proceed next job return -1. */
! 1100: if (ret >= 0)
! 1101: {
! 1102: /* If status is changed. */
! 1103: if (next != peer->status)
! 1104: bgp_fsm_change_status (peer, next);
! 1105:
! 1106: /* Make sure timer is set. */
! 1107: bgp_timer_set (peer);
! 1108: }
! 1109:
! 1110: return ret;
! 1111: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_fsm.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / bgpd