if (BGP_DEBUG(zebra, ZEBRA))
bgp_debug_list_print(vty, " BGP zebra debugging is on",
- bgp_debug_zebra_prefixes);
+ bgp_debug_zebra_prefixes);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- vty_out(vty,
- " BGP graceful-restart debugging is on");
+ vty_out(vty, " BGP graceful-restart debugging is on");
if (BGP_DEBUG(allow_martians, ALLOW_MARTIANS))
vty_out(vty, " BGP allow martian next hop debugging is on\n");
DEFINE_HOOK(peer_backward_transition, (struct peer * peer), (peer))
DEFINE_HOOK(peer_status_changed, (struct peer * peer), (peer))
-extern const char *get_afi_safi_str(afi_t afi,
- safi_t safi, bool for_json);
+extern const char *get_afi_safi_str(afi_t afi, safi_t safi, bool for_json);
/* Definition of display strings corresponding to FSM events. This should be
* kept consistent with the events defined in bgpd.h
*/
peer->peer_gr_new_status_flag = from_peer->peer_gr_new_status_flag;
bgp_peer_gr_flags_update(peer);
- BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(
- peer->bgp,
- peer->bgp->peer);
+ BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer->bgp,
+ peer->bgp->peer);
if (bgp_peer_gr_mode_get(peer) == PEER_DISABLE) {
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
- if (CHECK_FLAG(peer->sflags,
- PEER_STATUS_NSF_WAIT)) {
+ if (CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)) {
peer_nsf_stop(peer);
}
}
return -1;
/* Send graceful restart capabilty */
- BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(
- peer->bgp, peer->bgp->peer);
+ BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer->bgp,
+ peer->bgp->peer);
bgp_start(peer);
return 0;
/* Start the selection deferral timer thread for the specified AFI, SAFI */
static int bgp_start_deferral_timer(struct bgp *bgp, afi_t afi, safi_t safi,
- struct graceful_restart_info *gr_info)
+ struct graceful_restart_info *gr_info)
{
struct afi_safi_info *thread_info;
}
if (BGP_DEBUG(update, UPDATE_OUT))
zlog_debug("Started the deferral timer for %s eor_required %d",
- get_afi_safi_str(afi, safi, false),
- gr_info->eor_required);
+ get_afi_safi_str(afi, safi, false),
+ gr_info->eor_required);
return 0;
}
}
/* Restarting router */
- if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer) &&
- BGP_PEER_RESTARTING_MODE(peer)) {
+ if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer)
+ && BGP_PEER_RESTARTING_MODE(peer)) {
/* Check if the forwarding state is preserved */
if (bgp_flag_check(bgp, BGP_FLAG_GR_PRESERVE_FWD)) {
gr_info = &(bgp->gr_info[afi][safi]);
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT);
if (bgp_debug_neighbor_events(peer)) {
if (BGP_PEER_RESTARTING_MODE(peer))
- zlog_debug("peer %s BGP_RESTARTING_MODE",
- peer->host);
+ zlog_debug("peer %s BGP_RESTARTING_MODE", peer->host);
else if (BGP_PEER_HELPER_MODE(peer))
- zlog_debug("peer %s BGP_HELPER_MODE",
- peer->host);
+ zlog_debug("peer %s BGP_HELPER_MODE", peer->host);
}
for (afi = AFI_IP; afi < AFI_MAX; afi++)
for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN; safi++) {
status = bgp_update_gr_info(peer, afi,
safi);
if (status < 0)
- zlog_err("Error in updating graceful restart for %s",
- get_afi_safi_str(afi,
- safi, false));
+ zlog_err(
+ "Error in updating graceful restart for %s",
+ get_afi_safi_str(
+ afi, safi,
+ false));
} else {
if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(
- peer) &&
- BGP_PEER_RESTARTING_MODE(peer)
- && bgp_flag_check(peer->bgp,
- BGP_FLAG_GR_PRESERVE_FWD))
+ peer)
+ && BGP_PEER_RESTARTING_MODE(peer)
+ && bgp_flag_check(
+ peer->bgp,
+ BGP_FLAG_GR_PRESERVE_FWD))
peer->bgp->gr_info[afi][safi]
.eor_required++;
}
/* BGP GR Code */
int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
- enum global_mode global_new_state,
- enum global_mode global_old_state)
+ enum global_mode global_new_state,
+ enum global_mode global_old_state)
{
struct peer *peer = {0};
struct listnode *node = {0};
struct listnode *nnode = {0};
- enum peer_mode peer_old_state = PEER_INVALID;
+ enum peer_mode peer_old_state = PEER_INVALID;
for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug(
- "%s [BGP_GR] Peer: (%s) :",
- __func__, peer->host);
+ zlog_debug("%s [BGP_GR] Peer: (%s) :", __func__,
+ peer->host);
peer_old_state = bgp_peer_gr_mode_get(peer);
if (peer_old_state == PEER_GLOBAL_INHERIT) {
- /*
- *Reset only these peers and send a
- *new open message with the change capabilities.
- *Considering the mode to be "global_new_state" and
- *do all operation accordingly
- */
+ /*
+ *Reset only these peers and send a
+ *new open message with the change capabilities.
+ *Considering the mode to be "global_new_state" and
+ *do all operation accordingly
+ */
switch (global_new_state) {
case GLOBAL_HELPER:
BGP_PEER_GR_DISABLE(peer);
break;
case GLOBAL_INVALID:
- zlog_debug(
- "%s [BGP_GR] GLOBAL_INVALID",
- __func__);
+ zlog_debug("%s [BGP_GR] GLOBAL_INVALID",
+ __func__);
return BGP_ERR_GR_OPERATION_FAILED;
}
}
enum global_mode global_old_state = GLOBAL_INVALID;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug(
- "%s [BGP_GR]START: global_gr_cmd :%s:",
- __func__, print_global_gr_cmd(global_gr_cmd));
+ zlog_debug("%s [BGP_GR]START: global_gr_cmd :%s:", __func__,
+ print_global_gr_cmd(global_gr_cmd));
global_old_state = bgp_global_gr_mode_get(bgp);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug(
- "[BGP_GR] global_old_gr_state :%s:",
- print_global_gr_mode(global_old_state));
+ zlog_debug("[BGP_GR] global_old_gr_state :%s:",
+ print_global_gr_mode(global_old_state));
if (global_old_state != GLOBAL_INVALID) {
global_new_state =
bgp->GLOBAL_GR_FSM[global_old_state][global_gr_cmd];
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug(
- "[BGP_GR] global_new_gr_state :%s:",
- print_global_gr_mode(global_new_state));
+ zlog_debug("[BGP_GR] global_new_gr_state :%s:",
+ print_global_gr_mode(global_new_state));
} else {
- zlog_err(
- "%s [BGP_GR] global_old_state == GLOBAL_INVALID",
- __func__);
+ zlog_err("%s [BGP_GR] global_old_state == GLOBAL_INVALID",
+ __func__);
return BGP_ERR_GR_OPERATION_FAILED;
}
if (global_new_state == GLOBAL_INVALID) {
- zlog_err(
- "%s [BGP_GR] global_new_state == GLOBAL_INVALID",
- __func__);
+ zlog_err("%s [BGP_GR] global_new_state == GLOBAL_INVALID",
+ __func__);
return BGP_ERR_GR_INVALID_CMD;
}
if (global_new_state == global_old_state) {
/* Trace msg */
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
- "%s [BGP_GR] global_new_state == global_old_state :%s",
- __func__, print_global_gr_mode(global_new_state));
+ "%s [BGP_GR] global_new_state == global_old_state :%s",
+ __func__,
+ print_global_gr_mode(global_new_state));
return BGP_GR_NO_OPERATION;
}
- return bgp_gr_lookup_n_update_all_peer(bgp,
- global_new_state,
- global_old_state);
+ return bgp_gr_lookup_n_update_all_peer(bgp, global_new_state,
+ global_old_state);
}
const char *print_peer_gr_mode(enum peer_mode pr_mode)
return peer->peer_gr_present_state;
}
-int bgp_neighbor_graceful_restart(struct peer *peer,
- int peer_gr_cmd)
+int bgp_neighbor_graceful_restart(struct peer *peer, int peer_gr_cmd)
{
- enum peer_mode peer_new_state = PEER_INVALID;
- enum peer_mode peer_old_state = PEER_INVALID;
+ enum peer_mode peer_new_state = PEER_INVALID;
+ enum peer_mode peer_old_state = PEER_INVALID;
struct bgp_peer_gr peer_state;
int result = BGP_GR_FAILURE;
*/
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug(
- "%s [BGP_GR] START:Peer: (%s) : peer_gr_cmd :%s:",
- __func__, peer->host, print_peer_gr_cmd(peer_gr_cmd));
+ zlog_debug("%s [BGP_GR] START:Peer: (%s) : peer_gr_cmd :%s:",
+ __func__, peer->host,
+ print_peer_gr_cmd(peer_gr_cmd));
peer_old_state = bgp_peer_gr_mode_get(peer);
if (peer_old_state == PEER_INVALID) {
- zlog_debug(
- "[BGP_GR] peer_old_state == Invalid state !");
+ zlog_debug("[BGP_GR] peer_old_state == Invalid state !");
return BGP_ERR_GR_OPERATION_FAILED;
}
}
if (peer_new_state != peer_old_state) {
- result = peer_state.action_fun(peer,
- peer_old_state,
- peer_new_state);
+ result = peer_state.action_fun(peer, peer_old_state,
+ peer_new_state);
} else {
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
- "[BGP_GR] peer_old_state == peer_new_state !");
+ "[BGP_GR] peer_old_state == peer_new_state !");
return BGP_GR_NO_OPERATION;
}
/* Update the mode i.e peer_new_state into the peer structure */
peer->peer_gr_present_state = peer_new_state;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug("[BGP_GR] Succesfully change the state of the peer to : %s : !",
- print_peer_gr_mode(peer_new_state));
+ zlog_debug(
+ "[BGP_GR] Succesfully change the state of the peer to : %s : !",
+ print_peer_gr_mode(peer_new_state));
return BGP_GR_SUCCESS;
}
return result;
}
-unsigned int bgp_peer_gr_action(struct peer *peer,
- int old_peer_state, int new_peer_state)
+unsigned int bgp_peer_gr_action(struct peer *peer, int old_peer_state,
+ int new_peer_state)
{
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
unsigned int ret = BGP_GR_FAILURE;
if (old_peer_state == new_peer_state) {
- /* Nothing to do over here as the present and old state is the same */
+ /* Nothing to do over here as the present and old state is the
+ * same */
return BGP_GR_NO_OPERATION;
}
- if ((old_peer_state == PEER_INVALID) ||
- (new_peer_state == PEER_INVALID)) {
- /* something bad happend , print error message */
+ if ((old_peer_state == PEER_INVALID)
+ || (new_peer_state == PEER_INVALID)) {
+ /* something bad happend , print error message */
return BGP_ERR_GR_INVALID_CMD;
}
bgp_gr_global_mode = bgp_global_gr_mode_get(peer->bgp);
- if ((old_peer_state == PEER_GLOBAL_INHERIT) &&
- (new_peer_state != PEER_GLOBAL_INHERIT)) {
+ if ((old_peer_state == PEER_GLOBAL_INHERIT)
+ && (new_peer_state != PEER_GLOBAL_INHERIT)) {
/* fetch the Mode running in the Global state machine
*from the bgp structure into a variable called
BGP_PEER_GR_GLOBAL_INHERIT_UNSET(peer);
if (new_peer_state == bgp_gr_global_mode) {
- /*This is incremental updates i.e no tear down
- *of the existing session
- *as the peer is already working in the same mode.
- */
+ /*This is incremental updates i.e no tear down
+ *of the existing session
+ *as the peer is already working in the same mode.
+ */
ret = BGP_GR_SUCCESS;
} else {
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
/* In the case below peer is going into Global inherit mode i.e.
* the peer would work as the mode configured at the global level
*/
- else if ((new_peer_state == PEER_GLOBAL_INHERIT) &&
- (old_peer_state != PEER_GLOBAL_INHERIT)) {
+ else if ((new_peer_state == PEER_GLOBAL_INHERIT)
+ && (old_peer_state != PEER_GLOBAL_INHERIT)) {
/* Here in this case it would be destructive
* in all the cases except one case when,
* Global GR is configured Disabled
*/
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug("[BGP_GR] Peer state changed from :%s",
+ zlog_debug(
+ "[BGP_GR] Peer state changed from :%s",
print_peer_gr_mode(old_peer_state));
bgp_peer_move_to_gr_mode(peer, bgp_gr_global_mode);
*/
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("[BGP_GR] Peer state changed from :%s",
- print_peer_gr_mode(old_peer_state));
+ print_peer_gr_mode(old_peer_state));
bgp_peer_move_to_gr_mode(peer, new_peer_state);
if (bgp_global_gr_mode == GLOBAL_HELPER) {
BGP_PEER_GR_HELPER_ENABLE(peer);
- } else if (bgp_global_gr_mode == GLOBAL_GR) {
+ } else if (bgp_global_gr_mode == GLOBAL_GR) {
BGP_PEER_GR_ENABLE(peer);
} else if (bgp_global_gr_mode == GLOBAL_DISABLE) {
BGP_PEER_GR_DISABLE(peer);
} else {
zlog_err(
- "[BGP_GR] Default switch inherit mode ::: SOMETHING IS WRONG !!!");
+ "[BGP_GR] Default switch inherit mode ::: SOMETHING IS WRONG !!!");
}
break;
default:
- zlog_err("[BGP_GR] Default switch mode ::: SOMETHING IS WRONG !!!");
+ zlog_err(
+ "[BGP_GR] Default switch mode ::: SOMETHING IS WRONG !!!");
break;
}
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("[BGP_GR] Peer state changed --to--> : %d : !",
- new_state);
+ new_state);
}
void bgp_peer_gr_flags_update(struct peer *peer)
{
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug(
- "%s [BGP_GR] called !",
- __func__);
+ zlog_debug("%s [BGP_GR] called !", __func__);
if (CHECK_FLAG(peer->peer_gr_new_status_flag,
- PEER_GRACEFUL_RESTART_NEW_STATE_HELPER))
- SET_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_HELPER);
+ PEER_GRACEFUL_RESTART_NEW_STATE_HELPER))
+ SET_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART_HELPER);
else
- UNSET_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_HELPER);
+ UNSET_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART_HELPER);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_HELPER : %s : !",
peer->host,
(CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_HELPER) ?
- "Set" : "UnSet"));
+ PEER_FLAG_GRACEFUL_RESTART_HELPER)
+ ? "Set"
+ : "UnSet"));
if (CHECK_FLAG(peer->peer_gr_new_status_flag,
- PEER_GRACEFUL_RESTART_NEW_STATE_RESTART))
- SET_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART);
+ PEER_GRACEFUL_RESTART_NEW_STATE_RESTART))
+ SET_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART);
else
- UNSET_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART);
+ UNSET_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !",
peer->host,
- (CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART) ?
- "Set" : "UnSet"));
+ (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART)
+ ? "Set"
+ : "UnSet"));
if (CHECK_FLAG(peer->peer_gr_new_status_flag,
- PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT))
+ PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT))
SET_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT);
+ PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT);
else
UNSET_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT);
+ PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
- "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT : %s : !",
+ "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT : %s : !",
peer->host,
(CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT) ?
- "Set" : "UnSet"));
+ PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT)
+ ? "Set"
+ : "UnSet"));
- if (!CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART) &&
- !CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_HELPER)){
- zlog_debug(
- "[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_MODE!",
- peer->host);
+ if (!CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART)
+ && !CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART_HELPER)) {
+ zlog_debug("[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_MODE!",
+ peer->host);
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
- if (CHECK_FLAG(peer->sflags,
- PEER_STATUS_NSF_WAIT)) {
+ if (CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)) {
peer_nsf_stop(peer);
zlog_debug(
UNSET_FLAG(peer->peer_gr_new_status_flag, \
PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT)
-#define BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer) \
- (CHECK_FLAG(peer->cap, PEER_CAP_RESTART_ADV) && \
- CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV))
+#define BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer) \
+ (CHECK_FLAG(peer->cap, PEER_CAP_RESTART_ADV) \
+ && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV))
-#define BGP_PEER_RESTARTING_MODE(peer)\
- (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART) && \
- CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_ADV) && \
- !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_RCV))
+#define BGP_PEER_RESTARTING_MODE(peer) \
+ (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART) \
+ && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_ADV) \
+ && !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_RCV))
-#define BGP_PEER_HELPER_MODE(peer)\
- (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART_HELPER) && \
- CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_RCV) && \
- !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_ADV))
+#define BGP_PEER_HELPER_MODE(peer) \
+ (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART_HELPER) \
+ && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_RCV) \
+ && !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_BIT_ADV))
/* Prototypes. */
extern void bgp_fsm_event_update(struct peer *peer, int valid);
DECLARE_HOOK(peer_established, (struct peer *peer), (peer))
int bgp_gr_update_all(struct bgp *bgp, int global_gr_cmd);
-int bgp_neighbor_graceful_restart(struct peer *peer,
- int peer_gr_cmd);
+int bgp_neighbor_graceful_restart(struct peer *peer, int peer_gr_cmd);
unsigned int bgp_peer_gr_action(struct peer *peer,
int old_peer_state, int new_peer_state);
void bgp_peer_move_to_gr_mode(struct peer *peer, int new_state);
safe_strerror(errno));
if (peer->status == Established) {
- if ((CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART) ||
- CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_HELPER)) &&
- CHECK_FLAG(peer->sflags,
- PEER_STATUS_NSF_MODE)) {
+ if ((CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART)
+ || CHECK_FLAG(peer->flags,
+ PEER_FLAG_GRACEFUL_RESTART_HELPER))
+ && CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_MODE)) {
peer->last_reset = PEER_DOWN_NSF_CLOSE_SESSION;
SET_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT);
} else
} else if (nbytes == 0) {
if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [Event] BGP connection closed fd %d",
- peer->host, peer->fd);
+ peer->host, peer->fd);
if (peer->status == Established) {
- if ((CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART) ||
- CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART_HELPER)) &&
- CHECK_FLAG(peer->sflags,
- PEER_STATUS_NSF_MODE)) {
+ if ((CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART)
+ || CHECK_FLAG(peer->flags,
+ PEER_FLAG_GRACEFUL_RESTART_HELPER))
+ && CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_MODE)) {
peer->last_reset = PEER_DOWN_NSF_CLOSE_SESSION;
SET_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT);
} else
peer_xfer_config(peer, peer1);
bgp_peer_gr_flags_update(peer);
- BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(
- peer->bgp,
- peer->bgp->peer);
+ BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer->bgp,
+ peer->bgp->peer);
if (bgp_peer_gr_mode_get(peer) == PEER_DISABLE) {
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
- if (CHECK_FLAG(peer->sflags,
- PEER_STATUS_NSF_WAIT)) {
+ if (CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)) {
peer_nsf_stop(peer);
}
}
SET_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER);
/* Make dummy peer until read Open packet. */
if (peer1->status == Established
- && CHECK_FLAG(peer1->sflags, PEER_STATUS_NSF_MODE)) {
+ && CHECK_FLAG(peer1->sflags, PEER_STATUS_NSF_MODE)) {
/* If we have an existing established connection with graceful
* restart
* capability announced with one or more address families, then
*/
peer1->last_reset = PEER_DOWN_NSF_CLOSE_SESSION;
- if (CHECK_FLAG(peer1->flags,
- PEER_FLAG_GRACEFUL_RESTART) ||
- CHECK_FLAG(peer1->flags,
- PEER_FLAG_GRACEFUL_RESTART_HELPER))
- SET_FLAG(peer1->sflags,
- PEER_STATUS_NSF_WAIT);
+ if (CHECK_FLAG(peer1->flags, PEER_FLAG_GRACEFUL_RESTART)
+ || CHECK_FLAG(peer1->flags,
+ PEER_FLAG_GRACEFUL_RESTART_HELPER))
+ SET_FLAG(peer1->sflags, PEER_STATUS_NSF_WAIT);
bgp_event_update(peer1, TCP_connection_closed);
}
UNSET_FLAG(restart_flag_time, 0xF000);
peer->v_gr_restart = restart_flag_time;
}
-
}
return 0;
}
}
static void bgp_peer_send_gr_capability(struct stream *s, struct peer *peer,
- unsigned long cp)
+ unsigned long cp)
{
int len;
iana_afi_t pkt_afi;
*/
if (!next_pkt || !next_pkt->buffer) {
if (CHECK_FLAG(peer->cap,
- PEER_CAP_RESTART_RCV)) {
+ PEER_CAP_RESTART_RCV)) {
if (!(PAF_SUBGRP(paf))->t_coalesce
- && peer->afc_nego[afi][safi]
- && peer->synctime
- && !CHECK_FLAG(
- peer->af_sflags[afi][safi],
- PEER_STATUS_EOR_SEND)) {
+ && peer->afc_nego[afi][safi]
+ && peer->synctime
+ && !CHECK_FLAG(
+ peer->af_sflags[afi][safi],
+ PEER_STATUS_EOR_SEND)) {
/* If EOR is disabled,
* the message is not sent
*/
- if (BGP_SEND_EOR(peer->bgp,
- afi, safi)) {
+ if (BGP_SEND_EOR(peer->bgp, afi,
+ safi)) {
SET_FLAG(
- peer->af_sflags
- [afi][safi],
- PEER_STATUS_EOR_SEND);
+ peer->af_sflags
+ [afi]
+ [safi],
+ PEER_STATUS_EOR_SEND);
/* Update EOR
* send time
*/
- peer->eor_stime
- [afi][safi] =
- monotime(NULL);
+ peer->eor_stime[afi]
+ [safi] =
+ monotime(NULL);
BGP_UPDATE_EOR_PKT(
- peer, afi,
- safi, s);
+ peer, afi, safi,
+ s);
}
}
}
stream_fifo_push(peer->obuf, s);
bgp_peer_gr_flags_update(peer);
- BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(
- peer->bgp,
- peer->bgp->peer);
+ BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer->bgp,
+ peer->bgp->peer);
bgp_write_notify(peer);
}
struct graceful_restart_info *gr_info;
/* Restarting router */
- if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer) &&
- BGP_PEER_RESTARTING_MODE(peer))
+ if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer)
+ && BGP_PEER_RESTARTING_MODE(peer))
restart = true;
/* Non-MP IPv4/Unicast is a completely emtpy UPDATE - already
* deferral timer is running, cancel the timer
* and invoke the best path calculation
*/
- if (gr_info->eor_required ==
- gr_info->eor_received) {
- if (bgp_debug_neighbor_events(
- peer))
- zlog_debug("%s %d, %s %d",
+ if (gr_info->eor_required
+ == gr_info->eor_received) {
+ if (bgp_debug_neighbor_events(peer))
+ zlog_debug(
+ "%s %d, %s %d",
"EOR REQ",
gr_info->eor_required,
"EOR RCV",
gr_info->eor_received = 0;
/* Best path selection */
if (bgp_best_path_select_defer(
- peer->bgp, afi, safi) < 0)
+ peer->bgp, afi, safi)
+ < 0)
return BGP_Stop;
}
}
strlcpy(bgp_notify.data, c,
bgp_notify.length * 3);
-
}
bgp_notify.raw_data = (uint8_t *)peer->notify.data;
}
UNSET_FLAG(peer->sflags, PEER_STATUS_CAPABILITY_OPEN);
bgp_peer_gr_flags_update(peer);
- BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(
- peer->bgp,
- peer->bgp->peer);
+ BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer->bgp,
+ peer->bgp->peer);
return Receive_NOTIFICATION_message;
}
#define ORF_COMMON_PART_PERMIT 0x00
#define ORF_COMMON_PART_DENY 0x20
-#define BGP_UPDATE_EOR_PKT(_peer, _afi, _safi, _s) \
- do { \
- _s = bgp_update_packet_eor(_peer, _afi, _safi); \
- if (_s) { \
- bgp_packet_add(_peer, _s); \
- } \
- } while (0)
+#define BGP_UPDATE_EOR_PKT(_peer, _afi, _safi, _s) \
+ do { \
+ _s = bgp_update_packet_eor(_peer, _afi, _safi); \
+ if (_s) { \
+ bgp_packet_add(_peer, _s); \
+ } \
+ } while (0)
/* Packet send and receive function prototypes. */
extern void bgp_keepalive_send(struct peer *);
/* Extern from bgp_dump.c */
extern const char *bgp_origin_str[];
extern const char *bgp_origin_long_str[];
-const char *get_afi_safi_str(afi_t afi,
- safi_t safi, bool for_json);
+const char *get_afi_safi_str(afi_t afi, safi_t safi, bool for_json);
/* PMSI strings. */
#define PMSI_TNLTYPE_STR_NO_INFO "No info"
#define PMSI_TNLTYPE_STR_DEFAULT PMSI_TNLTYPE_STR_NO_INFO
if (CHECK_FLAG(rn->flags, BGP_NODE_PROCESS_SCHEDULED)) {
if (BGP_DEBUG(update, UPDATE_OUT)) {
prefix2str(&rn->p, buf, PREFIX2STR_BUFFER);
- zlog_debug("Route %s is in workqueue and being processed, not deferred.",
+ zlog_debug(
+ "Route %s is in workqueue and being processed, not deferred.",
buf);
}
return 0;
/* Route selection is deferred if there is a stale path which
* which indicates peer is in restart mode
*/
- if (CHECK_FLAG(old_pi->flags, BGP_PATH_STALE) &&
- (old_pi->sub_type == BGP_ROUTE_NORMAL)) {
+ if (CHECK_FLAG(old_pi->flags, BGP_PATH_STALE)
+ && (old_pi->sub_type == BGP_ROUTE_NORMAL)) {
set_flag = 1;
} else {
/* If the peer is graceful restart capable and peer is
* restarting mode, set the flag BGP_NODE_SELECT_DEFER
*/
peer = old_pi->peer;
- if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer) &&
- BGP_PEER_RESTARTING_MODE(peer) &&
- (old_pi && old_pi->sub_type == BGP_ROUTE_NORMAL)) {
+ if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer)
+ && BGP_PEER_RESTARTING_MODE(peer)
+ && (old_pi
+ && old_pi->sub_type == BGP_ROUTE_NORMAL)) {
set_flag = 1;
}
}
bgp->gr_info[afi][safi].route_list, rn);
if (BGP_DEBUG(update, UPDATE_OUT))
zlog_debug("DEFER route %s, rn %p, node %p",
- buf, rn, rn->rt_node);
+ buf, rn, rn->rt_node);
return 0;
}
}
bgp = info->bgp;
if (BGP_DEBUG(update, UPDATE_OUT))
- zlog_debug("afi %d, safi %d : route select timer expired",
- afi, safi);
+ zlog_debug("afi %d, safi %d : route select timer expired", afi,
+ safi);
bgp->gr_info[afi][safi].t_route_select = NULL;
BGP_TIMER_OFF(bgp->gr_info[afi][safi].t_route_select);
if (BGP_DEBUG(update, UPDATE_OUT)) {
- zlog_debug("%s: processing route for %s : cnt %d",
- __func__, get_afi_safi_str(afi, safi, false),
- listcount(bgp->gr_info[afi][safi].route_list));
+ zlog_debug("%s: processing route for %s : cnt %d", __func__,
+ get_afi_safi_str(afi, safi, false),
+ listcount(bgp->gr_info[afi][safi].route_list));
}
/* Process the route list */
bgp_send_delayed_eor(bgp);
/* Send route processing complete message to RIB */
bgp_zebra_update(afi, safi, bgp->vrf_id,
- ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE);
+ ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE);
return 0;
}
if (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER)) {
if (BGP_DEBUG(update, UPDATE_OUT))
zlog_debug("BGP_NODE_SELECT_DEFER set for route %p",
- rn);
+ rn);
return;
}
*/
if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
delete_route = true;
- else
- if (bgp_node_set_defer_flag(rn, true) < 0)
- delete_route = true;
+ else if (bgp_node_set_defer_flag(rn, true) < 0)
+ delete_route = true;
if (delete_route) {
if (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER)) {
UNSET_FLAG(rn->flags, BGP_NODE_SELECT_DEFER);
bgp = pi->peer->bgp;
- if ((rn->rt_node) &&
- (bgp->gr_info[afi][safi]
- .route_list)) {
- list_delete_node(
- bgp->gr_info[afi][safi]
- .route_list,
- rn->rt_node);
+ if ((rn->rt_node)
+ && (bgp->gr_info[afi][safi].route_list)) {
+ list_delete_node(bgp->gr_info[afi][safi]
+ .route_list,
+ rn->rt_node);
rn->rt_node = NULL;
}
}
if (bgp && rn && rn->lock == 1) {
/* Delete the route from the selection pending list */
- if ((node->rt_node) &&
- (bgp->gr_info[afi][safi].route_list)) {
+ if ((node->rt_node)
+ && (bgp->gr_info[afi][safi].route_list)) {
list_delete_node(
bgp->gr_info[afi][safi].route_list,
- node->rt_node);
+ node->rt_node);
node->rt_node = NULL;
}
}
(struct bgp *bgp, struct vty *vty),
(bgp, vty))
-#define GR_NO_OPER "The Graceful Restart No Operation was executed as cmd same as previous one."
-#define GR_INVALID "The Graceful Restart command used is not valid at this moment."
+#define GR_NO_OPER \
+ "The Graceful Restart No Operation was executed as cmd same as previous one."
+#define GR_INVALID \
+ "The Graceful Restart command used is not valid at this moment."
static struct peer_group *listen_range_exists(struct bgp *bgp,
struct prefix *range, int exact);
show_ipv6_peer
};
-static struct peer_group *listen_range_exists(
- struct bgp *bgp,
- struct prefix *range,
- int exact);
+static struct peer_group *listen_range_exists(struct bgp *bgp,
+ struct prefix *range, int exact);
-static void bgp_show_global_graceful_restart_mode_vty(
- struct vty *vty,
- struct bgp *bgp,
- bool use_json,
- json_object *json);
+static void bgp_show_global_graceful_restart_mode_vty(struct vty *vty,
+ struct bgp *bgp,
+ bool use_json,
+ json_object *json);
-static int bgp_show_neighbor_graceful_restart_afi_all(
- struct vty *vty,
- enum show_type type,
- const char *ip_str,
- afi_t afi,
- bool use_json);
+static int bgp_show_neighbor_graceful_restart_afi_all(struct vty *vty,
+ enum show_type type,
+ const char *ip_str,
+ afi_t afi, bool use_json);
static enum node_type bgp_node_type(afi_t afi, safi_t safi)
{
bgp_peer_gr_flags_update(peer);
- if (CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART))
+ if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
gr_router_detected = true;
ret = bgp_peer_clear(peer, afi, safi, nnode,
if (ret < 0)
bgp_clear_vty_error(vty, peer, afi, safi, ret);
-
}
- if (gr_router_detected &&
- bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
+ if (gr_router_detected
+ && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
bgp_zebra_send_capabilities(bgp, false);
- } else if (!gr_router_detected &&
- bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
+ } else if (!gr_router_detected
+ && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
bgp_zebra_send_capabilities(bgp, true);
}
bgp_peer_gr_flags_update(peer);
- if (CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART))
+ if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
gr_router_detected = true;
ret = bgp_peer_clear(peer, afi, safi, nnode, stype);
found = true;
}
- if (gr_router_detected &&
- bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
+ if (gr_router_detected
+ && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
bgp_zebra_send_capabilities(bgp, false);
- } else if (!gr_router_detected &&
- bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
+ } else if (!gr_router_detected
+ && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
bgp_zebra_send_capabilities(bgp, true);
}
bgp_peer_gr_flags_update(peer);
- if (CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART))
+ if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
gr_router_detected = true;
ret = bgp_peer_clear(peer, afi, safi, nnode, stype);
found = true;
}
- if (gr_router_detected &&
- bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
+ if (gr_router_detected
+ && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
bgp_zebra_send_capabilities(bgp, false);
- } else if (!gr_router_detected &&
- bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
+ } else if (!gr_router_detected
+ && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
bgp_zebra_send_capabilities(bgp, true);
}
ret = bgp_gr_update_all(bgp, GLOBAL_GR_CMD);
- VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp,
- bgp->peer, ret);
+ VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
+ ret);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : END ");
ret = bgp_gr_update_all(bgp, NO_GLOBAL_GR_CMD);
- VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp,
- bgp->peer, ret);
+ VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
+ ret);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : END ");
ret = bgp_gr_update_all(bgp, NO_GLOBAL_DISABLE_CMD);
- VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp,
- bgp->peer, ret);
+ VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
+ ret);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
zlog_debug(
"[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : START ");
- ret = bgp_neighbor_graceful_restart(peer,
- NO_PEER_HELPER_CMD);
+ ret = bgp_neighbor_graceful_restart(peer, NO_PEER_HELPER_CMD);
VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
if (!peer)
return CMD_WARNING_CONFIG_FAILED;
- ret = bgp_neighbor_graceful_restart(peer,
- PEER_DISABLE_CMD);
+ ret = bgp_neighbor_graceful_restart(peer, PEER_DISABLE_CMD);
if (peer->bgp->t_startup)
bgp_peer_gr_flags_update(peer);
}
}
-static void bgp_show_neighbor_graceful_restart_time(struct vty *vty,
- struct peer *p,
- bool use_json,
- json_object *json)
+static void bgp_show_neighbor_graceful_restart_time(struct vty *vty,
+ struct peer *p,
+ bool use_json,
+ json_object *json)
{
if (use_json) {
json_object *json_timer = NULL;
vty_out(vty,
" Restart Time Remaining(sec) : %ld\n",
thread_timer_remain_second(p->t_gr_restart));
+ if (p->t_gr_restart != NULL) {
+ vty_out(vty,
+ " Restart Time Remaining(sec) : %ld\n",
+ thread_timer_remain_second(p->t_gr_restart));
+ }
}
}
static void bgp_show_peer_gr_status(struct vty *vty, struct peer *p,
- bool use_json,
- json_object *json)
+ bool use_json, json_object *json)
{
char buf[SU_ADDRSTRLEN] = {0};
char dn_flag[2] = {0};
sprintf(neighborAddr, "%s%s", dn_flag, p->host);
if (use_json)
- json_object_string_add(
- json, "neighborAddr",
- neighborAddr);
+ json_object_string_add(json, "neighborAddr",
+ neighborAddr);
else
- vty_out(vty, "BGP neighbor is %s\n",
- neighborAddr);
+ vty_out(vty, "BGP neighbor is %s\n", neighborAddr);
}
/* more gr info in new format */
p->pmax_restart[afi][safi] * 60000);
}
json_object_object_add(json_neigh,
- get_afi_safi_str(afi,
- safi, true),
+ get_afi_safi_str(afi, safi, true),
json_addr);
} else {
json_grace_send = json_object_new_object();
json_grace_recv = json_object_new_object();
- if ((p->status == Established) &&
- CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
+ if ((p->status == Established)
+ && CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
FOREACH_AFI_SAFI (afi, safi) {
if (CHECK_FLAG(p->af_sflags[afi][safi],
- PEER_STATUS_EOR_SEND)) {
+ PEER_STATUS_EOR_SEND)) {
json_object_boolean_true_add(
json_grace_send,
get_afi_safi_str(afi,
}
FOREACH_AFI_SAFI (afi, safi) {
if (CHECK_FLAG(
- p->af_sflags[afi][safi],
- PEER_STATUS_EOR_RECEIVED)) {
+ p->af_sflags[afi][safi],
+ PEER_STATUS_EOR_RECEIVED)) {
json_object_boolean_true_add(
json_grace_recv,
get_afi_safi_str(afi,
}
}
}
- json_object_object_add(json_grace,
- "endOfRibSend",
- json_grace_send);
- json_object_object_add(json_grace,
- "endOfRibRecv",
- json_grace_recv);
+ json_object_object_add(json_grace, "endOfRibSend",
+ json_grace_send);
+ json_object_object_add(json_grace, "endOfRibRecv",
+ json_grace_recv);
if (p->t_gr_restart)
* 1000);
/* more gr info in new format */
BGP_SHOW_PEER_GR_CAPABILITY(vty, p, use_json,
- json_grace);
+ json_grace);
json_object_object_add(
json_neigh, "gracefulRestartInfo", json_grace);
} else {
vty_out(vty, " Graceful restart informations:\n");
- if ((p->status == Established) &&
- CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
+ if ((p->status == Established)
+ && CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
vty_out(vty, " End-of-RIB send: ");
FOREACH_AFI_SAFI (afi, safi) {
vty_out(vty, "%s%s",
eor_send_af_count ? ", "
: "",
- get_afi_safi_str(afi,
- safi,
- false));
+ get_afi_safi_str(
+ afi, safi,
+ false));
eor_send_af_count++;
}
}
}
}
-static int bgp_show_neighbor_graceful_restart(struct vty *vty,
- struct bgp *bgp,
- enum show_type type,
- union sockunion *su,
- const char *conf_if, afi_t afi,
- bool use_json, json_object *json)
+static int bgp_show_neighbor_graceful_restart(struct vty *vty, struct bgp *bgp,
+ enum show_type type,
+ union sockunion *su,
+ const char *conf_if, afi_t afi,
+ bool use_json, json_object *json)
{
struct listnode *node, *nnode;
struct peer *peer;
return CMD_SUCCESS;
}
-static void bgp_show_neighbor_graceful_restart_vty(struct vty *vty,
- enum show_type type, const char *ip_str,
- afi_t afi, bool use_json)
+static void bgp_show_neighbor_graceful_restart_vty(struct vty *vty,
+ enum show_type type,
+ const char *ip_str,
+ afi_t afi, bool use_json)
{
int ret;
afi_t afi = AFI_MAX;
bool uj = use_json(argc, argv);
- if (!argv_find_and_parse_afi(argv, argc, &idx, &afi))
+ if (!argv_find_and_parse_afi(argv, argc, &idx, &afi))
afi = AFI_MAX;
idx++;
return CMD_SUCCESS;
- return bgp_show_neighbor_graceful_restart_afi_all(vty,
- sh_type, sh_arg,
- afi, uj);
+ return bgp_show_neighbor_graceful_restart_afi_all(vty, sh_type, sh_arg,
+ afi, uj);
}
/* "show [ip] bgp neighbors" commands. */
/* Graceful Restart */
static void bgp_show_global_graceful_restart_mode_vty(struct vty *vty,
- struct bgp *bgp,
- bool use_json,
- json_object *json)
+ struct bgp *bgp,
+ bool use_json,
+ json_object *json)
{
vty_out(vty, "\n");
}
-static int bgp_show_neighbor_graceful_restart_afi_all(struct vty *vty,
- enum show_type type,
- const char *ip_str,
- afi_t afi,
- bool use_json)
+static int bgp_show_neighbor_graceful_restart_afi_all(struct vty *vty,
+ enum show_type type,
+ const char *ip_str,
+ afi_t afi, bool use_json)
{
if ((afi == AFI_MAX) && (ip_str == NULL)) {
afi = AFI_IP;
while ((afi != AFI_L2VPN) && (afi < AFI_MAX)) {
- bgp_show_neighbor_graceful_restart_vty(vty,
- type, ip_str,
- afi, use_json);
+ bgp_show_neighbor_graceful_restart_vty(
+ vty, type, ip_str, afi, use_json);
afi++;
}
} else if (afi != AFI_MAX) {
- bgp_show_neighbor_graceful_restart_vty(vty,
- type, ip_str,
- afi, use_json);
+ bgp_show_neighbor_graceful_restart_vty(vty, type, ip_str, afi,
+ use_json);
} else {
return CMD_ERR_INCOMPLETE;
}
install_element(BGP_NODE, &no_bgp_deterministic_med_cmd);
/* "bgp graceful-restart" command */
- install_element(BGP_NODE,
- &bgp_graceful_restart_cmd);
- install_element(BGP_NODE,
- &no_bgp_graceful_restart_cmd);
+ install_element(BGP_NODE, &bgp_graceful_restart_cmd);
+ install_element(BGP_NODE, &no_bgp_graceful_restart_cmd);
/* "bgp graceful-restart-disable" command */
- install_element(BGP_NODE,
- &bgp_graceful_restart_disable_cmd);
- install_element(BGP_NODE,
- &no_bgp_graceful_restart_disable_cmd);
+ install_element(BGP_NODE, &bgp_graceful_restart_disable_cmd);
+ install_element(BGP_NODE, &no_bgp_graceful_restart_disable_cmd);
/* "neighbor a:b:c:d graceful-restart" command */
- install_element(BGP_NODE,
- &bgp_neighbor_graceful_restart_set_cmd);
- install_element(BGP_NODE,
- &no_bgp_neighbor_graceful_restart_set_cmd);
+ install_element(BGP_NODE, &bgp_neighbor_graceful_restart_set_cmd);
+ install_element(BGP_NODE, &no_bgp_neighbor_graceful_restart_set_cmd);
/* "neighbor a:b:c:d graceful-restart-disable" command */
install_element(BGP_NODE,
/* "show [ip] bgp neighbors" commands. */
install_element(VIEW_NODE, &show_ip_bgp_neighbors_cmd);
- install_element(VIEW_NODE,
- &show_ip_bgp_neighbors_graceful_restart_cmd);
+ install_element(VIEW_NODE, &show_ip_bgp_neighbors_graceful_restart_cmd);
/* "show [ip] bgp peer-group" commands. */
install_element(VIEW_NODE, &show_ip_bgp_peer_groups_cmd);
vty, p, use_json, json); \
} while (0)
-#define VTY_BGP_GR_DEFINE_LOOP_VARIABLE \
- struct peer *peer_loop = NULL; \
- struct listnode *node = NULL; \
- struct listnode *nnode = NULL; \
- bool gr_router_detected = false
-
-#define VTY_BGP_GR_ROUTER_DETECT( \
- _bgp, _peer, _peer_list) \
- do { \
- if (_peer->bgp->t_startup) \
- bgp_peer_gr_flags_update(_peer); \
- for (ALL_LIST_ELEMENTS(_peer_list, \
- node, nnode, peer_loop)) { \
- if (CHECK_FLAG(peer_loop->flags,\
- PEER_FLAG_GRACEFUL_RESTART)) \
- gr_router_detected = true; \
- } \
+#define VTY_BGP_GR_DEFINE_LOOP_VARIABLE \
+ struct peer *peer_loop = NULL; \
+ struct listnode *node = NULL; \
+ struct listnode *nnode = NULL; \
+ bool gr_router_detected = false
+
+#define VTY_BGP_GR_ROUTER_DETECT(_bgp, _peer, _peer_list) \
+ do { \
+ if (_peer->bgp->t_startup) \
+ bgp_peer_gr_flags_update(_peer); \
+ for (ALL_LIST_ELEMENTS(_peer_list, node, nnode, peer_loop)) { \
+ if (CHECK_FLAG(peer_loop->flags, \
+ PEER_FLAG_GRACEFUL_RESTART)) \
+ gr_router_detected = true; \
+ } \
} while (0)
-#define VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(_bgp, _ret) \
- do { \
- if (gr_router_detected && \
- _bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) { \
- if (bgp_zebra_send_capabilities(_bgp, false)) \
- _ret = BGP_ERR_INVALID_VALUE;\
- } else if (!gr_router_detected && \
- _bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) { \
- if (bgp_zebra_send_capabilities(_bgp, true)) \
- _ret = BGP_ERR_INVALID_VALUE;\
- } \
+#define VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(_bgp, _ret) \
+ do { \
+ if (gr_router_detected \
+ && _bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) { \
+ if (bgp_zebra_send_capabilities(_bgp, false)) \
+ _ret = BGP_ERR_INVALID_VALUE; \
+ } else if (!gr_router_detected \
+ && _bgp->present_zebra_gr_state \
+ == ZEBRA_GR_ENABLE) { \
+ if (bgp_zebra_send_capabilities(_bgp, true)) \
+ _ret = BGP_ERR_INVALID_VALUE; \
+ } \
} while (0)
-#define VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA( \
- _bgp, _peer_list, _ret) \
- do { \
- struct peer *peer_loop; \
- bool gr_router_detected = false; \
- struct listnode *node = {0}; \
- struct listnode *nnode = {0}; \
- for (ALL_LIST_ELEMENTS( \
- _peer_list, node, \
- nnode, peer_loop)) { \
- if (peer_loop->bgp->t_startup) \
- bgp_peer_gr_flags_update(peer_loop); \
- if (CHECK_FLAG( \
- peer_loop->flags, \
- PEER_FLAG_GRACEFUL_RESTART)) \
- gr_router_detected = true; \
- } \
- if (gr_router_detected && \
- _bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) { \
- if (bgp_zebra_send_capabilities(_bgp, false)) \
- _ret = BGP_ERR_INVALID_VALUE;\
- } else if (!gr_router_detected && \
- _bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) { \
- if (bgp_zebra_send_capabilities(_bgp, true)) \
- _ret = BGP_ERR_INVALID_VALUE;\
- } \
+#define VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA( \
+ _bgp, _peer_list, _ret) \
+ do { \
+ struct peer *peer_loop; \
+ bool gr_router_detected = false; \
+ struct listnode *node = {0}; \
+ struct listnode *nnode = {0}; \
+ for (ALL_LIST_ELEMENTS(_peer_list, node, nnode, peer_loop)) { \
+ if (peer_loop->bgp->t_startup) \
+ bgp_peer_gr_flags_update(peer_loop); \
+ if (CHECK_FLAG(peer_loop->flags, \
+ PEER_FLAG_GRACEFUL_RESTART)) \
+ gr_router_detected = true; \
+ } \
+ if (gr_router_detected \
+ && _bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) { \
+ if (bgp_zebra_send_capabilities(_bgp, false)) \
+ _ret = BGP_ERR_INVALID_VALUE; \
+ } else if (!gr_router_detected \
+ && _bgp->present_zebra_gr_state \
+ == ZEBRA_GR_ENABLE) { \
+ if (bgp_zebra_send_capabilities(_bgp, true)) \
+ _ret = BGP_ERR_INVALID_VALUE; \
+ } \
} while (0)
-#define PRINT_EOR(_eor_flag) \
- do { \
- if (eor_flag) \
- vty_out(vty, "Yes\n"); \
- else \
- vty_out(vty, "No\n"); \
+#define PRINT_EOR(_eor_flag) \
+ do { \
+ if (eor_flag) \
+ vty_out(vty, "Yes\n"); \
+ else \
+ vty_out(vty, "No\n"); \
} while (0)
-#define PRINT_EOR_JSON(_eor_flag) \
- do { \
- if (eor_flag) \
- json_object_boolean_true_add( \
- json_endofrib_status, \
- "endOfRibSentAfterUpdate"); \
- else \
- json_object_boolean_false_add( \
- json_endofrib_status, \
- "endOfRibSentAfterUpdate"); \
+#define PRINT_EOR_JSON(_eor_flag) \
+ do { \
+ if (eor_flag) \
+ json_object_boolean_true_add( \
+ json_endofrib_status, \
+ "endOfRibSentAfterUpdate"); \
+ else \
+ json_object_boolean_false_add( \
+ json_endofrib_status, \
+ "endOfRibSentAfterUpdate"); \
} while (0)
extern void bgp_vty_init(void);
api.vrf_id = bgp->vrf_id;
}
- if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES,
- zclient, &api) < 0) {
+ if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES, zclient, &api)
+ < 0) {
zlog_err("error sending capability");
ret = BGP_GR_FAILURE;
} else {
api.vrf_id = vrf_id;
api.cap = type;
- if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES,
- zclient, &api) < 0) {
+ if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES, zclient, &api)
+ < 0) {
if (BGP_DEBUG(zebra, ZEBRA))
zlog_debug("error sending capability");
return BGP_GR_FAILURE;
api.cap = ZEBRA_CLIENT_RIB_STALE_TIME;
api.stale_removal_time = bgp->rib_stale_time;
api.vrf_id = bgp->vrf_id;
- if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES,
- zclient, &api) < 0) {
+ if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES, zclient, &api)
+ < 0) {
if (BGP_DEBUG(zebra, ZEBRA))
zlog_debug("error sending capability");
return BGP_GR_FAILURE;
extern void bgp_zebra_announce_default(struct bgp *bgp, struct nexthop *nh,
afi_t afi, uint32_t table_id, bool announce);
extern int bgp_zebra_send_capabilities(struct bgp *bgp, bool disable);
-extern int bgp_zebra_update(afi_t afi, safi_t safi, vrf_id_t vrf_id,
- int type);
+extern int bgp_zebra_update(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type);
extern int bgp_zebra_stale_timer_update(struct bgp *bgp);
#endif /* _QUAGGA_BGP_ZEBRA_H */
bgp_timer_set(peer);
bgp_peer_gr_flags_update(peer);
- BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(
- bgp,
- bgp->peer);
+ BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer);
return peer;
}
bgp->name = XSTRDUP(MTYPE_BGP, name);
thread_add_timer(bm->master, bgp_startup_timer_expire, bgp,
- bgp->restart_time, &bgp->t_startup);
+ bgp->restart_time, &bgp->t_startup);
/* printable name we can use in debug messages */
if (inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
bool gr_router_detected = false;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
- zlog_debug("[BGP_GR] %s called !",
- __func__);
+ zlog_debug("[BGP_GR] %s called !", __func__);
for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
bgp_peer_gr_flags_update(peer);
- if (CHECK_FLAG(peer->flags,
- PEER_FLAG_GRACEFUL_RESTART))
+ if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
gr_router_detected = true;
}
- if (gr_router_detected &&
- bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
+ if (gr_router_detected
+ && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
bgp_zebra_send_capabilities(bgp, true);
- } else if (!gr_router_detected &&
- bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
+ } else if (!gr_router_detected
+ && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
bgp_zebra_send_capabilities(bgp, false);
}
BGP_INSTANCE_TYPE_VIEW
};
-#define BGP_SEND_EOR(bgp, afi, safi) \
- (!bgp_flag_check(bgp, BGP_FLAG_GR_DISABLE_EOR) && \
- ((bgp->gr_info[afi][safi].t_select_deferral == NULL) || \
- (bgp->gr_info[afi][safi].eor_required == \
- bgp->gr_info[afi][safi].eor_received)))
+#define BGP_SEND_EOR(bgp, afi, safi) \
+ (!bgp_flag_check(bgp, BGP_FLAG_GR_DISABLE_EOR) \
+ && ((bgp->gr_info[afi][safi].t_select_deferral == NULL) \
+ || (bgp->gr_info[afi][safi].eor_required \
+ == bgp->gr_info[afi][safi].eor_received)))
/* BGP GR Global ds */
#define BGP_FLAG_GR_DISABLE_EOR (1 << 24)
enum global_mode GLOBAL_GR_FSM[BGP_GLOBAL_GR_MODE]
- [BGP_GLOBAL_GR_EVENT_CMD];
+ [BGP_GLOBAL_GR_EVENT_CMD];
enum global_mode global_gr_present_state;
/* This variable stores the current Graceful Restart state of Zebra
(struct bgp *bgp, struct vty *vty),
(bgp, vty))
- /* Thread callback information */
- struct afi_safi_info {
- afi_t afi;
- safi_t safi;
- struct bgp *bgp;
- };
+/* Thread callback information */
+struct afi_safi_info {
+ afi_t afi;
+ safi_t safi;
+ struct bgp *bgp;
+};
#define BGP_ROUTE_ADV_HOLD(bgp) (bgp->main_peers_update_hold)
|| (bgp->inst_type == BGP_INSTANCE_TYPE_VRF \
&& bgp->vrf_id != VRF_UNKNOWN))
-#define BGP_SELECT_DEFER_DISABLE(bgp) \
+#define BGP_SELECT_DEFER_DISABLE(bgp) \
(bgp_flag_check(bgp, BGP_FLAG_SELECT_DEFER_DISABLE))
/* BGP peer-group support. */
int bgp_peer_gr_init(struct peer *peer);
-#define BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA( \
- _bgp, _peer_list) \
-do { \
- struct peer *peer_loop; \
- bool gr_router_detected = false; \
- struct listnode *node = {0}; \
- for (ALL_LIST_ELEMENTS_RO( \
- _peer_list, node, \
- peer_loop)) { \
- if (CHECK_FLAG( \
- peer_loop->flags, \
- PEER_FLAG_GRACEFUL_RESTART)) \
- gr_router_detected = true; \
- } \
- if (gr_router_detected && \
- _bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) { \
- bgp_zebra_send_capabilities(_bgp, false); \
- } else if (!gr_router_detected && \
- _bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) { \
- bgp_zebra_send_capabilities(_bgp, true); \
- } \
-} while (0)
+#define BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(_bgp, _peer_list) \
+ do { \
+ struct peer *peer_loop; \
+ bool gr_router_detected = false; \
+ struct listnode *node = {0}; \
+ for (ALL_LIST_ELEMENTS_RO(_peer_list, node, peer_loop)) { \
+ if (CHECK_FLAG(peer_loop->flags, \
+ PEER_FLAG_GRACEFUL_RESTART)) \
+ gr_router_detected = true; \
+ } \
+ if (gr_router_detected \
+ && _bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) { \
+ bgp_zebra_send_capabilities(_bgp, false); \
+ } else if (!gr_router_detected \
+ && _bgp->present_zebra_gr_state \
+ == ZEBRA_GR_ENABLE) { \
+ bgp_zebra_send_capabilities(_bgp, true); \
+ } \
+ } while (0)
static inline struct bgp *bgp_lock(struct bgp *bgp)
{
str2prefix("42.1.1.0/24", &test_rn.p);
rt_node = bgp_node_to_rnode(&test_rn);
memcpy((struct route_table *)&rt_node->table, &rt->route_table,
- sizeof(struct route_table));
+ sizeof(struct route_table));
setup_bgp_mp_list(t);
for (i = 0; i < test_mp_list_info_count; i++)
bgp_path_info_add(&test_rn, &test_mp_list_info[i]);
projects / matthieu / frr.git / commitdiff