/* packet-fcswils.c

 * Routines for FC Inter-switch link services

 * Copyright 2001, 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 <epan/expert.h>

#include <epan/unit_strings.h>

#include "packet-fc.h"

#include "packet-fcswils.h"

#include "packet-fcct.h"

void proto_register_fcswils(void);

void proto_reg_handoff_fcswils(void);

static dissector_handle_t swils_handle;

/*

 * See the FC-SW specifications.

 */

#define FC_SWILS_RPLY               0x0

#define FC_SWILS_REQ                0x1

#define FC_SWILS_RSCN_DEVENTRY_SIZE 20

/* Zone name has the structure:

 * name_len (1 byte), rsvd (3 bytes), name (m bytes), fill (n bytes)

 * name_len excludes the 4 initial bytes before the name

 */

#define ZONENAME_LEN(x, y)  (tvb_get_uint8(x, y)+4)

/* Initialize the protocol and registered fields */

static int proto_fcswils;

static int hf_swils_opcode;

static int hf_swils_elp_rev;

static int hf_swils_elp_flags;

static int hf_swils_elp_r_a_tov;

static int hf_swils_elp_e_d_tov;

static int hf_swils_elp_req_epn;

static int hf_swils_elp_req_esn;

static int hf_swils_elp_clsf_svcp;

static int hf_swils_elp_clsf_rcvsz;

static int hf_swils_elp_clsf_conseq;

static int hf_swils_elp_clsf_e2e;

static int hf_swils_elp_clsf_openseq;

static int hf_swils_elp_cls1_svcp;

static int hf_swils_elp_cls1_rcvsz;

static int hf_swils_elp_cls2_svcp;

static int hf_swils_elp_cls2_rcvsz;

static int hf_swils_elp_cls3_svcp;

static int hf_swils_elp_cls3_rcvsz;

static int hf_swils_elp_isl_fc_mode;

static int hf_swils_elp_fcplen;

static int hf_swils_elp_b2bcredit;

static int hf_swils_elp_compat1;

static int hf_swils_elp_compat2;

static int hf_swils_elp_compat3;

static int hf_swils_elp_compat4;

static int hf_swils_efp_rec_type;

static int hf_swils_efp_dom_id;

static int hf_swils_efp_switch_name;

static int hf_swils_efp_mcast_grpno;

/* static int hf_swils_efp_alias_token; */

static int hf_swils_efp_record_len;

static int hf_swils_efp_payload_len;

static int hf_swils_efp_pswitch_pri;

static int hf_swils_efp_pswitch_name;

static int hf_swils_dia_switch_name;

static int hf_swils_rdi_payload_len;

static int hf_swils_rdi_req_sname;

/* static int hf_swils_fspfh_cmd; */

static int hf_swils_fspfh_rev;

static int hf_swils_fspfh_ar_num;

static int hf_swils_fspfh_auth_type;

static int hf_swils_fspfh_dom_id;

static int hf_swils_fspfh_auth;

static int hf_swils_hlo_options;

static int hf_swils_hlo_hloint;

static int hf_swils_hlo_deadint;

static int hf_swils_hlo_rcv_domid;

static int hf_swils_hlo_orig_pidx;

static int hf_swils_ldrec_linkid;

static int hf_swils_ldrec_out_pidx;

static int hf_swils_ldrec_nbr_pidx;

static int hf_swils_ldrec_link_type;

static int hf_swils_ldrec_link_cost;

static int hf_swils_lsrh_lsr_type;

static int hf_swils_lsrh_lsid;

static int hf_swils_lsrh_adv_domid;

static int hf_swils_lsrh_ls_incid;

static int hf_swils_esc_pdesc_vendorid;

static int hf_swils_esc_swvendorid;

static int hf_swils_esc_protocolid;

static int hf_swils_rscn_evtype;

static int hf_swils_rscn_addrfmt;

static int hf_swils_rscn_detectfn;

static int hf_swils_rscn_affectedport;

static int hf_swils_rscn_portstate;

static int hf_swils_rscn_portid;

static int hf_swils_rscn_pwwn;

static int hf_swils_rscn_nwwn;

static int hf_swils_zone_activezonenm;

static int hf_swils_zone_objname;

static int hf_swils_zone_objtype;

static int hf_swils_zone_mbrtype;

static int hf_swils_zone_protocol;

static int hf_swils_zone_mbrid;

static int hf_swils_zone_mbrid_fcwwn;

static int hf_swils_zone_mbrid_fc;

static int hf_swils_zone_mbrid_uint;

static int hf_swils_zone_status;

static int hf_swils_zone_reason;

static int hf_swils_aca_domainid;

static int hf_swils_sfc_opcode;

static int hf_swils_sfc_zonenm;

static int hf_swils_rjt;

static int hf_swils_rjtdet;

static int hf_swils_rjtvendor;

static int hf_swils_zone_mbrid_lun;

static int hf_swils_ess_rev;

static int hf_swils_ess_len;

static int hf_swils_ess_numobj;

static int hf_swils_interconnect_list_len;

static int hf_swils_ess_vendorname;

static int hf_swils_ess_modelname;

static int hf_swils_ess_relcode;

static int hf_swils_ess_vendorspecific;

static int hf_swils_ess_cap_type;

static int hf_swils_ess_cap_subtype;

static int hf_swils_ess_cap_numentries;

static int hf_swils_ess_cap_svc;

static int hf_swils_ess_dns_obj0h;

static int hf_swils_ess_dns_obj1h;

static int hf_swils_ess_dns_obj2h;

static int hf_swils_ess_dns_obj3h;

static int hf_swils_ess_dns_zlacc;

static int hf_swils_ess_dns_vendor;

static int hf_swils_ess_fctlr_rscn;

static int hf_swils_ess_fctlr_vendor;

static int hf_swils_ess_fcs_basic;

static int hf_swils_ess_fcs_platform;

static int hf_swils_ess_fcs_topology;

static int hf_swils_ess_fcs_enhanced;

static int hf_swils_ess_fzs_enh_supp;

static int hf_swils_ess_fzs_enh_ena;

static int hf_swils_ess_fzs_mr;

static int hf_swils_ess_fzs_zsdb_supp;

static int hf_swils_ess_fzs_zsdb_ena;

static int hf_swils_ess_fzs_adc_supp;

static int hf_swils_ess_fzs_hardzone;

static int hf_swils_mrra_rev;

static int hf_swils_mrra_size;

static int hf_swils_mrra_vendorid;

static int hf_swils_mrra_reply;

static int hf_swils_mrra_reply_size;

static int hf_swils_mrra_waittime;

static int hf_swils_ess_cap_t10;

static int hf_swils_ess_cap_vendorobj;

static int hf_swils_ess_fzs_defzone;

static int hf_swils_ess_cap_len;

static int hf_swils_mrra_vendorinfo;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_swils_lsrh_lsr_age;

static int hf_swils_zone_full_zone_set_length;

static int hf_swils_zone_num_zoning_objects;

static int hf_swils_lsrec_number_of_links;

static int hf_swils_sfc_zoneset_length;

static int hf_swils_zone_vendor_unique;

static int hf_swils_zone_num_members;

static int hf_swils_zone_active_zoneset_length;

static int hf_swils_lsack_num_of_lsr_headers;

static int hf_swils_lsrh_lsr_length;

static int hf_swils_esc_payload_length;

static int hf_swils_lsupdate_num_of_lsrs;

static int hf_swils_zone_mbr_identifier_length;

static int hf_swils_zone_mbrflags;

static int hf_swils_lsrh_options;

static int hf_swils_domain_id_list_length;

static int hf_swils_lsack_flags;

static int hf_swils_rscn_num_entries;

static int hf_swils_requested_domain_id;

static int hf_swils_lsrh_checksum;

static int hf_swils_granted_domain_id;

static int hf_swils_lsupdate_flags;

static expert_field ei_swils_efp_record_len;

static expert_field ei_swils_no_exchange;

static expert_field ei_swils_zone_mbrid;

/* Initialize the subtree pointers */

static int ett_fcswils;

static int ett_fcswils_swacc;

static int ett_fcswils_swrjt;

static int ett_fcswils_elp;

static int ett_fcswils_efp;

static int ett_fcswils_efplist;

static int ett_fcswils_dia;

static int ett_fcswils_rdi;

static int ett_fcswils_fspfhdr;

static int ett_fcswils_hlo;

static int ett_fcswils_lsrec;

static int ett_fcswils_lsrechdr;

static int ett_fcswils_ldrec;

static int ett_fcswils_lsu;

static int ett_fcswils_lsa;

static int ett_fcswils_bf;

static int ett_fcswils_rcf;

static int ett_fcswils_rscn;

static int ett_fcswils_rscn_dev;

static int ett_fcswils_drlir;

static int ett_fcswils_mr;

static int ett_fcswils_zoneobjlist;

static int ett_fcswils_zoneobj;

static int ett_fcswils_zonembr;

static int ett_fcswils_aca;

static int ett_fcswils_rca;

static int ett_fcswils_sfc;

static int ett_fcswils_ufc;

static int ett_fcswils_esc;

static int ett_fcswils_esc_pdesc;

static int ett_fcswils_ieinfo;

static int ett_fcswils_capinfo;

static const value_string fc_swils_opcode_key_val[] = {

    {FC_SWILS_SWRJT   , "SW_RJT"},

    {FC_SWILS_SWACC   , "SW_ACC"},

    {FC_SWILS_ELP     , "ELP"},

    {FC_SWILS_EFP     , "EFP"},

    {FC_SWILS_DIA     , "DIA"},

    {FC_SWILS_RDI     , "RDI"},

    {FC_SWILS_HLO     , "HLO"},

    {FC_SWILS_LSU     , "LSU"},

    {FC_SWILS_LSA     , "LSA"},

    {FC_SWILS_BF      , "BF"},

    {FC_SWILS_RCF     , "RCF"},

    {FC_SWILS_RSCN    , "SW_RSCN"},

    {FC_SWILS_DRLIR   , "DRLIR"},

    {FC_SWILS_DSCN    , "DSCN"},

    {FC_SWILS_LOOPD   , "LOOPD"},

    {FC_SWILS_MR      , "MR"},

    {FC_SWILS_ACA     , "ACA"},

    {FC_SWILS_RCA     , "RCA"},

    {FC_SWILS_SFC     , "SFC"},

    {FC_SWILS_UFC     , "UFC"},

    {FC_SWILS_ESC     , "ESC"},

    {FC_SWILS_ESS     , "ESS"},

    {FC_SWILS_MRRA    , "MRRA"},

    {FC_SWILS_AUTH_ILS, "AUTH_ILS"},

    {0, NULL},

};

static const value_string fc_swils_rjt_val [] = {

    {FC_SWILS_RJT_INVCODE   , "Invalid Cmd Code"},

    {FC_SWILS_RJT_INVVER    , "Invalid Revision"},

    {FC_SWILS_RJT_LOGERR    , "Logical Error"},

    {FC_SWILS_RJT_INVSIZE   , "Invalid Size"},

    {FC_SWILS_RJT_LOGBSY    , "Logical Busy"},

    {FC_SWILS_RJT_PROTERR   , "Protocol Error"},

    {FC_SWILS_RJT_GENFAIL   , "Unable to Perform"},

    {FC_SWILS_RJT_CMDNOTSUPP, "Unsupported Cmd"},

    {FC_SWILS_RJT_VENDUNIQ  , "Vendor Unique Err"},

    {0, NULL},

};

static const value_string fc_swils_deterr_val [] = {

    {FC_SWILS_RJT_NODET     , "No Additional Details"},

    {FC_SWILS_RJT_CLSF_ERR  , "Class F Svc Param Err"},

    {FC_SWILS_RJT_CLSN_ERR  , "Class N Svc Param Err"},

    {FC_SWILS_RJT_INVFC_CODE, "Unknown Flow Ctrl Code"},

    {FC_SWILS_RJT_INVFC_PARM, "Invalid Flow Ctrl Parm"},

    {FC_SWILS_RJT_INV_PNAME , "Invalid Port Name"},

    {FC_SWILS_RJT_INV_SNAME , "Invalid Switch Name"},

    {FC_SWILS_RJT_TOV_MSMTCH, "R_A_/E_D_TOV Mismatch"},

    {FC_SWILS_RJT_INV_DIDLST, "Invalid Domain ID List"},

    {FC_SWILS_RJT_CMD_INPROG, "Cmd Already in Progress"},

    {FC_SWILS_RJT_OORSRC    , "Insufficient Resources"},

    {FC_SWILS_RJT_NO_DID    , "Domain ID Unavailable"},

    {FC_SWILS_RJT_INV_DID   , "Invalid Domain ID"},

    {FC_SWILS_RJT_NO_REQ    , "Request Not Supported"},

    {FC_SWILS_RJT_NOLNK_PARM, "Link Parm Not Estd."},

    {FC_SWILS_RJT_NO_REQDID , "Group of Domain IDs Unavail"},

    {FC_SWILS_RJT_EP_ISOL   , "E_Port Isolated"},

    {0, NULL}

};

static const value_string fcswils_elp_fc_val[] = {

    {FC_SWILS_ELP_FC_VENDOR, "Vendor Unique"},

    {FC_SWILS_ELP_FC_RRDY  , "R_RDY Flow Ctrl"},

    {0, NULL},

};

static const value_string fcswils_rectype_val[] = {

    {FC_SWILS_LRECTYPE_DOMAIN, "Domain ID Record"},

    {FC_SWILS_LRECTYPE_MCAST , "Multicast ID Record"},

    {0, NULL},

};

static const value_string fc_swils_link_type_val[] = {

    {0x01, "P2P Link"},

    {0xF0, "Vendor Specific"},

    {0xF1, "Vendor Specific"},

    {0xF2, "Vendor Specific"},

    {0xF3, "Vendor Specific"},

    {0xF4, "Vendor Specific"},

    {0xF5, "Vendor Specific"},

    {0xF6, "Vendor Specific"},

    {0xF7, "Vendor Specific"},

    {0xF8, "Vendor Specific"},

    {0xF9, "Vendor Specific"},

    {0xFA, "Vendor Specific"},

    {0xFB, "Vendor Specific"},

    {0xFC, "Vendor Specific"},

    {0xFD, "Vendor Specific"},

    {0xFE, "Vendor Specific"},

    {0xFF, "Vendor Specific"},

    {0, NULL},

};

static const value_string fc_swils_fspf_linkrec_val[] = {

    {FC_SWILS_LSR_SLR, "Switch Link Record"},

    {FC_SWILS_LSR_ARS, "AR Summary Record"},

    {0, NULL},

};

static const value_string fc_swils_fspf_lsrflags_val[] = {

    {0x0, "LSR is for a Topology Update"},

    {0x1, "LSR is for Initial DB Sync | Not the last seq in DB sync"},

    {0x2, "Last Seq in DB Sync. LSU has no LSRs"},

    {0x3, "LSR is for Initial DB Sync | Last Seq in DB Sync"},

    {0, NULL},

};

static const value_string fc_swils_rscn_portstate_val[] = {

    {0, "No Additional Info"},

    {1, "Port is online"},

    {2, "Port is offline"},

    {0, NULL},

};

static const value_string fc_swils_rscn_addrfmt_val[] = {

    {0, "Port Addr Format"},

    {1, "Area Addr Format"},

    {2, "Domain Addr Format"},

    {3, "Fabric Addr Format"},

    {0, NULL},

};

static const value_string fc_swils_rscn_detectfn_val[] = {

    {1, "Fabric Detected"},

    {2, "N_Port Detected"},

    {0, NULL},

};

static const value_string fc_swils_esc_protocol_val[] = {

    {0, "Reserved"},

    {1, "FSPF-Backbone Protocol"},

    {2, "FSPF Protocol"},

    {0, NULL},

};

static const value_string fc_swils_zoneobj_type_val[] = {

    {0, "Reserved"},

    {FC_SWILS_ZONEOBJ_ZONESET  , "Zone Set"},

    {FC_SWILS_ZONEOBJ_ZONE     , "Zone"},

    {FC_SWILS_ZONEOBJ_ZONEALIAS, "Zone Alias"},

    {0, NULL},

};

const value_string fc_swils_zonembr_type_val[] = {

    {0                        , "Reserved"},

    {FC_SWILS_ZONEMBR_WWN     , "WWN"},

    {FC_SWILS_ZONEMBR_DP      , "Domain/Physical Port (0x00ddpppp)"},

    {FC_SWILS_ZONEMBR_FCID    , "FC Address"},

    {FC_SWILS_ZONEMBR_ALIAS   , "Zone Alias"},

    {FC_SWILS_ZONEMBR_WWN_LUN , "WWN+LUN"},

    {FC_SWILS_ZONEMBR_DP_LUN  , "Domain/Physical Port+LUN"},

    {FC_SWILS_ZONEMBR_FCID_LUN, "FCID+LUN"},

    {0, NULL},

};

static const value_string fc_swils_mr_rsp_val[] = {

    {0, "Successful"},

    {1, "Fabric Busy"},

    {2, "Failed"},

    {0, NULL},

};

static const value_string fc_swils_mr_reason_val[] = {

    {0x0, "No Reason"},

    {0x1, "Invalid Data Length"},

    {0x2, "Unsupported Command"},

    {0x3, "Reserved"},

    {0x4, "Not Authorized"},

    {0x5, "Invalid Request"},

    {0x6, "Fabric Changing"},

    {0x7, "Update Not Staged"},

    {0x8, "Invalid Zone Set Format"},

    {0x9, "Invalid Data"},

    {0xA, "Cannot Merge"},

    {0, NULL},

};

static const value_string fc_swils_sfc_op_val[] = {

    {0, "Reserved"},

    {1, "Reserved"},

    {2, "Reserved"},

    {3, "Activate Zone Set"},

    {4, "Deactivate Zone Set"},

    {0, NULL},

};

typedef struct _zonename {

    uint32_t namelen:8,

        rsvd:24;

    char    *name;

    char    *pad;

} zonename_t;

typedef struct _fcswils_conv_key {

    uint32_t conv_idx;

} fcswils_conv_key_t;

typedef struct _fcswils_conv_data {

    uint32_t opcode;

} fcswils_conv_data_t;

static wmem_map_t *fcswils_req_hash;

/* list of commands for each commandset */

typedef void (*fcswils_dissector_t)(tvbuff_t *tvb, packet_info* pinfo, proto_tree *tree, uint8_t isreq);

typedef struct _fcswils_func_table_t {

    fcswils_dissector_t func;

} fcswils_func_table_t;

static dissector_handle_t fcsp_handle;

static int get_zoneobj_len(tvbuff_t *tvb, int offset);

/*

 * Hash Functions

 */

static int

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

{

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

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

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

}

static unsigned

fcswils_hash(const void *v)

{

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

    unsigned val;

    val = key->conv_idx;

    return val;

}

static char *

zonenm_to_str(wmem_allocator_t *scope, tvbuff_t *tvb, int offset)

{

    int len = tvb_get_uint8(tvb, offset);

    return (char*)tvb_get_string_enc(scope, tvb, offset+4, len, ENC_ASCII);

}

/* Offset points to the start of the zone object */

static int

get_zoneobj_len(tvbuff_t *tvb, int offset)

{

    int    numrec, numrec1;

    uint8_t objtype;

    int    i, j, len;

    /* zone object structure is:

     * type (1 byte), protocol (1 byte), rsvd (2 bytes), obj name (x bytes),

     * num of zone mbrs (4 bytes ), list of zone members (each member if of

     * variable length).

     *

     * zone member structure is:

     * type (1 byte), rsvd (1 byte), flags (1 byte), id_len (1 byte),

     * id (id_len bytes)

     */

    objtype = tvb_get_uint8(tvb, offset);

    len = 4 + ZONENAME_LEN(tvb, offset+4); /* length up to num_of_mbrs field */

    numrec = tvb_get_ntohl(tvb, offset+len); /* gets us num of zone mbrs */

    len += 4;                   /* + num_mbrs */

    for (i = 0; i < numrec; i++) {

        if (objtype == FC_SWILS_ZONEOBJ_ZONESET) {

            len += 4 + ZONENAME_LEN(tvb, offset+4+len); /* length up to num_of_mbrs field */

            numrec1 = tvb_get_ntohl(tvb, offset+len);

            len += 4;

            for (j = 0; j < numrec1; j++) {

                len += 4 + tvb_get_uint8(tvb, offset+3+len);

            }

        }

        else {

            len += 4 + tvb_get_uint8(tvb, offset+3+len);

        }

    }

    return len;

}

#define MAX_INTERCONNECT_ELEMENT_INFO_LEN  252

static int

dissect_swils_interconnect_element_info(tvbuff_t *tvb, proto_tree *tree, int offset)

{

    int len, max_len = MAX_INTERCONNECT_ELEMENT_INFO_LEN;

    if (tree) {

        proto_tree_add_item(tree, hf_swils_interconnect_list_len, tvb, offset+3, 1, ENC_BIG_ENDIAN);

        len = tvb_strsize(tvb, offset+4);

        proto_tree_add_item(tree, hf_swils_ess_vendorname, tvb, offset+4, len, ENC_ASCII);

        offset += (4 + len);

        max_len -= len;

        len = tvb_strsize(tvb, offset);

        proto_tree_add_item(tree, hf_swils_ess_modelname, tvb, offset, len, ENC_ASCII);

        offset += len;

        max_len -= len;

        len = tvb_strsize(tvb, offset);

        proto_tree_add_item(tree, hf_swils_ess_relcode, tvb, offset, len, ENC_ASCII);

        offset += len;

        max_len -= len;

        while (max_len > 0) {

            /* Vendor specific field is a set of one or more null-terminated

             * strings

             */

            len = tvb_strsize(tvb, offset);

            proto_tree_add_item(tree, hf_swils_ess_vendorspecific, tvb, offset, len, ENC_ASCII);

            offset += len;

            max_len -= len;

        }

    }

    return true;

}

static void

dissect_swils_ess_capability(tvbuff_t *tvb, proto_tree *tree, int offset,

                             uint8_t srvr_type)

{

    if (tree) {

        switch (srvr_type) {

        case FCCT_GSRVR_DNS:

            proto_tree_add_item(tree, hf_swils_ess_dns_zlacc, tvb, offset+3,

                                1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_dns_obj3h, tvb, offset+3,

                                1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_dns_obj2h, tvb, offset+3,

                                1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_dns_obj1h, tvb, offset+3,

                                1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_dns_obj0h, tvb, offset+3,

                                1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_dns_vendor, tvb,

                                offset+4, 4, ENC_BIG_ENDIAN);

            break;

        case FCCT_GSRVR_FCTLR:

            proto_tree_add_item(tree, hf_swils_ess_fctlr_rscn, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fctlr_vendor, tvb,

                                offset+4, 4, ENC_BIG_ENDIAN);

            break;

        case FCCT_GSRVR_FCS:

            proto_tree_add_item(tree, hf_swils_ess_fcs_basic, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fcs_platform, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fcs_topology, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fcs_enhanced, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            break;

        case FCCT_GSRVR_FZS:

            proto_tree_add_item(tree, hf_swils_ess_fzs_enh_supp, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fzs_enh_ena, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fzs_mr, tvb, offset+3,

                                1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fzs_defzone, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fzs_zsdb_supp, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fzs_zsdb_ena, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fzs_adc_supp, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item(tree, hf_swils_ess_fzs_hardzone, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            break;

        default:

            break;

        }

    }

    return;

}

static int

dissect_swils_ess_capability_obj(tvbuff_t *tvb, packet_info* pinfo, proto_tree *tree, int offset)

{

    int         i = 0, num_entries = 0, len = 0, total_len = 0;

    uint8_t     type, subtype, srvr_type;

    proto_tree *capinfo_tree = NULL;

    if (tree) {

        /*

         * Structure of capability object is: WK type (1B), WK subtype(1),

         * rsvd (1), num_cap_entries (1), entry_1 (8) ... entry_n (8)

         */

        /* Compute length first to create subtree of cap object */

        type = tvb_get_uint8(tvb, offset);

        if (type != FCCT_GSTYPE_VENDOR) {

            num_entries = tvb_get_uint8(tvb, offset+3);

            total_len = 4 + (num_entries*8);

            capinfo_tree = proto_tree_add_subtree_format(tree, tvb, offset,

                                     total_len, ett_fcswils_capinfo, NULL, "Capability Object (%s)",

                                     val_to_str(pinfo->pool, type, fc_ct_gstype_vals,

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

        } else {

            i = tvb_get_uint8(tvb, offset+3);

            i += 12;

            capinfo_tree = proto_tree_add_subtree_format(tree, tvb, offset,

                                     i, ett_fcswils_capinfo, NULL, "Capability Object (Vendor-specific 0x%x)",

                                     type);

        }

        proto_tree_add_item(capinfo_tree, hf_swils_ess_cap_type, tvb, offset, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item(capinfo_tree, hf_swils_ess_cap_subtype, tvb, offset+1,

                            1, ENC_BIG_ENDIAN);

        subtype = tvb_get_uint8(tvb, offset+1);

        if (type != FCCT_GSTYPE_VENDOR) {

            srvr_type = get_gs_server(type, subtype);

            proto_tree_add_uint(capinfo_tree, hf_swils_ess_cap_svc, tvb, offset, 2,

                                srvr_type);

            proto_tree_add_item(capinfo_tree, hf_swils_ess_cap_numentries, tvb,

                                offset+3, 1, ENC_BIG_ENDIAN);

            offset += 4;

            len += 4;

            while ((num_entries > 0) && tvb_bytes_exist(tvb, offset, 8)) {

                dissect_swils_ess_capability(tvb, capinfo_tree, offset, srvr_type);

                num_entries--;

                offset += 8;

                len += 8;

            }

        } else {

            /* Those damn T11 guys defined another format for

             * Vendor-specific objects.

             */

            proto_tree_add_item(capinfo_tree, hf_swils_ess_cap_len, tvb, offset+3,

                                1, ENC_BIG_ENDIAN);

            proto_tree_add_item(capinfo_tree, hf_swils_ess_cap_t10, tvb, offset+4,

                                8, ENC_ASCII);

            i -= 8;          /* reduce length by t10 object size */

            offset += 12;

            len += 12;

            while ((i > 0) && tvb_bytes_exist(tvb, offset, 8)) {

                proto_tree_add_item(capinfo_tree, hf_swils_ess_cap_vendorobj,

                                    tvb, offset, 8, ENC_NA);

                i -= 8;

                offset += 8;

                len += 12;

            }

        }

    }

    return len;

}

static void

dissect_swils_nullpayload(tvbuff_t *tvb _U_, packet_info* pinfo _U_, proto_tree *tree _U_,

                          uint8_t isreq _U_)

{

    /* Common dissector for those ILSs without a payload */

    return;

}

static void

dissect_swils_elp(tvbuff_t *tvb, packet_info* pinfo, proto_tree *elp_tree, uint8_t isreq _U_)

{

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

    /* Response i.e. SW_ACC for an ELP has the same format as the request */

    /* We skip the initial 4 bytes as we don't care about the opcode */

    int          offset = 4;

    const char *flags;

    uint16_t isl_flwctrl_mode;

    uint8_t clsf_svcparm[6], cls1_svcparm[2], cls2_svcparm[2], cls3_svcparm[2];

    if (elp_tree) {

        offset += 4;

        proto_tree_add_item(elp_tree, hf_swils_elp_rev, tvb, offset++, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item(elp_tree, hf_swils_elp_flags, tvb, offset, 2, ENC_NA);

        offset += 3;

        proto_tree_add_item(elp_tree, hf_swils_elp_r_a_tov, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(elp_tree, hf_swils_elp_e_d_tov, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(elp_tree, hf_swils_elp_req_epn, tvb, offset, 8, ENC_NA);

        offset += 8;

        proto_tree_add_item(elp_tree, hf_swils_elp_req_esn, tvb, offset, 8, ENC_NA);

        offset += 8;

        tvb_memcpy(tvb, clsf_svcparm, offset, 6);

        if (clsf_svcparm[0] & 0x80) {

            if (clsf_svcparm[4] & 0x20) {

                flags="Class F Valid | X_ID Interlock";

            } else {

                flags="Class F Valid | No X_ID Interlk";

            }

        } else {

            flags="Class F Invld";

        }

        proto_tree_add_bytes_format_value(elp_tree, hf_swils_elp_clsf_svcp, tvb, offset, 6,

                                    clsf_svcparm, "(%s)", flags);

        offset += 6;

        proto_tree_add_item(elp_tree, hf_swils_elp_clsf_rcvsz, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item(elp_tree, hf_swils_elp_clsf_conseq, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item(elp_tree, hf_swils_elp_clsf_e2e, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item(elp_tree, hf_swils_elp_clsf_openseq, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 4;

        tvb_memcpy(tvb, cls1_svcparm, offset, 2);

        if (cls1_svcparm[0] & 0x80) {

#define MAX_FLAGS_LEN 40

            char *flagsbuf;

            int stroff, returned_length;

            flagsbuf=(char *)wmem_alloc(pinfo->pool, MAX_FLAGS_LEN);

            stroff = 0;

            returned_length = snprintf(flagsbuf+stroff, MAX_FLAGS_LEN-stroff,

                                         "Class 1 Valid");

            stroff += MIN(returned_length, MAX_FLAGS_LEN-stroff);

            if (cls1_svcparm[0] & 0x40) {

                returned_length = snprintf(flagsbuf+stroff, MAX_FLAGS_LEN-stroff, " | IMX");

                stroff += MIN(returned_length, MAX_FLAGS_LEN-stroff);

            }

            if (cls1_svcparm[0] & 0x20) {

                returned_length = snprintf(flagsbuf+stroff, MAX_FLAGS_LEN-stroff, " | IPS");

                stroff += MIN(returned_length, MAX_FLAGS_LEN-stroff);

            }

            if (cls1_svcparm[0] & 0x10) {

                /*returned_length =*/ snprintf(flagsbuf+stroff, MAX_FLAGS_LEN-stroff, " | LKS");

            }

            flags=flagsbuf;

        }

        else {

            flags="Class 1 Invalid";

        }

        proto_tree_add_bytes_format_value(elp_tree, hf_swils_elp_cls1_svcp, tvb, offset, 2,

                                    NULL, "(%s)", flags);

        offset += 2;

        if (cls1_svcparm[0] & 0x80) {

            proto_tree_add_item(elp_tree, hf_swils_elp_cls1_rcvsz, tvb, offset, 2, ENC_BIG_ENDIAN);

        }

        offset += 2;

        tvb_memcpy(tvb, cls2_svcparm, offset, 2);

        if (cls2_svcparm[0] & 0x80) {

            if (cls2_svcparm[0] & 0x08) {

                flags="Class 2 Valid | Seq Delivery";

            }

            else {

                flags="Class 2 Valid | No Seq Delivery";

            }

        }

        else {

            flags="Class 2 Invld";

        }

        proto_tree_add_bytes_format_value(elp_tree, hf_swils_elp_cls2_svcp, tvb, offset, 2,

                                    cls2_svcparm,

                                    "(%s)", flags);

        offset += 2;

        if (cls2_svcparm[0] & 0x80) {

            proto_tree_add_item(elp_tree, hf_swils_elp_cls2_rcvsz, tvb, offset, 2, ENC_BIG_ENDIAN);

        }

        offset += 2;

        tvb_memcpy(tvb, cls3_svcparm, offset, 2);

        if (cls3_svcparm[0] & 0x80) {

            if (cls3_svcparm[0] & 0x08) {

                flags="Class 3 Valid | Seq Delivery";

            }

            else {

                flags="Class 3 Valid | No Seq Delivery";

            }

        }

        else {

            flags="Class 3 Invld";

        }

        proto_tree_add_bytes_format_value(elp_tree, hf_swils_elp_cls3_svcp, tvb, offset, 2,

                                    cls3_svcparm,

                                    "(%s)", flags);

        offset += 2;

        if (cls3_svcparm[0] & 0x80) {

            proto_tree_add_item(elp_tree, hf_swils_elp_cls3_rcvsz, tvb, offset, 2, ENC_BIG_ENDIAN);

        }

        offset += 22;

        isl_flwctrl_mode = tvb_get_ntohs(tvb, offset);

        proto_tree_add_string(elp_tree, hf_swils_elp_isl_fc_mode, tvb, offset, 2,

                              val_to_str_const(isl_flwctrl_mode, fcswils_elp_fc_val, "Vendor Unique"));

        offset += 2;

        proto_tree_add_item(elp_tree, hf_swils_elp_fcplen, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item(elp_tree, hf_swils_elp_b2bcredit, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(elp_tree, hf_swils_elp_compat1, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(elp_tree, hf_swils_elp_compat2, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(elp_tree, hf_swils_elp_compat3, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(elp_tree, hf_swils_elp_compat4, tvb, offset, 4, ENC_BIG_ENDIAN);

    }

}

static void

dissect_swils_efp(tvbuff_t *tvb, packet_info* pinfo, proto_tree *efp_tree, uint8_t isreq _U_)

{

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

    proto_tree  *lrec_tree;

    proto_item  *rec_item;

    int          num_listrec = 0;

    int          offset      = 1; /* Skip opcode */

    uint8_t      reclen;

    uint16_t     payload_len;

    uint8_t      rec_type;

    reclen = tvb_get_uint8(tvb, offset);

    rec_item = proto_tree_add_uint(efp_tree, hf_swils_efp_record_len, tvb, offset, 1, reclen);

    offset += 1;

    payload_len = tvb_get_ntohs(tvb, offset);

    if (payload_len < FC_SWILS_EFP_SIZE) {

        proto_tree_add_uint_format_value(efp_tree, hf_swils_efp_payload_len,

                                       tvb, offset, 2, payload_len,

                                       "%u (bogus, must be >= %u)",

                                       payload_len, FC_SWILS_EFP_SIZE);

        return;

    }

    proto_tree_add_item(efp_tree, hf_swils_efp_payload_len, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 5;       /* skip 3 reserved bytes, too */

    proto_tree_add_item(efp_tree, hf_swils_efp_pswitch_pri, tvb,

                            offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    proto_tree_add_item(efp_tree, hf_swils_efp_pswitch_name, tvb, offset, 8, ENC_NA);

    offset += 8;

    if (reclen == 0) {

        expert_add_info(pinfo, rec_item, &ei_swils_efp_record_len);

        return;

    }

    /* Add List Records now */

    if (efp_tree) {

        num_listrec = (payload_len - FC_SWILS_EFP_SIZE)/reclen;

        while (num_listrec-- > 0) {

            rec_type = tvb_get_uint8(tvb, offset);

            lrec_tree = proto_tree_add_subtree(efp_tree, tvb, offset, -1,

                                        ett_fcswils_efplist, NULL,

                                        val_to_str(pinfo->pool, rec_type,

                                                   fcswils_rectype_val,

                                                   "Unknown record type (0x%02x)"));

            proto_tree_add_uint(lrec_tree, hf_swils_efp_rec_type, tvb, offset, 1,

                                rec_type);

            switch (rec_type) {

            case FC_SWILS_LRECTYPE_DOMAIN:

                proto_tree_add_item(lrec_tree, hf_swils_efp_dom_id, tvb, offset+1, 1, ENC_BIG_ENDIAN);

                proto_tree_add_item(lrec_tree, hf_swils_efp_switch_name, tvb, offset+8, 8, ENC_NA);

                break;

            case FC_SWILS_LRECTYPE_MCAST:

                proto_tree_add_item(lrec_tree, hf_swils_efp_mcast_grpno, tvb, offset+1, 1, ENC_BIG_ENDIAN);

                break;

            }

            offset += reclen;

        }

    }

}

static void

dissect_swils_dia(tvbuff_t *tvb, packet_info* pinfo _U_, proto_tree *dia_tree, uint8_t isreq _U_)

{

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

    int offset = 0;

    if (dia_tree) {

        proto_tree_add_item(dia_tree, hf_swils_dia_switch_name, tvb, offset+4,

                              8, ENC_NA);

    }

}

static void

dissect_swils_rdi(tvbuff_t *tvb, packet_info* pinfo _U_, proto_tree *rdi_tree, uint8_t isreq)

{

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

    int offset = 0;

    int i, plen, numrec;

    if (rdi_tree) {

        plen = tvb_get_ntohs(tvb, offset+2);

        proto_tree_add_item(rdi_tree, hf_swils_rdi_payload_len, tvb, offset+2, 2, ENC_BIG_ENDIAN);

        proto_tree_add_item(rdi_tree, hf_swils_rdi_req_sname, tvb, offset+4, 8, ENC_NA);

        /* 12 is the length of the initial header and 4 is the size of each

         * domain request record.

         */

        numrec = (plen - 12)/4;

        offset = 12;

        for (i = 0; i < numrec; i++) {

            if (isreq) {

                proto_tree_add_item(rdi_tree, hf_swils_requested_domain_id, tvb, offset+3, 1, ENC_BIG_ENDIAN);

            }

            else {

                proto_tree_add_item(rdi_tree, hf_swils_granted_domain_id, tvb, offset+3, 1, ENC_BIG_ENDIAN);

            }

            offset += 4;

        }

    }

}

static void

dissect_swils_fspf_hdr(tvbuff_t *tvb, proto_tree *tree, int offset)

{

    proto_tree *fspfh_tree;

    if (tree) {

        /* 20 is the size of FSPF header */

        fspfh_tree = proto_tree_add_subtree(tree, tvb, offset, 20, ett_fcswils_fspfhdr, NULL, "FSPF Header");

        proto_tree_add_item(fspfh_tree, hf_swils_fspfh_rev, tvb, offset+4,

                            1, ENC_BIG_ENDIAN);

        proto_tree_add_item(fspfh_tree, hf_swils_fspfh_ar_num, tvb,

                            offset+5, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item(fspfh_tree, hf_swils_fspfh_auth_type, tvb,

                            offset+6, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item(fspfh_tree, hf_swils_fspfh_dom_id, tvb, offset+11,

                            1, ENC_BIG_ENDIAN);

        proto_tree_add_item(fspfh_tree, hf_swils_fspfh_auth, tvb, offset+12,

                            8, ENC_NA);

    }

}

static void

dissect_swils_fspf_lsrechdr(tvbuff_t *tvb, proto_tree *tree, int offset)

{

    proto_tree_add_item(tree, hf_swils_lsrh_lsr_type, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_swils_lsrh_lsr_age, tvb, offset+2, 2, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_swils_lsrh_options, tvb, offset+4, 4, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_swils_lsrh_lsid, tvb, offset+11, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_swils_lsrh_adv_domid, tvb, offset+15, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_swils_lsrh_ls_incid, tvb, offset+16, 4, ENC_BIG_ENDIAN);

    proto_tree_add_checksum(tree, tvb, offset+20, hf_swils_lsrh_checksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);

    proto_tree_add_item(tree, hf_swils_lsrh_lsr_length, tvb, offset+22, 2, ENC_BIG_ENDIAN);

}

static void

dissect_swils_fspf_ldrec(tvbuff_t *tvb, proto_tree *tree, int offset)

{

    proto_tree_add_item(tree, hf_swils_ldrec_linkid, tvb, offset+1, 3, ENC_NA);

    proto_tree_add_item(tree, hf_swils_ldrec_out_pidx, tvb, offset+5, 3, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_swils_ldrec_nbr_pidx, tvb, offset+9, 3, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_swils_ldrec_link_type, tvb, offset+12, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_swils_ldrec_link_cost, tvb, offset+14, 2, ENC_BIG_ENDIAN);

}

static void

dissect_swils_fspf_lsrec(tvbuff_t *tvb, proto_tree *tree, int offset,

                         int num_lsrec)

{

    int         i, j, num_ldrec;

    proto_tree *lsrec_tree, *ldrec_tree, *lsrechdr_tree;

    if (tree) {

        for (j = 0; j < num_lsrec; j++) {

            num_ldrec = tvb_get_ntohs(tvb, offset+26);

            lsrec_tree = proto_tree_add_subtree_format(tree, tvb, offset, (28+num_ldrec*16),

                                        ett_fcswils_lsrec, NULL, "Link State Record %d (Domain %d)", j,

                                        tvb_get_uint8(tvb, offset+15));

            lsrechdr_tree = proto_tree_add_subtree(lsrec_tree, tvb, offset, 24,

                                        ett_fcswils_lsrechdr, NULL, "Link State Record Header");

            dissect_swils_fspf_lsrechdr(tvb, lsrechdr_tree, offset);

            proto_tree_add_item(tree, hf_swils_lsrec_number_of_links, tvb, offset+26, 2, ENC_BIG_ENDIAN);

            offset += 28;

            for (i = 0; i < num_ldrec; i++) {

                ldrec_tree = proto_tree_add_subtree_format(lsrec_tree, tvb, offset, 16,

                                             ett_fcswils_ldrec, NULL, "Link Descriptor %d "

                                             "(Neighbor domain %d)", i,

                                             tvb_get_uint8(tvb, offset+3));

                dissect_swils_fspf_ldrec(tvb, ldrec_tree, offset);

                offset += 16;

            }

        }

    }

}

static void

dissect_swils_hello(tvbuff_t *tvb, packet_info* pinfo _U_, proto_tree *hlo_tree, uint8_t isreq _U_)

{

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

    int offset = 0;

    if (hlo_tree) {

        dissect_swils_fspf_hdr(tvb, hlo_tree, offset);

        proto_tree_add_item(hlo_tree, hf_swils_hlo_options, tvb, offset+20, 4, ENC_NA);

        proto_tree_add_item(hlo_tree, hf_swils_hlo_hloint, tvb, offset+24, 4, ENC_BIG_ENDIAN);

        proto_tree_add_item(hlo_tree, hf_swils_hlo_deadint, tvb, offset+28, 4, ENC_BIG_ENDIAN);

        proto_tree_add_item(hlo_tree, hf_swils_hlo_rcv_domid, tvb, offset+35, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item(hlo_tree, hf_swils_hlo_orig_pidx, tvb, offset+37, 3, ENC_BIG_ENDIAN);

    }

}