summaryrefslogtreecommitdiffstats
path: root/isisd/isis_ldp_sync.c
diff options
context:
space:
mode:
Diffstat (limited to 'isisd/isis_ldp_sync.c')
-rw-r--r--isisd/isis_ldp_sync.c669
1 files changed, 669 insertions, 0 deletions
diff --git a/isisd/isis_ldp_sync.c b/isisd/isis_ldp_sync.c
new file mode 100644
index 0000000..3568543
--- /dev/null
+++ b/isisd/isis_ldp_sync.c
@@ -0,0 +1,669 @@
+/**
+ * isis_ldp_sync.c: ISIS LDP-IGP Sync handling routines
+ * Copyright (C) 2020 Volta Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+#include <string.h>
+
+#include "monotime.h"
+#include "memory.h"
+#include "thread.h"
+#include "prefix.h"
+#include "table.h"
+#include "vty.h"
+#include "command.h"
+#include "plist.h"
+#include "log.h"
+#include "zclient.h"
+#include <lib/json.h>
+#include "defaults.h"
+#include "ldp_sync.h"
+
+#include "isisd/isis_constants.h"
+#include "isisd/isis_common.h"
+#include "isisd/isis_flags.h"
+#include "isisd/isis_circuit.h"
+#include "isisd/isis_lsp.h"
+#include "isisd/isis_pdu.h"
+#include "isisd/isis_network.h"
+#include "isisd/isis_misc.h"
+#include "isisd/isis_constants.h"
+#include "isisd/isis_adjacency.h"
+#include "isisd/isis_dr.h"
+#include "isisd/isisd.h"
+#include "isisd/isis_csm.h"
+#include "isisd/isis_events.h"
+#include "isisd/isis_te.h"
+#include "isisd/isis_mt.h"
+#include "isisd/isis_errors.h"
+#include "isisd/isis_tx_queue.h"
+#include "isisd/isis_nb.h"
+#include "isisd/isis_ldp_sync.h"
+
+extern struct zclient *zclient;
+
+/*
+ * LDP-SYNC msg between IGP and LDP
+ */
+int isis_ldp_sync_state_update(struct ldp_igp_sync_if_state state)
+{
+ struct interface *ifp;
+ struct isis_circuit *circuit = NULL;
+ struct isis_area *area;
+
+ /* lookup circuit */
+ ifp = if_lookup_by_index(state.ifindex, VRF_DEFAULT);
+ if (ifp == NULL)
+ return 0;
+
+ circuit = ifp->info;
+ if (circuit == NULL)
+ return 0;
+
+ /* if isis is not enabled or LDP-SYNC is not configured ignore */
+ area = circuit->area;
+ if (area == NULL
+ || !CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE))
+ return 0;
+
+ /* received ldp-sync interface state from LDP */
+ ils_debug("%s: rcvd %s from LDP if %s", __func__,
+ state.sync_start ? "sync-start" : "sync-complete", ifp->name);
+ if (state.sync_start)
+ isis_ldp_sync_if_start(circuit, false);
+ else
+ isis_ldp_sync_if_complete(circuit);
+
+ return 0;
+}
+
+int isis_ldp_sync_announce_update(struct ldp_igp_sync_announce announce)
+{
+ struct isis_area *area;
+ struct listnode *anode, *cnode;
+ struct isis_circuit *circuit;
+ struct isis *isis = isis_lookup_by_vrfid(VRF_DEFAULT);
+
+ /* if isis is not enabled ignore */
+ if (!isis)
+ return 0;
+
+ if (announce.proto != ZEBRA_ROUTE_LDP)
+ return 0;
+
+ ils_debug("%s: rcvd announce from LDP", __func__);
+
+ /* LDP just started up:
+ * set cost to LSInfinity
+ * send request to LDP for LDP-SYNC state for each interface
+ */
+ for (ALL_LIST_ELEMENTS_RO(isis->area_list, anode, area)) {
+ if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE))
+ continue;
+
+ for (ALL_LIST_ELEMENTS_RO(area->circuit_list, cnode, circuit))
+ isis_ldp_sync_if_start(circuit, true);
+ }
+
+ return 0;
+}
+
+void isis_ldp_sync_state_req_msg(struct isis_circuit *circuit)
+{
+ struct ldp_igp_sync_if_state_req request;
+ struct interface *ifp = circuit->interface;
+
+ ils_debug("%s: send state request to LDP for %s", __func__, ifp->name);
+
+ memset(&request, 0, sizeof(request));
+ strlcpy(request.name, ifp->name, sizeof(ifp->name));
+ request.proto = LDP_IGP_SYNC_IF_STATE_REQUEST;
+ request.ifindex = ifp->ifindex;
+
+ zclient_send_opaque(zclient, LDP_IGP_SYNC_IF_STATE_REQUEST,
+ (uint8_t *)&request, sizeof(request));
+}
+
+/*
+ * LDP-SYNC general interface routines
+ */
+void isis_ldp_sync_if_start(struct isis_circuit *circuit,
+ bool send_state_req)
+{
+ struct ldp_sync_info *ldp_sync_info;
+
+ ldp_sync_info = circuit->ldp_sync_info;
+
+ /* Start LDP-SYNC on this interface:
+ * set cost of interface to LSInfinity so traffic will use different
+ * interface until LDP has learned all labels from peer
+ * start holddown timer if configured
+ * send msg to LDP to get LDP-SYNC state
+ */
+ if (ldp_sync_info &&
+ ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED &&
+ ldp_sync_info->state != LDP_IGP_SYNC_STATE_NOT_REQUIRED) {
+ ils_debug("%s: start on if %s state: %s", __func__,
+ circuit->interface->name, "Holding down until Sync");
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP;
+ isis_ldp_sync_set_if_metric(circuit, true);
+ isis_ldp_sync_holddown_timer_add(circuit);
+
+ if (send_state_req)
+ isis_ldp_sync_state_req_msg(circuit);
+ }
+}
+
+void isis_ldp_sync_if_complete(struct isis_circuit *circuit)
+{
+ struct ldp_sync_info *ldp_sync_info;
+
+ ldp_sync_info = circuit->ldp_sync_info;
+
+ /* received sync-complete from LDP:
+ * set state to up
+ * stop timer
+ * restore interface cost to original value
+ */
+ if (ldp_sync_info && ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED) {
+ if (ldp_sync_info->state == LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP)
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_UP;
+
+ THREAD_OFF(ldp_sync_info->t_holddown);
+
+ isis_ldp_sync_set_if_metric(circuit, true);
+ }
+}
+
+void isis_ldp_sync_ldp_fail(struct isis_circuit *circuit)
+{
+ struct ldp_sync_info *ldp_sync_info;
+
+ ldp_sync_info = circuit->ldp_sync_info;
+
+ /* LDP client close detected:
+ * stop holddown timer
+ * set cost of interface to LSInfinity so traffic will use different
+ * interface until LDP restarts and has learned all labels from peer
+ */
+ if (ldp_sync_info &&
+ ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED &&
+ ldp_sync_info->state != LDP_IGP_SYNC_STATE_NOT_REQUIRED) {
+ THREAD_OFF(ldp_sync_info->t_holddown);
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP;
+ isis_ldp_sync_set_if_metric(circuit, true);
+ }
+}
+
+static int isis_ldp_sync_adj_state_change(struct isis_adjacency *adj)
+{
+ struct isis_circuit *circuit = adj->circuit;
+ struct ldp_sync_info *ldp_sync_info = circuit->ldp_sync_info;
+ struct isis_area *area = circuit->area;
+
+ if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE)
+ || circuit->interface->vrf->vrf_id != VRF_DEFAULT
+ || if_is_loopback(circuit->interface))
+ return 0;
+
+ if (ldp_sync_info->enabled != LDP_IGP_SYNC_ENABLED)
+ return 0;
+
+ if (adj->adj_state == ISIS_ADJ_UP) {
+ if (circuit->circ_type == CIRCUIT_T_P2P ||
+ if_is_pointopoint(circuit->interface)) {
+ /* If LDP-SYNC is configure on interface then start */
+ ldp_sync_info->state =
+ LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP;
+ isis_ldp_sync_if_start(circuit, true);
+ } else {
+ /* non ptop link so don't run ldp-sync */
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
+ isis_ldp_sync_set_if_metric(circuit, true);
+ }
+ } else {
+ /* If LDP-SYNC is configure on this interface then stop it */
+ if (circuit->circ_type == CIRCUIT_T_P2P ||
+ if_is_pointopoint(circuit->interface))
+ ldp_sync_info->state =
+ LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP;
+ else
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
+
+ ils_debug("%s: down on if %s", __func__,
+ circuit->interface->name);
+ ldp_sync_if_down(circuit->ldp_sync_info);
+ }
+
+ return 0;
+}
+
+bool isis_ldp_sync_if_metric_config(struct isis_circuit *circuit, int level,
+ int metric)
+{
+ struct ldp_sync_info *ldp_sync_info = circuit->ldp_sync_info;
+ struct isis_area *area = circuit->area;
+
+ /* configured interface metric has been changed:
+ * if LDP-IGP Sync is running and metric has been set to LSInfinity
+ * change saved value so when ldp-sync completes proper metric is
+ * restored
+ */
+ if (area && CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE)
+ && ldp_sync_info != NULL) {
+
+ if (CHECK_FLAG(ldp_sync_info->flags,
+ LDP_SYNC_FLAG_SET_METRIC)) {
+ ldp_sync_info->metric[level-1] = metric;
+ ldp_sync_info->metric[level-1] = metric;
+ return false;
+ }
+ }
+ return true;
+}
+
+void isis_ldp_sync_set_if_metric(struct isis_circuit *circuit, bool run_regen)
+{
+ struct ldp_sync_info *ldp_sync_info;
+
+ /* set interface metric:
+ * if LDP-IGP Sync is starting set metric so interface
+ * is used only as last resort
+ * else restore metric to original value
+ */
+ if (circuit->ldp_sync_info == NULL || circuit->area == NULL)
+ return;
+
+ ldp_sync_info = circuit->ldp_sync_info;
+ if (ldp_sync_if_is_enabled(ldp_sync_info)) {
+ /* if metric already set to LSInfinity just return */
+ if (CHECK_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_SET_METRIC))
+ return;
+
+ SET_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_SET_METRIC);
+ if (circuit->is_type & IS_LEVEL_1) {
+ if (circuit->area->newmetric) {
+ ldp_sync_info->metric[0] =
+ circuit->te_metric[0];
+ circuit->te_metric[0] =
+ ISIS_WIDE_METRIC_INFINITY;
+ } else {
+ ldp_sync_info->metric[0] = circuit->metric[0];
+ circuit->metric[0] =
+ ISIS_NARROW_METRIC_INFINITY;
+ }
+ }
+ if (circuit->is_type & IS_LEVEL_2) {
+ if (circuit->area->newmetric) {
+ ldp_sync_info->metric[1] =
+ circuit->te_metric[1];
+ circuit->te_metric[1] =
+ ISIS_WIDE_METRIC_INFINITY;
+ } else {
+ ldp_sync_info->metric[1] = circuit->metric[1];
+ circuit->metric[1] =
+ ISIS_NARROW_METRIC_INFINITY;
+ }
+ }
+ } else {
+ /* if metric already restored just return */
+ if (!CHECK_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_SET_METRIC))
+ return;
+
+ UNSET_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_SET_METRIC);
+ if (circuit->is_type & IS_LEVEL_1) {
+ circuit->te_metric[0] = ldp_sync_info->metric[0];
+ circuit->metric[0] = ldp_sync_info->metric[0];
+ }
+ if (circuit->is_type & IS_LEVEL_2) {
+ circuit->te_metric[1] = ldp_sync_info->metric[1];
+ circuit->metric[1] = ldp_sync_info->metric[1];
+ }
+ }
+
+ if (run_regen)
+ lsp_regenerate_schedule(circuit->area, circuit->is_type, 0);
+}
+
+
+/*
+ * LDP-SYNC holddown timer routines
+ */
+static void isis_ldp_sync_holddown_timer(struct thread *thread)
+{
+ struct isis_circuit *circuit;
+ struct ldp_sync_info *ldp_sync_info;
+
+ /* holddown timer expired:
+ * didn't receive msg from LDP indicating sync-complete
+ * restore interface cost to original value
+ */
+ circuit = THREAD_ARG(thread);
+ if (circuit->ldp_sync_info == NULL)
+ return;
+
+ ldp_sync_info = circuit->ldp_sync_info;
+
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_UP;
+ ldp_sync_info->t_holddown = NULL;
+
+ ils_debug("%s: holddown timer expired for %s state:sync achieved",
+ __func__, circuit->interface->name);
+
+ isis_ldp_sync_set_if_metric(circuit, true);
+}
+
+void isis_ldp_sync_holddown_timer_add(struct isis_circuit *circuit)
+{
+ struct ldp_sync_info *ldp_sync_info;
+
+ ldp_sync_info = circuit->ldp_sync_info;
+
+ /* Start holddown timer:
+ * this timer is used to keep interface cost at LSInfinity
+ * once expires returns cost to original value
+ * if timer is already running or holddown time is off just return
+ */
+ if (ldp_sync_info->t_holddown ||
+ ldp_sync_info->holddown == LDP_IGP_SYNC_HOLDDOWN_DEFAULT)
+ return;
+
+ ils_debug("%s: start holddown timer for %s time %d", __func__,
+ circuit->interface->name, ldp_sync_info->holddown);
+
+ thread_add_timer(master, isis_ldp_sync_holddown_timer,
+ circuit, ldp_sync_info->holddown,
+ &ldp_sync_info->t_holddown);
+}
+
+/*
+ * LDP-SYNC handle client close routine
+ */
+void isis_ldp_sync_handle_client_close(struct zapi_client_close_info *info)
+{
+ struct isis_area *area;
+ struct listnode *anode, *cnode;
+ struct isis_circuit *circuit;
+ struct isis *isis = isis_lookup_by_vrfid(VRF_DEFAULT);
+
+ /* if isis is not enabled ignore */
+ if (!isis)
+ return;
+
+ /* Check if the LDP main client session closed */
+ if (info->proto != ZEBRA_ROUTE_LDP || info->session_id == 0)
+ return;
+
+ /* Handle the zebra notification that the LDP client session closed.
+ * set cost to LSInfinity
+ * send request to LDP for LDP-SYNC state for each interface
+ */
+ zlog_err("%s: LDP down", __func__);
+
+ for (ALL_LIST_ELEMENTS_RO(isis->area_list, anode, area)) {
+ if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE))
+ continue;
+
+ for (ALL_LIST_ELEMENTS_RO(area->circuit_list, cnode, circuit))
+ isis_ldp_sync_ldp_fail(circuit);
+ }
+}
+
+/*
+ * LDP-SYNC routes used by set commands.
+ */
+
+void isis_area_ldp_sync_enable(struct isis_area *area)
+{
+ struct isis_circuit *circuit;
+ struct listnode *node;
+
+ if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE)) {
+ SET_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE);
+
+ for (ALL_LIST_ELEMENTS_RO(area->circuit_list, node, circuit))
+ isis_if_ldp_sync_enable(circuit);
+ }
+}
+
+void isis_area_ldp_sync_disable(struct isis_area *area)
+{
+ struct isis_circuit *circuit;
+ struct listnode *node;
+
+ if (CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE)) {
+ for (ALL_LIST_ELEMENTS_RO(area->circuit_list, node, circuit))
+ isis_if_ldp_sync_disable(circuit);
+
+ UNSET_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE);
+
+ UNSET_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_HOLDDOWN);
+ area->ldp_sync_cmd.holddown = LDP_IGP_SYNC_HOLDDOWN_DEFAULT;
+ }
+}
+
+void isis_area_ldp_sync_set_holddown(struct isis_area *area, uint16_t holddown)
+{
+ struct isis_circuit *circuit;
+ struct listnode *node;
+
+ if (holddown == LDP_IGP_SYNC_HOLDDOWN_DEFAULT)
+ UNSET_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_HOLDDOWN);
+ else
+ SET_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_HOLDDOWN);
+
+ area->ldp_sync_cmd.holddown = holddown;
+
+ for (ALL_LIST_ELEMENTS_RO(area->circuit_list, node, circuit))
+ isis_if_set_ldp_sync_holddown(circuit);
+}
+
+void isis_if_ldp_sync_enable(struct isis_circuit *circuit)
+{
+ struct ldp_sync_info *ldp_sync_info = circuit->ldp_sync_info;
+ struct isis_area *area = circuit->area;
+
+ /* called when setting LDP-SYNC at the global level:
+ * specified on interface overrides global config
+ * if ptop link send msg to LDP indicating ldp-sync enabled
+ */
+ if (if_is_loopback(circuit->interface))
+ return;
+
+ if (circuit->interface->vrf->vrf_id != VRF_DEFAULT)
+ return;
+
+ ils_debug("%s: enable if %s", __func__, circuit->interface->name);
+
+ if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE))
+ return;
+
+ /* config on interface, overrides global config. */
+ if (CHECK_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_IF_CONFIG))
+ if (ldp_sync_info->enabled != LDP_IGP_SYNC_ENABLED)
+ return;
+
+ if (!CHECK_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_HOLDDOWN))
+ ldp_sync_info->holddown = area->ldp_sync_cmd.holddown;
+
+ if (circuit->circ_type == CIRCUIT_T_P2P
+ || if_is_pointopoint(circuit->interface)) {
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP;
+ isis_ldp_sync_state_req_msg(circuit);
+ } else {
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
+ ils_debug("%s: Sync only runs on P2P links %s", __func__,
+ circuit->interface->name);
+ }
+}
+
+void isis_if_ldp_sync_disable(struct isis_circuit *circuit)
+{
+ struct ldp_sync_info *ldp_sync_info = circuit->ldp_sync_info;
+ struct isis_area *area = circuit->area;
+
+ /* Stop LDP-SYNC on this interface:
+ * if holddown timer is running stop it
+ * delete ldp instance on interface
+ * restore metric
+ */
+ if (if_is_loopback(circuit->interface))
+ return;
+
+ ils_debug("%s: remove if %s", __func__, circuit->interface->name);
+
+ if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE))
+ return;
+
+ THREAD_OFF(ldp_sync_info->t_holddown);
+ ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
+ isis_ldp_sync_set_if_metric(circuit, true);
+}
+
+void isis_if_set_ldp_sync_holddown(struct isis_circuit *circuit)
+{
+ struct ldp_sync_info *ldp_sync_info = circuit->ldp_sync_info;
+ struct isis_area *area = circuit->area;
+
+ /* called when setting LDP-SYNC at the global level:
+ * specified on interface overrides global config.
+ */
+ if (if_is_loopback(circuit->interface))
+ return;
+
+ /* config on interface, overrides global config. */
+ if (CHECK_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_HOLDDOWN))
+ return;
+ if (CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_HOLDDOWN))
+ ldp_sync_info->holddown = area->ldp_sync_cmd.holddown;
+ else
+ ldp_sync_info->holddown = LDP_IGP_SYNC_HOLDDOWN_DEFAULT;
+}
+
+/*
+ * LDP-SYNC routines used by show commands.
+ */
+
+static void isis_circuit_ldp_sync_print_vty(struct isis_circuit *circuit,
+ struct vty *vty)
+{
+ struct ldp_sync_info *ldp_sync_info;
+ const char *ldp_state;
+
+ if (circuit->ldp_sync_info == NULL ||
+ if_is_loopback(circuit->interface))
+ return;
+
+ ldp_sync_info = circuit->ldp_sync_info;
+ vty_out(vty, "%-16s\n", circuit->interface->name);
+ if (circuit->state == C_STATE_CONF) {
+ vty_out(vty, " Interface down\n");
+ return;
+ }
+
+ vty_out(vty, " LDP-IGP Synchronization enabled: %s\n",
+ ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED
+ ? "yes"
+ : "no");
+ vty_out(vty, " holddown timer in seconds: %u\n",
+ ldp_sync_info->holddown);
+
+ switch (ldp_sync_info->state) {
+ case LDP_IGP_SYNC_STATE_REQUIRED_UP:
+ vty_out(vty, " State: Sync achieved\n");
+ break;
+ case LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP:
+ if (ldp_sync_info->t_holddown != NULL) {
+ struct timeval remain = thread_timer_remain(
+ ldp_sync_info->t_holddown);
+ vty_out(vty,
+ " Holddown timer is running %lld.%03lld remaining\n",
+ (long long)remain.tv_sec,
+ (long long)remain.tv_usec/1000);
+
+ vty_out(vty, " State: Holding down until Sync\n");
+ } else
+ vty_out(vty, " State: Sync not achieved\n");
+ break;
+ case LDP_IGP_SYNC_STATE_NOT_REQUIRED:
+ default:
+ if ((circuit->circ_type != CIRCUIT_T_P2P &&
+ !if_is_pointopoint(circuit->interface)) &&
+ circuit->circ_type != CIRCUIT_T_UNKNOWN)
+ ldp_state = "Sync not required: non-p2p link";
+ else
+ ldp_state = "Sync not required";
+ vty_out(vty, " State: %s\n", ldp_state);
+ break;
+ }
+}
+
+DEFUN (show_isis_mpls_ldp_interface,
+ show_isis_mpls_ldp_interface_cmd,
+ "show " PROTO_NAME " mpls ldp-sync [interface <INTERFACE|all>]",
+ SHOW_STR
+ PROTO_HELP
+ MPLS_STR
+ "LDP-IGP Sync information\n"
+ "Interface information\n"
+ "Interface name\n"
+ "All interfaces\n")
+{
+ char *ifname = NULL;
+ int idx_intf = 0;
+ struct listnode *anode, *cnode;
+ struct isis_area *area;
+ struct isis_circuit *circuit;
+ struct isis *isis = isis_lookup_by_vrfid(VRF_DEFAULT);
+ bool found = false;
+
+ if (!isis) {
+ vty_out(vty, "IS-IS Routing Process not enabled\n");
+ return CMD_SUCCESS;
+ }
+
+ if (argv_find(argv, argc, "INTERFACE", &idx_intf))
+ ifname = argv[idx_intf]->arg;
+
+ for (ALL_LIST_ELEMENTS_RO(isis->area_list, anode, area)) {
+ for (ALL_LIST_ELEMENTS_RO(area->circuit_list, cnode, circuit))
+ if (!ifname)
+ isis_circuit_ldp_sync_print_vty(circuit, vty);
+ else if (strcmp(circuit->interface->name, ifname)
+ == 0) {
+ isis_circuit_ldp_sync_print_vty(circuit, vty);
+ found = true;
+ }
+ }
+
+ if (found == false && ifname)
+ vty_out(vty, "%-16s\n ISIS not enabled\n", ifname);
+
+ return CMD_SUCCESS;
+}
+
+void isis_ldp_sync_init(void)
+{
+
+ /* "show ip isis mpls ldp interface" commands. */
+ install_element(VIEW_NODE, &show_isis_mpls_ldp_interface_cmd);
+
+ /* register for adjacency state changes */
+ hook_register(isis_adj_state_change_hook,
+ isis_ldp_sync_adj_state_change);
+}