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
  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 \f
  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 = time (NULL);
 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 /* Reset bgp update timer */
 319 static void
 320 bgp_uptime_reset (struct peer *peer)
 321 {
 322   peer->uptime = time (NULL);
 323 }
 324
 325 /* BGP Peer Down Cause */
 326 const char *peer_down_str[] =
 327 {
 328   "",
 329   "Router ID changed",
 330   "Remote AS changed",
 331   "Local AS change",
 332   "Cluster ID changed",
 333   "Confederation identifier changed",
 334   "Confederation peer changed",
 335   "RR client config change",
 336   "RS client config change",
 337   "Update source change",
 338   "Address family activated",
 339   "Admin. shutdown",
 340   "User reset",
 341   "BGP Notification received",
 342   "BGP Notification send",
 343   "Peer closed the session",
 344   "Neighbor deleted",
 345   "Peer-group add member",
 346   "Peer-group delete member",
 347   "Capability changed",
 348   "Passive config change",
 349   "Multihop config change",
 350   "NSF peer closed the session"
 351 };
 352
 353 static int
 354 bgp_graceful_restart_timer_expire (struct thread *thread)
 355 {
 356   struct peer *peer;
 357   afi_t afi;
 358   safi_t safi;
 359
 360   peer = THREAD_ARG (thread);
 361   peer->t_gr_restart = NULL;
 362
 363   /* NSF delete stale route */
 364   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
 365     for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
 366       if (peer->nsf[afi][safi])
 367         bgp_clear_stale_route (peer, afi, safi);
 368
 369   UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT);
 370   BGP_TIMER_OFF (peer->t_gr_stale);
 371
 372   if (BGP_DEBUG (events, EVENTS))
 373     {
 374       zlog_debug ("%s graceful restart timer expired", peer->host);
 375       zlog_debug ("%s graceful restart stalepath timer stopped", peer->host);
 376     }
 377
 378   bgp_timer_set (peer);
 379
 380   return 0;
 381 }
 382
 383 static int
 384 bgp_graceful_stale_timer_expire (struct thread *thread)
 385 {
 386   struct peer *peer;
 387   afi_t afi;
 388   safi_t safi;
 389
 390   peer = THREAD_ARG (thread);
 391   peer->t_gr_stale = NULL;
 392
 393   if (BGP_DEBUG (events, EVENTS))
 394     zlog_debug ("%s graceful restart stalepath timer expired", peer->host);
 395
 396   /* NSF delete stale route */
 397   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
 398     for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
 399       if (peer->nsf[afi][safi])
 400         bgp_clear_stale_route (peer, afi, safi);
 401
 402   return 0;
 403 }
 404
 405 /* Called after event occured, this function change status and reset
 406    read/write and timer thread. */
 407 void
 408 bgp_fsm_change_status (struct peer *peer, int status)
 409 {
 410   bgp_dump_state (peer, peer->status, status);
 411
 412   /* Transition into Clearing or Deleted must /always/ clear all routes..
 413    * (and must do so before actually changing into Deleted..
 414    */
 415   if (status >= Clearing)
 416     bgp_clear_route_all (peer);
 417
 418   /* Preserve old status and change into new status. */
 419   peer->ostatus = peer->status;
 420   peer->status = status;
 421
 422   if (BGP_DEBUG (normal, NORMAL))
 423     zlog_debug ("%s went from %s to %s",
 424                 peer->host,
 425                 LOOKUP (bgp_status_msg, peer->ostatus),
 426                 LOOKUP (bgp_status_msg, peer->status));
 427 }
 428
 429 /* Administrative BGP peer stop event. */
 430 int
 431 bgp_stop (struct peer *peer)
 432 {
 433   afi_t afi;
 434   safi_t safi;
 435   char orf_name[BUFSIZ];
 436
 437   /* Delete all existing events of the peer */
 438   BGP_EVENT_FLUSH (peer);
 439
 440   /* Increment Dropped count. */
 441   if (peer->status == Established)
 442     {
 443       peer->dropped++;
 444
 445       /* bgp log-neighbor-changes of neighbor Down */
 446       if (bgp_flag_check (peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES))
 447         zlog_info ("%%ADJCHANGE: neighbor %s Down %s", peer->host,
 448                    peer_down_str [(int) peer->last_reset]);
 449
 450       /* graceful restart */
 451       if (peer->t_gr_stale)
 452         {
 453           BGP_TIMER_OFF (peer->t_gr_stale);
 454           if (BGP_DEBUG (events, EVENTS))
 455             zlog_debug ("%s graceful restart stalepath timer stopped", peer->host);
 456         }
 457       if (CHECK_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT))
 458         {
 459           if (BGP_DEBUG (events, EVENTS))
 460             {
 461               zlog_debug ("%s graceful restart timer started for %d sec",
 462                           peer->host, peer->v_gr_restart);
 463               zlog_debug ("%s graceful restart stalepath timer started for %d sec",
 464                           peer->host, peer->bgp->stalepath_time);
 465             }
 466           BGP_TIMER_ON (peer->t_gr_restart, bgp_graceful_restart_timer_expire,
 467                         peer->v_gr_restart);
 468           BGP_TIMER_ON (peer->t_gr_stale, bgp_graceful_stale_timer_expire,
 469                         peer->bgp->stalepath_time);
 470         }
 471       else
 472         {
 473           UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_MODE);
 474
 475           for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
 476             for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
 477               peer->nsf[afi][safi] = 0;
 478         }
 479
 480       /* set last reset time */
 481       peer->resettime = time (NULL);
 482       /* Reset uptime. */
 483       bgp_uptime_reset (peer);
 484
 485 #ifdef HAVE_SNMP
 486       bgpTrapBackwardTransition (peer);
 487 #endif /* HAVE_SNMP */
 488
 489       /* Reset uptime. */
 490       bgp_uptime_reset (peer);
 491
 492       /* Reset peer synctime */
 493       peer->synctime = 0;
 494     }
 495
 496   /* Stop read and write threads when exists. */
 497   BGP_READ_OFF (peer->t_read);
 498   BGP_WRITE_OFF (peer->t_write);
 499
 500   /* Stop all timers. */
 501   BGP_TIMER_OFF (peer->t_start);
 502   BGP_TIMER_OFF (peer->t_connect);
 503   BGP_TIMER_OFF (peer->t_holdtime);
 504   BGP_TIMER_OFF (peer->t_keepalive);
 505   BGP_TIMER_OFF (peer->t_asorig);
 506   BGP_TIMER_OFF (peer->t_routeadv);
 507
 508   /* Stream reset. */
 509   peer->packet_size = 0;
 510
 511   /* Clear input and output buffer.  */
 512   if (peer->ibuf)
 513     stream_reset (peer->ibuf);
 514   if (peer->work)
 515     stream_reset (peer->work);
 516   if (peer->obuf)
 517     stream_fifo_clean (peer->obuf);
 518
 519   /* Close of file descriptor. */
 520   if (peer->fd >= 0)
 521     {
 522       close (peer->fd);
 523       peer->fd = -1;
 524     }
 525
 526   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
 527     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
 528       {
 529         /* Reset all negotiated variables */
 530         peer->afc_nego[afi][safi] = 0;
 531         peer->afc_adv[afi][safi] = 0;
 532         peer->afc_recv[afi][safi] = 0;
 533
 534         /* peer address family capability flags*/
 535         peer->af_cap[afi][safi] = 0;
 536
 537         /* peer address family status flags*/
 538         peer->af_sflags[afi][safi] = 0;
 539
 540         /* Received ORF prefix-filter */
 541         peer->orf_plist[afi][safi] = NULL;
 542
 543         /* ORF received prefix-filter pnt */
 544         sprintf (orf_name, "%s.%d.%d", peer->host, afi, safi);
 545         prefix_bgp_orf_remove_all (orf_name);
 546       }
 547
 548   /* Reset keepalive and holdtime */
 549   if (CHECK_FLAG (peer->config, PEER_CONFIG_TIMER))
 550     {
 551       peer->v_keepalive = peer->keepalive;
 552       peer->v_holdtime = peer->holdtime;
 553     }
 554   else
 555     {
 556       peer->v_keepalive = peer->bgp->default_keepalive;
 557       peer->v_holdtime = peer->bgp->default_holdtime;
 558     }
 559
 560   peer->update_time = 0;
 561
 562   /* Until we are sure that there is no problem about prefix count
 563      this should be commented out.*/
 564 #if 0
 565   /* Reset prefix count */
 566   peer->pcount[AFI_IP][SAFI_UNICAST] = 0;
 567   peer->pcount[AFI_IP][SAFI_MULTICAST] = 0;
 568   peer->pcount[AFI_IP][SAFI_MPLS_VPN] = 0;
 569   peer->pcount[AFI_IP6][SAFI_UNICAST] = 0;
 570   peer->pcount[AFI_IP6][SAFI_MULTICAST] = 0;
 571 #endif /* 0 */
 572
 573   return 0;
 574 }
 575
 576 /* BGP peer is stoped by the error. */
 577 static int
 578 bgp_stop_with_error (struct peer *peer)
 579 {
 580   /* Double start timer. */
 581   peer->v_start *= 2;
 582
 583   /* Overflow check. */
 584   if (peer->v_start >= (60 * 2))
 585     peer->v_start = (60 * 2);
 586
 587   bgp_stop (peer);
 588
 589   return 0;
 590 }
 591
 592 /* TCP connection open.  Next we send open message to remote peer. And
 593    add read thread for reading open message. */
 594 static int
 595 bgp_connect_success (struct peer *peer)
 596 {
 597   char buf1[BUFSIZ];
 598
 599   if (peer->fd < 0)
 600     {
 601       zlog_err ("bgp_connect_success peer's fd is negative value %d",
 602                 peer->fd);
 603       return -1;
 604     }
 605   BGP_READ_ON (peer->t_read, bgp_read, peer->fd);
 606
 607   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
 608     bgp_getsockname (peer);
 609
 610   if (BGP_DEBUG (normal, NORMAL))
 611     {
 612       if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
 613         zlog_debug ("%s open active, local address %s", peer->host,
 614                     sockunion2str (peer->su_local, buf1, SU_ADDRSTRLEN));
 615       else
 616         zlog_debug ("%s passive open", peer->host);
 617     }
 618
 619   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
 620     bgp_open_send (peer);
 621
 622   return 0;
 623 }
 624
 625 /* TCP connect fail */
 626 static int
 627 bgp_connect_fail (struct peer *peer)
 628 {
 629   bgp_stop (peer);
 630   return 0;
 631 }
 632
 633 /* This function is the first starting point of all BGP connection. It
 634    try to connect to remote peer with non-blocking IO. */
 635 int
 636 bgp_start (struct peer *peer)
 637 {
 638   int status;
 639
 640   if (BGP_PEER_START_SUPPRESSED (peer))
 641     {
 642       if (BGP_DEBUG (fsm, FSM))
 643         plog_err (peer->log, "%s [FSM] Trying to start suppressed peer"
 644                   " - this is never supposed to happen!", peer->host);
 645       return -1;
 646     }
 647
 648   /* Scrub some information that might be left over from a previous,
 649    * session
 650    */
 651   /* Connection information. */
 652   if (peer->su_local)
 653     {
 654       sockunion_free (peer->su_local);
 655       peer->su_local = NULL;
 656     }
 657
 658   if (peer->su_remote)
 659     {
 660       sockunion_free (peer->su_remote);
 661       peer->su_remote = NULL;
 662     }
 663
 664   /* Clear remote router-id. */
 665   peer->remote_id.s_addr = 0;
 666
 667   /* Clear peer capability flag. */
 668   peer->cap = 0;
 669
 670   /* If the peer is passive mode, force to move to Active mode. */
 671   if (CHECK_FLAG (peer->flags, PEER_FLAG_PASSIVE))
 672     {
 673       BGP_EVENT_ADD (peer, TCP_connection_open_failed);
 674       return 0;
 675     }
 676
 677   status = bgp_connect (peer);
 678
 679   switch (status)
 680     {
 681     case connect_error:
 682       if (BGP_DEBUG (fsm, FSM))
 683         plog_debug (peer->log, "%s [FSM] Connect error", peer->host);
 684       BGP_EVENT_ADD (peer, TCP_connection_open_failed);
 685       break;
 686     case connect_success:
 687       if (BGP_DEBUG (fsm, FSM))
 688         plog_debug (peer->log, "%s [FSM] Connect immediately success",
 689                    peer->host);
 690       BGP_EVENT_ADD (peer, TCP_connection_open);
 691       break;
 692     case connect_in_progress:
 693       /* To check nonblocking connect, we wait until socket is
 694          readable or writable. */
 695       if (BGP_DEBUG (fsm, FSM))
 696         plog_debug (peer->log, "%s [FSM] Non blocking connect waiting result",
 697                    peer->host);
 698       if (peer->fd < 0)
 699         {
 700           zlog_err ("bgp_start peer's fd is negative value %d",
 701                     peer->fd);
 702           return -1;
 703         }
 704       BGP_READ_ON (peer->t_read, bgp_read, peer->fd);
 705       BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
 706       break;
 707     }
 708   return 0;
 709 }
 710
 711 /* Connect retry timer is expired when the peer status is Connect. */
 712 static int
 713 bgp_reconnect (struct peer *peer)
 714 {
 715   bgp_stop (peer);
 716   bgp_start (peer);
 717   return 0;
 718 }
 719
 720 static int
 721 bgp_fsm_open (struct peer *peer)
 722 {
 723   /* Send keepalive and make keepalive timer */
 724   bgp_keepalive_send (peer);
 725
 726   /* Reset holdtimer value. */
 727   BGP_TIMER_OFF (peer->t_holdtime);
 728
 729   return 0;
 730 }
 731
 732 /* Keepalive send to peer. */
 733 static int
 734 bgp_fsm_keepalive_expire (struct peer *peer)
 735 {
 736   bgp_keepalive_send (peer);
 737   return 0;
 738 }
 739
 740 /* Hold timer expire.  This is error of BGP connection. So cut the
 741    peer and change to Idle status. */
 742 static int
 743 bgp_fsm_holdtime_expire (struct peer *peer)
 744 {
 745   if (BGP_DEBUG (fsm, FSM))
 746     zlog (peer->log, LOG_DEBUG, "%s [FSM] Hold timer expire", peer->host);
 747
 748   /* Send notify to remote peer. */
 749   bgp_notify_send (peer, BGP_NOTIFY_HOLD_ERR, 0);
 750
 751   /* Sweep if it is temporary peer. */
 752   if (CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
 753     {
 754       zlog_info ("%s [Event] Accepting BGP peer is deleted", peer->host);
 755       peer_delete (peer);
 756       return -1;
 757     }
 758
 759   return 0;
 760 }
 761
 762 /* Status goes to Established.  Send keepalive packet then make first
 763    update information. */
 764 static int
 765 bgp_establish (struct peer *peer)
 766 {
 767   struct bgp_notify *notify;
 768   afi_t afi;
 769   safi_t safi;
 770   int nsf_af_count = 0;
 771
 772   /* Reset capability open status flag. */
 773   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN))
 774     SET_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN);
 775
 776   /* Clear last notification data. */
 777   notify = &peer->notify;
 778   if (notify->data)
 779     XFREE (MTYPE_TMP, notify->data);
 780   memset (notify, 0, sizeof (struct bgp_notify));
 781
 782   /* Clear start timer value to default. */
 783   peer->v_start = BGP_INIT_START_TIMER;
 784
 785   /* Increment established count. */
 786   peer->established++;
 787   bgp_fsm_change_status (peer, Established);
 788
 789   /* bgp log-neighbor-changes of neighbor Up */
 790   if (bgp_flag_check (peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES))
 791     zlog_info ("%%ADJCHANGE: neighbor %s Up", peer->host);
 792
 793   /* graceful restart */
 794   UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT);
 795   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
 796     for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
 797       {
 798         if (peer->afc_nego[afi][safi]
 799             && CHECK_FLAG (peer->cap, PEER_CAP_RESTART_ADV)
 800             && CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_RESTART_AF_RCV))
 801           {
 802             if (peer->nsf[afi][safi]
 803                 && ! CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_RESTART_AF_PRESERVE_RCV))
 804               bgp_clear_stale_route (peer, afi, safi);
 805
 806             peer->nsf[afi][safi] = 1;
 807             nsf_af_count++;
 808           }
 809         else
 810           {
 811             if (peer->nsf[afi][safi])
 812               bgp_clear_stale_route (peer, afi, safi);
 813             peer->nsf[afi][safi] = 0;
 814           }
 815       }
 816
 817   if (nsf_af_count)
 818     SET_FLAG (peer->sflags, PEER_STATUS_NSF_MODE);
 819   else
 820     {
 821       UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_MODE);
 822       if (peer->t_gr_stale)
 823         {
 824           BGP_TIMER_OFF (peer->t_gr_stale);
 825           if (BGP_DEBUG (events, EVENTS))
 826             zlog_debug ("%s graceful restart stalepath timer stopped", peer->host);
 827         }
 828     }
 829
 830   if (peer->t_gr_restart)
 831     {
 832       BGP_TIMER_OFF (peer->t_gr_restart);
 833       if (BGP_DEBUG (events, EVENTS))
 834         zlog_debug ("%s graceful restart timer stopped", peer->host);
 835     }
 836
 837 #ifdef HAVE_SNMP
 838   bgpTrapEstablished (peer);
 839 #endif /* HAVE_SNMP */
 840
 841   /* Reset uptime, send keepalive, send current table. */
 842   bgp_uptime_reset (peer);
 843
 844   /* Send route-refresh when ORF is enabled */
 845   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
 846     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
 847       if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV))
 848         {
 849           if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV))
 850             bgp_route_refresh_send (peer, afi, safi, ORF_TYPE_PREFIX,
 851                                     REFRESH_IMMEDIATE, 0);
 852           else if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
 853             bgp_route_refresh_send (peer, afi, safi, ORF_TYPE_PREFIX_OLD,
 854                                     REFRESH_IMMEDIATE, 0);
 855         }
 856
 857   if (peer->v_keepalive)
 858     bgp_keepalive_send (peer);
 859
 860   /* First update is deferred until ORF or ROUTE-REFRESH is received */
 861   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
 862     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
 863       if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV))
 864         if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_RCV)
 865             || CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_OLD_RCV))
 866           SET_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_WAIT_REFRESH);
 867
 868   bgp_announce_route_all (peer);
 869
 870   BGP_TIMER_ON (peer->t_routeadv, bgp_routeadv_timer, 1);
 871
 872   return 0;
 873 }
 874
 875 /* Keepalive packet is received. */
 876 static int
 877 bgp_fsm_keepalive (struct peer *peer)
 878 {
 879   /* peer count update */
 880   peer->keepalive_in++;
 881
 882   BGP_TIMER_OFF (peer->t_holdtime);
 883   return 0;
 884 }
 885
 886 /* Update packet is received. */
 887 static int
 888 bgp_fsm_update (struct peer *peer)
 889 {
 890   BGP_TIMER_OFF (peer->t_holdtime);
 891   return 0;
 892 }
 893
 894 /* This is empty event. */
 895 static int
 896 bgp_ignore (struct peer *peer)
 897 {
 898   if (BGP_DEBUG (fsm, FSM))
 899     zlog (peer->log, LOG_DEBUG, "%s [FSM] bgp_ignore called", peer->host);
 900   return 0;
 901 }
 902 \f
 903 /* Finite State Machine structure */
 904 struct {
 905   int (*func) ();
 906   int next_state;
 907 } FSM [BGP_STATUS_MAX - 1][BGP_EVENTS_MAX - 1] =
 908 {
 909   {
 910     /* Idle state: In Idle state, all events other than BGP_Start is
 911        ignored.  With BGP_Start event, finite state machine calls
 912        bgp_start(). */
 913     {bgp_start,  Connect},      /* BGP_Start                    */
 914     {bgp_stop,   Idle},         /* BGP_Stop                     */
 915     {bgp_stop,   Idle},         /* TCP_connection_open          */
 916     {bgp_stop,   Idle},         /* TCP_connection_closed        */
 917     {bgp_ignore, Idle},         /* TCP_connection_open_failed   */
 918     {bgp_stop,   Idle},         /* TCP_fatal_error              */
 919     {bgp_ignore, Idle},         /* ConnectRetry_timer_expired   */
 920     {bgp_ignore, Idle},         /* Hold_Timer_expired           */
 921     {bgp_ignore, Idle},         /* KeepAlive_timer_expired      */
 922     {bgp_ignore, Idle},         /* Receive_OPEN_message         */
 923     {bgp_ignore, Idle},         /* Receive_KEEPALIVE_message    */
 924     {bgp_ignore, Idle},         /* Receive_UPDATE_message       */
 925     {bgp_ignore, Idle},         /* Receive_NOTIFICATION_message */
 926     {bgp_ignore, Idle},         /* Clearing_Completed           */
 927   },
 928   {
 929     /* Connect */
 930     {bgp_ignore,  Connect},     /* BGP_Start                    */
 931     {bgp_stop,    Idle},        /* BGP_Stop                     */
 932     {bgp_connect_success, OpenSent}, /* TCP_connection_open          */
 933     {bgp_stop, Idle},           /* TCP_connection_closed        */
 934     {bgp_connect_fail, Active}, /* TCP_connection_open_failed   */
 935     {bgp_connect_fail, Idle},   /* TCP_fatal_error              */
 936     {bgp_reconnect, Connect},   /* ConnectRetry_timer_expired   */
 937     {bgp_ignore,  Idle},        /* Hold_Timer_expired           */
 938     {bgp_ignore,  Idle},        /* KeepAlive_timer_expired      */
 939     {bgp_ignore,  Idle},        /* Receive_OPEN_message         */
 940     {bgp_ignore,  Idle},        /* Receive_KEEPALIVE_message    */
 941     {bgp_ignore,  Idle},        /* Receive_UPDATE_message       */
 942     {bgp_stop,    Idle},        /* Receive_NOTIFICATION_message */
 943     {bgp_ignore,  Idle},         /* Clearing_Completed           */
 944   },
 945   {
 946     /* Active, */
 947     {bgp_ignore,  Active},      /* BGP_Start                    */
 948     {bgp_stop,    Idle},        /* BGP_Stop                     */
 949     {bgp_connect_success, OpenSent}, /* TCP_connection_open          */
 950     {bgp_stop,    Idle},        /* TCP_connection_closed        */
 951     {bgp_ignore,  Active},      /* TCP_connection_open_failed   */
 952     {bgp_ignore,  Idle},        /* TCP_fatal_error              */
 953     {bgp_start,   Connect},     /* ConnectRetry_timer_expired   */
 954     {bgp_ignore,  Idle},        /* Hold_Timer_expired           */
 955     {bgp_ignore,  Idle},        /* KeepAlive_timer_expired      */
 956     {bgp_ignore,  Idle},        /* Receive_OPEN_message         */
 957     {bgp_ignore,  Idle},        /* Receive_KEEPALIVE_message    */
 958     {bgp_ignore,  Idle},        /* Receive_UPDATE_message       */
 959     {bgp_stop_with_error, Idle}, /* Receive_NOTIFICATION_message */
 960     {bgp_ignore, Idle},         /* Clearing_Completed           */
 961   },
 962   {
 963     /* OpenSent, */
 964     {bgp_ignore,  OpenSent},    /* BGP_Start                    */
 965     {bgp_stop,    Idle},        /* BGP_Stop                     */
 966     {bgp_stop,    Active},      /* TCP_connection_open          */
 967     {bgp_stop,    Active},      /* TCP_connection_closed        */
 968     {bgp_stop,    Active},      /* TCP_connection_open_failed   */
 969     {bgp_stop,    Active},      /* TCP_fatal_error              */
 970     {bgp_ignore,  Idle},        /* ConnectRetry_timer_expired   */
 971     {bgp_fsm_holdtime_expire, Idle},    /* Hold_Timer_expired           */
 972     {bgp_ignore,  Idle},        /* KeepAlive_timer_expired      */
 973     {bgp_fsm_open,    OpenConfirm},     /* Receive_OPEN_message         */
 974     {bgp_ignore,  Idle},        /* Receive_KEEPALIVE_message    */
 975     {bgp_ignore,  Idle},        /* Receive_UPDATE_message       */
 976     {bgp_stop_with_error, Idle}, /* Receive_NOTIFICATION_message */
 977     {bgp_ignore, Idle},         /* Clearing_Completed           */
 978   },
 979   {
 980     /* OpenConfirm, */
 981     {bgp_ignore,  OpenConfirm}, /* BGP_Start                    */
 982     {bgp_stop,    Idle},        /* BGP_Stop                     */
 983     {bgp_stop,    Idle},        /* TCP_connection_open          */
 984     {bgp_stop,    Idle},        /* TCP_connection_closed        */
 985     {bgp_stop,    Idle},        /* TCP_connection_open_failed   */
 986     {bgp_stop,    Idle},        /* TCP_fatal_error              */
 987     {bgp_ignore,  Idle},        /* ConnectRetry_timer_expired   */
 988     {bgp_fsm_holdtime_expire, Idle},    /* Hold_Timer_expired           */
 989     {bgp_ignore,  OpenConfirm}, /* KeepAlive_timer_expired      */
 990     {bgp_ignore,  Idle},        /* Receive_OPEN_message         */
 991     {bgp_establish, Established}, /* Receive_KEEPALIVE_message    */
 992     {bgp_ignore,  Idle},        /* Receive_UPDATE_message       */
 993     {bgp_stop_with_error, Idle}, /* Receive_NOTIFICATION_message */
 994     {bgp_ignore, Idle},         /* Clearing_Completed           */
 995   },
 996   {
 997     /* Established, */
 998     {bgp_ignore,               Established}, /* BGP_Start                    */
 999     {bgp_stop,                    Clearing}, /* BGP_Stop                     */
1000     {bgp_stop,                    Clearing}, /* TCP_connection_open          */
1001     {bgp_stop,                    Clearing}, /* TCP_connection_closed        */
1002     {bgp_ignore,                  Clearing}, /* TCP_connection_open_failed   */
1003     {bgp_stop,                    Clearing}, /* TCP_fatal_error              */
1004     {bgp_ignore,                  Clearing}, /* ConnectRetry_timer_expired   */
1005     {bgp_fsm_holdtime_expire,     Clearing}, /* Hold_Timer_expired           */
1006     {bgp_fsm_keepalive_expire, Established}, /* KeepAlive_timer_expired      */
1007     {bgp_stop,                    Clearing}, /* Receive_OPEN_message         */
1008     {bgp_fsm_keepalive,        Established}, /* Receive_KEEPALIVE_message    */
1009     {bgp_fsm_update,           Established}, /* Receive_UPDATE_message       */
1010     {bgp_stop_with_error,         Clearing}, /* Receive_NOTIFICATION_message */
1011     {bgp_ignore,                      Idle}, /* Clearing_Completed           */
1012   },
1013   {
1014     /* Clearing, */
1015     {bgp_ignore,  Clearing},    /* BGP_Start                    */
1016     {bgp_ignore,  Clearing},    /* BGP_Stop                     */
1017     {bgp_ignore,  Clearing},    /* TCP_connection_open          */
1018     {bgp_ignore,  Clearing},    /* TCP_connection_closed        */
1019     {bgp_ignore,  Clearing},    /* TCP_connection_open_failed   */
1020     {bgp_ignore,  Clearing},    /* TCP_fatal_error              */
1021     {bgp_ignore,  Clearing},    /* ConnectRetry_timer_expired   */
1022     {bgp_ignore,  Clearing},    /* Hold_Timer_expired           */
1023     {bgp_ignore,  Clearing},    /* KeepAlive_timer_expired      */
1024     {bgp_ignore,  Clearing},    /* Receive_OPEN_message         */
1025     {bgp_ignore,  Clearing},    /* Receive_KEEPALIVE_message    */
1026     {bgp_ignore,  Clearing},    /* Receive_UPDATE_message       */
1027     {bgp_ignore,  Clearing},    /* Receive_NOTIFICATION_message */
1028     {bgp_ignore,  Idle    },    /* Clearing_Completed           */
1029   },
1030   {
1031     /* Deleted, */
1032     {bgp_ignore,  Deleted},     /* BGP_Start                    */
1033     {bgp_ignore,  Deleted},     /* BGP_Stop                     */
1034     {bgp_ignore,  Deleted},     /* TCP_connection_open          */
1035     {bgp_ignore,  Deleted},     /* TCP_connection_closed        */
1036     {bgp_ignore,  Deleted},     /* TCP_connection_open_failed   */
1037     {bgp_ignore,  Deleted},     /* TCP_fatal_error              */
1038     {bgp_ignore,  Deleted},     /* ConnectRetry_timer_expired   */
1039     {bgp_ignore,  Deleted},     /* Hold_Timer_expired           */
1040     {bgp_ignore,  Deleted},     /* KeepAlive_timer_expired      */
1041     {bgp_ignore,  Deleted},     /* Receive_OPEN_message         */
1042     {bgp_ignore,  Deleted},     /* Receive_KEEPALIVE_message    */
1043     {bgp_ignore,  Deleted},     /* Receive_UPDATE_message       */
1044     {bgp_ignore,  Deleted},     /* Receive_NOTIFICATION_message */
1045     {bgp_ignore,  Deleted},     /* Clearing_Completed           */
1046   },
1047 };
1048
1049 static const char *bgp_event_str[] =
1050 {
1051   NULL,
1052   "BGP_Start",
1053   "BGP_Stop",
1054   "TCP_connection_open",
1055   "TCP_connection_closed",
1056   "TCP_connection_open_failed",
1057   "TCP_fatal_error",
1058   "ConnectRetry_timer_expired",
1059   "Hold_Timer_expired",
1060   "KeepAlive_timer_expired",
1061   "Receive_OPEN_message",
1062   "Receive_KEEPALIVE_message",
1063   "Receive_UPDATE_message",
1064   "Receive_NOTIFICATION_message",
1065   "Clearing_Completed",
1066 };
1067
1068 /* Execute event process. */
1069 int
1070 bgp_event (struct thread *thread)
1071 {
1072   int ret = 0;
1073   int event;
1074   int next;
1075   struct peer *peer;
1076
1077   peer = THREAD_ARG (thread);
1078   event = THREAD_VAL (thread);
1079
1080   /* Logging this event. */
1081   next = FSM [peer->status -1][event - 1].next_state;
1082
1083   if (BGP_DEBUG (fsm, FSM) && peer->status != next)
1084     plog_debug (peer->log, "%s [FSM] %s (%s->%s)", peer->host,
1085                bgp_event_str[event],
1086                LOOKUP (bgp_status_msg, peer->status),
1087                LOOKUP (bgp_status_msg, next));
1088
1089   /* Call function. */
1090   if (FSM [peer->status -1][event - 1].func)
1091     ret = (*(FSM [peer->status - 1][event - 1].func))(peer);
1092
1093   /* When function do not want proceed next job return -1. */
1094   if (ret >= 0)
1095     {
1096       /* If status is changed. */
1097       if (next != peer->status)
1098         bgp_fsm_change_status (peer, next);
1099
1100       /* Make sure timer is set. */
1101       bgp_timer_set (peer);
1102     }
1103
1104   return ret;
1105 }