/* packet-fc.c

 * Routines for Fibre Channel Decoding (FC Header, Link Ctl & Basic Link Svc)

 * Copyright 2001, Dinesh G Dutt <ddutt@cisco.com>

 *   Copyright 2003  Ronnie Sahlberg, exchange first/last matching and

 *                                    tap listener and misc updates

 *

 * 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 <epan/prefs.h>

#include <epan/tfs.h>

#include <wiretap/wtap.h>

#include <epan/reassemble.h>

#include <epan/conversation_table.h>

#include <epan/srt_table.h>

#include "packet-fc.h"

#include "packet-fclctl.h"

#include "packet-fcbls.h"

#include <epan/crc32-tvb.h>

#include <epan/expert.h>

void proto_register_fc(void);

void proto_reg_handoff_fc(void);

#define FC_HEADER_SIZE         24

#define FC_RCTL_VFT            0x50

#define MDSHDR_TRAILER_SIZE    6

/* Size of various fields in FC header in bytes */

#define FC_RCTL_SIZE           1

#define FC_DID_SIZE            3

#define FC_CSCTL_SIZE          1

#define FC_SID_SIZE            3

#define FC_TYPE_SIZE           1

#define FC_FCTL_SIZE           3

#define FC_SEQID_SIZE          1

#define FC_DFCTL_SIZE          1

#define FC_SEQCNT_SIZE         2

#define FC_OXID_SIZE           2

#define FC_RXID_SIZE           2

#define FC_PARAM_SIZE          4

/* Initialize the protocol and registered fields */

static int proto_fc;

static int hf_fc_time;

static int hf_fc_exchange_first_frame;

static int hf_fc_exchange_last_frame;

static int hf_fc_rctl;

static int hf_fc_did;

static int hf_fc_csctl;

static int hf_fc_sid;

static int hf_fc_id;

static int hf_fc_type;

static int hf_fc_fctl;

static int hf_fc_fctl_exchange_responder;

static int hf_fc_fctl_seq_recipient;

static int hf_fc_fctl_exchange_first;

static int hf_fc_fctl_exchange_last;

static int hf_fc_fctl_seq_last;

static int hf_fc_fctl_priority;

static int hf_fc_fctl_transfer_seq_initiative;

static int hf_fc_fctl_rexmitted_seq;

static int hf_fc_fctl_rel_offset;

static int hf_fc_fctl_abts_ack;

/* static int hf_fc_fctl_abts_not_ack; */

static int hf_fc_fctl_last_data_frame;

static int hf_fc_fctl_ack_0_1;

static int hf_fc_seqid;

static int hf_fc_dfctl;

static int hf_fc_seqcnt;

static int hf_fc_oxid;

static int hf_fc_rxid;

static int hf_fc_param;

static int hf_fc_ftype;    /* Derived field, non-existent in FC hdr */

static int hf_fc_reassembled;

static int hf_fc_relative_offset;

/* VFT fields */

static int hf_fc_vft;

static int hf_fc_vft_rctl;

static int hf_fc_vft_ver;

static int hf_fc_vft_type;

static int hf_fc_vft_pri;

static int hf_fc_vft_vf_id;

static int hf_fc_vft_hop_ct;

/* Network_Header fields */

static int hf_fc_nh_da;

static int hf_fc_nh_sa;

/* For Basic Link Svc */

static int hf_fc_bls_seqid_vld;

static int hf_fc_bls_lastvld_seqid;

static int hf_fc_bls_oxid;

static int hf_fc_bls_rxid;

static int hf_fc_bls_lowseqcnt;

static int hf_fc_bls_hiseqcnt;

static int hf_fc_bls_rjtcode;

static int hf_fc_bls_rjtdetail;

static int hf_fc_bls_vendor;

/* For FC SOF */

static int proto_fcsof;

static int hf_fcsof;

static int hf_fceof;

static int hf_fccrc;

static int hf_fccrc_status;

static int ett_fcsof;

static int ett_fceof;

static int ett_fccrc;

/* Initialize the subtree pointers */

static int ett_fc;

static int ett_fctl;

static int ett_fcbls;

static int ett_fc_vft;

static expert_field ei_fccrc;

static expert_field ei_short_hdr;

/* static expert_field ei_frag_size; */

static dissector_handle_t fc_handle, fcsof_handle;

static dissector_table_t fcftype_dissector_table;

static int fc_tap;

typedef struct _fc_conv_data_t {

    wmem_tree_t *exchanges;

    wmem_tree_t *luns;

} fc_conv_data_t;

/* Reassembly stuff */

static bool fc_reassemble = true;

static uint32_t fc_max_frame_size = 1024;

static reassembly_table fc_reassembly_table;

REASSEMBLE_ITEMS_DEFINE(fc, "Fibre Channel");

typedef struct _fcseq_conv_key {

    uint32_t conv_idx;

} fcseq_conv_key_t;

typedef struct _fcseq_conv_data {

    uint32_t seq_cnt;

} fcseq_conv_data_t;

static wmem_map_t *fcseq_req_hash;

/*

 * Hash Functions

 */

static int

fcseq_equal(const void *v, const void *w)

{

    const fcseq_conv_key_t *v1 = (const fcseq_conv_key_t *)v;

    const fcseq_conv_key_t *v2 = (const fcseq_conv_key_t *)w;

    return (v1->conv_idx == v2->conv_idx);

}

static unsigned

fcseq_hash (const void *v)

{

    const fcseq_conv_key_t *key = (const fcseq_conv_key_t *)v;

    unsigned val;

    val = key->conv_idx;

    return val;

}

static const char* fc_conv_get_filter_type(conv_item_t* conv, conv_filter_type_e filter)

{

    if ((filter == CONV_FT_SRC_ADDRESS) && (conv->src_address.type == AT_FC))

        return "fc.s_id";

    if ((filter == CONV_FT_DST_ADDRESS) && (conv->dst_address.type == AT_FC))

        return "fc.d_id";

    if ((filter == CONV_FT_ANY_ADDRESS) && (conv->src_address.type == AT_FC))

        return "fc.id";

    return CONV_FILTER_INVALID;

}

static ct_dissector_info_t fc_ct_dissector_info = {&fc_conv_get_filter_type};

static tap_packet_status

fc_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)

{

    conv_hash_t *hash = (conv_hash_t*) pct;

    hash->flags = flags;

    const fc_hdr *fchdr=(const fc_hdr *)vip;

    add_conversation_table_data(hash, &fchdr->s_id, &fchdr->d_id, 0, 0, 1, pinfo->fd->pkt_len, &pinfo->rel_ts, &pinfo->abs_ts, &fc_ct_dissector_info, CONVERSATION_NONE);

    return TAP_PACKET_REDRAW;

}

static const char* fc_endpoint_get_filter_type(endpoint_item_t* endpoint, conv_filter_type_e filter)

{

    if ((filter == CONV_FT_ANY_ADDRESS) && (endpoint->myaddress.type == AT_FC))

        return "fc.id";

    return CONV_FILTER_INVALID;

}

static et_dissector_info_t fc_endpoint_dissector_info = {&fc_endpoint_get_filter_type};

static tap_packet_status

fc_endpoint_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)

{

    conv_hash_t *hash = (conv_hash_t*) pit;

    hash->flags = flags;

    const fc_hdr *fchdr=(const fc_hdr *)vip;

    /* Take two "add" passes per packet, adding for each direction, ensures that all

    packets are counted properly (even if address is sending to itself)

    XXX - this could probably be done more efficiently inside endpoint_table */

    add_endpoint_table_data(hash, &fchdr->s_id, 0, true, 1, pinfo->fd->pkt_len, &fc_endpoint_dissector_info, ENDPOINT_NONE);

    add_endpoint_table_data(hash, &fchdr->d_id, 0, false, 1, pinfo->fd->pkt_len, &fc_endpoint_dissector_info, ENDPOINT_NONE);

    return TAP_PACKET_REDRAW;

}

#define FC_NUM_PROCEDURES     256

static void

fcstat_init(struct register_srt* srt _U_, GArray* srt_array)

{

    srt_stat_table *fc_srt_table;

    uint32_t i;

    fc_srt_table = init_srt_table("Fibre Channel Types", NULL, srt_array, FC_NUM_PROCEDURES, NULL, "fc.type", NULL);

    for (i = 0; i < FC_NUM_PROCEDURES; i++)

    {

        char* tmp_str = val_to_str(NULL, i, fc_fc4_val, "Unknown(0x%02x)");

        init_srt_table_row(fc_srt_table, i, tmp_str);

        wmem_free(NULL, tmp_str);

    }

}

static tap_packet_status

fcstat_packet(void *pss, packet_info *pinfo, epan_dissect_t *edt _U_, const void *prv, tap_flags_t flags _U_)

{

    unsigned i = 0;

    srt_stat_table *fc_srt_table;

    srt_data_t *data = (srt_data_t *)pss;

    const fc_hdr *fc=(const fc_hdr *)prv;

    /* we are only interested in reply packets */

    if(!(fc->fctl&FC_FCTL_EXCHANGE_RESPONDER)){

      return TAP_PACKET_DONT_REDRAW;

    }

    /* if we haven't seen the request, just ignore it */

    if ( (!fc->fc_ex) || (fc->fc_ex->first_exchange_frame==0) ){

      return TAP_PACKET_DONT_REDRAW;

    }

    fc_srt_table = g_array_index(data->srt_array, srt_stat_table*, i);

    add_srt_table_data(fc_srt_table, fc->type, &fc->fc_ex->fc_time, pinfo);

    return TAP_PACKET_REDRAW;

}

const value_string fc_fc4_val[] = {

    {FC_TYPE_BLS,        "Basic Link Svc"},

    {FC_TYPE_ELS,        "Ext Link Svc"},

    {FC_TYPE_LLCSNAP,    "LLC_SNAP"},

    {FC_TYPE_IP,         "IP/FC"},

    {FC_TYPE_SCSI,       "FCP"},

    {FC_TYPE_FCCT,       "FC_CT"},

    {FC_TYPE_SWILS,      "SW_ILS"},

    {FC_TYPE_AL,         "AL"},

    {FC_TYPE_SNMP,       "SNMP"},

    {FC_TYPE_SB_FROM_CU, "SB-3(CU->Channel)"},

    {FC_TYPE_SB_TO_CU,   "SB-3(Channel->CU)"},

    {0, NULL}

};

static const value_string fc_ftype_vals [] = {

    {FC_FTYPE_UNDEF ,    "Unknown frame"},

    {FC_FTYPE_SWILS,     "SW_ILS"},

    {FC_FTYPE_IP ,       "IP/FC"},

    {FC_FTYPE_SCSI ,     "FCP"},

    {FC_FTYPE_BLS ,      "Basic Link Svc"},

    {FC_FTYPE_ELS ,      "ELS"},

    {FC_FTYPE_FCCT ,     "FC_CT"},

    {FC_FTYPE_LINKDATA,  "Link Data"},

    {FC_FTYPE_VDO,       "Video Data"},

    {FC_FTYPE_LINKCTL,   "Link Ctl"},

    {FC_FTYPE_SBCCS,     "SBCCS"},

    {FC_FTYPE_OHMS,      "OHMS(Cisco MDS)"},

    {0, NULL}

};

static const value_string fc_wka_vals[] _U_ = {

    {FC_WKA_MULTICAST,    "Multicast Server"},

    {FC_WKA_CLKSYNC,      "Clock Sync Server"},

    {FC_WKA_KEYDIST,      "Key Distribution Server"},

    {FC_WKA_ALIAS,        "Alias Server"},

    {FC_WKA_QOSF,         "QoS Facilitator"},

    {FC_WKA_MGMT,         "Management Server"},

    {FC_WKA_TIME,         "Time Server"},

    {FC_WKA_DNS,          "Directory Server"},

    {FC_WKA_FABRIC_CTRLR, "Fabric Ctlr"},

    {FC_WKA_FPORT,        "F_Port Server"},

    {FC_WKA_BCAST,        "Broadcast ID"},

    {0, NULL}

};

static const value_string fc_routing_val[] = {

    {FC_RCTL_DEV_DATA,  "Device_Data"},

    {FC_RCTL_ELS,       "Extended Link Services"},

    {FC_RCTL_LINK_DATA, "FC-4 Link_Data"},

    {FC_RCTL_VIDEO,     "Video_Data"},

    {FC_RCTL_BLS,       "Basic Link Services"},

    {FC_RCTL_LINK_CTL,  "Link_Control Frame"},

    {0, NULL}

};

static const value_string fc_iu_val[] = {

    {FC_IU_UNCATEGORIZED   , "Uncategorized Data"},

    {FC_IU_SOLICITED_DATA  , "Solicited Data"},

    {FC_IU_UNSOLICITED_CTL , "Unsolicited Control"},

    {FC_IU_SOLICITED_CTL   , "Solicited Control"},

    {FC_IU_UNSOLICITED_DATA, "Solicited Data"},

    {FC_IU_DATA_DESCRIPTOR , "Data Descriptor"},

    {FC_IU_UNSOLICITED_CMD , "Unsolicited Command"},

    {FC_IU_CMD_STATUS      , "Command Status"},

    {0, NULL}

};

/* For FC SOF */

#define    FC_SOFC1  0xBCB51717

#define    FC_SOFI1  0xBCB55757

#define    FC_SOFN1  0xBCB53737

#define    FC_SOFI2  0xBCB55555

#define    FC_SOFN2  0xBCB53535

#define    FC_SOFI3  0xBCB55656

#define    FC_SOFN3  0xBCB53636

#define    FC_SOFC4  0xBCB51919

#define    FC_SOFI4  0xBCB55959

#define    FC_SOFN4  0xBCB53939

#define    FC_SOFF   0xBCB55858

#define    EOFT_NEG    0xBC957575

#define    EOFT_POS    0xBCB57575

#define    EOFDT_NEG   0xBC959595

#define    EOFDT_POS   0xBCB59595

#define    EOFA_NEG    0xBC95F5F5

#define    EOFA_POS    0xBCB5F5F5

#define    EOFN_NEG    0xBC95D5D5

#define    EOFN_POS    0xBCB5D5D5

#define    EOFNI_NEG   0xBC8AD5D5

#define    EOFNI_POS   0xBCAAD5D5

#define    EOFDTI_NEG  0xBC8A9595

#define    EOFDTI_POS  0xBCAA9595

#define    EOFRT_NEG   0xBC959999

#define    EOFRT_POS   0xBCB59999

#define    EOFRTI_NEG  0xBC8A9999

#define    EOFRTI_POS  0xBCAA9999

static const value_string fc_sof_vals[] = {

    {FC_SOFC1, "SOFc1 - SOF Connect Class 1 (Obsolete)" },

    {FC_SOFI1, "SOFi1 - SOF Initiate Class 1 (Obsolete)" },

    {FC_SOFN1, "SOFn1 - SOF Normal Class 1 (Obsolete)" },

    {FC_SOFI2, "SOFi2 - SOF Initiate Class 2" },

    {FC_SOFN2, "SOFn2 - SOF Normal Class 2" },

    {FC_SOFI3, "SOFi3 - SOF Initiate Class 3" },

    {FC_SOFN3, "SOFn3 - SOF Normal Class 3" },

    {FC_SOFC4, "SOFc4 - SOF Activate Class 4 (Obsolete)" },

    {FC_SOFI4, "SOFi4 - SOF Initiate Class 4 (Obsolete)" },

    {FC_SOFN4, "SOFn4 - SOF Normal Class 4 (Obsolete)" },

    {FC_SOFF,  "SOFf - SOF Fabric" },

    {0, NULL}

};

static const value_string fc_eof_vals[] = {

    {EOFT_NEG,   "EOFt- - EOF Terminate" },

    {EOFT_POS,   "EOFt+ - EOF Terminate" },

    {EOFDT_NEG,  "EOFdt- - EOF Disconnect-Terminate-Class 1 (Obsolete)" },

    {EOFDT_POS,  "EOFdt+ - EOF Disconnect-Terminate-Class 1 (Obsolete)" },

    {EOFA_NEG,   "EOFa- - EOF Abort" },

    {EOFA_POS,   "EOFa+ - EOF Abort" },

    {EOFN_NEG,   "EOFn- - EOF Normal" },

    {EOFN_POS,   "EOFn+ - EOF Normal" },

    {EOFNI_NEG,  "EOFni- - EOF Normal Invalid" },

    {EOFNI_POS,  "EOFni+ - EOF Normal Invalid" },

    {EOFDTI_NEG, "EOFdti- - EOF Disconnect-Terminate-Invalid Class 1 (Obsolete)" },

    {EOFDTI_POS, "EOFdti+ - EOF Disconnect-Terminate-Invalid Class 1 (Obsolete)" },

    {EOFRT_NEG,  "EOFrt- - EOF Remove-Terminate Class 4 (Obsolete)" },

    {EOFRT_POS,  "EOFrt+ - EOF Remove-Terminate Class 4 (Obsolete)" },

    {EOFRTI_NEG, "EOFrti- - EOF Remove-Terminate Invalid Class 4 (Obsolete)" },

    {EOFRTI_POS, "EOFrti+ - EOF Remove-Terminate Invalid Class 4 (Obsolete)" },

    {0, NULL}

};

/* BA_ACC & BA_RJT are decoded in this file itself instead of a traditional

 * dedicated file and dissector format because the dissector would require some

 * fields of the FC_HDR such as param in some cases, type in some others, the

 * lower 4 bits of r_ctl in some other cases etc. So, we decode BLS & Link Ctl

 * in this file itself.

 */

static void

dissect_fc_ba_acc (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)

{

    /* Set up structures needed to add the protocol subtree and manage it */

    proto_tree *acc_tree;

    int offset = 0;

    /* Make entries in Protocol column and Info column on summary display */

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "BLS");

    col_set_str(pinfo->cinfo, COL_INFO, "BA_ACC");

    if (tree) {

        acc_tree = proto_tree_add_subtree(tree, tvb, 0, -1, ett_fcbls, NULL, "Basic Link Svc");

        proto_tree_add_item (acc_tree, hf_fc_bls_seqid_vld, tvb, offset++, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item (acc_tree, hf_fc_bls_lastvld_seqid, tvb, offset++, 1, ENC_BIG_ENDIAN);

        offset += 2; /* Skip reserved field */

        proto_tree_add_item (acc_tree, hf_fc_bls_oxid, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item (acc_tree, hf_fc_bls_rxid, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item (acc_tree, hf_fc_bls_lowseqcnt, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item (acc_tree, hf_fc_bls_hiseqcnt, tvb, offset, 2, ENC_BIG_ENDIAN);

    }

}

static void

dissect_fc_ba_rjt (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)

{

    /* Set up structures needed to add the protocol subtree and manage it */

    proto_tree *rjt_tree;

    int offset = 0;

    /* Make entries in Protocol column and Info column on summary display */

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "BLS");

    col_set_str(pinfo->cinfo, COL_INFO, "BA_RJT");

    if (tree) {

        rjt_tree = proto_tree_add_subtree(tree, tvb, 0, -1, ett_fcbls, NULL, "Basic Link Svc");

        proto_tree_add_item (rjt_tree, hf_fc_bls_rjtcode, tvb, offset+1, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item (rjt_tree, hf_fc_bls_rjtdetail, tvb, offset+2, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item (rjt_tree, hf_fc_bls_vendor, tvb, offset+3, 1, ENC_BIG_ENDIAN);

    }

}

static uint8_t

fc_get_ftype (uint8_t r_ctl, uint8_t type)

{

    /* A simple attempt to determine the upper level protocol based on the

     * r_ctl & type fields.

     */

    switch (r_ctl & 0xF0) {

    case FC_RCTL_DEV_DATA:

        switch (type) {

        case FC_TYPE_SWILS:

            if ((r_ctl == 0x2) || (r_ctl == 0x3))

                return FC_FTYPE_SWILS;

            else

                return FC_FTYPE_UNDEF;

        case FC_TYPE_IP:

            return FC_FTYPE_IP;

        case FC_TYPE_SCSI:

            return FC_FTYPE_SCSI;

        case FC_TYPE_FCCT:

            return FC_FTYPE_FCCT;

        case FC_TYPE_SB_FROM_CU:

        case FC_TYPE_SB_TO_CU:

            return FC_FTYPE_SBCCS;

        case FC_TYPE_VENDOR:

             return FC_FTYPE_OHMS;

        default:

            return FC_FTYPE_UNDEF;

        }

    case FC_RCTL_ELS:

        if (((r_ctl & 0x0F) == 0x2) || ((r_ctl & 0x0F) == 0x3))

            return FC_FTYPE_ELS;

        else if (type == FC_TYPE_ELS)

            return FC_FTYPE_OHMS;

        else

             return FC_FTYPE_UNDEF;

    case FC_RCTL_LINK_DATA:

        switch (type) {

        case FC_TYPE_SCSI:

            return FC_FTYPE_SCSI;

        default:

            return FC_FTYPE_LINKDATA;

        }

    case FC_RCTL_VIDEO:

        return FC_FTYPE_VDO;

    case FC_RCTL_BLS:

        if (type == 0)

            return FC_FTYPE_BLS;

        else

            return FC_FTYPE_UNDEF;

    case FC_RCTL_LINK_CTL:

        return FC_FTYPE_LINKCTL;

    default:

        return FC_FTYPE_UNDEF;

    }

}

static const value_string abts_ack_vals[] = {

    {0,  "ABTS - Cont"},

    {1,  "ABTS - Abort"},

    {2,  "ABTS - Stop"},

    {3,  "ABTS - Imm Seq Retx"},

    {0,NULL}

};

#if 0

static const value_string abts_not_ack_vals[] = {

    {0x000000,  "ABTS - Abort/MS"},

    {0x000010,  "ABTS - Abort/SS"},

    {0x000020,  "ABTS - Process/IB"},

    {0x000030,  "ABTS - Discard/MS/Imm Retx"},

    {0,NULL}

};

#endif

static const value_string last_data_frame_vals[] = {

    {0,  "Last Data Frame - No Info"},

    {1,  "Last Data Frame - Seq Imm"},

    {2,  "Last Data Frame - Seq Soon"},

    {3,  "Last Data Frame - Seq Delyd"},

    {0,NULL}

};

static const value_string ack_0_1_vals[] = {

    {3,  "ACK_0 Required"},

    {2,  "ACK_0 Required"},

    {1,  "ACK_1 Required"},

    {0,  "no ack required"},

    {0,NULL}

};

static const true_false_string tfs_fc_fctl_exchange_responder = {

    "Exchange Responder",

    "Exchange Originator"

};

static const true_false_string tfs_fc_fctl_seq_recipient = {

    "Seq Recipient",

    "Seq Initiator"

};

static const true_false_string tfs_fc_fctl_exchange_first = {

    "Exchg First",

    "NOT exchg first"

};

static const true_false_string tfs_fc_fctl_exchange_last = {

    "Exchg Last",

    "NOT exchg last"

};

static const true_false_string tfs_fc_fctl_seq_last = {

    "Seq Last",

    "NOT seq last"

};

static const true_false_string tfs_fc_fctl_priority = {

    "Priority",

    "CS_CTL"

};

static const true_false_string tfs_fc_fctl_transfer_seq_initiative = {

    "Transfer Seq Initiative",

    "NOT transfer seq initiative"

};

static const true_false_string tfs_fc_fctl_rexmitted_seq = {

    "Retransmitted Sequence",

    "NOT retransmitted sequence"

};

static const true_false_string tfs_fc_fctl_rel_offset = {

    "Rel Offset SET",

    "Rel Offset NOT set"

};

/*

 * Dissect the VFT header.

 */

static void

dissect_fc_vft(proto_tree *parent_tree,

                tvbuff_t *tvb, int offset)

{

    proto_item *item;

    proto_tree *tree;

    uint8_t rctl;

    uint8_t ver;

    uint8_t type;

    uint8_t pri;

    uint16_t vf_id;

    uint8_t hop_ct;

    rctl = tvb_get_uint8(tvb, offset);

    type = tvb_get_uint8(tvb, offset + 1);

    ver = (type >> 6) & 3;

    type = (type >> 2) & 0xf;

    vf_id = tvb_get_ntohs(tvb, offset + 2);

    pri = (vf_id >> 13) & 7;

    vf_id = (vf_id >> 1) & 0xfff;

    hop_ct = tvb_get_uint8(tvb, offset + 4);

    item = proto_tree_add_uint_format_value(parent_tree, hf_fc_vft, tvb, offset,

            8, vf_id, "VF_ID %d Pri %d Hop Count %d",

            vf_id, pri, hop_ct);

    tree = proto_item_add_subtree(item, ett_fc_vft);

    proto_tree_add_uint(tree, hf_fc_vft_rctl, tvb, offset, 1, rctl);

    proto_tree_add_uint(tree, hf_fc_vft_ver, tvb, offset + 1, 1, ver);

    proto_tree_add_uint(tree, hf_fc_vft_type, tvb, offset + 1, 1, type);

    proto_tree_add_uint(tree, hf_fc_vft_pri, tvb, offset + 2, 1, pri);

    proto_tree_add_uint(tree, hf_fc_vft_vf_id, tvb, offset + 2, 2, vf_id);

    proto_tree_add_uint(tree, hf_fc_vft_hop_ct, tvb, offset + 4, 1, hop_ct);

}

/* code to dissect the  F_CTL bitmask */

static void

dissect_fc_fctl(packet_info *pinfo _U_, proto_tree *parent_tree, tvbuff_t *tvb, int offset)

{

    static int * const  flags[] = {

        &hf_fc_fctl_exchange_responder,

        &hf_fc_fctl_seq_recipient,

        &hf_fc_fctl_exchange_first,

        &hf_fc_fctl_exchange_last,

        &hf_fc_fctl_seq_last,

        &hf_fc_fctl_priority,

        &hf_fc_fctl_transfer_seq_initiative,

        &hf_fc_fctl_last_data_frame,

        &hf_fc_fctl_ack_0_1,

        &hf_fc_fctl_rexmitted_seq,

        &hf_fc_fctl_abts_ack,

        &hf_fc_fctl_rel_offset,

        NULL

    };

    proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hf_fc_fctl,

                                ett_fctl, flags, ENC_BIG_ENDIAN, BMT_NO_INT);

}

static const value_string fc_bls_proto_val[] = {

    {FC_BLS_NOP    , "NOP"},

    {FC_BLS_ABTS   , "ABTS"},

    {FC_BLS_RMC    , "RMC"},

    {FC_BLS_BAACC  , "BA_ACC"},

    {FC_BLS_BARJT  , "BA_RJT"},

    {FC_BLS_PRMT   , "PRMT"},

    {0, NULL}

};

static const value_string fc_els_proto_val[] = {

    {0x01    , "Solicited Data"},

    {0x02    , "Request"},

    {0x03    , "Reply"},

    {0, NULL}

};

/* Code to actually dissect the packets */

static void

dissect_fc_helper (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, bool is_ifcp, fc_data_t* fc_data)

{

   /* Set up structures needed to add the protocol subtree and manage it */

    proto_item *ti, *hidden_item;

    proto_tree *fc_tree;

    tvbuff_t *next_tvb;

    int offset = 0, next_offset;

    int vft_offset = -1;

    bool is_lastframe_inseq, is_1frame_inseq, is_exchg_resp = 0;

    fragment_head *fcfrag_head;

    uint32_t frag_id, frag_size;

    uint8_t df_ctl, seq_id;

    uint32_t f_ctl;

    address addr;

    uint32_t param, exchange_key;

    uint16_t real_seqcnt;

    uint8_t ftype;

    fc_hdr* fchdr = wmem_new(pinfo->pool, fc_hdr); /* Needed by conversations, not just tap */

    fc_exchange_t *fc_ex;

    fc_conv_data_t *fc_conv_data=NULL;

    conversation_t *conversation;

    fcseq_conv_data_t *cdata;

    fcseq_conv_key_t ckey, *req_key;

    /* Make entries in Protocol column and Info column on summary display */

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "FC");

    fchdr->r_ctl = tvb_get_uint8 (tvb, offset);

    fchdr->fc_ex = NULL;

    /*

     * If the frame contains a VFT (virtual fabric tag), decode it

     * as a separate header before the FC frame header.

     *

     * This used to be called the Cisco-proprietary EISL field, but is now

     * standardized in FC-FS-2.  See section 10.2.4.

     */

    if (fchdr->r_ctl == FC_RCTL_VFT) {

        vft_offset = offset;

        offset += 8;

        fchdr->r_ctl = tvb_get_uint8 (tvb, offset);

    }

    /* Each fc endpoint pair gets its own TCP session in iFCP but

     * the src/dst ids are undefined(==semi-random) in the FC header.

     * This means we can no track conversations for FC over iFCP by using

     * the FC src/dst addresses.

     * For iFCP: Do not update the pinfo src/dst struct and let it remain

     * being tcpip src/dst so that request/response matching in the FCP layer

     * will use ip addresses instead and still work.

     */

    if(!is_ifcp){

        set_address_tvb (&pinfo->dst, AT_FC, 3, tvb, offset+1);

        set_address_tvb (&pinfo->src, AT_FC, 3, tvb, offset+5);

        conversation_set_conv_addr_port_endpoints(pinfo, &pinfo->src, &pinfo->dst, CONVERSATION_EXCHG, 0, 0);

    } else {

        conversation_set_conv_addr_port_endpoints(pinfo, &pinfo->src, &pinfo->dst, CONVERSATION_EXCHG, pinfo->srcport, pinfo->destport);

    }

    set_address(&fchdr->d_id, pinfo->dst.type, pinfo->dst.len, pinfo->dst.data);

    set_address(&fchdr->s_id, pinfo->src.type, pinfo->src.len, pinfo->src.data);

    fchdr->cs_ctl = tvb_get_uint8 (tvb, offset+4);

    fchdr->type  = tvb_get_uint8 (tvb, offset+8);

    fchdr->fctl=tvb_get_ntoh24(tvb,offset+9);

    fchdr->seqcnt = tvb_get_ntohs (tvb, offset+14);

    fchdr->oxid=tvb_get_ntohs(tvb,offset+16);

    fchdr->rxid=tvb_get_ntohs(tvb,offset+18);

    fchdr->relative_offset=0;

    param = tvb_get_ntohl (tvb, offset+20);

    seq_id = tvb_get_uint8 (tvb, offset+12);

    /* set up a conversation and conversation data */

    /* TODO treat the fc address  s_id==00.00.00 as a wildcard matching anything */

    conversation=find_or_create_conversation(pinfo);

    fc_conv_data=(fc_conv_data_t *)conversation_get_proto_data(conversation, proto_fc);

    if(!fc_conv_data){

        fc_conv_data=wmem_new(wmem_file_scope(), fc_conv_data_t);

        fc_conv_data->exchanges=wmem_tree_new(wmem_file_scope());

        fc_conv_data->luns=wmem_tree_new(wmem_file_scope());

        conversation_add_proto_data(conversation, proto_fc, fc_conv_data);

    }

    /* Set up LUN data. OXID + LUN make up unique exchanges, but LUN is populated in subdissectors

       and not necessarily in every frame. Stub it here for now */

    fchdr->lun = 0xFFFF;

    if (pinfo->fd->visited) {

        fchdr->lun = (uint16_t)GPOINTER_TO_UINT(wmem_tree_lookup32(fc_conv_data->luns, fchdr->oxid));

    }

    /* In the interest of speed, if "tree" is NULL, don't do any work not

       necessary to generate protocol tree items. */

    ti = proto_tree_add_protocol_format (tree, proto_fc, tvb, offset, FC_HEADER_SIZE, "Fibre Channel");

    fc_tree = proto_item_add_subtree (ti, ett_fc);

    /*is_ack = ((fchdr->r_ctl == 0xC0) || (fchdr->r_ctl == 0xC1));*/

    /* There are two ways to determine if this is the first frame of a

     * sequence. Either:

     * (i) The SOF bits indicate that this is the first frame OR

     * (ii) This is an SOFf frame and seqcnt is 0.

     */

    is_1frame_inseq = (((fc_data->sof_eof & FC_DATA_SOF_FIRST_FRAME) == FC_DATA_SOF_FIRST_FRAME) ||

                       (((fc_data->sof_eof & FC_DATA_SOF_SOFF) == FC_DATA_SOF_SOFF) &&

                        (fchdr->seqcnt == 0)));

    is_lastframe_inseq = ((fc_data->sof_eof & FC_DATA_EOF_LAST_FRAME) == FC_DATA_EOF_LAST_FRAME);

    is_lastframe_inseq |= fchdr->fctl & FC_FCTL_SEQ_LAST;

    /*is_valid_frame = ((pinfo->sof_eof & 0x40) == 0x40);*/

    ftype = fc_get_ftype (fchdr->r_ctl, fchdr->type);

    col_add_str (pinfo->cinfo, COL_INFO, val_to_str(pinfo->pool, ftype, fc_ftype_vals,

                                                        "Unknown Type (0x%x)"));

    if (ftype == FC_FTYPE_LINKCTL)

        col_append_fstr (pinfo->cinfo, COL_INFO, ", %s",

                            val_to_str(pinfo->pool, (fchdr->r_ctl & 0x0F),

                                        fc_lctl_proto_val,

                                        "LCTL 0x%x"));

    if (vft_offset >= 0) {

        dissect_fc_vft(fc_tree, tvb, vft_offset);

    }

    switch (fchdr->r_ctl & 0xF0) {

    case FC_RCTL_DEV_DATA:

    case FC_RCTL_LINK_DATA:

    case FC_RCTL_VIDEO:

        /* the lower 4 bits of R_CTL are the information category */

        proto_tree_add_uint_format_value(fc_tree, hf_fc_rctl, tvb, offset,

                                    FC_RCTL_SIZE, fchdr->r_ctl,

                                    "0x%x(%s/%s)",

                                    fchdr->r_ctl,

                                    val_to_str(pinfo->pool, (fchdr->r_ctl & 0xF0),

                                                fc_routing_val, "0x%x"),

                                    val_to_str(pinfo->pool, (fchdr->r_ctl & 0x0F),

                                                fc_iu_val, "0x%x"));

        break;

    case FC_RCTL_LINK_CTL:

        /* the lower 4 bits of R_CTL indicate the type of link ctl frame */

        proto_tree_add_uint_format_value(fc_tree, hf_fc_rctl, tvb, offset,

                                    FC_RCTL_SIZE, fchdr->r_ctl,

                                    "0x%x(%s/%s)",

                                    fchdr->r_ctl,

                                    val_to_str(pinfo->pool, (fchdr->r_ctl & 0xF0),

                                                fc_routing_val, "0x%x"),

                                    val_to_str(pinfo->pool, (fchdr->r_ctl & 0x0F),

                                                fc_lctl_proto_val, "0x%x"));

        break;

    case FC_RCTL_BLS:

        switch (fchdr->type) {

        case 0x00:

            /* the lower 4 bits of R_CTL indicate the type of BLS frame */

            proto_tree_add_uint_format_value(fc_tree, hf_fc_rctl, tvb, offset,

                                        FC_RCTL_SIZE, fchdr->r_ctl,

                                        "0x%x(%s/%s)",

                                        fchdr->r_ctl,

                                        val_to_str(pinfo->pool, (fchdr->r_ctl & 0xF0),

                                                    fc_routing_val, "0x%x"),

                                        val_to_str(pinfo->pool, (fchdr->r_ctl & 0x0F),

                                                    fc_bls_proto_val, "0x%x"));

            break;

        default:

            proto_tree_add_uint_format_value(fc_tree, hf_fc_rctl, tvb, offset,

                                        FC_RCTL_SIZE, fchdr->r_ctl,

                                        "0x%x(%s/0x%x)",

                                        fchdr->r_ctl,

                                        val_to_str(pinfo->pool, (fchdr->r_ctl & 0xF0),

                                                    fc_routing_val, "0x%x"),

                                        fchdr->r_ctl & 0x0F);

            break;

        }

        break;

    case FC_RCTL_ELS:

        switch (fchdr->type) {

        case 0x01:

            /* the lower 4 bits of R_CTL indicate the type of ELS frame */

            proto_tree_add_uint_format_value(fc_tree, hf_fc_rctl, tvb, offset,

                                        FC_RCTL_SIZE, fchdr->r_ctl,

                                        "0x%x(%s/%s)",

                                        fchdr->r_ctl,

                                        val_to_str(pinfo->pool, (fchdr->r_ctl & 0xF0),

                                                    fc_routing_val, "0x%x"),

                                        val_to_str(pinfo->pool, (fchdr->r_ctl & 0x0F),

                                                    fc_els_proto_val, "0x%x"));

            break;

        default:

            proto_tree_add_uint_format_value(fc_tree, hf_fc_rctl, tvb, offset,

                                        FC_RCTL_SIZE, fchdr->r_ctl,

                                        "0x%x(%s/0x%x)",

                                        fchdr->r_ctl,

                                        val_to_str(pinfo->pool, (fchdr->r_ctl & 0xF0),

                                                    fc_routing_val, "0x%x"),

                                        fchdr->r_ctl & 0x0F);

            break;

        }

        break;

    default:

        proto_tree_add_uint_format_value(fc_tree, hf_fc_rctl, tvb, offset,

                                    FC_RCTL_SIZE, fchdr->r_ctl,

                                    "0x%x(%s/0x%x)",

                                    fchdr->r_ctl,

                                    val_to_str(pinfo->pool, (fchdr->r_ctl & 0xF0),

                                                fc_routing_val, "0x%x"),

                                    fchdr->r_ctl & 0x0F);

        break;

    }

    hidden_item = proto_tree_add_uint (fc_tree, hf_fc_ftype, tvb, offset, 1,

                                       ftype);

    proto_item_set_hidden(hidden_item);

    /* XXX - use "fc_wka_vals[]" on this? */

    set_address(&addr, AT_FC, 3, fchdr->d_id.data);

    proto_tree_add_item(fc_tree, hf_fc_did, tvb, offset+1, 3, ENC_NA);

    hidden_item = proto_tree_add_item (fc_tree, hf_fc_id, tvb, offset+1, 3, ENC_NA);

    proto_item_set_hidden(hidden_item);

    proto_tree_add_uint (fc_tree, hf_fc_csctl, tvb, offset+4, 1, fchdr->cs_ctl);

    /* XXX - use "fc_wka_vals[]" on this? */

    set_address(&addr, AT_FC, 3, fchdr->s_id.data);

    proto_tree_add_item(fc_tree, hf_fc_sid, tvb, offset+5, 3, ENC_NA);

    hidden_item = proto_tree_add_item (fc_tree, hf_fc_id, tvb, offset+5, 3, ENC_NA);

    proto_item_set_hidden(hidden_item);

    if (ftype == FC_FTYPE_LINKCTL) {

        if (((fchdr->r_ctl & 0x0F) == FC_LCTL_FBSYB) ||

            ((fchdr->r_ctl & 0x0F) == FC_LCTL_FBSYL)) {

            /* for F_BSY frames, the upper 4 bits of the type field specify the

             * reason for the BSY.

             */

            proto_tree_add_uint_format_value(fc_tree, hf_fc_type, tvb,

                                        offset+8, FC_TYPE_SIZE,

                                        fchdr->type,"0x%x(%s)", fchdr->type,

                                        fclctl_get_typestr (pinfo->pool, (uint8_t) (fchdr->r_ctl & 0x0F),

                                                            fchdr->type));

        } else {

            proto_tree_add_item (fc_tree, hf_fc_type, tvb, offset+8, 1, ENC_BIG_ENDIAN);

        }

    } else {

        proto_tree_add_item (fc_tree, hf_fc_type, tvb, offset+8, 1, ENC_BIG_ENDIAN);

    }

    dissect_fc_fctl(pinfo, fc_tree, tvb, offset+9);

    f_ctl = tvb_get_ntoh24(tvb, offset+9);

    proto_tree_add_item (fc_tree, hf_fc_seqid, tvb, offset+12, 1, ENC_BIG_ENDIAN);

    df_ctl = tvb_get_uint8(tvb, offset+13);

    proto_tree_add_uint (fc_tree, hf_fc_dfctl, tvb, offset+13, 1, df_ctl);

    proto_tree_add_uint (fc_tree, hf_fc_seqcnt, tvb, offset+14, 2, fchdr->seqcnt);

    proto_tree_add_uint (fc_tree, hf_fc_oxid, tvb, offset+16, 2, fchdr->oxid);

    proto_tree_add_uint (fc_tree, hf_fc_rxid, tvb, offset+18, 2, fchdr->rxid);

    if (ftype == FC_FTYPE_LINKCTL) {

        if (((fchdr->r_ctl & 0x0F) == FC_LCTL_FRJT) ||

            ((fchdr->r_ctl & 0x0F) == FC_LCTL_PRJT) ||

            ((fchdr->r_ctl & 0x0F) == FC_LCTL_PBSY)) {

            /* In all these cases of Link Ctl frame, the parameter field

             * encodes the detailed error message

             */

            proto_tree_add_uint_format_value(fc_tree, hf_fc_param, tvb,

                                        offset+20, 4, param,

                                        "0x%x(%s)", param,

                                        fclctl_get_paramstr (pinfo->pool, (fchdr->r_ctl & 0x0F),

                                                             param));

        } else {

            proto_tree_add_item (fc_tree, hf_fc_param, tvb, offset+20, 4, ENC_BIG_ENDIAN);

        }

    } else if (ftype == FC_FTYPE_BLS) {

        if ((fchdr->r_ctl & 0x0F) == FC_BLS_ABTS) {

            proto_tree_add_uint_format_value(fc_tree, hf_fc_param, tvb,

                                        offset+20, 4, param,

                                        "0x%x(%s)", param,

                                        ((param & 0x0F) == 1 ? "Abort Sequence" :

                                         "Abort Exchange"));

        } else {

            proto_tree_add_item (fc_tree, hf_fc_param, tvb, offset+20,

                                 4, ENC_BIG_ENDIAN);

        }

    } else if (ftype == FC_FTYPE_SCSI ) {

        if (f_ctl&FC_FCTL_REL_OFFSET){

            proto_tree_add_item (fc_tree, hf_fc_relative_offset, tvb, offset+20, 4, ENC_BIG_ENDIAN);

            fchdr->relative_offset=tvb_get_ntohl(tvb, offset+20);

        } else {

            proto_tree_add_item (fc_tree, hf_fc_param, tvb, offset+20, 4, ENC_BIG_ENDIAN);

        }

    } else {

        proto_tree_add_item (fc_tree, hf_fc_param, tvb, offset+20, 4, ENC_BIG_ENDIAN);

    }

    /* Skip the Frame_Header */

    next_offset = offset + FC_HEADER_SIZE;

    /* Network_Header present? */

    if (df_ctl & FC_DFCTL_NH) {

        proto_tree_add_item(fc_tree, hf_fc_nh_da, tvb, next_offset, 8, ENC_NA);

        proto_tree_add_item(fc_tree, hf_fc_nh_sa, tvb, next_offset+8, 8, ENC_NA);

        next_offset += 16;

    }

    /* XXX - handle Association_Header and Device_Header here */

    if (ftype == FC_FTYPE_LINKCTL) {

        /* ACK_1 frames and other LINK_CTL frames echo the last seq bit if the

         * packet they're ack'ing did not have it set. So, we'll incorrectly

         * flag them as being fragmented when they're not. This fixes the

         * problem

         */

        is_lastframe_inseq = true;

    } else {

        is_exchg_resp = (f_ctl & FC_FCTL_EXCHANGE_RESPONDER) != 0;

    }

    if (tvb_reported_length (tvb) < FC_HEADER_SIZE) {

        proto_tree_add_expert(fc_tree, pinfo, &ei_short_hdr,

                tvb, 0, tvb_reported_length(tvb));

        return;

    }

    frag_size = tvb_reported_length (tvb)-FC_HEADER_SIZE;

    /* If there is an MDS header, we need to subtract the MDS trailer size

     * Link Ctl, BLS & OHMS are all (encap header + FC Header + encap trailer)

     * and are never fragmented and so we ignore the frag_size assertion for

     *  these frames.

     */

    if (fc_data->ethertype == ETHERTYPE_FCFT) {

        if ((frag_size < MDSHDR_TRAILER_SIZE) ||

            ((frag_size == MDSHDR_TRAILER_SIZE) && (ftype != FC_FTYPE_LINKCTL) &&

             (ftype != FC_FTYPE_BLS) && (ftype != FC_FTYPE_OHMS))) {

            proto_tree_add_expert(fc_tree, pinfo, &ei_short_hdr,

                    tvb, FC_HEADER_SIZE, frag_size);

            return;

        }

        frag_size -= MDSHDR_TRAILER_SIZE;

    } else if (fc_data->ethertype == ETHERTYPE_BRDWALK) {

        if (frag_size <= 8) {

            proto_tree_add_expert(fc_tree, pinfo, &ei_short_hdr,

                    tvb, FC_HEADER_SIZE, frag_size);

            return;

        }

        frag_size -= 8;         /* 4 byte of FC CRC +

                                   4 bytes of error+EOF = 8 bytes  */

    }

    if (!is_lastframe_inseq) {

        /* Show this only as a fragmented FC frame */

        col_append_str (pinfo->cinfo, COL_INFO, " (Fragmented)");

    }

    /* If this is a fragment, attempt to check if fully reassembled frame is

     * present, if we're configured to reassemble.

     */

    if ((ftype != FC_FTYPE_LINKCTL) && (ftype != FC_FTYPE_BLS) &&

        (ftype != FC_FTYPE_OHMS) &&

        (!is_lastframe_inseq || !is_1frame_inseq) && fc_reassemble &&

        tvb_bytes_exist(tvb, FC_HEADER_SIZE, frag_size)) {

        /* Add this to the list of fragments */

        /* In certain cases such as FICON, the SEQ_CNT is streaming

         * i.e. continuously increasing. So, zero does not signify the

         * first frame of the sequence. To fix this, we need to save the