bgpd: BGP Garaceful Restart debug logs.

Reorganizing bgp gr debug logs and code review comments.

Signed-off-by: Biswajit Sadhu <sadhub@vmware.com>

diff --git a/bgpd/bgp_fsm.c b/bgpd/bgp_fsm.c
index 9834fbc447145156ef7babb5cb929cb698c697aa..77a7836f4fb51acbdb01b9d85da2dd61d59957ff 100644 (file)
--- a/bgpd/bgp_fsm.c
+++ b/bgpd/bgp_fsm.c
@@ -1122,10 +1122,11 @@ int bgp_stop(struct peer *peer)
        safi_t safi;
        char orf_name[BUFSIZ];
        int ret = 0;
-       peer->nsf_af_count = 0;
        struct bgp *bgp = peer->bgp;
        struct graceful_restart_info *gr_info = NULL;
 
+       peer->nsf_af_count = 0;
+
        if (peer_dynamic_neighbor(peer)
            && !(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) {
                if (bgp_debug_neighbor_events(peer))
@@ -1208,7 +1209,7 @@ int bgp_stop(struct peer *peer)
                                        if (gr_info && BGP_DEBUG(update,
                                                UPDATE_OUT))
                                                zlog_debug(
-                                                       "peer %s, EOR %d",
+                                                       "peer %s, EOR_required %d",
                                                        peer->host,
                                                        gr_info->eor_required);
 
@@ -1741,7 +1742,7 @@ static int bgp_update_gr_info(struct peer *peer, afi_t afi, safi_t safi)
                        ret = bgp_start_deferral_timer(bgp, afi, safi, gr_info);
                }
        }
-       return (ret);
+       return ret;
 }
 
 /**
@@ -1830,8 +1831,8 @@ static int bgp_establish(struct peer *peer)
                                        status = bgp_update_gr_info(peer, afi,
                                                                    safi);
                                        if (status < 0)
-                                               zlog_debug("Error in updating graceful restart for %s",
-                                               get_afi_safi_str(afi,
+                                               zlog_err("Error in updating graceful restart for %s",
+                                                       get_afi_safi_str(afi,
                                                        safi, false));
                                } else {
                                        if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(
@@ -2278,7 +2279,7 @@ int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
 
                if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                        zlog_debug(
-                       "BGP_GR:: %s Peer: (%s) :",
+                       "%s [BGP_GR] Peer: (%s) :",
                                __func__, peer->host);
 
                peer_old_state = bgp_peer_gr_mode_get(peer);
@@ -2293,29 +2294,23 @@ int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
                 */
 
                        switch (global_new_state) {
-
                        case GLOBAL_HELPER:
-
                                BGP_PEER_GR_HELPER_ENABLE(peer);
                                break;
                        case GLOBAL_GR:
-
                                BGP_PEER_GR_ENABLE(peer);
                                break;
                        case GLOBAL_DISABLE:
-
                                BGP_PEER_GR_DISABLE(peer);
                                break;
                        case GLOBAL_INVALID:
-
                                zlog_debug(
-                               "BGP_GR:: %s :GLOBAL_INVALID",
+                               "%s [BGP_GR]GLOBAL_INVALID",
                                __func__);
                                return BGP_ERR_GR_OPERATION_FAILED;
                        default:
-
                                zlog_debug(
-                               "BGP_GR:: %s :Global unknown ERROR",
+                               "%s [BGP_GR]Global unknown ERROR",
                                __func__);
                                return BGP_ERR_GR_OPERATION_FAILED;
                        }
@@ -2324,45 +2319,53 @@ int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
 
        bgp->global_gr_present_state = global_new_state;
 
-       /* debug Trace msg */
        return BGP_GR_SUCCESS;
 }
 
-int bgp_gr_update_all(struct bgp *bgp, int global_GR_Cmd)
+int bgp_gr_update_all(struct bgp *bgp, int global_gr_cmd)
 {
        enum global_mode global_new_state = GLOBAL_INVALID;
        enum global_mode global_old_state = GLOBAL_INVALID;
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-               "BGP_GR::%s:START: global_GR_Cmd :%d:",
-                       __func__, global_GR_Cmd);
+               "%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 (global_old_state != GLOBAL_INVALID) {
+       if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
+               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];
+                       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));
        } else {
-               /* Trace msg */
-               zlog_debug("BGP_GR::%s:global_old_state == GLOBAL_INVALID",
+               zlog_err(
+                       "%s [BGP_GR] global_old_state == GLOBAL_INVALID",
                        __func__);
                return BGP_ERR_GR_OPERATION_FAILED;
        }
 
        if (global_new_state == GLOBAL_INVALID) {
-               /* Trace msg */
-               zlog_debug(
-                       "BGP_GR::%s: global_new_state == GLOBAL_INVALID",
+               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 */
-               zlog_debug(
-               "BGP_GR::%s : global_new_state == global_old_state",
-                       __func__);
+               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));
                return BGP_GR_NO_OPERATION;
        }
 
@@ -2371,6 +2374,103 @@ int bgp_gr_update_all(struct bgp *bgp, int global_GR_Cmd)
                                        global_old_state);
 }
 
+const char *print_peer_gr_mode(enum peer_mode pr_mode)
+{
+       const char *peer_gr_mode = NULL;
+
+       switch (pr_mode) {
+       case PEER_HELPER:
+               peer_gr_mode = "PEER_HELPER";
+               break;
+       case PEER_GR:
+               peer_gr_mode = "PEER_GR";
+               break;
+       case PEER_DISABLE:
+               peer_gr_mode = "PEER_DISABLE";
+               break;
+       case PEER_INVALID:
+               peer_gr_mode = "PEER_INVALID";
+               break;
+       case PEER_GLOBAL_INHERIT:
+               peer_gr_mode = "PEER_GLOBAL_INHERIT";
+               break;
+       }
+
+       return peer_gr_mode;
+}
+
+const char *print_peer_gr_cmd(enum peer_gr_command pr_gr_cmd)
+{
+       const char *peer_gr_cmd = NULL;
+
+       switch (pr_gr_cmd) {
+       case PEER_GR_CMD:
+               peer_gr_cmd = "PEER_GR_CMD";
+               break;
+       case NO_PEER_GR_CMD:
+               peer_gr_cmd = "NO_PEER_GR_CMD";
+               break;
+       case PEER_DISABLE_CMD:
+               peer_gr_cmd = "PEER_GR_CMD";
+               break;
+       case NO_PEER_DISABLE_CMD:
+               peer_gr_cmd = "NO_PEER_GR_CMD";
+               break;
+       case PEER_HELPER_CMD:
+               peer_gr_cmd = "PEER_HELPER_CMD";
+               break;
+       case NO_PEER_HELPER_CMD:
+               peer_gr_cmd = "NO_PEER_HELPER_CMD";
+               break;
+       }
+
+       return peer_gr_cmd;
+}
+
+const char *print_global_gr_mode(enum global_mode gl_mode)
+{
+       const char *global_gr_mode = NULL;
+
+       switch (gl_mode) {
+       case GLOBAL_HELPER:
+               global_gr_mode = "GLOBAL_HELPER";
+               break;
+       case GLOBAL_GR:
+               global_gr_mode = "GLOBAL_GR";
+               break;
+       case GLOBAL_DISABLE:
+               global_gr_mode = "GLOBAL_DISABLE";
+               break;
+       case GLOBAL_INVALID:
+               global_gr_mode = "GLOBAL_INVALID";
+               break;
+       }
+
+       return global_gr_mode;
+}
+
+const char *print_global_gr_cmd(enum global_gr_command gl_gr_cmd)
+{
+       const char *global_gr_cmd = NULL;
+
+       switch (gl_gr_cmd) {
+       case GLOBAL_GR_CMD:
+               global_gr_cmd = "GLOBAL_GR_CMD";
+               break;
+       case NO_GLOBAL_GR_CMD:
+               global_gr_cmd = "NO_GLOBAL_GR_CMD";
+               break;
+       case GLOBAL_DISABLE_CMD:
+               global_gr_cmd = "GLOBAL_DISABLE_CMD";
+               break;
+       case NO_GLOBAL_DISABLE_CMD:
+               global_gr_cmd = "NO_GLOBAL_DISABLE_CMD";
+               break;
+       }
+
+       return global_gr_cmd;
+}
+
 enum global_mode bgp_global_gr_mode_get(struct bgp *bgp)
 {
        return bgp->global_gr_present_state;
@@ -2382,7 +2482,7 @@ enum peer_mode bgp_peer_gr_mode_get(struct peer *peer)
 }
 
 int bgp_neighbor_graceful_restart(struct peer *peer,
-                                               int peer_GR_Cmd)
+                                               int peer_gr_cmd)
 {
        enum peer_mode  peer_new_state = PEER_INVALID;
        enum peer_mode  peer_old_state = PEER_INVALID;
@@ -2397,25 +2497,23 @@ int bgp_neighbor_graceful_restart(struct peer *peer,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-               "BGP_GR:: %s:START--->Peer: (%s) : peer_GR_Cmd :%d:",
-                 __func__, peer->host, peer_GR_Cmd);
+               "%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) {
-               /* debug Trace msg */
                zlog_debug(
-                       "BGP_GR:: peer_old_state ==Invalid state !");
+                       "[BGP_GR] peer_old_state == Invalid state !");
                return BGP_ERR_GR_OPERATION_FAILED;
        }
 
-       peer_state = peer->PEER_GR_FSM[peer_old_state][peer_GR_Cmd];
+       peer_state = peer->PEER_GR_FSM[peer_old_state][peer_gr_cmd];
        peer_new_state = peer_state.next_state;
 
        if (peer_new_state == PEER_INVALID) {
-               /* debug Trace msg */
                zlog_debug(
-                       "BGP_GR:: Invalid bgp graceful restart command used !");
+                       "[BGP_GR] Invalid bgp graceful restart command used !");
                return BGP_ERR_GR_INVALID_CMD;
        }
 
@@ -2424,9 +2522,9 @@ int bgp_neighbor_graceful_restart(struct peer *peer,
                                                peer_old_state,
                                                peer_new_state);
        } else {
-                       /* debug Trace msg */
-               zlog_debug(
-                       "BGP_GR:: peer_old_state == peer_new_state !");
+               if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
+                       zlog_debug(
+                       "[BGP_GR] peer_old_state == peer_new_state !");
                return BGP_GR_NO_OPERATION;
        }
 
@@ -2434,10 +2532,9 @@ int bgp_neighbor_graceful_restart(struct peer *peer,
 
                /* Update the mode i.e peer_new_state into the peer structure */
                peer->peer_gr_present_state = peer_new_state;
-               /* debug Trace msg */
                if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
-                       zlog_debug("BGP_GR:: Succesfully change the state of the peer to : %d : !",
-                                                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;
        }
@@ -2450,15 +2547,15 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
 {
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: %s : Move peer from old_peer_state :%d: to old_peer_state :%d: !!!!",
-                       __func__, old_peer_state, new_peer_state);
+                       "%s [BGP_GR] Move peer from old_peer_state :%s: to new_peer_state :%s: !!!!",
+                       __func__, print_peer_gr_mode(old_peer_state),
+                       print_peer_gr_mode(new_peer_state));
 
        int bgp_gr_global_mode = GLOBAL_INVALID;
        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 */
-       /* debug Trace msg */
                return BGP_GR_NO_OPERATION;
        }
        if ((old_peer_state == PEER_INVALID) ||
@@ -2490,13 +2587,12 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
                 *of the existing session
                 *as the peer is already working in the same mode.
                 */
-                       /* debug Trace msg */
                        ret = BGP_GR_SUCCESS;
                } else {
                        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                                zlog_debug(
-                                       "BGP_GR:: Peer state changed from :%d  =>",
-                                       old_peer_state);
+                                       "[BGP_GR] Peer state changed from :%s ",
+                                       print_peer_gr_mode(old_peer_state));
 
                        bgp_peer_move_to_gr_mode(peer, new_peer_state);
 
@@ -2531,8 +2627,8 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
                         */
 
                        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
-                               zlog_debug("BGP_GR:: Peer state changed from :%d  ==>",
-                                               old_peer_state);
+                               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);
 
@@ -2545,8 +2641,8 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
                 *( old_peer_state != Peer_Global )
                 */
                if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
-                       zlog_debug("BGP_GR:: Peer state changed from :%d ===>",
-                                               old_peer_state);
+                       zlog_debug("[BGP_GR] Peer state changed from :%s",
+                                       print_peer_gr_mode(old_peer_state));
 
                bgp_peer_move_to_gr_mode(peer, new_peer_state);
 
@@ -2562,19 +2658,15 @@ inline void bgp_peer_move_to_gr_mode(struct peer *peer, int new_state)
        int bgp_global_gr_mode = bgp_global_gr_mode_get(peer->bgp);
 
        switch (new_state) {
-
        case PEER_HELPER:
                BGP_PEER_GR_HELPER_ENABLE(peer);
                break;
-
        case PEER_GR:
                BGP_PEER_GR_ENABLE(peer);
                break;
-
        case PEER_DISABLE:
                BGP_PEER_GR_DISABLE(peer);
                break;
-
        case PEER_GLOBAL_INHERIT:
                BGP_PEER_GR_GLOBAL_INHERIT_SET(peer);
 
@@ -2585,16 +2677,16 @@ inline void bgp_peer_move_to_gr_mode(struct peer *peer, int new_state)
                } else if (bgp_global_gr_mode == GLOBAL_DISABLE) {
                        BGP_PEER_GR_DISABLE(peer);
                } else {
-                       zlog_debug(
-                       "BGP_GR:: Default switch inherit mode ::: SOMETHING IS WRONG !!!");
+                       zlog_err(
+                       "[BGP_GR] Default switch inherit mode ::: SOMETHING IS WRONG !!!");
                }
                break;
        default:
-               zlog_debug("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 : !",
+               zlog_debug("[BGP_GR] Peer state changed  --to-->  : %d : !",
                                         new_state);
 }
 
@@ -2602,7 +2694,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
 {
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: %s called !",
+                       "%s [BGP_GR] called !",
                                __func__);
        if (CHECK_FLAG(peer->peer_gr_new_status_flag,
                PEER_GRACEFUL_RESTART_NEW_STATE_HELPER))
@@ -2613,7 +2705,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
                                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 : !",
+                       "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_HELPER : %s : !",
                        peer->host,
                        (CHECK_FLAG(peer->flags,
                                PEER_FLAG_GRACEFUL_RESTART_HELPER) ?
@@ -2627,7 +2719,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
                                PEER_FLAG_GRACEFUL_RESTART);
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !",
+                       "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !",
                        peer->host,
                        (CHECK_FLAG(peer->flags,
                                PEER_FLAG_GRACEFUL_RESTART) ?
@@ -2641,7 +2733,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
                                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) ?
@@ -2652,7 +2744,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
                !CHECK_FLAG(peer->flags,
                        PEER_FLAG_GRACEFUL_RESTART_HELPER)){
                zlog_debug(
-                       "BGP_GR:: Peer %s UNSET PEER_STATUS_NSF_MODE!",
+                       "[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_MODE!",
                        peer->host);
 
                UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
@@ -2662,7 +2754,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
 
                        peer_nsf_stop(peer);
                        zlog_debug(
-                               "BGP_GR:: Peer %s UNSET PEER_STATUS_NSF_WAIT!",
+                               "[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_WAIT!",
                                peer->host);
                }
        }

diff --git a/bgpd/bgp_fsm.h b/bgpd/bgp_fsm.h
index ced4f292a5fc9f95502852894f2a1839e49fcb52..b6abaf3e9252f2da57e826ec116af4f2039a0081 100644 (file)
--- a/bgpd/bgp_fsm.h
+++ b/bgpd/bgp_fsm.h
@@ -142,9 +142,9 @@ extern void bgp_adjust_routeadv(struct peer *);
 DECLARE_HOOK(peer_backward_transition, (struct peer *peer), (peer))
 DECLARE_HOOK(peer_established, (struct peer *peer), (peer))
 
-int bgp_gr_update_all(struct bgp *bgp, int global_GR_Cmd);
+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 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);
@@ -160,4 +160,8 @@ int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
                enum global_mode global_new_state,
                enum global_mode global_old_state);
 void bgp_peer_gr_flags_update(struct peer *peer);
+const char *print_peer_gr_mode(enum peer_mode pr_mode);
+const char *print_peer_gr_cmd(enum peer_gr_command pr_gr_cmd);
+const char *print_global_gr_mode(enum global_mode gl_mode);
+const char *print_global_gr_cmd(enum global_gr_command gl_gr_cmd);
 #endif /* _QUAGGA_BGP_FSM_H */

diff --git a/bgpd/bgp_open.c b/bgpd/bgp_open.c
index 4b6c8218aa75bee9b263b573ac58e922b3a8c133..e04964ff36cca75efe54929f82c048f79cdf3226 100644 (file)
--- a/bgpd/bgp_open.c
+++ b/bgpd/bgp_open.c
@@ -1327,7 +1327,7 @@ static void bgp_peer_send_gr_capability(struct stream *s, struct peer *peer,
 
                if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                        zlog_debug(
-                               "BGP_GR:: Sending helper Capability for Peer :%s :",
+                               "[BGP_GR] Sending helper Capability for Peer :%s :",
                                peer->host);
 
                SET_FLAG(peer->cap, PEER_CAP_RESTART_ADV);
@@ -1345,7 +1345,7 @@ static void bgp_peer_send_gr_capability(struct stream *s, struct peer *peer,
 
                        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                                zlog_debug(
-                                       "BGP_GR:: Sending R-Bit for Peer :%s :",
+                                       "[BGP_GR] Sending R-Bit for Peer :%s :",
                                        peer->host);
                }
 
@@ -1360,7 +1360,7 @@ static void bgp_peer_send_gr_capability(struct stream *s, struct peer *peer,
                                        if (BGP_DEBUG(graceful_restart,
                                                        GRACEFUL_RESTART))
                                                zlog_debug(
-                                               "BGP_GR:: Sending GR Capability for AFI :%d :, SAFI :%d:",
+                                               "[BGP_GR] Sending GR Capability for AFI :%d :, SAFI :%d:",
                                                afi, safi);
 
                                        /* Convert AFI, SAFI to values for

diff --git a/bgpd/bgp_packet.c b/bgpd/bgp_packet.c
index a6e723ce21459c22cabc406314a1d82101ac5be9..f114443e0abc823784d5ba478e6c1341df1c3a6d 100644 (file)
--- a/bgpd/bgp_packet.c
+++ b/bgpd/bgp_packet.c
@@ -738,14 +738,14 @@ void bgp_notify_send_with_data(struct peer *peer, uint8_t code,
                                                 data[i]);
 
                                        strlcat(bgp_notify.data, c,
-                                               bgp_notify.length * 3);
+                                               bgp_notify.length);
 
                                } else {
                                        first = 1;
                                        snprintf(c, sizeof(c), "%02x", data[i]);
 
                                        strlcpy(bgp_notify.data, c,
-                                               bgp_notify.length * 3);
+                                               bgp_notify.length);
 
                                }
                }

diff --git a/bgpd/bgp_route.c b/bgpd/bgp_route.c
index 6cf380b126e0737ddd094780bbd80e04fc434c88..f7ace6aede628045406cd51da1645fbcd5eefac8 100644 (file)
--- a/bgpd/bgp_route.c
+++ b/bgpd/bgp_route.c
@@ -311,7 +311,7 @@ static int bgp_node_set_defer_flag(struct bgp_node *rn, bool delete)
        /* If the flag BGP_NODE_SELECT_DEFER is set and new path is added
         * then the route selection is deferred
         */
-       if (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER) && (delete == false))
+       if (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER) && (!delete))
                return 0;
 
        if (CHECK_FLAG(rn->flags, BGP_NODE_PROCESS_SCHEDULED)) {
@@ -359,7 +359,7 @@ static int bgp_node_set_defer_flag(struct bgp_node *rn, bool delete)
        /* Set the flag BGP_NODE_SELECT_DEFER if route selection deferral timer
         * is active
         */
-       if (set_flag) {
+       if (set_flag && table) {
                if (bgp && (bgp->gr_info[afi][safi].t_select_deferral)) {
                        SET_FLAG(rn->flags, BGP_NODE_SELECT_DEFER);
                        prefix2str(&rn->p, buf, PREFIX2STR_BUFFER);
@@ -2486,7 +2486,7 @@ static void bgp_process_main_one(struct bgp *bgp, struct bgp_node *rn,
         */
        if (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER)) {
                if (BGP_DEBUG(update, UPDATE_OUT))
-                       zlog_debug("DEFER set for route %p", rn);
+                       zlog_debug("SELECT_DEFER falg set for route %p", rn);
                return;
        }
 

diff --git a/bgpd/bgp_table.c b/bgpd/bgp_table.c
index 2ef272b5719e2b0341e28dfcb328da4cee000eea..4868686305632caed81dc54b9de0bf979a817ae6 100644 (file)
--- a/bgpd/bgp_table.c
+++ b/bgpd/bgp_table.c
@@ -146,7 +146,9 @@ void bgp_delete_listnode(struct bgp_node *node)
                        bgp = table->bgp;
                        afi = table->afi;
                        safi = table->safi;
-               }
+               } else
+                       return;
+
                rn = bgp_node_to_rnode(node);
 
                if (bgp && rn && rn->lock == 1) {

diff --git a/bgpd/bgp_vty.c b/bgpd/bgp_vty.c
index 8ea76432ef6e9f34e0d6daa498c0b2eb544e1e3d..eff5b3b7bca6635c5429b407e75281261fceb410 100644 (file)
--- a/bgpd/bgp_vty.c
+++ b/bgpd/bgp_vty.c
@@ -105,7 +105,7 @@ DEFINE_HOOK(bgp_inst_config_write,
                (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_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);
@@ -944,7 +944,7 @@ static int bgp_clear(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
 
                        if (CHECK_FLAG(peer->flags,
                                PEER_FLAG_GRACEFUL_RESTART))
-                               gr_router_detected = TRUE;
+                               gr_router_detected = true;
 
                        ret = bgp_peer_clear(peer, afi, safi, nnode, stype);
 
@@ -982,7 +982,7 @@ static int bgp_clear(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
 
                        if (CHECK_FLAG(peer->flags,
                                PEER_FLAG_GRACEFUL_RESTART))
-                               gr_router_detected = TRUE;
+                               gr_router_detected = true;
 
                        ret = bgp_peer_clear(peer, afi, safi, nnode, stype);
 
@@ -2182,16 +2182,16 @@ DEFUN (no_bgp_deterministic_med,
 
 /* "bgp graceful-restart mode" configuration. */
 DEFUN (bgp_graceful_restart,
-               bgp_graceful_restart_cmd,
-               "bgp graceful-restart",
-               "BGP specific commands\n"
-               GR_CMD
+       bgp_graceful_restart_cmd,
+       "bgp graceful-restart",
+       "BGP specific commands\n"
+       GR_CMD
       )
 {
        int ret = BGP_GR_FAILURE;
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
-               zlog_debug("BGP_GR:: bgp_graceful_restart_cmd : START ");
+               zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : START ");
 
        VTY_DECLVAR_CONTEXT(bgp, bgp);
 
@@ -2201,24 +2201,24 @@ DEFUN (bgp_graceful_restart,
                                bgp->peer, ret);
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
-               zlog_debug("BGP_GR:: bgp_graceful_restart_cmd : END ");
+               zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset all peers to take effect\n");
        return bgp_vty_return(vty, ret);
 }
 
 DEFUN (no_bgp_graceful_restart,
-               no_bgp_graceful_restart_cmd,
-               "no bgp graceful-restart",
-               NO_STR
-               "BGP specific commands\n"
-               NO_GR_CMD
+       no_bgp_graceful_restart_cmd,
+       "no bgp graceful-restart",
+       NO_STR
+       "BGP specific commands\n"
+       NO_GR_CMD
       )
 {
        VTY_DECLVAR_CONTEXT(bgp, bgp);
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
-               zlog_debug("BGP_GR:: no_bgp_graceful_restart_cmd : START ");
+               zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : START ");
 
        int ret = BGP_GR_FAILURE;
 
@@ -2228,7 +2228,7 @@ DEFUN (no_bgp_graceful_restart,
                        bgp->peer, ret);
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
-               zlog_debug("BGP_GR:: no_bgp_graceful_restart_cmd : END ");
+               zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset all peers to take effect\n");
 
@@ -2236,12 +2236,12 @@ DEFUN (no_bgp_graceful_restart,
 }
 
 DEFUN (bgp_graceful_restart_stalepath_time,
-               bgp_graceful_restart_stalepath_time_cmd,
-               "bgp graceful-restart stalepath-time (1-4095)",
-               "BGP specific commands\n"
-               "Graceful restart capability parameters\n"
-               "Set the max time to hold onto restarting peer's stale paths\n"
-               "Delay value (seconds)\n")
+       bgp_graceful_restart_stalepath_time_cmd,
+       "bgp graceful-restart stalepath-time (1-4095)",
+       "BGP specific commands\n"
+       "Graceful restart capability parameters\n"
+       "Set the max time to hold onto restarting peer's stale paths\n"
+       "Delay value (seconds)\n")
 {
        VTY_DECLVAR_CONTEXT(bgp, bgp);
        int idx_number = 3;
@@ -2253,12 +2253,12 @@ DEFUN (bgp_graceful_restart_stalepath_time,
 }
 
 DEFUN (bgp_graceful_restart_restart_time,
-               bgp_graceful_restart_restart_time_cmd,
-               "bgp graceful-restart restart-time (1-4095)",
-               "BGP specific commands\n"
-               "Graceful restart capability parameters\n"
-               "Set the time to wait to delete stale routes before a BGP open message is received\n"
-               "Delay value (seconds)\n")
+       bgp_graceful_restart_restart_time_cmd,
+       "bgp graceful-restart restart-time (1-4095)",
+       "BGP specific commands\n"
+       "Graceful restart capability parameters\n"
+       "Set the time to wait to delete stale routes before a BGP open message is received\n"
+       "Delay value (seconds)\n")
 {
        VTY_DECLVAR_CONTEXT(bgp, bgp);
        int idx_number = 3;
@@ -2292,13 +2292,13 @@ DEFUN (bgp_graceful_restart_select_defer_time,
 }
 
 DEFUN (no_bgp_graceful_restart_stalepath_time,
-               no_bgp_graceful_restart_stalepath_time_cmd,
-               "no bgp graceful-restart stalepath-time [(1-4095)]",
-               NO_STR
-               "BGP specific commands\n"
-               "Graceful restart capability parameters\n"
-               "Set the max time to hold onto restarting peer's stale paths\n"
-               "Delay value (seconds)\n")
+       no_bgp_graceful_restart_stalepath_time_cmd,
+       "no bgp graceful-restart stalepath-time [(1-4095)]",
+       NO_STR
+       "BGP specific commands\n"
+       "Graceful restart capability parameters\n"
+       "Set the max time to hold onto restarting peer's stale paths\n"
+       "Delay value (seconds)\n")
 {
        VTY_DECLVAR_CONTEXT(bgp, bgp);
 
@@ -2307,13 +2307,13 @@ DEFUN (no_bgp_graceful_restart_stalepath_time,
 }
 
 DEFUN (no_bgp_graceful_restart_restart_time,
-               no_bgp_graceful_restart_restart_time_cmd,
-               "no bgp graceful-restart restart-time [(1-4095)]",
-               NO_STR
-               "BGP specific commands\n"
-               "Graceful restart capability parameters\n"
-               "Set the time to wait to delete stale routes before a BGP open message is received\n"
-               "Delay value (seconds)\n")
+       no_bgp_graceful_restart_restart_time_cmd,
+       "no bgp graceful-restart restart-time [(1-4095)]",
+       NO_STR
+       "BGP specific commands\n"
+       "Graceful restart capability parameters\n"
+       "Set the time to wait to delete stale routes before a BGP open message is received\n"
+       "Delay value (seconds)\n")
 {
        VTY_DECLVAR_CONTEXT(bgp, bgp);
 
@@ -2339,11 +2339,11 @@ DEFUN (no_bgp_graceful_restart_select_defer_time,
 }
 
 DEFUN (bgp_graceful_restart_preserve_fw,
-               bgp_graceful_restart_preserve_fw_cmd,
-               "bgp graceful-restart preserve-fw-state",
-               "BGP specific commands\n"
-               "Graceful restart capability parameters\n"
-               "Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
+       bgp_graceful_restart_preserve_fw_cmd,
+       "bgp graceful-restart preserve-fw-state",
+       "BGP specific commands\n"
+       "Graceful restart capability parameters\n"
+       "Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
 {
        VTY_DECLVAR_CONTEXT(bgp, bgp);
        bgp_flag_set(bgp, BGP_FLAG_GR_PRESERVE_FWD);
@@ -2351,12 +2351,12 @@ DEFUN (bgp_graceful_restart_preserve_fw,
 }
 
 DEFUN (no_bgp_graceful_restart_preserve_fw,
-               no_bgp_graceful_restart_preserve_fw_cmd,
-               "no bgp graceful-restart preserve-fw-state",
-               NO_STR
-               "BGP specific commands\n"
-               "Graceful restart capability parameters\n"
-               "Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
+       no_bgp_graceful_restart_preserve_fw_cmd,
+       "no bgp graceful-restart preserve-fw-state",
+       NO_STR
+       "BGP specific commands\n"
+       "Graceful restart capability parameters\n"
+       "Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
 {
        VTY_DECLVAR_CONTEXT(bgp, bgp);
        bgp_flag_unset(bgp, BGP_FLAG_GR_PRESERVE_FWD);
@@ -2364,16 +2364,16 @@ DEFUN (no_bgp_graceful_restart_preserve_fw,
 }
 
 DEFUN (bgp_graceful_restart_disable,
-               bgp_graceful_restart_disable_cmd,
-               "bgp graceful-restart-disable",
-               "BGP specific commands\n"
-               GR_DISABLE)
+       bgp_graceful_restart_disable_cmd,
+       "bgp graceful-restart-disable",
+       "BGP specific commands\n"
+       GR_DISABLE)
 {
        int ret = BGP_GR_FAILURE;
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: bgp_graceful_restart_disable_cmd : START ");
+                       "[BGP_GR] bgp_graceful_restart_disable_cmd : START ");
 
        VTY_DECLVAR_CONTEXT(bgp, bgp);
 
@@ -2384,7 +2384,7 @@ DEFUN (bgp_graceful_restart_disable,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: bgp_graceful_restart_disable_cmd : END ");
+                       "[BGP_GR] bgp_graceful_restart_disable_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset all peers to take effect\n");
 
@@ -2392,18 +2392,18 @@ DEFUN (bgp_graceful_restart_disable,
 }
 
 DEFUN (no_bgp_graceful_restart_disable,
-               no_bgp_graceful_restart_disable_cmd,
-               "no bgp graceful-restart-disable",
-               NO_STR
-               "BGP specific commands\n"
-               NO_GR_DISABLE
+       no_bgp_graceful_restart_disable_cmd,
+       "no bgp graceful-restart-disable",
+       NO_STR
+       "BGP specific commands\n"
+       NO_GR_DISABLE
       )
 {
        VTY_DECLVAR_CONTEXT(bgp, bgp);
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: no_bgp_graceful_restart_disable_cmd : START ");
+                       "[BGP_GR] no_bgp_graceful_restart_disable_cmd : START ");
 
        int ret = BGP_GR_FAILURE;
 
@@ -2414,7 +2414,7 @@ DEFUN (no_bgp_graceful_restart_disable,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: no_bgp_graceful_restart_disable_cmd : END ");
+                       "[BGP_GR] no_bgp_graceful_restart_disable_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset all peers to take effect\n");
 
@@ -2422,11 +2422,11 @@ DEFUN (no_bgp_graceful_restart_disable,
 }
 
 DEFUN (bgp_neighbor_graceful_restart_set,
-               bgp_neighbor_graceful_restart_set_cmd,
-               "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
-               NEIGHBOR_STR
-               NEIGHBOR_ADDR_STR2
-               GR_NEIGHBOR_CMD
+       bgp_neighbor_graceful_restart_set_cmd,
+       "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
+       NEIGHBOR_STR
+       NEIGHBOR_ADDR_STR2
+       GR_NEIGHBOR_CMD
       )
 {
        int idx_peer = 1;
@@ -2437,7 +2437,7 @@ DEFUN (bgp_neighbor_graceful_restart_set,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: bgp_neighbor_graceful_restart_set_cmd : START ");
+                       "[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : START ");
 
        peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
        if (!peer)
@@ -2450,7 +2450,7 @@ DEFUN (bgp_neighbor_graceful_restart_set,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: bgp_neighbor_graceful_restart_set_cmd : END ");
+                       "[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset this peer to take effect\n");
 
@@ -2458,12 +2458,12 @@ DEFUN (bgp_neighbor_graceful_restart_set,
 }
 
 DEFUN (no_bgp_neighbor_graceful_restart,
-               no_bgp_neighbor_graceful_restart_set_cmd,
-               "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
-               NO_STR
-               NEIGHBOR_STR
-               NEIGHBOR_ADDR_STR2
-               NO_GR_NEIGHBOR_CMD
+       no_bgp_neighbor_graceful_restart_set_cmd,
+       "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
+       NO_STR
+       NEIGHBOR_STR
+       NEIGHBOR_ADDR_STR2
+       NO_GR_NEIGHBOR_CMD
       )
 {
        int idx_peer = 2;
@@ -2478,7 +2478,7 @@ DEFUN (no_bgp_neighbor_graceful_restart,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: no_bgp_neighbor_graceful_restart_set_cmd : START ");
+                       "[BGP_GR] no_bgp_neighbor_graceful_restart_set_cmd : START ");
 
        ret = bgp_neighbor_graceful_restart(peer, NO_PEER_GR_CMD);
 
@@ -2487,7 +2487,7 @@ DEFUN (no_bgp_neighbor_graceful_restart,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: no_bgp_neighbor_graceful_restart_set_cmd : END ");
+                       "[BGP_GR] no_bgp_neighbor_graceful_restart_set_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset this peer to take effect\n");
 
@@ -2495,11 +2495,11 @@ DEFUN (no_bgp_neighbor_graceful_restart,
 }
 
 DEFUN (bgp_neighbor_graceful_restart_helper_set,
-               bgp_neighbor_graceful_restart_helper_set_cmd,
-               "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
-               NEIGHBOR_STR
-               NEIGHBOR_ADDR_STR2
-               GR_NEIGHBOR_HELPER_CMD
+       bgp_neighbor_graceful_restart_helper_set_cmd,
+       "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
+       NEIGHBOR_STR
+       NEIGHBOR_ADDR_STR2
+       GR_NEIGHBOR_HELPER_CMD
       )
 {
        int idx_peer = 1;
@@ -2510,7 +2510,7 @@ DEFUN (bgp_neighbor_graceful_restart_helper_set,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: bgp_neighbor_graceful_restart_helper_set_cmd : START ");
+                       "[BGP_GR] bgp_neighbor_graceful_restart_helper_set_cmd : START ");
 
        peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
 
@@ -2525,7 +2525,7 @@ DEFUN (bgp_neighbor_graceful_restart_helper_set,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: bgp_neighbor_graceful_restart_helper_set_cmd : END ");
+                       "[BGP_GR] bgp_neighbor_graceful_restart_helper_set_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset this peer to take effect\n");
 
@@ -2533,12 +2533,12 @@ DEFUN (bgp_neighbor_graceful_restart_helper_set,
 }
 
 DEFUN (no_bgp_neighbor_graceful_restart_helper,
-               no_bgp_neighbor_graceful_restart_helper_set_cmd,
-               "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
-               NO_STR
-               NEIGHBOR_STR
-               NEIGHBOR_ADDR_STR2
-               NO_GR_NEIGHBOR_HELPER_CMD
+       no_bgp_neighbor_graceful_restart_helper_set_cmd,
+       "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
+       NO_STR
+       NEIGHBOR_STR
+       NEIGHBOR_ADDR_STR2
+       NO_GR_NEIGHBOR_HELPER_CMD
       )
 {
        int idx_peer = 2;
@@ -2553,7 +2553,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_helper,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: no_bgp_neighbor_graceful_restart_helper_set_cmd : START ");
+                       "[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : START ");
 
        ret = bgp_neighbor_graceful_restart(peer,
                        NO_PEER_HELPER_CMD);
@@ -2563,7 +2563,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_helper,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: no_bgp_neighbor_graceful_restart_helper_set_cmd : END ");
+                       "[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset this peer to take effect\n");
 
@@ -2571,11 +2571,11 @@ DEFUN (no_bgp_neighbor_graceful_restart_helper,
 }
 
 DEFUN (bgp_neighbor_graceful_restart_disable_set,
-               bgp_neighbor_graceful_restart_disable_set_cmd,
-               "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
-               NEIGHBOR_STR
-               NEIGHBOR_ADDR_STR2
-               GR_NEIGHBOR_DISABLE_CMD
+       bgp_neighbor_graceful_restart_disable_set_cmd,
+       "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
+       NEIGHBOR_STR
+       NEIGHBOR_ADDR_STR2
+       GR_NEIGHBOR_DISABLE_CMD
       )
 {
        int idx_peer = 1;
@@ -2586,14 +2586,14 @@ DEFUN (bgp_neighbor_graceful_restart_disable_set,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: bgp_neighbor_graceful_restart_disable_set_cmd : START ");
+                       "[BGP_GR] bgp_neighbor_graceful_restart_disable_set_cmd : START ");
 
        peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
        if (!peer)
                return CMD_WARNING_CONFIG_FAILED;
 
        ret = bgp_neighbor_graceful_restart(peer,
-                               PEER_DISABLE_cmd);
+                               PEER_DISABLE_CMD);
 
        if (peer->bgp->t_startup)
                bgp_peer_gr_flags_update(peer);
@@ -2603,7 +2603,7 @@ DEFUN (bgp_neighbor_graceful_restart_disable_set,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR::bgp_neighbor_graceful_restart_disable_set_cmd : END ");
+                       "[BGP_GR]bgp_neighbor_graceful_restart_disable_set_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset this peer to take effect\n");
 
@@ -2611,12 +2611,12 @@ DEFUN (bgp_neighbor_graceful_restart_disable_set,
 }
 
 DEFUN (no_bgp_neighbor_graceful_restart_disable,
-               no_bgp_neighbor_graceful_restart_disable_set_cmd,
-               "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
-               NO_STR
-               NEIGHBOR_STR
-               NEIGHBOR_ADDR_STR2
-               NO_GR_NEIGHBOR_DISABLE_CMD
+       no_bgp_neighbor_graceful_restart_disable_set_cmd,
+       "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
+       NO_STR
+       NEIGHBOR_STR
+       NEIGHBOR_ADDR_STR2
+       NO_GR_NEIGHBOR_DISABLE_CMD
       )
 {
        int idx_peer = 2;
@@ -2631,7 +2631,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_disable,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: no_bgp_neighbor_graceful_restart_disable_set_cmd : START ");
+                       "[BGP_GR] no_bgp_neighbor_graceful_restart_disable_set_cmd : START ");
 
        ret = bgp_neighbor_graceful_restart(peer, NO_PEER_DISABLE_CMD);
 
@@ -2640,7 +2640,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_disable,
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug(
-                       "BGP_GR:: no_bgp_neighbor_graceful_restart_disable_set_cmd : END ");
+                       "[BGP_GR] no_bgp_neighbor_graceful_restart_disable_set_cmd : END ");
        vty_out(vty,
                "Graceful restart configuration changed, reset this peer to take effect\n");
 
@@ -9507,19 +9507,16 @@ static void bgp_show_neighbor_graceful_restart_remote_mode(
                if ((peer->nsf_af_count == 0) &&
                        !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
 
-                       /*Gr disabled case*/
                        mode = "Disable";
 
                } else if (peer->nsf_af_count == 0 &&
                        CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
 
-                       /* Helper */
                        mode = "Helper";
 
                } else if (peer->nsf_af_count != 0 &&
                        CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
 
-                       /* Restart */
                        mode = "Restart";
 
                }
@@ -9548,7 +9545,7 @@ static void  bgp_show_neighbor_graceful_restart_local_mode(struct vty *vty,
                mode = "Restart";
        else if (bgp_peer_gr_mode_get(p) == PEER_DISABLE)
                mode = "Disable";
-       else if (bgp_peer_gr_mode_get(p) == PEER_GLOBAL_INHERIT)
+       else if (bgp_peer_gr_mode_get(p) == PEER_GLOBAL_INHERIT) {
                if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_HELPER)
                        mode = "Helper*";
                else if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_GR)
@@ -9557,8 +9554,7 @@ static void  bgp_show_neighbor_graceful_restart_local_mode(struct vty *vty,
                        mode = "Disable*";
                else
                        mode = "Invalid*";
-       else
-               mode = "Invalid";
+       }
 
        if (use_json) {
                json_object_string_add(json,
@@ -9572,8 +9568,8 @@ static void  bgp_show_neighbor_graceful_restart_capability_per_afi_safi(
                                        struct vty *vty, struct peer *peer,
                                        bool use_json, json_object *json)
 {
-       afi_t afi = AFI_MAX;
-       safi_t safi = SAFI_MAX;
+       afi_t afi;
+       safi_t safi;
        json_object *json_afi_safi = NULL;
        json_object *json_timer = NULL;
        json_object *json_endofrib_status = NULL;
@@ -9809,7 +9805,7 @@ static void  bgp_show_neighbor_graceful_restart_time(struct vty *vty,
                                        p->bgp->restart_time);
 
                json_object_int_add(json_timer,
-                                       "recivedRestartTimer",
+                                       "receivedRestartTimer",
                                        p->v_gr_restart);
 
                if (p->t_gr_restart != NULL) {
@@ -9848,7 +9844,6 @@ static void bgp_show_peer_gr_status(struct vty *vty, struct peer *p,
        char dn_flag[2] = {0};
        char neighborAddr[INET6_ADDRSTRLEN] = {0};
 
-       memset(dn_flag, '\0', sizeof(dn_flag));
        if (!p->conf_if && peer_dynamic_neighbor(p))
                dn_flag[0] = '*';
 
@@ -12197,7 +12192,7 @@ static int bgp_show_neighbor_graceful_restart(struct vty *vty,
                if (use_json)
                        json_neighbor = json_object_new_object();
 
-               if (show_all == type) {
+               if (type == show_all) {
                        bgp_show_peer_gr_status(vty, peer, use_json,
                                                        json_neighbor);
 
@@ -12205,7 +12200,7 @@ static int bgp_show_neighbor_graceful_restart(struct vty *vty,
                                json_object_object_add(json,
                                                peer->host, json_neighbor);
 
-               } else if (show_peer == type) {
+               } else if (type == show_peer) {
                        if (conf_if) {
                                if ((peer->conf_if
                                        && !strcmp(peer->conf_if, conf_if))
@@ -12554,7 +12549,6 @@ DEFUN (show_ip_bgp_neighbors_gracrful_restart,
        enum show_type sh_type;
        int idx = 0;
        afi_t afi = AFI_MAX;
-
        bool uj = use_json(argc, argv);
 
        if      (!argv_find_and_parse_afi(argv, argc, &idx, &afi))
@@ -12734,23 +12728,23 @@ static void bgp_show_global_graceful_restart_mode_vty(struct vty *vty,
 
        case GLOBAL_HELPER:
                vty_out(vty,
-                               "Global Bgp GR Mode :  Helper\n");
+                               "Global BGP GR Mode :  Helper\n");
                break;
 
        case GLOBAL_GR:
                vty_out(vty,
-                       "Global Bgp GR Mode :  Restart\n");
+                       "Global BGP GR Mode :  Restart\n");
                break;
 
        case GLOBAL_DISABLE:
                vty_out(vty,
-                               "Global Bgp GR Mode :  Disable\n");
+                               "Global BGP GR Mode :  Disable\n");
                break;
 
        case GLOBAL_INVALID:
        default:
                vty_out(vty,
-                       "Global Bgp GR Mode  Invalid\n");
+                       "Global BGP GR Mode  Invalid\n");
                break;
        }
        vty_out(vty, "\n");

diff --git a/bgpd/bgp_zebra.c b/bgpd/bgp_zebra.c
index 997cbc40369302bdc5c7c7c3edc61a23df3b1db2..03d5cd984fd6c3dddad93ab5cfa37fc5349e6712 100644 (file)
--- a/bgpd/bgp_zebra.c
+++ b/bgpd/bgp_zebra.c
@@ -3052,8 +3052,7 @@ int bgp_zebra_send_capabilities(struct bgp *bgp, bool disable)
 
        if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES,
                                      zclient, &api) < 0) {
-               if (BGP_DEBUG(zebra, ZEBRA))
-                       zlog_debug("error sending capability");
+               zlog_err("error sending capability");
                ret = BGP_GR_FAILURE;
        } else {
                if (disable)
@@ -3073,11 +3072,11 @@ int bgp_zebra_send_capabilities(struct bgp *bgp, bool disable)
  */
 int bgp_zebra_update(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type)
 {
-       struct zapi_cap api;
+       struct zapi_cap api = {0};
 
        if (zclient == NULL) {
                if (BGP_DEBUG(zebra, ZEBRA))
-                       zlog_debug("zclient invalid");
+                       zlog_debug("zclient == NULL, invalid");
                return BGP_GR_FAILURE;
        }
 
@@ -3088,7 +3087,6 @@ int bgp_zebra_update(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type)
                return BGP_GR_FAILURE;
        }
 
-       memset(&api, 0, sizeof(struct zapi_cap));
        api.afi = afi;
        api.safi = safi;
        api.vrf_id = vrf_id;
@@ -3141,9 +3139,6 @@ int zclient_capabilities_send(uint32_t cmd, struct zclient *zclient,
        return zclient_send_message(zclient);
 }
 
-
-
-
 /* Send RIB stale timer update */
 int bgp_zebra_stale_timer_update(struct bgp *bgp)
 {

diff --git a/bgpd/bgp_zebra.h b/bgpd/bgp_zebra.h
index bd5c3a1781803446ccf8e02975be78de59bec5b7..c0e305286ecfea96e006a485cb06e32d348dc045 100644 (file)
--- a/bgpd/bgp_zebra.h
+++ b/bgpd/bgp_zebra.h
@@ -85,7 +85,6 @@ struct bgp_pbr_match;
 struct bgp_pbr_rule;
 struct bgp_pbr_match_entry;
 
-
 extern void bgp_send_pbr_rule_action(struct bgp_pbr_action *pbra,
                                     struct bgp_pbr_rule *pbr,
                                     bool install);

diff --git a/bgpd/bgpd.c b/bgpd/bgpd.c
index de7a35a5a788f692433f372730f0e7ff75653c2e..d866ba7f5d28fd2942f8155bdf6dd19d71287a01 100644 (file)
--- a/bgpd/bgpd.c
+++ b/bgpd/bgpd.c
@@ -1109,7 +1109,7 @@ int bgp_global_gr_init(struct bgp *bgp)
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug("%s called ..", __func__);
 
-       int local_GLOBAL_GR_FSM[GLOBAL_MODE][EVENT_CMD] = {
+       int local_GLOBAL_GR_FSM[BGP_GLOBAL_GR_MODE][BGP_GLOBAL_GR_EVENT_CMD] = {
                /* GLOBAL_HELPER Mode  */
                {
                /*Event -> */
@@ -1157,12 +1157,13 @@ int bgp_peer_gr_init(struct peer *peer)
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
                zlog_debug("%s called ..", __func__);
 
-       struct bgp_peer_gr local_Peer_GR_FSM[PEER_MODE][PEER_EVENT_CMD] = {
+       struct bgp_peer_gr local_Peer_GR_FSM[BGP_PEER_GR_MODE]
+                                       [BGP_PEER_GR_EVENT_CMD] = {
        {
        /*      PEER_HELPER Mode        */
        /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
                { PEER_GR, bgp_peer_gr_action }, {PEER_INVALID, NULL },
-       /* Event-> */ /* PEER_DISABLE_cmd */ /* NO_PEER_DISABLE_CMD */
+       /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
                {PEER_DISABLE, bgp_peer_gr_action }, {PEER_INVALID, NULL },
        /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
                { PEER_INVALID, NULL }, {PEER_GLOBAL_INHERIT,
@@ -1173,7 +1174,7 @@ int bgp_peer_gr_init(struct peer *peer)
        /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
                { PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT,
                                                bgp_peer_gr_action },
-       /* Event-> */ /* PEER_DISABLE_cmd */ /* NO_PEER_DISABLE_CMD */
+       /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
                {PEER_DISABLE, bgp_peer_gr_action }, { PEER_INVALID, NULL },
        /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
                { PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL }
@@ -1182,7 +1183,7 @@ int bgp_peer_gr_init(struct peer *peer)
        /*      PEER_DISABLE Mode       */
        /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
                { PEER_GR, bgp_peer_gr_action }, { PEER_INVALID, NULL },
-       /* Event-> */ /* PEER_DISABLE_cmd */ /* NO_PEER_DISABLE_CMD */
+       /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
                { PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT,
                                                bgp_peer_gr_action },
        /* Event-> */ /* PEER_HELPER_cmd */  /* NO_PEER_HELPER_CMD */
@@ -1192,7 +1193,7 @@ int bgp_peer_gr_init(struct peer *peer)
        /*      PEER_INVALID Mode       */
        /* Event-> */ /* PEER_GR_CMD */  /* NO_PEER_GR_CMD */
                { PEER_INVALID, NULL }, { PEER_INVALID, NULL },
-       /* Event-> */ /* PEER_DISABLE_cmd */  /* NO_PEER_DISABLE_CMD */
+       /* Event-> */ /* PEER_DISABLE_CMD */  /* NO_PEER_DISABLE_CMD */
                { PEER_INVALID, NULL }, { PEER_INVALID, NULL },
        /* Event-> */ /* PEER_HELPER_cmd */  /* NO_PEER_HELPER_CMD */
                { PEER_INVALID, NULL }, { PEER_INVALID, NULL },
@@ -1201,7 +1202,7 @@ int bgp_peer_gr_init(struct peer *peer)
        /*      PEER_GLOBAL_INHERIT Mode        */
        /* Event-> */ /* PEER_GR_CMD */         /* NO_PEER_GR_CMD */
                { PEER_GR, bgp_peer_gr_action }, { PEER_INVALID, NULL },
-       /* Event-> */ /* PEER_DISABLE_cmd */     /* NO_PEER_DISABLE_CMD */
+       /* Event-> */ /* PEER_DISABLE_CMD */     /* NO_PEER_DISABLE_CMD */
                { PEER_DISABLE, bgp_peer_gr_action}, { PEER_INVALID, NULL },
        /* Event-> */ /* PEER_HELPER_cmd */     /* NO_PEER_HELPER_CMD */
                { PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL }
@@ -7253,7 +7254,7 @@ void bgp_gr_apply_running_config(void)
        bool gr_router_detected = false;
 
        if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
-               zlog_debug("BGP_GR:: %s called !",
+               zlog_debug("[BGP_GR] %s called !",
                                __func__);
 
        for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
@@ -7266,10 +7267,10 @@ void bgp_gr_apply_running_config(void)
 
                if (gr_router_detected &&
                        bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
-                       bgp_zebra_send_capabilities(bgp, false);
+                       bgp_zebra_send_capabilities(bgp, true);
                } else if (!gr_router_detected &&
                        bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
-                       bgp_zebra_send_capabilities(bgp, true);
+                       bgp_zebra_send_capabilities(bgp, false);
                }
 
                gr_router_detected = false;

diff --git a/bgpd/bgpd.h b/bgpd/bgpd.h
index 9529c8ebc56c1709b772f095179ad8e9fa9204eb..3f33139ef2389a1d4c7a47582f70c9278e4b3f96 100644 (file)
--- a/bgpd/bgpd.h
+++ b/bgpd/bgpd.h
@@ -246,8 +246,8 @@ enum bgp_instance_type {
 
 /* BGP GR Global ds */
 
-#define GLOBAL_MODE 4
-#define EVENT_CMD 4
+#define BGP_GLOBAL_GR_MODE 4
+#define BGP_GLOBAL_GR_EVENT_CMD 4
 
 /* Graceful restart selection deferral timer info */
 struct graceful_restart_info {
@@ -425,7 +425,8 @@ struct bgp {
 #define BGP_FLAG_SELECT_DEFER_DISABLE     (1 << 23)
 #define BGP_FLAG_GR_DISABLE_EOR           (1 << 24)
 
-       enum global_mode GLOBAL_GR_FSM[GLOBAL_MODE][EVENT_CMD];
+       enum global_mode GLOBAL_GR_FSM[BGP_GLOBAL_GR_MODE]
+                               [BGP_GLOBAL_GR_EVENT_CMD];
        enum global_mode global_gr_present_state;
 
        /* This variable stores the current Graceful Restart state of Zebra
@@ -618,12 +619,6 @@ struct bgp {
 #define BGP_VRF_RD_CFGD                     (1 << 3)
 #define BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY    (1 << 4)
 
-#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)))
-
        /* unique ID for auto derivation of RD for this vrf */
        uint16_t vrf_rd_id;
 
@@ -813,8 +808,8 @@ struct peer_af {
 };
 /* BGP GR per peer ds */
 
-#define PEER_MODE 5
-#define PEER_EVENT_CMD 6
+#define BGP_PEER_GR_MODE 5
+#define BGP_PEER_GR_EVENT_CMD 6
 
 enum peer_mode {
        PEER_HELPER = 0,
@@ -828,7 +823,7 @@ enum peer_mode {
 enum peer_gr_command {
        PEER_GR_CMD = 0,
        NO_PEER_GR_CMD,
-       PEER_DISABLE_cmd,
+       PEER_DISABLE_CMD,
        NO_PEER_DISABLE_CMD,
        PEER_HELPER_CMD,
        NO_PEER_HELPER_CMD
@@ -1073,7 +1068,7 @@ struct peer {
         *and PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT
         */
 
-       struct bgp_peer_gr PEER_GR_FSM[PEER_MODE][PEER_EVENT_CMD];
+       struct bgp_peer_gr PEER_GR_FSM[BGP_PEER_GR_MODE][BGP_PEER_GR_EVENT_CMD];
        enum peer_mode peer_gr_present_state;
        /* Non stop forwarding afi-safi count for BGP gr feature*/
        uint8_t nsf_af_count;

diff --git a/doc/user/bgp.rst b/doc/user/bgp.rst
index 7d8c7fabd9116090cc6b02753786934fbb4da93c..81b4e34647bbbd99fc95b52b7897e47223595abc 100644 (file)
--- a/doc/user/bgp.rst
+++ b/doc/user/bgp.rst
@@ -827,7 +827,7 @@ Default global mode is helper and default peer per mode is inherit from global.
 If per peer mode is configured, the GR mode of this particular peer will
 override the global mode.
 
-.. _bgp-GR-globla-mode-cmd:
+.. _bgp-GR-global-mode-cmd:
 
 BGP GR Global Mode Commands
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^

diff --git a/lib/zclient.c b/lib/zclient.c
index 150edc1276a1119adc72b22423386df0fb43224b..7ddf0085dee82257230518cbab5208d1fba7d12e 100644 (file)
--- a/lib/zclient.c
+++ b/lib/zclient.c
@@ -3324,6 +3324,7 @@ int zapi_capabilities_decode(struct stream *s, struct zapi_cap *api)
        default:
                        break;
        }
+
 stream_failure:
        return 0;
 }