bgpd/bgp_fsm.h

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* BGP-4 Finite State Machine
   3  * From RFC1771 [A Border Gateway Protocol 4 (BGP-4)]
   4  * Copyright (C) 1998 Kunihiro Ishiguro
   5  */
   6
   7 #ifndef _QUAGGA_BGP_FSM_H
   8 #define _QUAGGA_BGP_FSM_H
   9
  10 /* Macro for BGP read, write and timer thread.  */
  11 #define BGP_TIMER_ON(T, F, V)                                                  \
  12         do {                                                                   \
  13                 if ((peer->status != Deleted))                                 \
  14                         thread_add_timer(bm->master, (F), peer, (V), &(T));    \
  15         } while (0)
  16
  17 #define BGP_EVENT_ADD(P, E)                                                    \
  18         do {                                                                   \
  19                 if ((P)->status != Deleted)                                    \
  20                         thread_add_event(bm->master, bgp_event, (P), (E),      \
  21                                          NULL);                                \
  22         } while (0)
  23
  24 #define BGP_EVENT_FLUSH(P)                                                     \
  25         do {                                                                   \
  26                 assert(peer);                                                  \
  27                 thread_cancel_event_ready(bm->master, (P));                    \
  28         } while (0)
  29
  30 #define BGP_UPDATE_GROUP_TIMER_ON(T, F)                                        \
  31         do {                                                                   \
  32                 if (BGP_SUPPRESS_FIB_ENABLED(peer->bgp) &&                     \
  33                     PEER_ROUTE_ADV_DELAY(peer))                                \
  34                         thread_add_timer_msec(bm->master, (F), peer,           \
  35                                 (BGP_DEFAULT_UPDATE_ADVERTISEMENT_TIME * 1000),\
  36                                 (T));                                          \
  37                 else                                                           \
  38                         thread_add_timer_msec(bm->master, (F), peer,           \
  39                                               0, (T));                         \
  40         } while (0)                                                            \
  41
  42 #define BGP_MSEC_JITTER 10
  43
  44 /* Status codes for bgp_event_update() */
  45 #define FSM_PEER_NOOP           0
  46 #define FSM_PEER_STOPPED        1
  47 #define FSM_PEER_TRANSFERRED    2
  48 #define FSM_PEER_TRANSITIONED   3
  49
  50 #define BGP_PEER_GR_HELPER_ENABLE(peer) \
  51         do {            \
  52                 UNSET_FLAG( \
  53                         peer->peer_gr_new_status_flag,          \
  54                         PEER_GRACEFUL_RESTART_NEW_STATE_RESTART);       \
  55                 SET_FLAG( \
  56                         peer->peer_gr_new_status_flag,  \
  57                         PEER_GRACEFUL_RESTART_NEW_STATE_HELPER);\
  58         } while (0)
  59
  60 #define BGP_PEER_GR_ENABLE(peer)\
  61         do {                            \
  62                 SET_FLAG(   \
  63                         peer->peer_gr_new_status_flag,  \
  64                         PEER_GRACEFUL_RESTART_NEW_STATE_RESTART); \
  65                 UNSET_FLAG( \
  66                         peer->peer_gr_new_status_flag,  \
  67                         PEER_GRACEFUL_RESTART_NEW_STATE_HELPER);\
  68         } while (0)
  69
  70 #define BGP_PEER_GR_DISABLE(peer)\
  71         do {                            \
  72                 UNSET_FLAG( \
  73                         peer->peer_gr_new_status_flag,  \
  74                         PEER_GRACEFUL_RESTART_NEW_STATE_RESTART);\
  75                 UNSET_FLAG(\
  76                         peer->peer_gr_new_status_flag, \
  77                         PEER_GRACEFUL_RESTART_NEW_STATE_HELPER);\
  78         } while (0)
  79
  80 #define BGP_PEER_GR_GLOBAL_INHERIT_SET(peer) \
  81                         SET_FLAG(peer->peer_gr_new_status_flag, \
  82                                 PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT)
  83
  84 #define BGP_PEER_GR_GLOBAL_INHERIT_UNSET(peer)  \
  85                         UNSET_FLAG(peer->peer_gr_new_status_flag, \
  86                                 PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT)
  87
  88 #define BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer)                                \
  89         (CHECK_FLAG(peer->cap, PEER_CAP_RESTART_ADV)                           \
  90          && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV))
  91
  92 #define BGP_PEER_RESTARTING_MODE(peer)                                         \
  93         (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART) &&                \
  94          CHECK_FLAG(peer->cap, PEER_CAP_GRACEFUL_RESTART_R_BIT_ADV) &&         \
  95          !CHECK_FLAG(peer->cap, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV))
  96
  97 #define BGP_PEER_HELPER_MODE(peer)                                             \
  98         (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART_HELPER) &&         \
  99          CHECK_FLAG(peer->cap, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV) &&         \
 100          !CHECK_FLAG(peer->cap, PEER_CAP_GRACEFUL_RESTART_R_BIT_ADV))
 101
 102 /* Prototypes. */
 103
 104 /*
 105  * Update FSM for peer based on whether we have valid nexthops or not.
 106  */
 107 extern void bgp_fsm_nht_update(struct peer *peer, bool has_valid_nexthops);
 108 extern void bgp_event(struct thread *);
 109 extern int bgp_event_update(struct peer *, enum bgp_fsm_events event);
 110 extern int bgp_stop(struct peer *peer);
 111 extern void bgp_timer_set(struct peer *);
 112 extern void bgp_routeadv_timer(struct thread *);
 113 extern void bgp_fsm_change_status(struct peer *peer,
 114                                   enum bgp_fsm_status status);
 115 extern const char *const peer_down_str[];
 116 extern void bgp_update_delay_end(struct bgp *);
 117 extern void bgp_maxmed_update(struct bgp *);
 118 extern bool bgp_maxmed_onstartup_configured(struct bgp *);
 119 extern bool bgp_maxmed_onstartup_active(struct bgp *);
 120 extern int bgp_fsm_error_subcode(int status);
 121
 122 /**
 123  * Start the route advertisement timer (that honors MRAI) for all the
 124  * peers. Typically called at the end of initial convergence, coming
 125  * out of read-only mode.
 126  */
 127 extern void bgp_start_routeadv(struct bgp *);
 128
 129 /**
 130  * See if the route advertisement timer needs to be adjusted for a
 131  * peer. For example, if the last update was written to the peer a
 132  * long while back, we don't need to wait for the periodic advertisement
 133  * timer to expire to send the new set of prefixes. It should fire
 134  * instantly and updates should go out sooner.
 135  */
 136 extern void bgp_adjust_routeadv(struct peer *);
 137
 138 #include "hook.h"
 139 DECLARE_HOOK(peer_backward_transition, (struct peer *peer), (peer));
 140 DECLARE_HOOK(peer_established, (struct peer *peer), (peer));
 141
 142 int bgp_gr_update_all(struct bgp *bgp, int global_gr_cmd);
 143 int bgp_neighbor_graceful_restart(struct peer *peer, int peer_gr_cmd);
 144 unsigned int bgp_peer_gr_action(struct peer *peer,
 145                 int old_peer_state, int new_peer_state);
 146 void bgp_peer_move_to_gr_mode(struct peer *peer, int new_state);
 147 unsigned int bgp_peer_gr_helper_enable(struct peer *peer);
 148 unsigned int bgp_peer_gr_enable(struct peer *peer);
 149 unsigned int bgp_peer_gr_global_inherit(struct peer *peer);
 150 unsigned int bgp_peer_gr_disable(struct peer *peer);
 151 enum peer_mode bgp_peer_gr_mode_get(struct peer *peer);
 152 enum global_mode bgp_global_gr_mode_get(struct bgp *bgp);
 153 enum peer_mode bgp_get_peer_gr_mode_from_flags(struct peer *peer);
 154 unsigned int bgp_peer_gr_global_inherit_unset(struct peer *peer);
 155 int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
 156                 enum global_mode global_new_state,
 157                 enum global_mode global_old_state);
 158 void bgp_peer_gr_flags_update(struct peer *peer);
 159 const char *print_peer_gr_mode(enum peer_mode pr_mode);
 160 const char *print_peer_gr_cmd(enum peer_gr_command pr_gr_cmd);
 161 const char *print_global_gr_mode(enum global_mode gl_mode);
 162 const char *print_global_gr_cmd(enum global_gr_command gl_gr_cmd);
 163 int bgp_peer_reg_with_nht(struct peer *peer);
 164 #endif /* _QUAGGA_BGP_FSM_H */