Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1145 insertions, 0 deletions

diff --git a/epan/dissectors/packet-fcsb3.c b/epan/dissectors/packet-fcsb3.c
new file mode 100644
index 00000000..d520f4e7
--- /dev/null
+++ b/epan/dissectors/packet-fcsb3.c
@@ -0,0 +1,1145 @@
+/* packet-fc-sb3.c
+ * Routines for Fibre Channel Single Byte Protocol (SBCCS); used in FICON.
+ * This decoder is for FC-SB3 version 1.4
+ * Copyright 2003, Dinesh G Dutt <ddutt@cisco.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "config.h"
+
+#include <epan/packet.h>
+#include "packet-fc.h"
+#include "packet-fcsb3.h"
+
+void proto_register_fcsbccs(void);
+void proto_reg_handoff_fcsbccs(void);
+
+static dissector_handle_t fc_sbccs_handle;
+
+/* Initialize the protocol and registered fields */
+static int proto_fc_sbccs = -1;
+static int hf_sbccs_chid = -1;
+static int hf_sbccs_cuid = -1;
+static int hf_sbccs_devaddr = -1;
+static int hf_sbccs_ccw = -1;
+static int hf_sbccs_token = -1;
+static int hf_sbccs_dib_iucnt = -1;
+static int hf_sbccs_dib_datacnt = -1;
+static int hf_sbccs_dib_ccw_cmd = -1;
+static int hf_sbccs_dib_ccw_cnt = -1;
+static int hf_sbccs_dib_residualcnt = -1;
+static int hf_sbccs_dib_qtuf = -1;
+static int hf_sbccs_dib_qtu = -1;
+static int hf_sbccs_dib_dtuf = -1;
+static int hf_sbccs_dib_dtu = -1;
+static int hf_sbccs_dib_ctlfn = -1;
+static int hf_sbccs_lrc = -1;
+static int hf_sbccs_dib_iupacing = -1;
+static int hf_sbccs_dev_xcp_code = -1;
+static int hf_sbccs_prg_pth_errcode = -1;
+static int hf_sbccs_prg_rsp_errcode = -1;
+static int hf_sbccs_dib_ctccntr = -1;
+static int hf_sbccs_dib_lprcode = -1;
+static int hf_sbccs_dib_tin_imgid_cnt = -1;
+static int hf_sbccs_dib_lrjcode = -1;
+static int hf_sbccs_dib_ioprio = -1;
+static int hf_sbccs_dib_linkctlfn = -1;
+static int hf_sbccs_iui = -1;
+static int hf_sbccs_iui_as = -1;
+static int hf_sbccs_iui_es = -1;
+static int hf_sbccs_iui_val = -1;
+static int hf_sbccs_dhflags = -1;
+static int hf_sbccs_dhflags_end = -1;
+static int hf_sbccs_dhflags_chaining = -1;
+static int hf_sbccs_dhflags_earlyend = -1;
+static int hf_sbccs_dhflags_nocrc = -1;
+static int hf_sbccs_dib_ccw_flags = -1;
+static int hf_sbccs_dib_ccw_flags_cd = -1;
+static int hf_sbccs_dib_ccw_flags_cc = -1;
+static int hf_sbccs_dib_ccw_flags_sli = -1;
+static int hf_sbccs_dib_ccw_flags_crr = -1;
+static int hf_sbccs_dib_cmdflags = -1;
+static int hf_sbccs_dib_cmdflags_du = -1;
+static int hf_sbccs_dib_cmdflags_coc = -1;
+static int hf_sbccs_dib_cmdflags_syr = -1;
+static int hf_sbccs_dib_cmdflags_rex = -1;
+static int hf_sbccs_dib_cmdflags_sss = -1;
+static int hf_sbccs_dib_statusflags = -1;
+static int hf_sbccs_dib_statusflags_ffc = -1;
+static int hf_sbccs_dib_statusflags_ci = -1;
+static int hf_sbccs_dib_statusflags_cr = -1;
+static int hf_sbccs_dib_statusflags_lri = -1;
+static int hf_sbccs_dib_statusflags_rv = -1;
+static int hf_sbccs_dib_status = -1;
+static int hf_sbccs_dib_status_attention = -1;
+static int hf_sbccs_dib_status_modifier = -1;
+static int hf_sbccs_dib_status_cue = -1;
+static int hf_sbccs_dib_status_busy = -1;
+static int hf_sbccs_dib_status_channelend = -1;
+static int hf_sbccs_dib_status_deviceend = -1;
+static int hf_sbccs_dib_status_unit_check = -1;
+static int hf_sbccs_dib_status_unit_exception = -1;
+static int hf_sbccs_dib_ctlparam = -1;
+static int hf_sbccs_dib_ctlparam_rc = -1;
+static int hf_sbccs_dib_ctlparam_ru = -1;
+static int hf_sbccs_dib_ctlparam_ro = -1;
+static int hf_sbccs_dib_linkctlinfo = -1;
+static int hf_sbccs_dib_linkctlinfo_ctcconn = -1;
+static int hf_sbccs_dib_linkctlinfo_ecrcg = -1;
+static int hf_sbccs_logical_path = -1;
+
+/* Initialize the subtree pointers */
+static gint ett_fc_sbccs = -1;
+static gint ett_sbccs_iui = -1;
+static gint ett_sbccs_dhflags = -1;
+static gint ett_sbccs_dib_ccw_flags = -1;
+static gint ett_sbccs_dib_cmdflags = -1;
+static gint ett_sbccs_dib_statusflags = -1;
+static gint ett_sbccs_dib_status = -1;
+static gint ett_sbccs_dib_ctlparam = -1;
+static gint ett_sbccs_dib_linkctlinfo = -1;
+
+#if 0
+typedef struct {
+    guint32 conv_id;
+    guint32 task_id;
+} sb3_task_id_t;
+#endif
+
+static const value_string fc_sbccs_iu_val[] = {
+    {FC_SBCCS_IU_DATA,            "Data"},
+    {FC_SBCCS_IU_CMD_HDR,         "Command Header"},
+    {FC_SBCCS_IU_STATUS,          "Status"},
+    {FC_SBCCS_IU_CTL,             "Control"},
+    {FC_SBCCS_IU_CMD_DATA,        "Command Header & Data"},
+    {FC_SBCCS_IU_CMD_LINK_CTL,    "Link Control"},
+    {0x6,                         "Reserved"},
+    {0x7,                         "Reserved"},
+    {0x0,                         NULL},
+};
+
+static const value_string fc_sbccs_dib_cmd_val[] = {
+    { 0, "Reserved"},
+    { 1, "Write"},
+    { 2, "Read"},
+    { 3, "Control"},
+    { 4, "Sense"},
+    { 5, "Write (Modifier)"},
+    { 6, "Read (Modifier)"},
+    { 7, "Control (Modifier)"},
+    { 8, "Reserved"},
+    { 9, "Write (Modifier)"},
+    {10, "Read (Modifier)"},
+    {11, "Control (Modifier)"},
+    {12, "Read Backward"},
+    {13, "Write (Modifier)"},
+    {14, "Read (Modifier)"},
+    {15, "Control (Modifier)"},
+    {0, NULL},
+};
+
+static const value_string fc_sbccs_dib_ctl_fn_val[] = {
+    {FC_SBCCS_CTL_FN_CTL_END,   "Control End"},
+    {FC_SBCCS_CTL_FN_CMD_RSP,   "Command Response"},
+    {FC_SBCCS_CTL_FN_STK_STS,   "Stack Status"},
+    {FC_SBCCS_CTL_FN_CANCEL,    "Cancel"},
+    {FC_SBCCS_CTL_FN_SYS_RST,   "System Reset"},
+    {FC_SBCCS_CTL_FN_SEL_RST,   "Selective Reset"},
+    {FC_SBCCS_CTL_FN_REQ_STS,   "Request Status"},
+    {FC_SBCCS_CTL_FN_DEV_XCP,   "Device Level Exception"},
+    {FC_SBCCS_CTL_FN_STS_ACC,   "Status Accepted"},
+    {FC_SBCCS_CTL_FN_DEV_ACK,   "Device-Level Ack"},
+    {FC_SBCCS_CTL_FN_PRG_PTH,   "Purge Path"},
+    {FC_SBCCS_CTL_FN_PRG_RSP,   "Purge Path Response"},
+    {0, NULL},
+};
+
+static const value_string fc_sbccs_dib_dev_xcpcode_val[] = {
+    {1, "Address Exception"},
+    {0, NULL},
+};
+
+static const value_string fc_sbccs_dib_purge_path_err_val[] = {
+    { 0, "Error Code Xfer Not Supported"},
+    { 1, "SB-3 Protocol Timeout"},
+    { 2, "SB-3 Link Failure"},
+    { 3, "Reserved"},
+    { 4, "SB-3 Offline Condition"},
+    { 5, "FC-PH Link Failure"},
+    { 6, "SB-3 Length Error"},
+    { 7, "LRC Error"},
+    { 8, "SB-3 CRC Error"},
+    { 9, "IU Count Error"},
+    {10, "SB-3 Link Level Protocol Error"},
+    {11, "SB-3 Device Level Protocol Error"},
+    {12, "Receive ABTS"},
+    {13, "Cancel Function Timeout"},
+    {14, "Abnormal Termination of Xchg"},
+    {15, "Reserved"},
+    {0,  NULL},
+};
+
+static const value_string fc_sbccs_dib_purge_path_rsp_err_val[] = {
+    { 0, "No Errors"},
+    { 1, "SB-3 Protocol Timeout"},
+    { 2, "SB-3 Link Failure"},
+    { 3, "Logical Path Timeout Error"},
+    { 4, "SB-3 Offline Condition"},
+    { 5, "FC-PH Link Failure"},
+    { 6, "SB-3 Length Error"},
+    { 7, "LRC Error"},
+    { 8, "SB-3 CRC Error"},
+    { 9, "IU Count Error"},
+    {10, "SB-3 Link Level Protocol Error"},
+    {11, "SB-3 Device Level Protocol Error"},
+    {12, "Receive ABTS"},
+    {13, "Reserved"},
+    {14, "Abnormal Termination of Xchg"},
+    {15, "Logical Path Not Estd"},
+    {16, "Test Init Result Error"},
+    {0,  NULL},
+};
+
+static const value_string fc_sbccs_dib_link_ctl_fn_val[] = {
+    {FC_SBCCS_LINK_CTL_FN_ELP,  "ELP"},
+    {FC_SBCCS_LINK_CTL_FN_RLP,  "RLP"},
+    {FC_SBCCS_LINK_CTL_FN_TIN,  "TIN"},
+    {FC_SBCCS_LINK_CTL_FN_LPE,  "LPE"},
+    {FC_SBCCS_LINK_CTL_FN_LPR,  "LPR"},
+    {FC_SBCCS_LINK_CTL_FN_TIR,  "TIR"},
+    {FC_SBCCS_LINK_CTL_FN_LRJ,  "LRJ"},
+    {FC_SBCCS_LINK_CTL_FN_LBY,  "LBY"},
+    {FC_SBCCS_LINK_CTL_FN_LACK, "LACK"},
+    {0, NULL},
+};
+
+static const value_string fc_sbccs_dib_lpr_errcode_val[] = {
+    {0x0, "Response to RLP"},
+    {0x1, "Optional Features Conflict"},
+    {0x2, "Out of Resources"},
+    {0x3, "Device Init In Progress"},
+    {0x4, "No CU Image"},
+    {0x0, NULL},
+};
+
+static const value_string fc_sbccs_dib_lrj_errcode_val[] = {
+    {0x6, "Logical Path Not Estd"},
+    {0x9, "Protocol Error"},
+    {0x0, NULL},
+};
+
+static void
+dissect_iui_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags)
+{
+    static int * const iui_flags[] = {
+        &hf_sbccs_iui_as,
+        &hf_sbccs_iui_es,
+        &hf_sbccs_iui_val,
+        NULL
+    };
+
+    proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_iui,
+                                   ett_sbccs_iui, iui_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
+}
+
+static void
+dissect_linkctlinfo (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags)
+{
+    static int * const linkctlinfo_flags[] = {
+        &hf_sbccs_dib_linkctlinfo_ctcconn,
+        &hf_sbccs_dib_linkctlinfo_ecrcg,
+        NULL
+    };
+
+    proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_linkctlinfo,
+                                   ett_sbccs_dib_linkctlinfo, linkctlinfo_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
+}
+
+
+static void
+dissect_dh_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags)
+{
+    static int * const dh_flags[] = {
+        &hf_sbccs_dhflags_end,
+        &hf_sbccs_dhflags_chaining,
+        &hf_sbccs_dhflags_earlyend,
+        &hf_sbccs_dhflags_nocrc,
+        NULL
+    };
+
+    proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dhflags,
+                                   ett_sbccs_dhflags, dh_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
+}
+
+
+static void
+dissect_ccw_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags)
+{
+    static int * const ccw_flags[] = {
+        &hf_sbccs_dib_ccw_flags_cd,
+        &hf_sbccs_dib_ccw_flags_cc,
+        &hf_sbccs_dib_ccw_flags_sli,
+        &hf_sbccs_dib_ccw_flags_crr,
+        NULL
+    };
+
+    proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_ccw_flags,
+                                   ett_sbccs_dib_ccw_flags, ccw_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
+}
+
+
+static void
+dissect_cmd_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags)
+{
+    static int * const cmd_flags[] = {
+        &hf_sbccs_dib_cmdflags_du,
+        &hf_sbccs_dib_cmdflags_coc,
+        &hf_sbccs_dib_cmdflags_syr,
+        &hf_sbccs_dib_cmdflags_rex,
+        &hf_sbccs_dib_cmdflags_sss,
+        NULL
+    };
+
+    proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_cmdflags,
+                                   ett_sbccs_dib_cmdflags, cmd_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
+}
+
+static const value_string status_ffc_val[] = {
+    { 0, "" },
+    { 1, "FFC:Queuing Information Valid" },
+    { 2, "FFC:Resetting Event" },
+    { 0, NULL }
+};
+
+
+static void
+dissect_status_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags)
+{
+    static int * const status_flags[] = {
+        &hf_sbccs_dib_statusflags_ffc,
+        &hf_sbccs_dib_statusflags_ci,
+        &hf_sbccs_dib_statusflags_cr,
+        &hf_sbccs_dib_statusflags_lri,
+        &hf_sbccs_dib_statusflags_rv,
+        NULL
+    };
+
+    proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_statusflags,
+                                   ett_sbccs_dib_statusflags, status_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
+}
+
+
+static void
+dissect_status (packet_info *pinfo, proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags)
+{
+    static int * const status_flags[] = {
+        &hf_sbccs_dib_status_attention,
+        &hf_sbccs_dib_status_modifier,
+        &hf_sbccs_dib_status_cue,
+        &hf_sbccs_dib_status_busy,
+        &hf_sbccs_dib_status_channelend,
+        &hf_sbccs_dib_status_deviceend,
+        &hf_sbccs_dib_status_unit_check,
+        &hf_sbccs_dib_status_unit_exception,
+        NULL
+    };
+    proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_status,
+                                   ett_sbccs_dib_status, status_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
+
+    if (flags & 0x80) {
+        col_append_str(pinfo->cinfo, COL_INFO, "  Attention");
+    }
+
+    if (flags & 0x40) {
+        col_append_str(pinfo->cinfo, COL_INFO, "  Status Modifier");
+    }
+
+    if (flags & 0x20) {
+        col_append_str(pinfo->cinfo, COL_INFO, "  Control-Unit End");
+    }
+
+    if (flags & 0x10) {
+        col_append_str(pinfo->cinfo, COL_INFO, "  Busy");
+    }
+    if (flags & 0x08) {
+        col_append_str(pinfo->cinfo, COL_INFO, "  Channel End");
+    }
+
+    if (flags & 0x04) {
+        col_append_str(pinfo->cinfo, COL_INFO, "  Device End");
+    }
+
+    if (flags & 0x02) {
+        col_append_str(pinfo->cinfo, COL_INFO, "  Unit Check");
+    }
+
+    if (flags & 0x01) {
+        col_append_str(pinfo->cinfo, COL_INFO, "  Unit Exception");
+    }
+}
+
+
+static void
+dissect_sel_rst_param (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint32 flags)
+{
+    static int * const rst_param_flags[] = {
+        &hf_sbccs_dib_ctlparam_rc,
+        &hf_sbccs_dib_ctlparam_ru,
+        &hf_sbccs_dib_ctlparam_ro,
+        NULL
+    };
+
+    proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_ctlparam,
+                                   ett_sbccs_dib_ctlparam, rst_param_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
+}
+
+static void get_fc_sbccs_conv_data (tvbuff_t *tvb, guint offset,
+                                    guint16 *ch_cu_id, guint16 *dev_addr,
+                                    guint16 *ccw)
+{
+    *ch_cu_id  = *dev_addr = *ccw = 0;
+
+    *ch_cu_id  = (tvb_get_guint8 (tvb, offset+1)) << 8;
+    *ch_cu_id |= tvb_get_guint8 (tvb, offset+3);
+    *dev_addr  = tvb_get_ntohs (tvb, offset+4);
+    *ccw       = tvb_get_ntohs (tvb, offset+10);
+}
+
+/* Decode both the SB-3 and basic IU header */
+static void
+dissect_fc_sbccs_sb3_iu_hdr (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+                             guint offset)
+{
+    proto_tree *sb3hdr_tree;
+    proto_tree *iuhdr_tree;
+    guint8      iui, dhflags;
+    guint       type;
+
+    /* Decode the basic SB3 and IU header and determine type of frame */
+    type = get_fc_sbccs_iu_type (tvb, offset);
+
+    col_add_str (pinfo->cinfo, COL_INFO, val_to_str (type, fc_sbccs_iu_val,
+                                                         "0x%x"));
+
+    if (tree) {
+        /* Dissect SB3 header first */
+        sb3hdr_tree = proto_tree_add_subtree(tree, tvb, offset, FC_SBCCS_SB3_HDR_SIZE,
+                                     ett_fc_sbccs, NULL, "SB-3 Header");
+
+        proto_tree_add_item (sb3hdr_tree, hf_sbccs_chid, tvb, offset+1, 1, ENC_BIG_ENDIAN);
+        proto_tree_add_item (sb3hdr_tree, hf_sbccs_cuid, tvb, offset+3, 1, ENC_BIG_ENDIAN);
+        proto_tree_add_item (sb3hdr_tree, hf_sbccs_devaddr, tvb, offset+4, 2, ENC_BIG_ENDIAN);
+
+        /* Dissect IU Header */
+        iuhdr_tree = proto_tree_add_subtree(tree, tvb, offset + FC_SBCCS_SB3_HDR_SIZE,
+                                     FC_SBCCS_IU_HDR_SIZE, ett_fc_sbccs, NULL, "IU Header");
+        offset += FC_SBCCS_SB3_HDR_SIZE;
+
+        iui = tvb_get_guint8 (tvb, offset);
+        dissect_iui_flags(iuhdr_tree, tvb, offset, iui);
+
+        dhflags = tvb_get_guint8 (tvb, offset+1);
+        dissect_dh_flags(iuhdr_tree, tvb, offset+1, dhflags);
+
+        proto_tree_add_item (iuhdr_tree, hf_sbccs_ccw, tvb, offset+2, 2, ENC_BIG_ENDIAN);
+        proto_tree_add_item (iuhdr_tree, hf_sbccs_token, tvb, offset+5, 3, ENC_BIG_ENDIAN);
+    }
+}
+
+static void dissect_fc_sbccs_dib_data_hdr (tvbuff_t *tvb,
+                                           packet_info *pinfo _U_,
+                                           proto_tree *tree, guint offset)
+{
+    if (tree) {
+        proto_tree_add_item (tree, hf_sbccs_dib_iucnt, tvb, offset+9, 1, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_dib_datacnt, tvb, offset+10, 2, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_lrc, tvb, offset+12, 4, ENC_BIG_ENDIAN);
+    }
+}
+
+static void dissect_fc_sbccs_dib_cmd_hdr (tvbuff_t *tvb, packet_info *pinfo,
+                                          proto_tree *tree, guint offset)
+{
+    guint8 flags;
+
+    col_append_fstr (pinfo->cinfo, COL_INFO,
+                         ": %s", val_to_str (tvb_get_guint8 (tvb, offset),
+                                             fc_sbccs_dib_cmd_val,
+                                             "0x%x"));
+
+    if (tree) {
+        proto_tree_add_item (tree, hf_sbccs_dib_ccw_cmd, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+        flags = tvb_get_guint8 (tvb, offset+1);
+        dissect_ccw_flags(tree, tvb, offset+1, flags);
+
+        proto_tree_add_item (tree, hf_sbccs_dib_ccw_cnt, tvb, offset+2, 2, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_dib_ioprio, tvb, offset+5, 1, ENC_BIG_ENDIAN);
+
+        flags = tvb_get_guint8 (tvb, offset+7);
+        dissect_cmd_flags(tree, tvb, offset+7, flags);
+
+        proto_tree_add_item (tree, hf_sbccs_dib_iucnt, tvb, offset+9, 1, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_dib_datacnt, tvb, offset+10, 2, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_lrc, tvb, offset+12, 4, ENC_BIG_ENDIAN);
+
+    }
+}
+
+static void dissect_fc_sbccs_dib_status_hdr (tvbuff_t *tvb, packet_info *pinfo,
+                                             proto_tree *tree, guint offset)
+{
+    guint8    flags;
+    gboolean  rv_valid, qparam_valid;
+    tvbuff_t *next_tvb;
+    guint16   supp_status_cnt = 0;
+
+    if (tree) {
+        flags = tvb_get_guint8 (tvb, offset);
+        rv_valid = flags & 0x1; /* if residual count is valid */
+        qparam_valid = (((flags & 0xE0) >> 5) == 0x1); /* From the FFC field */
+        dissect_status_flags(tree, tvb, offset, flags);
+
+        flags = tvb_get_guint8 (tvb, offset+1);
+        dissect_status(pinfo, tree, tvb, offset+1, flags);
+
+        if (rv_valid) {
+            proto_tree_add_item (tree, hf_sbccs_dib_residualcnt, tvb, offset+2,
+                                 2, ENC_BIG_ENDIAN);
+        }
+        else {
+            proto_tree_add_item (tree, hf_sbccs_dib_iupacing, tvb, offset+3,
+                                 1, ENC_BIG_ENDIAN);
+        }
+
+        if (qparam_valid) {
+            proto_tree_add_item (tree, hf_sbccs_dib_qtuf, tvb, offset+4, 1, ENC_BIG_ENDIAN);
+            proto_tree_add_item (tree, hf_sbccs_dib_qtu, tvb, offset+4, 2, ENC_BIG_ENDIAN);
+        }
+
+        proto_tree_add_item (tree, hf_sbccs_dib_dtuf, tvb, offset+6, 1, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_dib_dtu, tvb, offset+6, 2, ENC_BIG_ENDIAN);
+
+        proto_tree_add_item (tree, hf_sbccs_dib_iucnt, tvb, offset+9, 1, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_dib_datacnt, tvb, offset+10, 2, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_lrc, tvb, offset+12, 4, ENC_BIG_ENDIAN);
+    }
+
+    supp_status_cnt = tvb_get_ntohs (tvb, offset+10);
+
+    if (supp_status_cnt) {
+        next_tvb = tvb_new_subset_remaining (tvb, offset+FC_SBCCS_DIB_LRC_HDR_SIZE);
+        call_data_dissector(next_tvb, pinfo, tree);
+    }
+}
+
+static void dissect_fc_sbccs_dib_ctl_hdr (tvbuff_t *tvb, packet_info *pinfo,
+                                          proto_tree *tree, guint offset)
+{
+    guint8 ctlfn;
+
+    ctlfn = tvb_get_guint8 (tvb, offset);
+    col_append_fstr (pinfo->cinfo, COL_INFO,
+                         ": %s",
+                         val_to_str (ctlfn,
+                                     fc_sbccs_dib_ctl_fn_val,
+                                     "0x%x"));
+
+    if (tree) {
+        proto_tree_add_item (tree, hf_sbccs_dib_ctlfn, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+        /* Control Function Parameter is to be interpreted in some cases */
+        switch (ctlfn) {
+        case FC_SBCCS_CTL_FN_SEL_RST:
+            dissect_sel_rst_param(tree, tvb, offset+1, tvb_get_ntoh24 (tvb, offset+1));
+            break;
+        case FC_SBCCS_CTL_FN_DEV_XCP:
+            proto_tree_add_item (tree, hf_sbccs_dev_xcp_code, tvb, offset+1,
+                                 1, ENC_BIG_ENDIAN);
+            break;
+        case FC_SBCCS_CTL_FN_PRG_PTH:
+            proto_tree_add_item (tree, hf_sbccs_prg_pth_errcode, tvb, offset+1,
+                                 1, ENC_BIG_ENDIAN);
+            break;
+        default:
+            proto_tree_add_item (tree, hf_sbccs_dib_ctlparam, tvb, offset+1,
+                                 3, ENC_BIG_ENDIAN);
+            break;
+        }
+
+        proto_tree_add_item (tree, hf_sbccs_dib_iucnt, tvb, offset+9, 1, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_dib_datacnt, tvb, offset+10, 2, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_lrc, tvb, offset+12, 4, ENC_BIG_ENDIAN);
+
+        if (ctlfn == FC_SBCCS_CTL_FN_PRG_RSP) {
+            /* Need to decode the LESBs */
+            proto_tree_add_item (tree, hf_sbccs_prg_rsp_errcode, tvb, offset+60,
+                                 1, ENC_BIG_ENDIAN);
+        }
+    }
+}
+
+static void dissect_fc_sbccs_dib_link_hdr (tvbuff_t *tvb, packet_info *pinfo,
+                                           proto_tree *tree, guint offset)
+{
+    guint8  link_ctl;
+    guint16 ctl_info;
+    guint   link_payload_len, i;
+
+    col_append_fstr (pinfo->cinfo, COL_INFO,
+                         ": %s",
+                         val_to_str (tvb_get_guint8 (tvb, offset+1),
+                                     fc_sbccs_dib_link_ctl_fn_val,
+                                     "0x%x"));
+
+    if (tree) {
+        link_ctl = tvb_get_guint8 (tvb, offset+1);
+        proto_tree_add_item (tree, hf_sbccs_dib_linkctlfn, tvb, offset+1, 1, ENC_BIG_ENDIAN);
+
+        ctl_info = tvb_get_ntohs (tvb, offset+2);
+        switch (link_ctl) {
+        case FC_SBCCS_LINK_CTL_FN_ELP:
+        case FC_SBCCS_LINK_CTL_FN_LPE:
+            dissect_linkctlinfo(tree, tvb, offset+2, ctl_info);
+            break;
+        case FC_SBCCS_LINK_CTL_FN_LPR:
+            proto_tree_add_item (tree, hf_sbccs_dib_lprcode, tvb, offset+2, 1,
+                                 ENC_BIG_ENDIAN);
+            break;
+        case FC_SBCCS_LINK_CTL_FN_TIN:
+            proto_tree_add_item (tree, hf_sbccs_dib_tin_imgid_cnt, tvb,
+                                 offset+3, 1, ENC_BIG_ENDIAN);
+            break;
+        case FC_SBCCS_LINK_CTL_FN_TIR:
+            proto_tree_add_item (tree, hf_sbccs_dib_tin_imgid_cnt, tvb,
+                                 offset+3, 1, ENC_BIG_ENDIAN);
+            break;
+        case FC_SBCCS_LINK_CTL_FN_LRJ:
+            proto_tree_add_item (tree, hf_sbccs_dib_lrjcode, tvb, offset+2,
+                                 1, ENC_BIG_ENDIAN);
+            break;
+        default:
+            /* Do Nothing */
+            break;
+        }
+
+        proto_tree_add_item (tree, hf_sbccs_dib_ctccntr, tvb, offset+4, 2, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_dib_iucnt, tvb, offset+9, 1, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_dib_datacnt, tvb, offset+10, 2, ENC_BIG_ENDIAN);
+        proto_tree_add_item (tree, hf_sbccs_lrc, tvb, offset+12, 4, ENC_BIG_ENDIAN);
+
+        if (link_ctl == FC_SBCCS_LINK_CTL_FN_TIR) {
+            link_payload_len = tvb_get_ntohs (tvb, offset+10);
+            i = 0;
+            offset += 16;
+
+            while (i < link_payload_len) {
+                proto_tree_add_bytes_format(tree, hf_sbccs_logical_path, tvb, offset, 4,
+                                     NULL, "Logical Paths %d-%d: %s",
+                                     i*8, ((i+4)*8) - 1,
+                                     tvb_bytes_to_str_punct(pinfo->pool, tvb, offset, 4, ':'));
+                i += 4;
+                offset += 4;
+            }
+        }
+    }
+}
+
+static int dissect_fc_sbccs (tvbuff_t *tvb, packet_info *pinfo,
+                              proto_tree *tree, void* data _U_)
+{
+    guint8          type;
+    guint16         ch_cu_id, dev_addr, ccw;
+    guint           offset   = 0;
+    proto_item     *ti;
+    proto_tree     *sb3_tree = NULL;
+    proto_tree     *dib_tree = NULL;
+    tvbuff_t       *next_tvb;
+    conversation_t *conversation;
+#if 0
+    sb3_task_id_t   task_key;
+#endif
+
+    /* Make entries in Protocol column and Info column on summary display */
+    col_set_str(pinfo->cinfo, COL_PROTOCOL, "FC-SB3");
+
+    /* Decode the basic SB3 and IU header and determine type of frame */
+    type = get_fc_sbccs_iu_type (tvb, offset);
+    get_fc_sbccs_conv_data (tvb, offset, &ch_cu_id, &dev_addr, &ccw);
+
+    col_add_str (pinfo->cinfo, COL_INFO, val_to_str (type, fc_sbccs_iu_val,
+                                                         "0x%x"));
+
+    /* Retrieve conversation state to determine expected payload */
+    conversation = find_conversation (pinfo->num, &pinfo->src, &pinfo->dst,
+                                      CONVERSATION_SBCCS, ch_cu_id, dev_addr, 0);
+
+    if (conversation) {
+#if 0
+        task_key.conv_id = conversation->index;
+        task_key.task_id = ccw;
+#endif
+    }
+    else if ((type == FC_SBCCS_IU_CMD_HDR) ||
+             (type != FC_SBCCS_IU_CMD_DATA)) {
+#if 0
+        conversation =
+#endif
+                       conversation_new (pinfo->num, &pinfo->src, &pinfo->dst,
+                                         CONVERSATION_SBCCS, ch_cu_id, dev_addr, 0);
+#if 0
+        task_key.conv_id = conversation->index;
+        task_key.task_id = ccw;
+#endif
+    }
+
+    if (tree) {
+        ti = proto_tree_add_protocol_format (tree, proto_fc_sbccs, tvb, 0, -1,
+                                             "FC-SB3");
+        sb3_tree = proto_item_add_subtree (ti, ett_fc_sbccs);
+
+        dissect_fc_sbccs_sb3_iu_hdr (tvb, pinfo, sb3_tree, offset);
+        offset += (FC_SBCCS_SB3_HDR_SIZE + FC_SBCCS_IU_HDR_SIZE);
+
+        dib_tree = proto_tree_add_subtree(sb3_tree, tvb, offset,
+                                  FC_SBCCS_DIB_LRC_HDR_SIZE, ett_fc_sbccs, NULL, "DIB Header");
+    }
+    else {
+        offset += (FC_SBCCS_SB3_HDR_SIZE + FC_SBCCS_IU_HDR_SIZE);
+    }
+
+    switch (type) {
+    case FC_SBCCS_IU_DATA:
+        dissect_fc_sbccs_dib_data_hdr (tvb, pinfo, dib_tree, offset);
+        break;
+    case FC_SBCCS_IU_CMD_HDR:
+    case FC_SBCCS_IU_CMD_DATA:
+        dissect_fc_sbccs_dib_cmd_hdr (tvb, pinfo, dib_tree, offset);
+        break;
+    case FC_SBCCS_IU_STATUS:
+        dissect_fc_sbccs_dib_status_hdr (tvb, pinfo, dib_tree, offset);
+        break;
+    case FC_SBCCS_IU_CTL:
+        dissect_fc_sbccs_dib_ctl_hdr (tvb, pinfo, dib_tree, offset);
+        break;
+    case FC_SBCCS_IU_CMD_LINK_CTL:
+        dissect_fc_sbccs_dib_link_hdr (tvb, pinfo, dib_tree, offset);
+        break;
+    default:
+        next_tvb = tvb_new_subset_remaining (tvb, offset);
+        call_data_dissector(next_tvb, pinfo, dib_tree);
+        break;
+    }
+
+    if ((get_fc_sbccs_iu_type (tvb, 0) != FC_SBCCS_IU_CTL) &&
+        (get_fc_sbccs_iu_type (tvb, 0) != FC_SBCCS_IU_CMD_LINK_CTL))  {
+        next_tvb = tvb_new_subset_remaining (tvb, offset+FC_SBCCS_DIB_LRC_HDR_SIZE);
+        call_data_dissector(next_tvb, pinfo, tree);
+    }
+    return tvb_captured_length(tvb);
+}
+
+/* Register the protocol with Wireshark */
+
+/* this format is required because a script is used to build the C function
+   that calls all the protocol registration.
+*/
+
+void
+proto_register_fcsbccs (void)
+{
+    /* Setup list of header fields  See Section 1.6.1 for details*/
+    static hf_register_info hf[] = {
+        { &hf_sbccs_chid,
+          { "Channel Image ID", "fcsb3.chid",
+            FT_UINT8, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_cuid,
+          { "Control Unit Image ID", "fcsb3.cuid",
+            FT_UINT8, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_devaddr,
+          { "Device Address", "fcsb3.devaddr",
+            FT_UINT16, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_iui,
+          { "Information Unit Identifier", "fcsb3.iui",
+            FT_UINT8, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dhflags,
+          { "DH Flags", "fcsb3.dhflags",
+            FT_UINT8, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_ccw,
+          { "CCW Number", "fcsb3.ccw",
+            FT_UINT16, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_token,
+          { "Token", "fcsb3.token",
+            FT_UINT24, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_iucnt,
+          { "DIB IU Count", "fcsb3.iucnt",
+            FT_UINT8, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_datacnt,
+          { "DIB Data Byte Count", "fcsb3.databytecnt",
+            FT_UINT16, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ccw_cmd,
+          { "CCW Command", "fcsb3.ccwcmd",
+            FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_cmd_val), 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ccw_cnt,
+          { "CCW Count", "fcsb3.ccwcnt",
+            FT_UINT16, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ioprio,
+          { "I/O Priority", "fcsb3.ioprio",
+            FT_UINT8, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status,
+          { "Status", "fcsb3.status",
+            FT_UINT8, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_residualcnt,
+          { "Residual Count", "fcsb3.residualcnt",
+            FT_UINT16, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_iupacing,
+          { "IU Pacing", "fcsb3.iupacing",
+            FT_UINT8, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_qtuf,
+          { "Queue-Time Unit Factor", "fcsb3.qtuf",
+            FT_UINT8, BASE_DEC, NULL, 0xF0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_qtu,
+          { "Queue-Time Unit", "fcsb3.qtu",
+            FT_UINT16, BASE_DEC, NULL, 0x0FFF,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_dtuf,
+          { "Defer-Time Unit Function", "fcsb3.dtuf",
+            FT_UINT8, BASE_DEC, NULL, 0xF0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_dtu,
+          { "Defer-Time Unit", "fcsb3.dtu",
+            FT_UINT16, BASE_DEC, NULL, 0x0FFF,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ctlfn,
+          { "Control Function", "fcsb3.ctlfn",
+            FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_ctl_fn_val), 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_linkctlfn,
+          { "Link Control Function", "fcsb3.linkctlfn",
+            FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_link_ctl_fn_val), 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ctccntr,
+          { "CTC Counter", "fcsb3.ctccntr",
+            FT_UINT16, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_lrc,
+          { "LRC", "fcsb3.lrc",
+            FT_UINT32, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dev_xcp_code,
+          { "Device Level Exception Code", "fcsb3.dip.xcpcode",
+            FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_dev_xcpcode_val), 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_prg_pth_errcode,
+          { "Purge Path Error Code", "fcsb3.purgepathcode",
+            FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_purge_path_err_val), 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_prg_rsp_errcode,
+          { "Purge Path Response Error Code", "fcsb3.purgepathrspcode",
+            FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_purge_path_rsp_err_val), 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_lprcode,
+          { "LPR Reason Code", "fcsb3.lprcode",
+            FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_lpr_errcode_val), 0xF,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_tin_imgid_cnt,
+          { "TIN Image ID", "fcsb3.tinimageidcnt",
+            FT_UINT8, BASE_DEC, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_lrjcode,
+          { "LRJ Reason Code", "fcsb3.lrjcode",
+            FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_lrj_errcode_val), 0x7F,
+            NULL, HFILL}},
+
+        { &hf_sbccs_iui_as,
+          { "AS", "fcsb3.iui.as",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x10,
+            NULL, HFILL}},
+
+        { &hf_sbccs_iui_es,
+          { "ES", "fcsb3.iui.es",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x08,
+            NULL, HFILL}},
+
+        { &hf_sbccs_iui_val,
+          { "Val", "fcsb3.iui.val",
+            FT_UINT8, BASE_HEX, VALS(fc_sbccs_iu_val), 0x07,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dhflags_end,
+          { "End", "fcsb3.dhflags.end",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x80,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dhflags_chaining,
+          { "Chaining", "fcsb3.dhflags.chaining",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x10,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dhflags_earlyend,
+          { "Early End", "fcsb3.dhflags.earlyend",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x08,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dhflags_nocrc,
+          { "No CRC", "fcsb3.dhflags.nocrc",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x04,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ccw_flags,
+          { "CCW Control Flags", "fcsb3.ccwflags",
+            FT_UINT8, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ccw_flags_cd,
+          { "CD", "fcsb3.ccwflags.cd",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x80,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ccw_flags_cc,
+          { "CC", "fcsb3.ccwflags.cc",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x40,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ccw_flags_sli,
+          { "SLI", "fcsb3.ccwflags.sli",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x20,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ccw_flags_crr,
+          { "CRR", "fcsb3.ccwflags.crr",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x08,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_cmdflags,
+          { "Command Flags", "fcsb3.cmdflags",
+            FT_UINT8, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_cmdflags_du,
+          { "DU", "fcsb3.cmdflags.du",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x10,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_cmdflags_coc,
+          { "COC", "fcsb3.cmdflags.coc",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x08,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_cmdflags_syr,
+          { "SYR", "fcsb3.cmdflags.syr",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x04,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_cmdflags_rex,
+          { "REX", "fcsb3.cmdflags.rex",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x02,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_cmdflags_sss,
+          { "SSS", "fcsb3.cmdflags.sss",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x01,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_statusflags,
+          { "Status Flags", "fcsb3.statusflags",
+            FT_UINT8, BASE_HEX, NULL, 0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_statusflags_ffc,
+          { "FFC", "fcsb3.statusflags.ffc",
+            FT_UINT8, BASE_HEX, VALS(status_ffc_val), 0xE0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_statusflags_ci,
+          { "CI", "fcsb3.statusflags.ci",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x10,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_statusflags_cr,
+          { "CR", "fcsb3.statusflags.cr",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x04,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_statusflags_lri,
+          { "LRI", "fcsb3.statusflags.lri",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x02,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_statusflags_rv,
+          { "RV", "fcsb3.statusflags.rv",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x01,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status_attention,
+          { "Attention", "fcsb3.status.attention",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x80,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status_modifier,
+          { "Status Modifier", "fcsb3.status.modifier",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x40,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status_cue,
+          { "Control-Unit End", "fcsb3.status.cue",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x20,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status_busy,
+          { "Busy", "fcsb3.status.busy",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x10,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status_channelend,
+          { "Channel End", "fcsb3.status.channel_end",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x08,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status_deviceend,
+          { "Device End", "fcsb3.status.device_end",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x04,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status_unit_check,
+          { "Unit Check", "fcsb3.status.unit_check",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x02,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_status_unit_exception,
+          { "Unit Exception", "fcsb3.status.unitexception",
+            FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x01,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ctlparam,
+          { "Control Parameters", "fcsb3.ctlparam",
+            FT_UINT24, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ctlparam_rc,
+          { "RC", "fcsb3.ctlparam.rc",
+            FT_BOOLEAN, 24, TFS(&tfs_set_notset), 0x000080,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ctlparam_ru,
+          { "RU", "fcsb3.ctlparam.ru",
+            FT_BOOLEAN, 24, TFS(&tfs_set_notset), 0x000010,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_ctlparam_ro,
+          { "RO", "fcsb3.ctlparam.ro",
+            FT_BOOLEAN, 24, TFS(&tfs_set_notset), 0x000008,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_linkctlinfo,
+          { "Link Control Information", "fcsb3.linkctlinfo",
+            FT_UINT16, BASE_HEX, NULL, 0x0,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_linkctlinfo_ctcconn,
+          { "CTC Conn", "fcsb3.linkctlinfo.ctc_conn",
+            FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0080,
+            NULL, HFILL}},
+
+        { &hf_sbccs_dib_linkctlinfo_ecrcg,
+          { "Enhanced CRC Generation", "fcsb3.linkctlinfo.ecrcg",
+            FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0001,
+            NULL, HFILL}},
+
+        { &hf_sbccs_logical_path,
+          { "Logical Path", "fcsb3.logical_path",
+            FT_BYTES, SEP_COLON, NULL, 0x0,
+            NULL, HFILL}},
+    };
+
+
+    /* Setup protocol subtree array */
+    static gint *ett[] = {
+        &ett_fc_sbccs,
+        &ett_sbccs_iui,
+        &ett_sbccs_dhflags,
+        &ett_sbccs_dib_ccw_flags,
+        &ett_sbccs_dib_cmdflags,
+        &ett_sbccs_dib_statusflags,
+        &ett_sbccs_dib_status,
+        &ett_sbccs_dib_ctlparam,
+        &ett_sbccs_dib_linkctlinfo,
+    };
+
+    /* Register the protocol name and description */
+    proto_fc_sbccs = proto_register_protocol ("Fibre Channel Single Byte Command",
+                                              "FC-SB3", "fcsb3");
+
+    proto_register_field_array(proto_fc_sbccs, hf, array_length(hf));
+    proto_register_subtree_array(ett, array_length(ett));
+
+    fc_sbccs_handle = register_dissector("fcsb3", dissect_fc_sbccs, proto_fc_sbccs);
+}
+
+void
+proto_reg_handoff_fcsbccs (void)
+{
+    dissector_add_uint("fc.ftype", FC_FTYPE_SBCCS, fc_sbccs_handle);
+}
+
+/*
+ * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */